\u001b[0m in \u001b[0;36madd\u001b[1;34m(n1, n2)\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn1\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mn2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
70 | "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
71 | ]
72 | }
73 | ],
74 | "source": [
75 | "add(number1, number2)"
76 | ]
77 | },
78 | {
79 | "cell_type": "code",
80 | "execution_count": 12,
81 | "metadata": {},
82 | "outputs": [
83 | {
84 | "name": "stdout",
85 | "output_type": "stream",
86 | "text": [
87 | "Add went well!\n",
88 | "20\n"
89 | ]
90 | }
91 | ],
92 | "source": [
93 | "try:\n",
94 | " # Want to attempt this code\n",
95 | " # May have an error\n",
96 | " result = 10 + 10\n",
97 | "except:\n",
98 | " print(\"Hey it looks like you aren't adding correctly!\")\n",
99 | "else:\n",
100 | " print(\"Add went well!\")\n",
101 | " print(result)"
102 | ]
103 | },
104 | {
105 | "cell_type": "code",
106 | "execution_count": 9,
107 | "metadata": {},
108 | "outputs": [
109 | {
110 | "data": {
111 | "text/plain": [
112 | "20"
113 | ]
114 | },
115 | "execution_count": 9,
116 | "metadata": {},
117 | "output_type": "execute_result"
118 | }
119 | ],
120 | "source": [
121 | "result"
122 | ]
123 | },
124 | {
125 | "cell_type": "code",
126 | "execution_count": 14,
127 | "metadata": {},
128 | "outputs": [
129 | {
130 | "name": "stdout",
131 | "output_type": "stream",
132 | "text": [
133 | "Hey you have an OS Error\n",
134 | "I always run\n"
135 | ]
136 | }
137 | ],
138 | "source": [
139 | "try:\n",
140 | " f = open('testfile', 'r')\n",
141 | " f.write('Write a test line')\n",
142 | "except TypeError:\n",
143 | " print(\"There was a type error!\")\n",
144 | "except OSError:\n",
145 | " print('Hey you have an OS Error')\n",
146 | "finally:\n",
147 | " print('I always run')"
148 | ]
149 | },
150 | {
151 | "cell_type": "code",
152 | "execution_count": 25,
153 | "metadata": {},
154 | "outputs": [],
155 | "source": [
156 | "def ask_for_int():\n",
157 | " \n",
158 | " while True:\n",
159 | " \n",
160 | " try:\n",
161 | " result = int(input(\"Please provide number: \"))\n",
162 | " except:\n",
163 | " print(\"Whoops! That is not a number\")\n",
164 | " continue\n",
165 | " else:\n",
166 | " print(\"Yes thank you\")\n",
167 | " break"
168 | ]
169 | },
170 | {
171 | "cell_type": "code",
172 | "execution_count": 26,
173 | "metadata": {},
174 | "outputs": [
175 | {
176 | "name": "stdout",
177 | "output_type": "stream",
178 | "text": [
179 | "Please provide number: 20\n",
180 | "Yes thank you\n"
181 | ]
182 | }
183 | ],
184 | "source": [
185 | "ask_for_int()"
186 | ]
187 | },
188 | {
189 | "cell_type": "code",
190 | "execution_count": null,
191 | "metadata": {},
192 | "outputs": [],
193 | "source": []
194 | },
195 | {
196 | "cell_type": "code",
197 | "execution_count": null,
198 | "metadata": {},
199 | "outputs": [],
200 | "source": []
201 | },
202 | {
203 | "cell_type": "code",
204 | "execution_count": null,
205 | "metadata": {},
206 | "outputs": [],
207 | "source": []
208 | },
209 | {
210 | "cell_type": "code",
211 | "execution_count": null,
212 | "metadata": {},
213 | "outputs": [],
214 | "source": []
215 | },
216 | {
217 | "cell_type": "code",
218 | "execution_count": null,
219 | "metadata": {},
220 | "outputs": [],
221 | "source": []
222 | },
223 | {
224 | "cell_type": "code",
225 | "execution_count": null,
226 | "metadata": {},
227 | "outputs": [],
228 | "source": []
229 | },
230 | {
231 | "cell_type": "code",
232 | "execution_count": null,
233 | "metadata": {},
234 | "outputs": [],
235 | "source": []
236 | },
237 | {
238 | "cell_type": "code",
239 | "execution_count": null,
240 | "metadata": {},
241 | "outputs": [],
242 | "source": []
243 | }
244 | ],
245 | "metadata": {
246 | "kernelspec": {
247 | "display_name": "Python 3",
248 | "language": "python",
249 | "name": "python3"
250 | },
251 | "language_info": {
252 | "codemirror_mode": {
253 | "name": "ipython",
254 | "version": 3
255 | },
256 | "file_extension": ".py",
257 | "mimetype": "text/x-python",
258 | "name": "python",
259 | "nbconvert_exporter": "python",
260 | "pygments_lexer": "ipython3",
261 | "version": "3.7.3"
262 | }
263 | },
264 | "nbformat": 4,
265 | "nbformat_minor": 2
266 | }
267 |
--------------------------------------------------------------------------------
/Functions and Methods Homework.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Functions and Methods Homework \n",
8 | "\n",
9 | "Complete the following questions:\n",
10 | "____\n",
11 | "**Write a function that computes the volume of a sphere given its radius.**\n",
12 | "The volume of a sphere is given as $$\\frac{4}{3} πr^3$$
"
13 | ]
14 | },
15 | {
16 | "cell_type": "code",
17 | "execution_count": 1,
18 | "metadata": {},
19 | "outputs": [],
20 | "source": [
21 | "def vol(rad):\n",
22 | " return (4.0/3)*(3.14)*(rad**3)"
23 | ]
24 | },
25 | {
26 | "cell_type": "code",
27 | "execution_count": 2,
28 | "metadata": {},
29 | "outputs": [
30 | {
31 | "data": {
32 | "text/plain": [
33 | "33.49333333333333"
34 | ]
35 | },
36 | "execution_count": 2,
37 | "metadata": {},
38 | "output_type": "execute_result"
39 | }
40 | ],
41 | "source": [
42 | "# Check\n",
43 | "vol(2)"
44 | ]
45 | },
46 | {
47 | "cell_type": "markdown",
48 | "metadata": {},
49 | "source": [
50 | "___\n",
51 | "**Write a function that checks whether a number is in a given range (inclusive of high and low)**"
52 | ]
53 | },
54 | {
55 | "cell_type": "code",
56 | "execution_count": 7,
57 | "metadata": {},
58 | "outputs": [],
59 | "source": [
60 | "def ran_check(num,low,high):\n",
61 | " \n",
62 | " # Check if num is between low and high (including low and high)\n",
63 | " if num in range(low,high+1):\n",
64 | " print('{} is in the range between {} and {}'.format(num,low,high))\n",
65 | " else:\n",
66 | " print('The number is outside the range.')"
67 | ]
68 | },
69 | {
70 | "cell_type": "code",
71 | "execution_count": 8,
72 | "metadata": {},
73 | "outputs": [
74 | {
75 | "name": "stdout",
76 | "output_type": "stream",
77 | "text": [
78 | "5 is in the range between 2 and 7\n"
79 | ]
80 | }
81 | ],
82 | "source": [
83 | "# Check\n",
84 | "ran_check(5,2,7)"
85 | ]
86 | },
87 | {
88 | "cell_type": "markdown",
89 | "metadata": {},
90 | "source": [
91 | "If you only wanted to return a boolean:"
92 | ]
93 | },
94 | {
95 | "cell_type": "code",
96 | "execution_count": 9,
97 | "metadata": {},
98 | "outputs": [],
99 | "source": [
100 | "def ran_bool(num,low,high):\n",
101 | " return num in range(low, high)"
102 | ]
103 | },
104 | {
105 | "cell_type": "code",
106 | "execution_count": 10,
107 | "metadata": {},
108 | "outputs": [
109 | {
110 | "data": {
111 | "text/plain": [
112 | "True"
113 | ]
114 | },
115 | "execution_count": 10,
116 | "metadata": {},
117 | "output_type": "execute_result"
118 | }
119 | ],
120 | "source": [
121 | "ran_bool(3,1,10)"
122 | ]
123 | },
124 | {
125 | "cell_type": "markdown",
126 | "metadata": {},
127 | "source": [
128 | "____\n",
129 | "**Write a Python function that accepts a string and calculates the number of upper case letters and lower case letters.**\n",
130 | "\n",
131 | " Sample String : 'Hello Mr. Rogers, how are you this fine Tuesday?'\n",
132 | " Expected Output : \n",
133 | " No. of Upper case characters : 4\n",
134 | " No. of Lower case Characters : 33\n",
135 | "\n",
136 | "HINT: Two string methods that might prove useful: **.isupper()** and **.islower()**\n",
137 | "\n",
138 | "If you feel ambitious, explore the Collections module to solve this problem!"
139 | ]
140 | },
141 | {
142 | "cell_type": "code",
143 | "execution_count": 13,
144 | "metadata": {},
145 | "outputs": [],
146 | "source": [
147 | "def up_low(s):\n",
148 | " d={'upper':0, 'lower':0}\n",
149 | " for c in s:\n",
150 | " if c.isupper():\n",
151 | " d['upper']+=1\n",
152 | " elif c.islower():\n",
153 | " d['lower']+=1\n",
154 | " else:\n",
155 | " pass\n",
156 | " print('Original String : ', s)\n",
157 | " print('No. of Upper case characters : ', d['upper'])\n",
158 | " print('No. of Lower case characters : ', d['lower'])"
159 | ]
160 | },
161 | {
162 | "cell_type": "code",
163 | "execution_count": 8,
164 | "metadata": {},
165 | "outputs": [
166 | {
167 | "name": "stdout",
168 | "output_type": "stream",
169 | "text": [
170 | "Original String : Hello Mr. Rogers, how are you this fine Tuesday?\n",
171 | "No. of Upper case characters : 4\n",
172 | "No. of Lower case Characters : 33\n"
173 | ]
174 | }
175 | ],
176 | "source": [
177 | "s = 'Hello Mr. Rogers, how are you this fine Tuesday?'\n",
178 | "up_low(s)"
179 | ]
180 | },
181 | {
182 | "cell_type": "markdown",
183 | "metadata": {},
184 | "source": [
185 | "____\n",
186 | "**Write a Python function that takes a list and returns a new list with unique elements of the first list.**\n",
187 | "\n",
188 | " Sample List : [1,1,1,1,2,2,3,3,3,3,4,5]\n",
189 | " Unique List : [1, 2, 3, 4, 5]"
190 | ]
191 | },
192 | {
193 | "cell_type": "code",
194 | "execution_count": 16,
195 | "metadata": {},
196 | "outputs": [],
197 | "source": [
198 | "def unique_list(l):\n",
199 | " x = []\n",
200 | " for a in l:\n",
201 | " if a not in x:\n",
202 | " x.append(a)\n",
203 | " return x"
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": 17,
209 | "metadata": {},
210 | "outputs": [
211 | {
212 | "data": {
213 | "text/plain": [
214 | "[1, 2, 3, 4, 5]"
215 | ]
216 | },
217 | "execution_count": 17,
218 | "metadata": {},
219 | "output_type": "execute_result"
220 | }
221 | ],
222 | "source": [
223 | "unique_list([1,1,1,1,2,2,3,3,3,3,4,5])"
224 | ]
225 | },
226 | {
227 | "cell_type": "markdown",
228 | "metadata": {},
229 | "source": [
230 | "____\n",
231 | "**Write a Python function to multiply all the numbers in a list.**\n",
232 | "\n",
233 | " Sample List : [1, 2, 3, -4]\n",
234 | " Expected Output : -24"
235 | ]
236 | },
237 | {
238 | "cell_type": "code",
239 | "execution_count": 18,
240 | "metadata": {},
241 | "outputs": [],
242 | "source": [
243 | "def multiply(numbers): \n",
244 | " total = numbers[0]\n",
245 | " for x in numbers:\n",
246 | " total *= x\n",
247 | " return total"
248 | ]
249 | },
250 | {
251 | "cell_type": "code",
252 | "execution_count": 19,
253 | "metadata": {},
254 | "outputs": [
255 | {
256 | "data": {
257 | "text/plain": [
258 | "-24"
259 | ]
260 | },
261 | "execution_count": 19,
262 | "metadata": {},
263 | "output_type": "execute_result"
264 | }
265 | ],
266 | "source": [
267 | "multiply([1,2,3,-4])"
268 | ]
269 | },
270 | {
271 | "cell_type": "markdown",
272 | "metadata": {},
273 | "source": [
274 | "____\n",
275 | "**Write a Python function that checks whether a passed in string is palindrome or not.**\n",
276 | "\n",
277 | "Note: A palindrome is word, phrase, or sequence that reads the same backward as forward, e.g., madam or nurses run."
278 | ]
279 | },
280 | {
281 | "cell_type": "code",
282 | "execution_count": 20,
283 | "metadata": {},
284 | "outputs": [],
285 | "source": [
286 | "def palindrome(s):\n",
287 | " return s == s[::-1]"
288 | ]
289 | },
290 | {
291 | "cell_type": "code",
292 | "execution_count": 21,
293 | "metadata": {},
294 | "outputs": [
295 | {
296 | "data": {
297 | "text/plain": [
298 | "True"
299 | ]
300 | },
301 | "execution_count": 21,
302 | "metadata": {},
303 | "output_type": "execute_result"
304 | }
305 | ],
306 | "source": [
307 | "palindrome('helleh')"
308 | ]
309 | },
310 | {
311 | "cell_type": "markdown",
312 | "metadata": {},
313 | "source": [
314 | "____\n",
315 | "#### Hard:\n",
316 | "\n",
317 | "**Write a Python function to check whether a string is pangram or not.**\n",
318 | "\n",
319 | " Note : Pangrams are words or sentences containing every letter of the alphabet at least once.\n",
320 | " For example : \"The quick brown fox jumps over the lazy dog\"\n",
321 | "\n",
322 | "Hint: Look at the string module"
323 | ]
324 | },
325 | {
326 | "cell_type": "code",
327 | "execution_count": 22,
328 | "metadata": {},
329 | "outputs": [],
330 | "source": [
331 | "import string\n",
332 | "\n",
333 | "def ispangram(str1, alphabet=string.ascii_lowercase):\n",
334 | " alphaset = set(alphabet)\n",
335 | " return alphaset <= set(str1.lower())"
336 | ]
337 | },
338 | {
339 | "cell_type": "code",
340 | "execution_count": 23,
341 | "metadata": {},
342 | "outputs": [
343 | {
344 | "data": {
345 | "text/plain": [
346 | "True"
347 | ]
348 | },
349 | "execution_count": 23,
350 | "metadata": {},
351 | "output_type": "execute_result"
352 | }
353 | ],
354 | "source": [
355 | "ispangram(\"The quick brown fox jumps over the lazy dog\")"
356 | ]
357 | },
358 | {
359 | "cell_type": "code",
360 | "execution_count": 24,
361 | "metadata": {},
362 | "outputs": [
363 | {
364 | "data": {
365 | "text/plain": [
366 | "'abcdefghijklmnopqrstuvwxyz'"
367 | ]
368 | },
369 | "execution_count": 24,
370 | "metadata": {},
371 | "output_type": "execute_result"
372 | }
373 | ],
374 | "source": [
375 | "string.ascii_lowercase"
376 | ]
377 | }
378 | ],
379 | "metadata": {
380 | "kernelspec": {
381 | "display_name": "Python 3",
382 | "language": "python",
383 | "name": "python3"
384 | },
385 | "language_info": {
386 | "codemirror_mode": {
387 | "name": "ipython",
388 | "version": 3
389 | },
390 | "file_extension": ".py",
391 | "mimetype": "text/x-python",
392 | "name": "python",
393 | "nbconvert_exporter": "python",
394 | "pygments_lexer": "ipython3",
395 | "version": "3.7.3"
396 | }
397 | },
398 | "nbformat": 4,
399 | "nbformat_minor": 1
400 | }
401 |
--------------------------------------------------------------------------------
/2. Python Comparison Operators.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {},
7 | "outputs": [
8 | {
9 | "data": {
10 | "text/plain": [
11 | "True"
12 | ]
13 | },
14 | "execution_count": 1,
15 | "metadata": {},
16 | "output_type": "execute_result"
17 | }
18 | ],
19 | "source": [
20 | "2 == 2"
21 | ]
22 | },
23 | {
24 | "cell_type": "code",
25 | "execution_count": 2,
26 | "metadata": {},
27 | "outputs": [
28 | {
29 | "data": {
30 | "text/plain": [
31 | "False"
32 | ]
33 | },
34 | "execution_count": 2,
35 | "metadata": {},
36 | "output_type": "execute_result"
37 | }
38 | ],
39 | "source": [
40 | "2 == 1"
41 | ]
42 | },
43 | {
44 | "cell_type": "code",
45 | "execution_count": 3,
46 | "metadata": {},
47 | "outputs": [
48 | {
49 | "data": {
50 | "text/plain": [
51 | "False"
52 | ]
53 | },
54 | "execution_count": 3,
55 | "metadata": {},
56 | "output_type": "execute_result"
57 | }
58 | ],
59 | "source": [
60 | "'hello' == 'bye'"
61 | ]
62 | },
63 | {
64 | "cell_type": "code",
65 | "execution_count": 4,
66 | "metadata": {},
67 | "outputs": [
68 | {
69 | "data": {
70 | "text/plain": [
71 | "False"
72 | ]
73 | },
74 | "execution_count": 4,
75 | "metadata": {},
76 | "output_type": "execute_result"
77 | }
78 | ],
79 | "source": [
80 | "'Bye' == 'bye'"
81 | ]
82 | },
83 | {
84 | "cell_type": "code",
85 | "execution_count": 5,
86 | "metadata": {},
87 | "outputs": [
88 | {
89 | "data": {
90 | "text/plain": [
91 | "False"
92 | ]
93 | },
94 | "execution_count": 5,
95 | "metadata": {},
96 | "output_type": "execute_result"
97 | }
98 | ],
99 | "source": [
100 | "'2' == 2"
101 | ]
102 | },
103 | {
104 | "cell_type": "code",
105 | "execution_count": 6,
106 | "metadata": {},
107 | "outputs": [
108 | {
109 | "data": {
110 | "text/plain": [
111 | "True"
112 | ]
113 | },
114 | "execution_count": 6,
115 | "metadata": {},
116 | "output_type": "execute_result"
117 | }
118 | ],
119 | "source": [
120 | "2.0 == 2"
121 | ]
122 | },
123 | {
124 | "cell_type": "code",
125 | "execution_count": 7,
126 | "metadata": {},
127 | "outputs": [
128 | {
129 | "data": {
130 | "text/plain": [
131 | "False"
132 | ]
133 | },
134 | "execution_count": 7,
135 | "metadata": {},
136 | "output_type": "execute_result"
137 | }
138 | ],
139 | "source": [
140 | "3 != 3"
141 | ]
142 | },
143 | {
144 | "cell_type": "code",
145 | "execution_count": 8,
146 | "metadata": {},
147 | "outputs": [
148 | {
149 | "data": {
150 | "text/plain": [
151 | "False"
152 | ]
153 | },
154 | "execution_count": 8,
155 | "metadata": {},
156 | "output_type": "execute_result"
157 | }
158 | ],
159 | "source": [
160 | "1 > 2"
161 | ]
162 | },
163 | {
164 | "cell_type": "code",
165 | "execution_count": 9,
166 | "metadata": {},
167 | "outputs": [
168 | {
169 | "data": {
170 | "text/plain": [
171 | "True"
172 | ]
173 | },
174 | "execution_count": 9,
175 | "metadata": {},
176 | "output_type": "execute_result"
177 | }
178 | ],
179 | "source": [
180 | "2<= 2"
181 | ]
182 | },
183 | {
184 | "cell_type": "code",
185 | "execution_count": 10,
186 | "metadata": {},
187 | "outputs": [
188 | {
189 | "data": {
190 | "text/plain": [
191 | "True"
192 | ]
193 | },
194 | "execution_count": 10,
195 | "metadata": {},
196 | "output_type": "execute_result"
197 | }
198 | ],
199 | "source": [
200 | "2 <= 2"
201 | ]
202 | },
203 | {
204 | "cell_type": "markdown",
205 | "metadata": {},
206 | "source": [
207 | "## Chaining Comparison Operators"
208 | ]
209 | },
210 | {
211 | "cell_type": "code",
212 | "execution_count": 11,
213 | "metadata": {},
214 | "outputs": [
215 | {
216 | "data": {
217 | "text/plain": [
218 | "True"
219 | ]
220 | },
221 | "execution_count": 11,
222 | "metadata": {},
223 | "output_type": "execute_result"
224 | }
225 | ],
226 | "source": [
227 | "1 < 2"
228 | ]
229 | },
230 | {
231 | "cell_type": "code",
232 | "execution_count": 12,
233 | "metadata": {},
234 | "outputs": [
235 | {
236 | "data": {
237 | "text/plain": [
238 | "True"
239 | ]
240 | },
241 | "execution_count": 12,
242 | "metadata": {},
243 | "output_type": "execute_result"
244 | }
245 | ],
246 | "source": [
247 | "2 < 3"
248 | ]
249 | },
250 | {
251 | "cell_type": "code",
252 | "execution_count": 13,
253 | "metadata": {},
254 | "outputs": [
255 | {
256 | "data": {
257 | "text/plain": [
258 | "True"
259 | ]
260 | },
261 | "execution_count": 13,
262 | "metadata": {},
263 | "output_type": "execute_result"
264 | }
265 | ],
266 | "source": [
267 | "1 < 2 < 3"
268 | ]
269 | },
270 | {
271 | "cell_type": "code",
272 | "execution_count": 14,
273 | "metadata": {},
274 | "outputs": [
275 | {
276 | "data": {
277 | "text/plain": [
278 | "False"
279 | ]
280 | },
281 | "execution_count": 14,
282 | "metadata": {},
283 | "output_type": "execute_result"
284 | }
285 | ],
286 | "source": [
287 | "1 < 2 and 2 > 3"
288 | ]
289 | },
290 | {
291 | "cell_type": "code",
292 | "execution_count": 15,
293 | "metadata": {},
294 | "outputs": [
295 | {
296 | "data": {
297 | "text/plain": [
298 | "True"
299 | ]
300 | },
301 | "execution_count": 15,
302 | "metadata": {},
303 | "output_type": "execute_result"
304 | }
305 | ],
306 | "source": [
307 | "'h' == 'h' and 2 == 2"
308 | ]
309 | },
310 | {
311 | "cell_type": "code",
312 | "execution_count": 17,
313 | "metadata": {},
314 | "outputs": [
315 | {
316 | "data": {
317 | "text/plain": [
318 | "True"
319 | ]
320 | },
321 | "execution_count": 17,
322 | "metadata": {},
323 | "output_type": "execute_result"
324 | }
325 | ],
326 | "source": [
327 | "100 == 1 or 2 == 2"
328 | ]
329 | },
330 | {
331 | "cell_type": "code",
332 | "execution_count": 18,
333 | "metadata": {},
334 | "outputs": [
335 | {
336 | "data": {
337 | "text/plain": [
338 | "True"
339 | ]
340 | },
341 | "execution_count": 18,
342 | "metadata": {},
343 | "output_type": "execute_result"
344 | }
345 | ],
346 | "source": [
347 | "1 == 1"
348 | ]
349 | },
350 | {
351 | "cell_type": "code",
352 | "execution_count": 19,
353 | "metadata": {},
354 | "outputs": [
355 | {
356 | "data": {
357 | "text/plain": [
358 | "False"
359 | ]
360 | },
361 | "execution_count": 19,
362 | "metadata": {},
363 | "output_type": "execute_result"
364 | }
365 | ],
366 | "source": [
367 | "not(1==1)"
368 | ]
369 | },
370 | {
371 | "cell_type": "markdown",
372 | "metadata": {},
373 | "source": [
374 | "## If, elif, else Statements"
375 | ]
376 | },
377 | {
378 | "cell_type": "code",
379 | "execution_count": 25,
380 | "metadata": {},
381 | "outputs": [
382 | {
383 | "name": "stdout",
384 | "output_type": "stream",
385 | "text": [
386 | "Feed me\n"
387 | ]
388 | }
389 | ],
390 | "source": [
391 | "hungry = True\n",
392 | "\n",
393 | "if hungry:\n",
394 | " print('Feed me')\n",
395 | "else:\n",
396 | " print('im not hungry')"
397 | ]
398 | },
399 | {
400 | "cell_type": "code",
401 | "execution_count": 27,
402 | "metadata": {},
403 | "outputs": [
404 | {
405 | "name": "stdout",
406 | "output_type": "stream",
407 | "text": [
408 | "Cars are Cool!\n"
409 | ]
410 | }
411 | ],
412 | "source": [
413 | "loc = 'Auto Shop'\n",
414 | "\n",
415 | "if loc == 'Auto Shop':\n",
416 | " print('Cars are Cool!') \n",
417 | "elif loc == 'Bank':\n",
418 | " print('Welcome to the store!')\n",
419 | "else:\n",
420 | " print('I do not know much')"
421 | ]
422 | },
423 | {
424 | "cell_type": "code",
425 | "execution_count": 30,
426 | "metadata": {},
427 | "outputs": [
428 | {
429 | "name": "stdout",
430 | "output_type": "stream",
431 | "text": [
432 | "What is your name?\n"
433 | ]
434 | }
435 | ],
436 | "source": [
437 | "name = 'Jose'\n",
438 | "\n",
439 | "if name == 'Frankie':\n",
440 | " print('Hello Frankie')\n",
441 | "elif name == 'Sammy':\n",
442 | " print('Hello Sammy')\n",
443 | "else:\n",
444 | " print('What is your name?')"
445 | ]
446 | },
447 | {
448 | "cell_type": "markdown",
449 | "metadata": {},
450 | "source": [
451 | "## For Loops in Python"
452 | ]
453 | },
454 | {
455 | "cell_type": "code",
456 | "execution_count": 31,
457 | "metadata": {},
458 | "outputs": [
459 | {
460 | "name": "stdout",
461 | "output_type": "stream",
462 | "text": [
463 | "1\n",
464 | "2\n",
465 | "3\n",
466 | "4\n",
467 | "5\n",
468 | "6\n",
469 | "7\n",
470 | "8\n",
471 | "9\n",
472 | "10\n"
473 | ]
474 | }
475 | ],
476 | "source": [
477 | "mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
478 | "for num in mylist:\n",
479 | " print(num) # you can use any variable name, not just num"
480 | ]
481 | },
482 | {
483 | "cell_type": "code",
484 | "execution_count": null,
485 | "metadata": {},
486 | "outputs": [],
487 | "source": []
488 | }
489 | ],
490 | "metadata": {
491 | "kernelspec": {
492 | "display_name": "Python 3",
493 | "language": "python",
494 | "name": "python3"
495 | },
496 | "language_info": {
497 | "codemirror_mode": {
498 | "name": "ipython",
499 | "version": 3
500 | },
501 | "file_extension": ".py",
502 | "mimetype": "text/x-python",
503 | "name": "python",
504 | "nbconvert_exporter": "python",
505 | "pygments_lexer": "ipython3",
506 | "version": "3.7.3"
507 | }
508 | },
509 | "nbformat": 4,
510 | "nbformat_minor": 2
511 | }
512 |
--------------------------------------------------------------------------------
/7. Python Decorators & Generators.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 11,
6 | "metadata": {},
7 | "outputs": [],
8 | "source": [
9 | "def func():\n",
10 | " return 1"
11 | ]
12 | },
13 | {
14 | "cell_type": "code",
15 | "execution_count": 12,
16 | "metadata": {},
17 | "outputs": [
18 | {
19 | "data": {
20 | "text/plain": [
21 | "1"
22 | ]
23 | },
24 | "execution_count": 12,
25 | "metadata": {},
26 | "output_type": "execute_result"
27 | }
28 | ],
29 | "source": [
30 | "func()"
31 | ]
32 | },
33 | {
34 | "cell_type": "code",
35 | "execution_count": 13,
36 | "metadata": {},
37 | "outputs": [],
38 | "source": [
39 | "def hello():\n",
40 | " return 'Hello!'"
41 | ]
42 | },
43 | {
44 | "cell_type": "code",
45 | "execution_count": 14,
46 | "metadata": {},
47 | "outputs": [
48 | {
49 | "data": {
50 | "text/plain": [
51 | "'Hello!'"
52 | ]
53 | },
54 | "execution_count": 14,
55 | "metadata": {},
56 | "output_type": "execute_result"
57 | }
58 | ],
59 | "source": [
60 | "hello()"
61 | ]
62 | },
63 | {
64 | "cell_type": "code",
65 | "execution_count": 15,
66 | "metadata": {},
67 | "outputs": [],
68 | "source": [
69 | "greet = hello"
70 | ]
71 | },
72 | {
73 | "cell_type": "code",
74 | "execution_count": 16,
75 | "metadata": {},
76 | "outputs": [
77 | {
78 | "data": {
79 | "text/plain": [
80 | "'Hello!'"
81 | ]
82 | },
83 | "execution_count": 16,
84 | "metadata": {},
85 | "output_type": "execute_result"
86 | }
87 | ],
88 | "source": [
89 | "greet()"
90 | ]
91 | },
92 | {
93 | "cell_type": "code",
94 | "execution_count": 17,
95 | "metadata": {},
96 | "outputs": [],
97 | "source": [
98 | "del hello"
99 | ]
100 | },
101 | {
102 | "cell_type": "code",
103 | "execution_count": 18,
104 | "metadata": {},
105 | "outputs": [
106 | {
107 | "ename": "NameError",
108 | "evalue": "name 'hello' is not defined",
109 | "output_type": "error",
110 | "traceback": [
111 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
112 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
113 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mhello\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
114 | "\u001b[1;31mNameError\u001b[0m: name 'hello' is not defined"
115 | ]
116 | }
117 | ],
118 | "source": [
119 | "hello()"
120 | ]
121 | },
122 | {
123 | "cell_type": "code",
124 | "execution_count": null,
125 | "metadata": {},
126 | "outputs": [],
127 | "source": [
128 | "greet()"
129 | ]
130 | },
131 | {
132 | "cell_type": "code",
133 | "execution_count": null,
134 | "metadata": {},
135 | "outputs": [],
136 | "source": [
137 | "def hello(name='Jose'):\n",
138 | " print('The hello() function has been executed!')\n",
139 | " \n",
140 | " def greet():\n",
141 | " return '\\t This is the greet() func inside hello!'\n",
142 | " \n",
143 | " def welcome():\n",
144 | " return '\\t this is welcome() func inside hello!'\n",
145 | " \n",
146 | " print(\"I am going to return a function! !\")\n",
147 | " \n",
148 | " if name == 'Jose':\n",
149 | " return greet\n",
150 | " else:\n",
151 | " return welcome"
152 | ]
153 | },
154 | {
155 | "cell_type": "code",
156 | "execution_count": null,
157 | "metadata": {},
158 | "outputs": [],
159 | "source": [
160 | "my_new_func = hello('Jose')"
161 | ]
162 | },
163 | {
164 | "cell_type": "code",
165 | "execution_count": null,
166 | "metadata": {},
167 | "outputs": [],
168 | "source": [
169 | "print(my_new_func())"
170 | ]
171 | },
172 | {
173 | "cell_type": "code",
174 | "execution_count": null,
175 | "metadata": {},
176 | "outputs": [],
177 | "source": [
178 | "def cool():\n",
179 | " \n",
180 | " def super_cool():\n",
181 | " return 'I am very cool!'\n",
182 | " \n",
183 | " return super_cool"
184 | ]
185 | },
186 | {
187 | "cell_type": "code",
188 | "execution_count": null,
189 | "metadata": {},
190 | "outputs": [],
191 | "source": [
192 | "some_func = cool()"
193 | ]
194 | },
195 | {
196 | "cell_type": "code",
197 | "execution_count": null,
198 | "metadata": {},
199 | "outputs": [],
200 | "source": [
201 | "some_func"
202 | ]
203 | },
204 | {
205 | "cell_type": "code",
206 | "execution_count": null,
207 | "metadata": {},
208 | "outputs": [],
209 | "source": [
210 | "def hello():\n",
211 | " return 'Hi Jose!'"
212 | ]
213 | },
214 | {
215 | "cell_type": "code",
216 | "execution_count": null,
217 | "metadata": {},
218 | "outputs": [],
219 | "source": [
220 | "def other(some_def_func):\n",
221 | " print('Other code runs here!')\n",
222 | " print(some_def_func())"
223 | ]
224 | },
225 | {
226 | "cell_type": "code",
227 | "execution_count": null,
228 | "metadata": {},
229 | "outputs": [],
230 | "source": [
231 | "hello"
232 | ]
233 | },
234 | {
235 | "cell_type": "code",
236 | "execution_count": null,
237 | "metadata": {},
238 | "outputs": [],
239 | "source": [
240 | "hello()"
241 | ]
242 | },
243 | {
244 | "cell_type": "code",
245 | "execution_count": null,
246 | "metadata": {},
247 | "outputs": [],
248 | "source": [
249 | "other(hello)"
250 | ]
251 | },
252 | {
253 | "cell_type": "code",
254 | "execution_count": null,
255 | "metadata": {},
256 | "outputs": [],
257 | "source": [
258 | "def new_decorator(original_func):\n",
259 | " \n",
260 | " def wrap_func():\n",
261 | " \n",
262 | " print('Some extra code, before the original function')\n",
263 | " \n",
264 | " original_func()\n",
265 | " \n",
266 | " print('Some extra code, after the original function!')\n",
267 | " \n",
268 | " return wrap_func\n",
269 | " "
270 | ]
271 | },
272 | {
273 | "cell_type": "code",
274 | "execution_count": null,
275 | "metadata": {},
276 | "outputs": [],
277 | "source": [
278 | "def func_needs_decorator():\n",
279 | " print(\"I want to be decorated!\")"
280 | ]
281 | },
282 | {
283 | "cell_type": "code",
284 | "execution_count": null,
285 | "metadata": {},
286 | "outputs": [],
287 | "source": [
288 | "func_needs_decorator()"
289 | ]
290 | },
291 | {
292 | "cell_type": "code",
293 | "execution_count": null,
294 | "metadata": {},
295 | "outputs": [],
296 | "source": [
297 | "decorated_func = new_decorator(func_needs_decorator)"
298 | ]
299 | },
300 | {
301 | "cell_type": "code",
302 | "execution_count": null,
303 | "metadata": {},
304 | "outputs": [],
305 | "source": [
306 | "decorated_func()"
307 | ]
308 | },
309 | {
310 | "cell_type": "code",
311 | "execution_count": null,
312 | "metadata": {},
313 | "outputs": [],
314 | "source": [
315 | "@new_decorator\n",
316 | "def func_needs_decorator():\n",
317 | " print(\"I want to be decorated!\")"
318 | ]
319 | },
320 | {
321 | "cell_type": "code",
322 | "execution_count": null,
323 | "metadata": {},
324 | "outputs": [],
325 | "source": [
326 | "func_needs_decorator()"
327 | ]
328 | },
329 | {
330 | "cell_type": "code",
331 | "execution_count": null,
332 | "metadata": {},
333 | "outputs": [],
334 | "source": [
335 | "def create_cubes(n):\n",
336 | " result = []\n",
337 | " for x in range(n):\n",
338 | " result.append(x**3)\n",
339 | " return result"
340 | ]
341 | },
342 | {
343 | "cell_type": "code",
344 | "execution_count": 20,
345 | "metadata": {},
346 | "outputs": [
347 | {
348 | "data": {
349 | "text/plain": [
350 | "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]"
351 | ]
352 | },
353 | "execution_count": 20,
354 | "metadata": {},
355 | "output_type": "execute_result"
356 | }
357 | ],
358 | "source": [
359 | "list(create_cubes(10))"
360 | ]
361 | },
362 | {
363 | "cell_type": "code",
364 | "execution_count": 21,
365 | "metadata": {},
366 | "outputs": [],
367 | "source": [
368 | "def gen_fibon(n):\n",
369 | " a = 1\n",
370 | " b = 1\n",
371 | " for i in range(n):\n",
372 | " yield a\n",
373 | " a, b = b, a+b"
374 | ]
375 | },
376 | {
377 | "cell_type": "code",
378 | "execution_count": 22,
379 | "metadata": {},
380 | "outputs": [
381 | {
382 | "name": "stdout",
383 | "output_type": "stream",
384 | "text": [
385 | "1\n",
386 | "1\n",
387 | "2\n",
388 | "3\n",
389 | "5\n",
390 | "8\n",
391 | "13\n",
392 | "21\n",
393 | "34\n",
394 | "55\n"
395 | ]
396 | }
397 | ],
398 | "source": [
399 | "for number in gen_fibon(10):\n",
400 | " print(number)"
401 | ]
402 | },
403 | {
404 | "cell_type": "code",
405 | "execution_count": 23,
406 | "metadata": {},
407 | "outputs": [],
408 | "source": [
409 | "def simple_gen():\n",
410 | " for x in range(3):\n",
411 | " yield x"
412 | ]
413 | },
414 | {
415 | "cell_type": "code",
416 | "execution_count": 24,
417 | "metadata": {},
418 | "outputs": [
419 | {
420 | "name": "stdout",
421 | "output_type": "stream",
422 | "text": [
423 | "0\n",
424 | "1\n",
425 | "2\n"
426 | ]
427 | }
428 | ],
429 | "source": [
430 | "for number in simple_gen():\n",
431 | " print(number)"
432 | ]
433 | },
434 | {
435 | "cell_type": "code",
436 | "execution_count": 25,
437 | "metadata": {},
438 | "outputs": [],
439 | "source": [
440 | "g = simple_gen()"
441 | ]
442 | },
443 | {
444 | "cell_type": "code",
445 | "execution_count": 26,
446 | "metadata": {},
447 | "outputs": [
448 | {
449 | "data": {
450 | "text/plain": [
451 | ""
452 | ]
453 | },
454 | "execution_count": 26,
455 | "metadata": {},
456 | "output_type": "execute_result"
457 | }
458 | ],
459 | "source": [
460 | "g"
461 | ]
462 | },
463 | {
464 | "cell_type": "code",
465 | "execution_count": 27,
466 | "metadata": {},
467 | "outputs": [
468 | {
469 | "name": "stdout",
470 | "output_type": "stream",
471 | "text": [
472 | "0\n"
473 | ]
474 | }
475 | ],
476 | "source": [
477 | "print(next(g))"
478 | ]
479 | },
480 | {
481 | "cell_type": "code",
482 | "execution_count": 28,
483 | "metadata": {},
484 | "outputs": [
485 | {
486 | "name": "stdout",
487 | "output_type": "stream",
488 | "text": [
489 | "1\n"
490 | ]
491 | }
492 | ],
493 | "source": [
494 | "print(next(g))"
495 | ]
496 | },
497 | {
498 | "cell_type": "code",
499 | "execution_count": 29,
500 | "metadata": {},
501 | "outputs": [],
502 | "source": [
503 | "s = 'hello'"
504 | ]
505 | },
506 | {
507 | "cell_type": "code",
508 | "execution_count": 30,
509 | "metadata": {},
510 | "outputs": [
511 | {
512 | "name": "stdout",
513 | "output_type": "stream",
514 | "text": [
515 | "h\n",
516 | "e\n",
517 | "l\n",
518 | "l\n",
519 | "o\n"
520 | ]
521 | }
522 | ],
523 | "source": [
524 | "for letter in s:\n",
525 | " print(letter)"
526 | ]
527 | },
528 | {
529 | "cell_type": "code",
530 | "execution_count": 31,
531 | "metadata": {},
532 | "outputs": [],
533 | "source": [
534 | "s_iter = iter(s)"
535 | ]
536 | },
537 | {
538 | "cell_type": "code",
539 | "execution_count": 32,
540 | "metadata": {},
541 | "outputs": [
542 | {
543 | "data": {
544 | "text/plain": [
545 | "'h'"
546 | ]
547 | },
548 | "execution_count": 32,
549 | "metadata": {},
550 | "output_type": "execute_result"
551 | }
552 | ],
553 | "source": [
554 | "next(s_iter)"
555 | ]
556 | },
557 | {
558 | "cell_type": "code",
559 | "execution_count": 33,
560 | "metadata": {},
561 | "outputs": [
562 | {
563 | "data": {
564 | "text/plain": [
565 | "'e'"
566 | ]
567 | },
568 | "execution_count": 33,
569 | "metadata": {},
570 | "output_type": "execute_result"
571 | }
572 | ],
573 | "source": [
574 | "next(s_iter)"
575 | ]
576 | },
577 | {
578 | "cell_type": "code",
579 | "execution_count": null,
580 | "metadata": {},
581 | "outputs": [],
582 | "source": []
583 | },
584 | {
585 | "cell_type": "code",
586 | "execution_count": null,
587 | "metadata": {},
588 | "outputs": [],
589 | "source": []
590 | }
591 | ],
592 | "metadata": {
593 | "kernelspec": {
594 | "display_name": "Python 3",
595 | "language": "python",
596 | "name": "python3"
597 | },
598 | "language_info": {
599 | "codemirror_mode": {
600 | "name": "ipython",
601 | "version": 3
602 | },
603 | "file_extension": ".py",
604 | "mimetype": "text/x-python",
605 | "name": "python",
606 | "nbconvert_exporter": "python",
607 | "pygments_lexer": "ipython3",
608 | "version": "3.7.3"
609 | }
610 | },
611 | "nbformat": 4,
612 | "nbformat_minor": 2
613 | }
614 |
--------------------------------------------------------------------------------
/5. Object Oriented Programming.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "#### Attributes and Class Keyword"
8 | ]
9 | },
10 | {
11 | "cell_type": "code",
12 | "execution_count": 1,
13 | "metadata": {},
14 | "outputs": [],
15 | "source": [
16 | "mylist = [1,2,3]"
17 | ]
18 | },
19 | {
20 | "cell_type": "code",
21 | "execution_count": 2,
22 | "metadata": {},
23 | "outputs": [],
24 | "source": [
25 | "myset = set()"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": 3,
31 | "metadata": {},
32 | "outputs": [
33 | {
34 | "data": {
35 | "text/plain": [
36 | "set"
37 | ]
38 | },
39 | "execution_count": 3,
40 | "metadata": {},
41 | "output_type": "execute_result"
42 | }
43 | ],
44 | "source": [
45 | "type(myset)"
46 | ]
47 | },
48 | {
49 | "cell_type": "code",
50 | "execution_count": 4,
51 | "metadata": {},
52 | "outputs": [
53 | {
54 | "data": {
55 | "text/plain": [
56 | "list"
57 | ]
58 | },
59 | "execution_count": 4,
60 | "metadata": {},
61 | "output_type": "execute_result"
62 | }
63 | ],
64 | "source": [
65 | "type(mylist)"
66 | ]
67 | },
68 | {
69 | "cell_type": "code",
70 | "execution_count": 5,
71 | "metadata": {},
72 | "outputs": [],
73 | "source": [
74 | "class Sample():\n",
75 | " pass"
76 | ]
77 | },
78 | {
79 | "cell_type": "code",
80 | "execution_count": 6,
81 | "metadata": {},
82 | "outputs": [],
83 | "source": [
84 | "my_sample = Sample()"
85 | ]
86 | },
87 | {
88 | "cell_type": "code",
89 | "execution_count": 7,
90 | "metadata": {},
91 | "outputs": [
92 | {
93 | "data": {
94 | "text/plain": [
95 | "__main__.Sample"
96 | ]
97 | },
98 | "execution_count": 7,
99 | "metadata": {},
100 | "output_type": "execute_result"
101 | }
102 | ],
103 | "source": [
104 | "type(my_sample)"
105 | ]
106 | },
107 | {
108 | "cell_type": "code",
109 | "execution_count": 10,
110 | "metadata": {},
111 | "outputs": [],
112 | "source": [
113 | "class Dog():\n",
114 | " \n",
115 | " def __init__(self, breed):\n",
116 | " \n",
117 | " self.breed = breed"
118 | ]
119 | },
120 | {
121 | "cell_type": "code",
122 | "execution_count": 11,
123 | "metadata": {},
124 | "outputs": [],
125 | "source": [
126 | "my_dog = Dog(breed='Lab')"
127 | ]
128 | },
129 | {
130 | "cell_type": "code",
131 | "execution_count": 12,
132 | "metadata": {},
133 | "outputs": [
134 | {
135 | "data": {
136 | "text/plain": [
137 | "__main__.Dog"
138 | ]
139 | },
140 | "execution_count": 12,
141 | "metadata": {},
142 | "output_type": "execute_result"
143 | }
144 | ],
145 | "source": [
146 | "type(my_dog)"
147 | ]
148 | },
149 | {
150 | "cell_type": "code",
151 | "execution_count": null,
152 | "metadata": {},
153 | "outputs": [],
154 | "source": [
155 | "my_dog.breed"
156 | ]
157 | },
158 | {
159 | "cell_type": "code",
160 | "execution_count": 17,
161 | "metadata": {},
162 | "outputs": [],
163 | "source": [
164 | "class Dog():\n",
165 | " \n",
166 | " def __init__(self, mybreed):\n",
167 | " \n",
168 | " # Attributes\n",
169 | " # We take in the argument\n",
170 | " # We assign it using self.attribute_name\n",
171 | " self.my_attribute = mybreed"
172 | ]
173 | },
174 | {
175 | "cell_type": "code",
176 | "execution_count": 18,
177 | "metadata": {},
178 | "outputs": [],
179 | "source": [
180 | "my_dog = Dog(mybreed ='Huskie')"
181 | ]
182 | },
183 | {
184 | "cell_type": "code",
185 | "execution_count": 19,
186 | "metadata": {},
187 | "outputs": [
188 | {
189 | "data": {
190 | "text/plain": [
191 | "__main__.Dog"
192 | ]
193 | },
194 | "execution_count": 19,
195 | "metadata": {},
196 | "output_type": "execute_result"
197 | }
198 | ],
199 | "source": [
200 | "type(my_dog)"
201 | ]
202 | },
203 | {
204 | "cell_type": "code",
205 | "execution_count": 21,
206 | "metadata": {},
207 | "outputs": [
208 | {
209 | "data": {
210 | "text/plain": [
211 | "'Huskie'"
212 | ]
213 | },
214 | "execution_count": 21,
215 | "metadata": {},
216 | "output_type": "execute_result"
217 | }
218 | ],
219 | "source": [
220 | "my_dog.my_attribute"
221 | ]
222 | },
223 | {
224 | "cell_type": "code",
225 | "execution_count": 24,
226 | "metadata": {},
227 | "outputs": [],
228 | "source": [
229 | "class Dog():\n",
230 | " \n",
231 | " def __init__(self, breed, name, spots):\n",
232 | " \n",
233 | " # Attributes\n",
234 | " # We take in the argument\n",
235 | " # We assign it using self.attribute_name\n",
236 | " self.breed = breed\n",
237 | " self.name = name\n",
238 | " \n",
239 | " # Expects boolean True/False\n",
240 | " self.spots = spots"
241 | ]
242 | },
243 | {
244 | "cell_type": "code",
245 | "execution_count": 25,
246 | "metadata": {},
247 | "outputs": [],
248 | "source": [
249 | "my_dog = Dog(breed = 'Chihuahua', name = 'Bonnie', spots = True)"
250 | ]
251 | },
252 | {
253 | "cell_type": "code",
254 | "execution_count": 26,
255 | "metadata": {},
256 | "outputs": [
257 | {
258 | "data": {
259 | "text/plain": [
260 | "__main__.Dog"
261 | ]
262 | },
263 | "execution_count": 26,
264 | "metadata": {},
265 | "output_type": "execute_result"
266 | }
267 | ],
268 | "source": [
269 | "type(my_dog)"
270 | ]
271 | },
272 | {
273 | "cell_type": "code",
274 | "execution_count": 27,
275 | "metadata": {},
276 | "outputs": [
277 | {
278 | "data": {
279 | "text/plain": [
280 | "'Chihuahua'"
281 | ]
282 | },
283 | "execution_count": 27,
284 | "metadata": {},
285 | "output_type": "execute_result"
286 | }
287 | ],
288 | "source": [
289 | "my_dog.breed"
290 | ]
291 | },
292 | {
293 | "cell_type": "code",
294 | "execution_count": 28,
295 | "metadata": {},
296 | "outputs": [
297 | {
298 | "data": {
299 | "text/plain": [
300 | "'Bonnie'"
301 | ]
302 | },
303 | "execution_count": 28,
304 | "metadata": {},
305 | "output_type": "execute_result"
306 | }
307 | ],
308 | "source": [
309 | "my_dog.name"
310 | ]
311 | },
312 | {
313 | "cell_type": "code",
314 | "execution_count": 29,
315 | "metadata": {},
316 | "outputs": [
317 | {
318 | "data": {
319 | "text/plain": [
320 | "True"
321 | ]
322 | },
323 | "execution_count": 29,
324 | "metadata": {},
325 | "output_type": "execute_result"
326 | }
327 | ],
328 | "source": [
329 | "my_dog.spots"
330 | ]
331 | },
332 | {
333 | "cell_type": "markdown",
334 | "metadata": {},
335 | "source": [
336 | "#### Class Object Attributes and Methods "
337 | ]
338 | },
339 | {
340 | "cell_type": "code",
341 | "execution_count": 33,
342 | "metadata": {},
343 | "outputs": [],
344 | "source": [
345 | "class Dog():\n",
346 | " \n",
347 | " # Class object attribute\n",
348 | " # Same for any instance of a class\n",
349 | " species = 'Mammal'\n",
350 | " \n",
351 | " def __init__(self, breed, name, spots):\n",
352 | " \n",
353 | " # Attributes\n",
354 | " # We take in the argument\n",
355 | " # We assign it using self.attribute_name\n",
356 | " self.breed = breed\n",
357 | " self.name = name\n",
358 | " \n",
359 | " # Expects boolean True/False\n",
360 | " self.spots = spots"
361 | ]
362 | },
363 | {
364 | "cell_type": "code",
365 | "execution_count": 36,
366 | "metadata": {},
367 | "outputs": [],
368 | "source": [
369 | "my_dog = Dog(breed = 'Lab', name = 'Haus', spots = False)"
370 | ]
371 | },
372 | {
373 | "cell_type": "code",
374 | "execution_count": 35,
375 | "metadata": {},
376 | "outputs": [
377 | {
378 | "data": {
379 | "text/plain": [
380 | "__main__.Dog"
381 | ]
382 | },
383 | "execution_count": 35,
384 | "metadata": {},
385 | "output_type": "execute_result"
386 | }
387 | ],
388 | "source": [
389 | "type(my_dog)"
390 | ]
391 | },
392 | {
393 | "cell_type": "code",
394 | "execution_count": 37,
395 | "metadata": {},
396 | "outputs": [
397 | {
398 | "data": {
399 | "text/plain": [
400 | "'Mammal'"
401 | ]
402 | },
403 | "execution_count": 37,
404 | "metadata": {},
405 | "output_type": "execute_result"
406 | }
407 | ],
408 | "source": [
409 | "my_dog.species"
410 | ]
411 | },
412 | {
413 | "cell_type": "code",
414 | "execution_count": 38,
415 | "metadata": {},
416 | "outputs": [
417 | {
418 | "data": {
419 | "text/plain": [
420 | "'Lab'"
421 | ]
422 | },
423 | "execution_count": 38,
424 | "metadata": {},
425 | "output_type": "execute_result"
426 | }
427 | ],
428 | "source": [
429 | "my_dog.breed"
430 | ]
431 | },
432 | {
433 | "cell_type": "code",
434 | "execution_count": 39,
435 | "metadata": {},
436 | "outputs": [
437 | {
438 | "data": {
439 | "text/plain": [
440 | "'Haus'"
441 | ]
442 | },
443 | "execution_count": 39,
444 | "metadata": {},
445 | "output_type": "execute_result"
446 | }
447 | ],
448 | "source": [
449 | "my_dog.name"
450 | ]
451 | },
452 | {
453 | "cell_type": "code",
454 | "execution_count": 55,
455 | "metadata": {},
456 | "outputs": [],
457 | "source": [
458 | "class Dog():\n",
459 | " \n",
460 | " # Class object attribute\n",
461 | " # Same for any instance of a class\n",
462 | " species = 'Mammal'\n",
463 | " \n",
464 | " def __init__(self, breed, name):\n",
465 | " \n",
466 | " # Attributes\n",
467 | " # We take in the argument\n",
468 | " # We assign it using self.attribute_name\n",
469 | " self.breed = breed\n",
470 | " self.name = name\n",
471 | " \n",
472 | " # Operations/Actions ----> Methods\n",
473 | " def bark(self, number):\n",
474 | " print('WOOF! My name is {} and the number is {}'.format(self.name, number))"
475 | ]
476 | },
477 | {
478 | "cell_type": "code",
479 | "execution_count": 56,
480 | "metadata": {},
481 | "outputs": [],
482 | "source": [
483 | "my_dog = Dog('Lab', 'Frankie')"
484 | ]
485 | },
486 | {
487 | "cell_type": "code",
488 | "execution_count": 57,
489 | "metadata": {},
490 | "outputs": [
491 | {
492 | "data": {
493 | "text/plain": [
494 | "__main__.Dog"
495 | ]
496 | },
497 | "execution_count": 57,
498 | "metadata": {},
499 | "output_type": "execute_result"
500 | }
501 | ],
502 | "source": [
503 | "type(my_dog)"
504 | ]
505 | },
506 | {
507 | "cell_type": "code",
508 | "execution_count": 58,
509 | "metadata": {},
510 | "outputs": [
511 | {
512 | "data": {
513 | "text/plain": [
514 | "'Mammal'"
515 | ]
516 | },
517 | "execution_count": 58,
518 | "metadata": {},
519 | "output_type": "execute_result"
520 | }
521 | ],
522 | "source": [
523 | "my_dog.species"
524 | ]
525 | },
526 | {
527 | "cell_type": "code",
528 | "execution_count": 59,
529 | "metadata": {},
530 | "outputs": [
531 | {
532 | "data": {
533 | "text/plain": [
534 | "'Frankie'"
535 | ]
536 | },
537 | "execution_count": 59,
538 | "metadata": {},
539 | "output_type": "execute_result"
540 | }
541 | ],
542 | "source": [
543 | "my_dog.name"
544 | ]
545 | },
546 | {
547 | "cell_type": "code",
548 | "execution_count": 62,
549 | "metadata": {},
550 | "outputs": [
551 | {
552 | "name": "stdout",
553 | "output_type": "stream",
554 | "text": [
555 | "WOOF! My name is Frankie and the number is 10\n"
556 | ]
557 | }
558 | ],
559 | "source": [
560 | "my_dog.bark(10)"
561 | ]
562 | },
563 | {
564 | "cell_type": "code",
565 | "execution_count": 72,
566 | "metadata": {},
567 | "outputs": [],
568 | "source": [
569 | "class Circle():\n",
570 | " \n",
571 | " # CLASS OBJECT ATTRIBUTE\n",
572 | " pi = 3.14\n",
573 | " \n",
574 | " def __init__(self, radius=1):\n",
575 | " \n",
576 | " self.radius = radius\n",
577 | " self.area = radius*radius*self.pi\n",
578 | " \n",
579 | " # METHOD\n",
580 | " def get_circumference(self):\n",
581 | " return self.radius * self.pi * 2"
582 | ]
583 | },
584 | {
585 | "cell_type": "code",
586 | "execution_count": 73,
587 | "metadata": {},
588 | "outputs": [],
589 | "source": [
590 | "my_circle = Circle(30)"
591 | ]
592 | },
593 | {
594 | "cell_type": "code",
595 | "execution_count": 74,
596 | "metadata": {},
597 | "outputs": [
598 | {
599 | "data": {
600 | "text/plain": [
601 | "3.14"
602 | ]
603 | },
604 | "execution_count": 74,
605 | "metadata": {},
606 | "output_type": "execute_result"
607 | }
608 | ],
609 | "source": [
610 | "my_circle.pi"
611 | ]
612 | },
613 | {
614 | "cell_type": "code",
615 | "execution_count": 75,
616 | "metadata": {},
617 | "outputs": [
618 | {
619 | "data": {
620 | "text/plain": [
621 | "30"
622 | ]
623 | },
624 | "execution_count": 75,
625 | "metadata": {},
626 | "output_type": "execute_result"
627 | }
628 | ],
629 | "source": [
630 | "my_circle.radius"
631 | ]
632 | },
633 | {
634 | "cell_type": "code",
635 | "execution_count": 76,
636 | "metadata": {},
637 | "outputs": [
638 | {
639 | "data": {
640 | "text/plain": [
641 | "2826.0"
642 | ]
643 | },
644 | "execution_count": 76,
645 | "metadata": {},
646 | "output_type": "execute_result"
647 | }
648 | ],
649 | "source": [
650 | "my_circle.area"
651 | ]
652 | },
653 | {
654 | "cell_type": "code",
655 | "execution_count": 71,
656 | "metadata": {},
657 | "outputs": [
658 | {
659 | "data": {
660 | "text/plain": [
661 | "188.4"
662 | ]
663 | },
664 | "execution_count": 71,
665 | "metadata": {},
666 | "output_type": "execute_result"
667 | }
668 | ],
669 | "source": [
670 | "my_circle.get_circumference()"
671 | ]
672 | },
673 | {
674 | "cell_type": "markdown",
675 | "metadata": {},
676 | "source": [
677 | "#### Inheritance"
678 | ]
679 | },
680 | {
681 | "cell_type": "code",
682 | "execution_count": 39,
683 | "metadata": {},
684 | "outputs": [],
685 | "source": [
686 | "class Animal():\n",
687 | " \n",
688 | " def __init__(self):\n",
689 | " print('ANIMAL CREATED')\n",
690 | " \n",
691 | " def who_am_i(self):\n",
692 | " print('I am an animal')\n",
693 | " def eat(self):\n",
694 | " print('I am eating')"
695 | ]
696 | },
697 | {
698 | "cell_type": "code",
699 | "execution_count": 40,
700 | "metadata": {},
701 | "outputs": [
702 | {
703 | "name": "stdout",
704 | "output_type": "stream",
705 | "text": [
706 | "ANIMAL CREATED\n"
707 | ]
708 | }
709 | ],
710 | "source": [
711 | "myanimal = Animal()"
712 | ]
713 | },
714 | {
715 | "cell_type": "code",
716 | "execution_count": 41,
717 | "metadata": {},
718 | "outputs": [
719 | {
720 | "name": "stdout",
721 | "output_type": "stream",
722 | "text": [
723 | "I am eating\n"
724 | ]
725 | }
726 | ],
727 | "source": [
728 | "myanimal.eat()"
729 | ]
730 | },
731 | {
732 | "cell_type": "code",
733 | "execution_count": 42,
734 | "metadata": {},
735 | "outputs": [
736 | {
737 | "name": "stdout",
738 | "output_type": "stream",
739 | "text": [
740 | "I am an animal\n"
741 | ]
742 | }
743 | ],
744 | "source": [
745 | "myanimal.who_am_i()"
746 | ]
747 | },
748 | {
749 | "cell_type": "code",
750 | "execution_count": 43,
751 | "metadata": {},
752 | "outputs": [],
753 | "source": [
754 | "class Dog(Animal):\n",
755 | " \n",
756 | " def __init__(self):\n",
757 | " Animal.__init__(self)\n",
758 | " print('Dog Created')\n",
759 | " \n",
760 | " def eat(self):\n",
761 | " print('I am a dog and eating')\n",
762 | " \n",
763 | " def bark(self):\n",
764 | " print('WOOF')"
765 | ]
766 | },
767 | {
768 | "cell_type": "code",
769 | "execution_count": 44,
770 | "metadata": {},
771 | "outputs": [
772 | {
773 | "name": "stdout",
774 | "output_type": "stream",
775 | "text": [
776 | "ANIMAL CREATED\n",
777 | "Dog Created\n"
778 | ]
779 | }
780 | ],
781 | "source": [
782 | "mydog = Dog()"
783 | ]
784 | },
785 | {
786 | "cell_type": "code",
787 | "execution_count": 46,
788 | "metadata": {},
789 | "outputs": [
790 | {
791 | "name": "stdout",
792 | "output_type": "stream",
793 | "text": [
794 | "I am a dog and eating\n"
795 | ]
796 | }
797 | ],
798 | "source": [
799 | "mydog.eat()"
800 | ]
801 | },
802 | {
803 | "cell_type": "code",
804 | "execution_count": 47,
805 | "metadata": {},
806 | "outputs": [
807 | {
808 | "name": "stdout",
809 | "output_type": "stream",
810 | "text": [
811 | "I am an animal\n"
812 | ]
813 | }
814 | ],
815 | "source": [
816 | "mydog.who_am_i()"
817 | ]
818 | },
819 | {
820 | "cell_type": "code",
821 | "execution_count": 48,
822 | "metadata": {},
823 | "outputs": [
824 | {
825 | "name": "stdout",
826 | "output_type": "stream",
827 | "text": [
828 | "WOOF\n"
829 | ]
830 | }
831 | ],
832 | "source": [
833 | "mydog.bark()"
834 | ]
835 | },
836 | {
837 | "cell_type": "markdown",
838 | "metadata": {},
839 | "source": [
840 | "#### Special (Magic/Dunder) Methods"
841 | ]
842 | },
843 | {
844 | "cell_type": "code",
845 | "execution_count": 57,
846 | "metadata": {},
847 | "outputs": [],
848 | "source": [
849 | "class Book():\n",
850 | " \n",
851 | " def __init__(self, title, author, pages):\n",
852 | " \n",
853 | " self.title = title\n",
854 | " self.author = author\n",
855 | " self.pages = pages\n",
856 | " \n",
857 | " def __str__(self):\n",
858 | " return f\"{self.title} by {self.author}\"\n",
859 | " \n",
860 | " def __len__(self):\n",
861 | " return self.pages\n",
862 | " \n",
863 | " def __del__(self):\n",
864 | " print('A book object has been deleted')"
865 | ]
866 | },
867 | {
868 | "cell_type": "code",
869 | "execution_count": 58,
870 | "metadata": {},
871 | "outputs": [],
872 | "source": [
873 | "b = Book('Python rocks', 'Jose', 200)"
874 | ]
875 | },
876 | {
877 | "cell_type": "code",
878 | "execution_count": 59,
879 | "metadata": {},
880 | "outputs": [
881 | {
882 | "name": "stdout",
883 | "output_type": "stream",
884 | "text": [
885 | "Python rocks by Jose\n"
886 | ]
887 | }
888 | ],
889 | "source": [
890 | "print(b)"
891 | ]
892 | },
893 | {
894 | "cell_type": "code",
895 | "execution_count": 60,
896 | "metadata": {},
897 | "outputs": [
898 | {
899 | "data": {
900 | "text/plain": [
901 | "200"
902 | ]
903 | },
904 | "execution_count": 60,
905 | "metadata": {},
906 | "output_type": "execute_result"
907 | }
908 | ],
909 | "source": [
910 | "len(b)"
911 | ]
912 | },
913 | {
914 | "cell_type": "code",
915 | "execution_count": 61,
916 | "metadata": {},
917 | "outputs": [
918 | {
919 | "name": "stdout",
920 | "output_type": "stream",
921 | "text": [
922 | "A book object has been deleted\n"
923 | ]
924 | }
925 | ],
926 | "source": [
927 | "del b"
928 | ]
929 | },
930 | {
931 | "cell_type": "code",
932 | "execution_count": 62,
933 | "metadata": {},
934 | "outputs": [
935 | {
936 | "ename": "NameError",
937 | "evalue": "name 'b' is not defined",
938 | "output_type": "error",
939 | "traceback": [
940 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
941 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
942 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mb\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
943 | "\u001b[1;31mNameError\u001b[0m: name 'b' is not defined"
944 | ]
945 | }
946 | ],
947 | "source": [
948 | "b"
949 | ]
950 | }
951 | ],
952 | "metadata": {
953 | "kernelspec": {
954 | "display_name": "Python 3",
955 | "language": "python",
956 | "name": "python3"
957 | },
958 | "language_info": {
959 | "codemirror_mode": {
960 | "name": "ipython",
961 | "version": 3
962 | },
963 | "file_extension": ".py",
964 | "mimetype": "text/x-python",
965 | "name": "python",
966 | "nbconvert_exporter": "python",
967 | "pygments_lexer": "ipython3",
968 | "version": "3.7.3"
969 | }
970 | },
971 | "nbformat": 4,
972 | "nbformat_minor": 2
973 | }
974 |
--------------------------------------------------------------------------------
/3. Python Statements.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {},
7 | "outputs": [],
8 | "source": [
9 | "mylist = [1,2,3,4,5,6,7,8,9,10]"
10 | ]
11 | },
12 | {
13 | "cell_type": "code",
14 | "execution_count": 2,
15 | "metadata": {},
16 | "outputs": [
17 | {
18 | "name": "stdout",
19 | "output_type": "stream",
20 | "text": [
21 | "hello\n",
22 | "hello\n",
23 | "hello\n",
24 | "hello\n",
25 | "hello\n",
26 | "hello\n",
27 | "hello\n",
28 | "hello\n",
29 | "hello\n",
30 | "hello\n"
31 | ]
32 | }
33 | ],
34 | "source": [
35 | "for num in mylist:\n",
36 | " print('hello')"
37 | ]
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": 4,
42 | "metadata": {},
43 | "outputs": [
44 | {
45 | "name": "stdout",
46 | "output_type": "stream",
47 | "text": [
48 | "Odd Number:1\n",
49 | "2\n",
50 | "Odd Number:3\n",
51 | "4\n",
52 | "Odd Number:5\n",
53 | "6\n",
54 | "Odd Number:7\n",
55 | "8\n",
56 | "Odd Number:9\n",
57 | "10\n"
58 | ]
59 | }
60 | ],
61 | "source": [
62 | "for num in mylist:\n",
63 | " #check for even\n",
64 | " if num % 2 == 0:\n",
65 | " print(num)\n",
66 | " else:\n",
67 | " print(f'Odd Number:{num}')"
68 | ]
69 | },
70 | {
71 | "cell_type": "code",
72 | "execution_count": 5,
73 | "metadata": {},
74 | "outputs": [
75 | {
76 | "name": "stdout",
77 | "output_type": "stream",
78 | "text": [
79 | "55\n"
80 | ]
81 | }
82 | ],
83 | "source": [
84 | "list_sum = 0\n",
85 | "\n",
86 | "for num in mylist:\n",
87 | " list_sum = list_sum + num\n",
88 | "\n",
89 | "print(list_sum)"
90 | ]
91 | },
92 | {
93 | "cell_type": "code",
94 | "execution_count": 6,
95 | "metadata": {},
96 | "outputs": [
97 | {
98 | "name": "stdout",
99 | "output_type": "stream",
100 | "text": [
101 | "H\n",
102 | "e\n",
103 | "l\n",
104 | "l\n",
105 | "o\n",
106 | " \n",
107 | "W\n",
108 | "o\n",
109 | "r\n",
110 | "l\n",
111 | "d\n"
112 | ]
113 | }
114 | ],
115 | "source": [
116 | "mystring = 'Hello World'\n",
117 | "\n",
118 | "for letter in mystring:\n",
119 | " print(letter)"
120 | ]
121 | },
122 | {
123 | "cell_type": "code",
124 | "execution_count": 7,
125 | "metadata": {},
126 | "outputs": [
127 | {
128 | "name": "stdout",
129 | "output_type": "stream",
130 | "text": [
131 | "1\n",
132 | "2\n",
133 | "3\n"
134 | ]
135 | }
136 | ],
137 | "source": [
138 | "tup = (1,2,3)\n",
139 | "\n",
140 | "for item in tup:\n",
141 | " print(item)"
142 | ]
143 | },
144 | {
145 | "cell_type": "code",
146 | "execution_count": 8,
147 | "metadata": {},
148 | "outputs": [],
149 | "source": [
150 | "mylist = [(1,2), (3,4), (5,6), (7,8)]"
151 | ]
152 | },
153 | {
154 | "cell_type": "code",
155 | "execution_count": 9,
156 | "metadata": {},
157 | "outputs": [
158 | {
159 | "data": {
160 | "text/plain": [
161 | "4"
162 | ]
163 | },
164 | "execution_count": 9,
165 | "metadata": {},
166 | "output_type": "execute_result"
167 | }
168 | ],
169 | "source": [
170 | "len(mylist)"
171 | ]
172 | },
173 | {
174 | "cell_type": "code",
175 | "execution_count": 10,
176 | "metadata": {},
177 | "outputs": [
178 | {
179 | "name": "stdout",
180 | "output_type": "stream",
181 | "text": [
182 | "(1, 2)\n",
183 | "(3, 4)\n",
184 | "(5, 6)\n",
185 | "(7, 8)\n"
186 | ]
187 | }
188 | ],
189 | "source": [
190 | "for item in mylist:\n",
191 | " print(item)"
192 | ]
193 | },
194 | {
195 | "cell_type": "code",
196 | "execution_count": 11,
197 | "metadata": {},
198 | "outputs": [
199 | {
200 | "name": "stdout",
201 | "output_type": "stream",
202 | "text": [
203 | "1\n",
204 | "3\n",
205 | "5\n",
206 | "7\n"
207 | ]
208 | }
209 | ],
210 | "source": [
211 | "for a, b in mylist:\n",
212 | " print(a)"
213 | ]
214 | },
215 | {
216 | "cell_type": "code",
217 | "execution_count": 14,
218 | "metadata": {},
219 | "outputs": [
220 | {
221 | "name": "stdout",
222 | "output_type": "stream",
223 | "text": [
224 | "3\n",
225 | "6\n",
226 | "9\n"
227 | ]
228 | }
229 | ],
230 | "source": [
231 | "mylist = [(1,2,3), (4,5,6), (7,8,9)]\n",
232 | "\n",
233 | "for a, b, c in mylist:\n",
234 | " print(c)"
235 | ]
236 | },
237 | {
238 | "cell_type": "code",
239 | "execution_count": 15,
240 | "metadata": {},
241 | "outputs": [
242 | {
243 | "name": "stdout",
244 | "output_type": "stream",
245 | "text": [
246 | "k1\n",
247 | "k2\n",
248 | "k3\n"
249 | ]
250 | }
251 | ],
252 | "source": [
253 | "d = {'k1': 1, 'k2': 2, 'k3': 3}\n",
254 | "\n",
255 | "for item in d:\n",
256 | " print(item)"
257 | ]
258 | },
259 | {
260 | "cell_type": "code",
261 | "execution_count": 16,
262 | "metadata": {},
263 | "outputs": [
264 | {
265 | "name": "stdout",
266 | "output_type": "stream",
267 | "text": [
268 | "4\n",
269 | "5\n",
270 | "6\n"
271 | ]
272 | }
273 | ],
274 | "source": [
275 | "d = {'k4': 4, 'k5' : 5, 'k6' : 6}\n",
276 | "\n",
277 | "for key, value in d.items():\n",
278 | " print(value)"
279 | ]
280 | },
281 | {
282 | "cell_type": "markdown",
283 | "metadata": {},
284 | "source": [
285 | "## While Loops in Python"
286 | ]
287 | },
288 | {
289 | "cell_type": "code",
290 | "execution_count": 18,
291 | "metadata": {},
292 | "outputs": [
293 | {
294 | "name": "stdout",
295 | "output_type": "stream",
296 | "text": [
297 | "The current value of x is 0\n",
298 | "The current value of x is 2\n",
299 | "The current value of x is 4\n",
300 | "X is not less than 5\n"
301 | ]
302 | }
303 | ],
304 | "source": [
305 | "x = 0\n",
306 | "\n",
307 | "while x < 5:\n",
308 | " print(f'The current value of x is {x}')\n",
309 | " x = x + 1\n",
310 | " x += 1\n",
311 | "else:\n",
312 | " print(\"X is not less than 5\")"
313 | ]
314 | },
315 | {
316 | "cell_type": "code",
317 | "execution_count": 19,
318 | "metadata": {},
319 | "outputs": [
320 | {
321 | "name": "stdout",
322 | "output_type": "stream",
323 | "text": [
324 | "End of my script\n"
325 | ]
326 | }
327 | ],
328 | "source": [
329 | "x = [1,2,3]\n",
330 | "\n",
331 | "for item in x:\n",
332 | " pass\n",
333 | "print('End of my script')"
334 | ]
335 | },
336 | {
337 | "cell_type": "code",
338 | "execution_count": 20,
339 | "metadata": {},
340 | "outputs": [],
341 | "source": [
342 | "mystring = 'Sammy'"
343 | ]
344 | },
345 | {
346 | "cell_type": "code",
347 | "execution_count": 23,
348 | "metadata": {},
349 | "outputs": [
350 | {
351 | "name": "stdout",
352 | "output_type": "stream",
353 | "text": [
354 | "S\n",
355 | "m\n",
356 | "m\n",
357 | "y\n"
358 | ]
359 | }
360 | ],
361 | "source": [
362 | "for letter in mystring:\n",
363 | " if letter == 'a':\n",
364 | " continue\n",
365 | " \n",
366 | " print(letter)"
367 | ]
368 | },
369 | {
370 | "cell_type": "code",
371 | "execution_count": 24,
372 | "metadata": {},
373 | "outputs": [
374 | {
375 | "name": "stdout",
376 | "output_type": "stream",
377 | "text": [
378 | "S\n"
379 | ]
380 | }
381 | ],
382 | "source": [
383 | "for letter in mystring:\n",
384 | " if letter == 'a':\n",
385 | " break\n",
386 | " print(letter)"
387 | ]
388 | },
389 | {
390 | "cell_type": "code",
391 | "execution_count": 26,
392 | "metadata": {},
393 | "outputs": [
394 | {
395 | "name": "stdout",
396 | "output_type": "stream",
397 | "text": [
398 | "0\n",
399 | "1\n"
400 | ]
401 | }
402 | ],
403 | "source": [
404 | "x = 0\n",
405 | "\n",
406 | "while x < 5:\n",
407 | " \n",
408 | " if x == 2:\n",
409 | " break\n",
410 | " print(x)\n",
411 | " x += 1"
412 | ]
413 | },
414 | {
415 | "cell_type": "markdown",
416 | "metadata": {},
417 | "source": [
418 | "## Useful Operators in Python"
419 | ]
420 | },
421 | {
422 | "cell_type": "code",
423 | "execution_count": 27,
424 | "metadata": {},
425 | "outputs": [],
426 | "source": [
427 | "mylist = [1,2,3]"
428 | ]
429 | },
430 | {
431 | "cell_type": "code",
432 | "execution_count": 28,
433 | "metadata": {},
434 | "outputs": [
435 | {
436 | "name": "stdout",
437 | "output_type": "stream",
438 | "text": [
439 | "0\n",
440 | "2\n",
441 | "4\n",
442 | "6\n",
443 | "8\n",
444 | "10\n"
445 | ]
446 | }
447 | ],
448 | "source": [
449 | "for num in range (0,11,2):\n",
450 | " print(num)"
451 | ]
452 | },
453 | {
454 | "cell_type": "code",
455 | "execution_count": 29,
456 | "metadata": {},
457 | "outputs": [
458 | {
459 | "name": "stdout",
460 | "output_type": "stream",
461 | "text": [
462 | "a\n",
463 | "b\n",
464 | "c\n",
465 | "d\n",
466 | "e\n"
467 | ]
468 | }
469 | ],
470 | "source": [
471 | "index_count = 0\n",
472 | "word = 'abcde'\n",
473 | "\n",
474 | "for letter in word:\n",
475 | " \n",
476 | " print(word[index_count])\n",
477 | " index_count += 1"
478 | ]
479 | },
480 | {
481 | "cell_type": "code",
482 | "execution_count": 30,
483 | "metadata": {},
484 | "outputs": [],
485 | "source": [
486 | "# can be done this way too"
487 | ]
488 | },
489 | {
490 | "cell_type": "code",
491 | "execution_count": 31,
492 | "metadata": {},
493 | "outputs": [
494 | {
495 | "name": "stdout",
496 | "output_type": "stream",
497 | "text": [
498 | "(0, 'a')\n",
499 | "(1, 'b')\n",
500 | "(2, 'c')\n",
501 | "(3, 'd')\n",
502 | "(4, 'e')\n"
503 | ]
504 | }
505 | ],
506 | "source": [
507 | "word = 'abcde'\n",
508 | "\n",
509 | "for item in enumerate(word):\n",
510 | " print(item)"
511 | ]
512 | },
513 | {
514 | "cell_type": "code",
515 | "execution_count": 32,
516 | "metadata": {},
517 | "outputs": [],
518 | "source": [
519 | "mylist1 = [1,2,3]\n",
520 | "mylist2 = ['a','b','c']"
521 | ]
522 | },
523 | {
524 | "cell_type": "code",
525 | "execution_count": 33,
526 | "metadata": {},
527 | "outputs": [
528 | {
529 | "name": "stdout",
530 | "output_type": "stream",
531 | "text": [
532 | "(1, 'a')\n",
533 | "(2, 'b')\n",
534 | "(3, 'c')\n"
535 | ]
536 | }
537 | ],
538 | "source": [
539 | "for item in zip(mylist1, mylist2):\n",
540 | " print(item)"
541 | ]
542 | },
543 | {
544 | "cell_type": "code",
545 | "execution_count": 34,
546 | "metadata": {},
547 | "outputs": [
548 | {
549 | "data": {
550 | "text/plain": [
551 | "[(1, 'a'), (2, 'b'), (3, 'c')]"
552 | ]
553 | },
554 | "execution_count": 34,
555 | "metadata": {},
556 | "output_type": "execute_result"
557 | }
558 | ],
559 | "source": [
560 | "list(zip(mylist1, mylist2))"
561 | ]
562 | },
563 | {
564 | "cell_type": "code",
565 | "execution_count": 35,
566 | "metadata": {},
567 | "outputs": [
568 | {
569 | "data": {
570 | "text/plain": [
571 | "False"
572 | ]
573 | },
574 | "execution_count": 35,
575 | "metadata": {},
576 | "output_type": "execute_result"
577 | }
578 | ],
579 | "source": [
580 | "d = {'mykey': 345}\n",
581 | "\n",
582 | "345 in d.keys()"
583 | ]
584 | },
585 | {
586 | "cell_type": "code",
587 | "execution_count": 51,
588 | "metadata": {},
589 | "outputs": [],
590 | "source": [
591 | "from random import shuffle"
592 | ]
593 | },
594 | {
595 | "cell_type": "code",
596 | "execution_count": 52,
597 | "metadata": {},
598 | "outputs": [],
599 | "source": [
600 | "mylist = [1,2,3,4,5,6,7,8,9,10]"
601 | ]
602 | },
603 | {
604 | "cell_type": "code",
605 | "execution_count": 53,
606 | "metadata": {},
607 | "outputs": [],
608 | "source": [
609 | "shuffle(mylist)"
610 | ]
611 | },
612 | {
613 | "cell_type": "code",
614 | "execution_count": 54,
615 | "metadata": {},
616 | "outputs": [
617 | {
618 | "data": {
619 | "text/plain": [
620 | "[7, 2, 4, 1, 8, 9, 5, 3, 6, 10]"
621 | ]
622 | },
623 | "execution_count": 54,
624 | "metadata": {},
625 | "output_type": "execute_result"
626 | }
627 | ],
628 | "source": [
629 | "mylist"
630 | ]
631 | },
632 | {
633 | "cell_type": "code",
634 | "execution_count": 56,
635 | "metadata": {},
636 | "outputs": [],
637 | "source": [
638 | "from random import randint"
639 | ]
640 | },
641 | {
642 | "cell_type": "code",
643 | "execution_count": 57,
644 | "metadata": {},
645 | "outputs": [
646 | {
647 | "data": {
648 | "text/plain": [
649 | "58"
650 | ]
651 | },
652 | "execution_count": 57,
653 | "metadata": {},
654 | "output_type": "execute_result"
655 | }
656 | ],
657 | "source": [
658 | "randint(0,100)"
659 | ]
660 | },
661 | {
662 | "cell_type": "code",
663 | "execution_count": 61,
664 | "metadata": {},
665 | "outputs": [
666 | {
667 | "name": "stdout",
668 | "output_type": "stream",
669 | "text": [
670 | "What is your favorite number:27\n"
671 | ]
672 | }
673 | ],
674 | "source": [
675 | "result = input('What is your favorite number:')"
676 | ]
677 | },
678 | {
679 | "cell_type": "code",
680 | "execution_count": 62,
681 | "metadata": {},
682 | "outputs": [
683 | {
684 | "data": {
685 | "text/plain": [
686 | "'27'"
687 | ]
688 | },
689 | "execution_count": 62,
690 | "metadata": {},
691 | "output_type": "execute_result"
692 | }
693 | ],
694 | "source": [
695 | "result"
696 | ]
697 | },
698 | {
699 | "cell_type": "markdown",
700 | "metadata": {},
701 | "source": [
702 | "## List Comprehensions in Python"
703 | ]
704 | },
705 | {
706 | "cell_type": "code",
707 | "execution_count": 1,
708 | "metadata": {},
709 | "outputs": [],
710 | "source": [
711 | "mystring = 'hello'"
712 | ]
713 | },
714 | {
715 | "cell_type": "code",
716 | "execution_count": 2,
717 | "metadata": {},
718 | "outputs": [],
719 | "source": [
720 | "mylist = []\n",
721 | "\n",
722 | "for letter in mystring:\n",
723 | " mylist.append(letter)"
724 | ]
725 | },
726 | {
727 | "cell_type": "code",
728 | "execution_count": 3,
729 | "metadata": {},
730 | "outputs": [
731 | {
732 | "data": {
733 | "text/plain": [
734 | "['h', 'e', 'l', 'l', 'o']"
735 | ]
736 | },
737 | "execution_count": 3,
738 | "metadata": {},
739 | "output_type": "execute_result"
740 | }
741 | ],
742 | "source": [
743 | "mylist"
744 | ]
745 | },
746 | {
747 | "cell_type": "code",
748 | "execution_count": 4,
749 | "metadata": {},
750 | "outputs": [],
751 | "source": [
752 | "mylist = []\n",
753 | "\n",
754 | "for letter in mystring:\n",
755 | " mylist.append(letter) # it is also the same if you do it this way, check below"
756 | ]
757 | },
758 | {
759 | "cell_type": "code",
760 | "execution_count": 5,
761 | "metadata": {},
762 | "outputs": [],
763 | "source": [
764 | "mylist = [letter for letter in mystring]"
765 | ]
766 | },
767 | {
768 | "cell_type": "code",
769 | "execution_count": 6,
770 | "metadata": {},
771 | "outputs": [
772 | {
773 | "data": {
774 | "text/plain": [
775 | "['h', 'e', 'l', 'l', 'o']"
776 | ]
777 | },
778 | "execution_count": 6,
779 | "metadata": {},
780 | "output_type": "execute_result"
781 | }
782 | ],
783 | "source": [
784 | "mylist"
785 | ]
786 | },
787 | {
788 | "cell_type": "code",
789 | "execution_count": 7,
790 | "metadata": {},
791 | "outputs": [],
792 | "source": [
793 | "mylist = [x for x in 'word']"
794 | ]
795 | },
796 | {
797 | "cell_type": "code",
798 | "execution_count": 8,
799 | "metadata": {},
800 | "outputs": [
801 | {
802 | "data": {
803 | "text/plain": [
804 | "['w', 'o', 'r', 'd']"
805 | ]
806 | },
807 | "execution_count": 8,
808 | "metadata": {},
809 | "output_type": "execute_result"
810 | }
811 | ],
812 | "source": [
813 | "mylist"
814 | ]
815 | },
816 | {
817 | "cell_type": "code",
818 | "execution_count": 9,
819 | "metadata": {},
820 | "outputs": [],
821 | "source": [
822 | "mylist = [num for num in range(0,11)]"
823 | ]
824 | },
825 | {
826 | "cell_type": "code",
827 | "execution_count": 10,
828 | "metadata": {},
829 | "outputs": [
830 | {
831 | "data": {
832 | "text/plain": [
833 | "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
834 | ]
835 | },
836 | "execution_count": 10,
837 | "metadata": {},
838 | "output_type": "execute_result"
839 | }
840 | ],
841 | "source": [
842 | "mylist"
843 | ]
844 | },
845 | {
846 | "cell_type": "code",
847 | "execution_count": 11,
848 | "metadata": {},
849 | "outputs": [],
850 | "source": [
851 | "mylist = [num**2 for num in range(0,11)]"
852 | ]
853 | },
854 | {
855 | "cell_type": "code",
856 | "execution_count": 12,
857 | "metadata": {},
858 | "outputs": [
859 | {
860 | "data": {
861 | "text/plain": [
862 | "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
863 | ]
864 | },
865 | "execution_count": 12,
866 | "metadata": {},
867 | "output_type": "execute_result"
868 | }
869 | ],
870 | "source": [
871 | "mylist"
872 | ]
873 | },
874 | {
875 | "cell_type": "code",
876 | "execution_count": 15,
877 | "metadata": {},
878 | "outputs": [],
879 | "source": [
880 | "mylist = [x**2 for x in range(0,11) if x%2==0]"
881 | ]
882 | },
883 | {
884 | "cell_type": "code",
885 | "execution_count": 16,
886 | "metadata": {},
887 | "outputs": [
888 | {
889 | "data": {
890 | "text/plain": [
891 | "[0, 4, 16, 36, 64, 100]"
892 | ]
893 | },
894 | "execution_count": 16,
895 | "metadata": {},
896 | "output_type": "execute_result"
897 | }
898 | ],
899 | "source": [
900 | "mylist"
901 | ]
902 | },
903 | {
904 | "cell_type": "code",
905 | "execution_count": 18,
906 | "metadata": {},
907 | "outputs": [],
908 | "source": [
909 | "celcius = [0,10,20,35.4]\n",
910 | "\n",
911 | "fahrenheit = [( (9/5)*temp + 32)for temp in celcius]"
912 | ]
913 | },
914 | {
915 | "cell_type": "code",
916 | "execution_count": 19,
917 | "metadata": {},
918 | "outputs": [
919 | {
920 | "data": {
921 | "text/plain": [
922 | "[32.0, 50.0, 68.0, 95.72]"
923 | ]
924 | },
925 | "execution_count": 19,
926 | "metadata": {},
927 | "output_type": "execute_result"
928 | }
929 | ],
930 | "source": [
931 | "fahrenheit"
932 | ]
933 | },
934 | {
935 | "cell_type": "code",
936 | "execution_count": 20,
937 | "metadata": {},
938 | "outputs": [],
939 | "source": [
940 | "# you can also do it this way"
941 | ]
942 | },
943 | {
944 | "cell_type": "code",
945 | "execution_count": 21,
946 | "metadata": {},
947 | "outputs": [],
948 | "source": [
949 | "fahrenheit = []\n",
950 | "\n",
951 | "for temp in celcius:\n",
952 | " fahrenheit.append(((9/5)*temp + 32))"
953 | ]
954 | },
955 | {
956 | "cell_type": "code",
957 | "execution_count": 22,
958 | "metadata": {},
959 | "outputs": [
960 | {
961 | "data": {
962 | "text/plain": [
963 | "[32.0, 50.0, 68.0, 95.72]"
964 | ]
965 | },
966 | "execution_count": 22,
967 | "metadata": {},
968 | "output_type": "execute_result"
969 | }
970 | ],
971 | "source": [
972 | "fahrenheit"
973 | ]
974 | },
975 | {
976 | "cell_type": "code",
977 | "execution_count": null,
978 | "metadata": {},
979 | "outputs": [],
980 | "source": []
981 | }
982 | ],
983 | "metadata": {
984 | "kernelspec": {
985 | "display_name": "Python 3",
986 | "language": "python",
987 | "name": "python3"
988 | },
989 | "language_info": {
990 | "codemirror_mode": {
991 | "name": "ipython",
992 | "version": 3
993 | },
994 | "file_extension": ".py",
995 | "mimetype": "text/x-python",
996 | "name": "python",
997 | "nbconvert_exporter": "python",
998 | "pygments_lexer": "ipython3",
999 | "version": "3.7.3"
1000 | }
1001 | },
1002 | "nbformat": 4,
1003 | "nbformat_minor": 2
1004 | }
1005 |
--------------------------------------------------------------------------------
/4. Methods and Functions.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 2,
6 | "metadata": {},
7 | "outputs": [
8 | {
9 | "data": {
10 | "text/plain": [
11 | "[1, 2, 3, 4]"
12 | ]
13 | },
14 | "execution_count": 2,
15 | "metadata": {},
16 | "output_type": "execute_result"
17 | }
18 | ],
19 | "source": [
20 | "mylist = [1,2,3]\n",
21 | "mylist.append(4)\n",
22 | "mylist"
23 | ]
24 | },
25 | {
26 | "cell_type": "code",
27 | "execution_count": 3,
28 | "metadata": {},
29 | "outputs": [
30 | {
31 | "data": {
32 | "text/plain": [
33 | "4"
34 | ]
35 | },
36 | "execution_count": 3,
37 | "metadata": {},
38 | "output_type": "execute_result"
39 | }
40 | ],
41 | "source": [
42 | "mylist.pop()"
43 | ]
44 | },
45 | {
46 | "cell_type": "code",
47 | "execution_count": 4,
48 | "metadata": {},
49 | "outputs": [
50 | {
51 | "data": {
52 | "text/plain": [
53 | "[1, 2, 3]"
54 | ]
55 | },
56 | "execution_count": 4,
57 | "metadata": {},
58 | "output_type": "execute_result"
59 | }
60 | ],
61 | "source": [
62 | "mylist"
63 | ]
64 | },
65 | {
66 | "cell_type": "code",
67 | "execution_count": 5,
68 | "metadata": {},
69 | "outputs": [
70 | {
71 | "name": "stdout",
72 | "output_type": "stream",
73 | "text": [
74 | "Help on built-in function insert:\n",
75 | "\n",
76 | "insert(index, object, /) method of builtins.list instance\n",
77 | " Insert object before index.\n",
78 | "\n"
79 | ]
80 | }
81 | ],
82 | "source": [
83 | "help(mylist.insert)"
84 | ]
85 | },
86 | {
87 | "cell_type": "markdown",
88 | "metadata": {},
89 | "source": [
90 | "### Functions in Python"
91 | ]
92 | },
93 | {
94 | "cell_type": "code",
95 | "execution_count": 10,
96 | "metadata": {},
97 | "outputs": [],
98 | "source": [
99 | "def name_function():\n",
100 | " '''\n",
101 | " DOCSTRING: Information about the function\n",
102 | " INPUT: no input...\n",
103 | " OUTPUT: no output...\n",
104 | " '''\n",
105 | " print('Hello')"
106 | ]
107 | },
108 | {
109 | "cell_type": "code",
110 | "execution_count": 12,
111 | "metadata": {},
112 | "outputs": [
113 | {
114 | "name": "stdout",
115 | "output_type": "stream",
116 | "text": [
117 | "Help on function name_function in module __main__:\n",
118 | "\n",
119 | "name_function()\n",
120 | " DOCSTRING: Information about the function\n",
121 | " INPUT: no input...\n",
122 | " OUTPUT: no output...\n",
123 | "\n"
124 | ]
125 | }
126 | ],
127 | "source": [
128 | "help(name_function)"
129 | ]
130 | },
131 | {
132 | "cell_type": "code",
133 | "execution_count": 21,
134 | "metadata": {},
135 | "outputs": [],
136 | "source": [
137 | "def say_hello(name='NAME'):\n",
138 | " print('hello ' + name)"
139 | ]
140 | },
141 | {
142 | "cell_type": "code",
143 | "execution_count": 23,
144 | "metadata": {},
145 | "outputs": [
146 | {
147 | "name": "stdout",
148 | "output_type": "stream",
149 | "text": [
150 | "hello David\n"
151 | ]
152 | }
153 | ],
154 | "source": [
155 | "say_hello('David')"
156 | ]
157 | },
158 | {
159 | "cell_type": "code",
160 | "execution_count": 25,
161 | "metadata": {},
162 | "outputs": [],
163 | "source": [
164 | "def say_hello(name='NAME'):\n",
165 | " return 'hello '+name"
166 | ]
167 | },
168 | {
169 | "cell_type": "code",
170 | "execution_count": 26,
171 | "metadata": {},
172 | "outputs": [],
173 | "source": [
174 | "result = say_hello('Jose')"
175 | ]
176 | },
177 | {
178 | "cell_type": "code",
179 | "execution_count": 27,
180 | "metadata": {},
181 | "outputs": [
182 | {
183 | "data": {
184 | "text/plain": [
185 | "'hello Jose'"
186 | ]
187 | },
188 | "execution_count": 27,
189 | "metadata": {},
190 | "output_type": "execute_result"
191 | }
192 | ],
193 | "source": [
194 | "result"
195 | ]
196 | },
197 | {
198 | "cell_type": "code",
199 | "execution_count": 28,
200 | "metadata": {},
201 | "outputs": [],
202 | "source": [
203 | "def add(n1, n2):\n",
204 | " return n1+n2"
205 | ]
206 | },
207 | {
208 | "cell_type": "code",
209 | "execution_count": 29,
210 | "metadata": {},
211 | "outputs": [],
212 | "source": [
213 | "result = add(20,30)"
214 | ]
215 | },
216 | {
217 | "cell_type": "code",
218 | "execution_count": 30,
219 | "metadata": {},
220 | "outputs": [
221 | {
222 | "data": {
223 | "text/plain": [
224 | "50"
225 | ]
226 | },
227 | "execution_count": 30,
228 | "metadata": {},
229 | "output_type": "execute_result"
230 | }
231 | ],
232 | "source": [
233 | "result"
234 | ]
235 | },
236 | {
237 | "cell_type": "code",
238 | "execution_count": 1,
239 | "metadata": {},
240 | "outputs": [],
241 | "source": [
242 | "def dog_check(mystring):\n",
243 | " if 'dog' in mystring:\n",
244 | " return True\n",
245 | " else:\n",
246 | " return False"
247 | ]
248 | },
249 | {
250 | "cell_type": "code",
251 | "execution_count": 2,
252 | "metadata": {},
253 | "outputs": [
254 | {
255 | "data": {
256 | "text/plain": [
257 | "False"
258 | ]
259 | },
260 | "execution_count": 2,
261 | "metadata": {},
262 | "output_type": "execute_result"
263 | }
264 | ],
265 | "source": [
266 | "dog_check('My cat ran away')"
267 | ]
268 | },
269 | {
270 | "cell_type": "code",
271 | "execution_count": 3,
272 | "metadata": {},
273 | "outputs": [
274 | {
275 | "data": {
276 | "text/plain": [
277 | "True"
278 | ]
279 | },
280 | "execution_count": 3,
281 | "metadata": {},
282 | "output_type": "execute_result"
283 | }
284 | ],
285 | "source": [
286 | "dog_check('My dog ran away')"
287 | ]
288 | },
289 | {
290 | "cell_type": "code",
291 | "execution_count": null,
292 | "metadata": {},
293 | "outputs": [],
294 | "source": [
295 | "# you actually don't need to specify the if statement because 'dog' in 'dog ran away' will return True statement"
296 | ]
297 | },
298 | {
299 | "cell_type": "code",
300 | "execution_count": 4,
301 | "metadata": {},
302 | "outputs": [],
303 | "source": [
304 | "def dog_check(mystring):\n",
305 | " return 'dog' in mystring.lower()"
306 | ]
307 | },
308 | {
309 | "cell_type": "code",
310 | "execution_count": 5,
311 | "metadata": {},
312 | "outputs": [
313 | {
314 | "data": {
315 | "text/plain": [
316 | "True"
317 | ]
318 | },
319 | "execution_count": 5,
320 | "metadata": {},
321 | "output_type": "execute_result"
322 | }
323 | ],
324 | "source": [
325 | "dog_check('Your dog ran away')"
326 | ]
327 | },
328 | {
329 | "cell_type": "markdown",
330 | "metadata": {},
331 | "source": [
332 | "### Pig Latin"
333 | ]
334 | },
335 | {
336 | "cell_type": "markdown",
337 | "metadata": {},
338 | "source": [
339 | "- If word starts with a vowel, add 'ay'to end\n",
340 | "- If word does not start with a vowel, put first letter at the end, then add 'ay'\n",
341 | "- word --> ordway\n",
342 | "- apple --> appleay"
343 | ]
344 | },
345 | {
346 | "cell_type": "code",
347 | "execution_count": 7,
348 | "metadata": {},
349 | "outputs": [],
350 | "source": [
351 | "def pig_latin(word):\n",
352 | " \n",
353 | " first_letter = word[0]\n",
354 | " \n",
355 | " # Check if vowel\n",
356 | " if first_letter in 'aeiou':\n",
357 | " pig_word = word + 'ay'\n",
358 | " else:\n",
359 | " pig_word = word[1:] + first_letter + 'ay'\n",
360 | " \n",
361 | " return pig_word"
362 | ]
363 | },
364 | {
365 | "cell_type": "code",
366 | "execution_count": 8,
367 | "metadata": {},
368 | "outputs": [
369 | {
370 | "data": {
371 | "text/plain": [
372 | "'appleay'"
373 | ]
374 | },
375 | "execution_count": 8,
376 | "metadata": {},
377 | "output_type": "execute_result"
378 | }
379 | ],
380 | "source": [
381 | "pig_latin('apple')"
382 | ]
383 | },
384 | {
385 | "cell_type": "markdown",
386 | "metadata": {},
387 | "source": [
388 | "#### Lambda Expressions, Map, and Filter Functions"
389 | ]
390 | },
391 | {
392 | "cell_type": "code",
393 | "execution_count": 1,
394 | "metadata": {},
395 | "outputs": [],
396 | "source": [
397 | "def square(num):\n",
398 | " return num**2"
399 | ]
400 | },
401 | {
402 | "cell_type": "code",
403 | "execution_count": 2,
404 | "metadata": {},
405 | "outputs": [],
406 | "source": [
407 | "my_nums = [1, 2, 3, 4, 5]"
408 | ]
409 | },
410 | {
411 | "cell_type": "code",
412 | "execution_count": 3,
413 | "metadata": {},
414 | "outputs": [
415 | {
416 | "data": {
417 | "text/plain": [
418 | "