├── ArgumentsandKeywordArguments.ipynb
├── BooleansandSets.ipynb
├── ClassesAttributesandMethods.ipynb
├── ComparisonandChainingOperators.ipynb
├── CupsGameCombiningFunctions.ipynb
├── IfElifandElse.ipynb
├── IndexingandSlicing.ipynb
├── InheritancePolymorphismandAbstractClasses.ipynb
├── IntroductiontoFunctions.ipynb
├── LambdaExpressions.ipynb
├── ListComprehensions.ipynb
├── Lists.ipynb
├── LogicStatementsandTupleUnpackinginFunctions.ipynb
├── MapandFilterFunctions.ipynb
├── README.md
├── SpecialPythonMethods.ipynb
├── StringMethodsandFormatting.ipynb
├── Strings.ipynb
├── Tuples.ipynb
├── VariableScope.ipynb
└── Variables.ipynb


/ArgumentsandKeywordArguments.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "02e57415",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "def find_percentage(value1, value2, value3):\n",
 11 |     "    return sum((value1, value2, value3)) * 0.20"
 12 |    ]
 13 |   },
 14 |   {
 15 |    "cell_type": "code",
 16 |    "execution_count": 2,
 17 |    "id": "bbffd930",
 18 |    "metadata": {},
 19 |    "outputs": [
 20 |     {
 21 |      "data": {
 22 |       "text/plain": [
 23 |        "20.0"
 24 |       ]
 25 |      },
 26 |      "execution_count": 2,
 27 |      "metadata": {},
 28 |      "output_type": "execute_result"
 29 |     }
 30 |    ],
 31 |    "source": [
 32 |     "find_percentage(30,50,20)"
 33 |    ]
 34 |   },
 35 |   {
 36 |    "cell_type": "code",
 37 |    "execution_count": 3,
 38 |    "id": "4a9e53b7",
 39 |    "metadata": {},
 40 |    "outputs": [],
 41 |    "source": [
 42 |     "def find_percentage(*args):\n",
 43 |     "    print(args)"
 44 |    ]
 45 |   },
 46 |   {
 47 |    "cell_type": "code",
 48 |    "execution_count": 4,
 49 |    "id": "2b1dbf03",
 50 |    "metadata": {},
 51 |    "outputs": [
 52 |     {
 53 |      "name": "stdout",
 54 |      "output_type": "stream",
 55 |      "text": [
 56 |       "(30, 56, 98, 78, 12)\n"
 57 |      ]
 58 |     }
 59 |    ],
 60 |    "source": [
 61 |     "find_percentage(30,56,98,78,12)"
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "code",
 66 |    "execution_count": 5,
 67 |    "id": "26d4b237",
 68 |    "metadata": {},
 69 |    "outputs": [],
 70 |    "source": [
 71 |     "def pets(**kwargs):\n",
 72 |     "   # print(kwargs)\n",
 73 |     "    if 'cat' in kwargs:\n",
 74 |     "        print(\"My cat's name is {}\".format(kwargs['cat']))\n",
 75 |     "    else:\n",
 76 |     "        print(\"No cat's name is found\")"
 77 |    ]
 78 |   },
 79 |   {
 80 |    "cell_type": "code",
 81 |    "execution_count": 6,
 82 |    "id": "6144adb3",
 83 |    "metadata": {},
 84 |    "outputs": [
 85 |     {
 86 |      "name": "stdout",
 87 |      "output_type": "stream",
 88 |      "text": [
 89 |       "My cat's name is Luna\n"
 90 |      ]
 91 |     }
 92 |    ],
 93 |    "source": [
 94 |     "pets(cat='Luna', dog='charlie')"
 95 |    ]
 96 |   },
 97 |   {
 98 |    "cell_type": "code",
 99 |    "execution_count": 7,
100 |    "id": "33e0ddbc",
101 |    "metadata": {},
102 |    "outputs": [],
103 |    "source": [
104 |     "def students(*args, **kwargs):\n",
105 |     "    print('Students need {} {}.'.format(args[1], kwargs['equipment']))"
106 |    ]
107 |   },
108 |   {
109 |    "cell_type": "code",
110 |    "execution_count": 8,
111 |    "id": "e8c7bda2",
112 |    "metadata": {},
113 |    "outputs": [
114 |     {
115 |      "name": "stdout",
116 |      "output_type": "stream",
117 |      "text": [
118 |       "Students need 34 laptops.\n"
119 |      ]
120 |     }
121 |    ],
122 |    "source": [
123 |     "students(53,34,46,clothes='shirts',equipment='laptops',food='pizzas' )"
124 |    ]
125 |   }
126 |  ],
127 |  "metadata": {
128 |   "kernelspec": {
129 |    "display_name": "Python 3",
130 |    "language": "python",
131 |    "name": "python3"
132 |   },
133 |   "language_info": {
134 |    "codemirror_mode": {
135 |     "name": "ipython",
136 |     "version": 3
137 |    },
138 |    "file_extension": ".py",
139 |    "mimetype": "text/x-python",
140 |    "name": "python",
141 |    "nbconvert_exporter": "python",
142 |    "pygments_lexer": "ipython3",
143 |    "version": "3.8.8"
144 |   }
145 |  },
146 |  "nbformat": 4,
147 |  "nbformat_minor": 5
148 | }
149 | 


--------------------------------------------------------------------------------
/BooleansandSets.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "26c81a4c",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "set_example = set()"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 3,
 16 |    "id": "069cc67e",
 17 |    "metadata": {},
 18 |    "outputs": [],
 19 |    "source": [
 20 |     "set_example.add(10)"
 21 |    ]
 22 |   },
 23 |   {
 24 |    "cell_type": "code",
 25 |    "execution_count": 4,
 26 |    "id": "18a1a76a",
 27 |    "metadata": {},
 28 |    "outputs": [
 29 |     {
 30 |      "data": {
 31 |       "text/plain": [
 32 |        "{10}"
 33 |       ]
 34 |      },
 35 |      "execution_count": 4,
 36 |      "metadata": {},
 37 |      "output_type": "execute_result"
 38 |     }
 39 |    ],
 40 |    "source": [
 41 |     "set_example"
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "code",
 46 |    "execution_count": 5,
 47 |    "id": "b4f69064",
 48 |    "metadata": {},
 49 |    "outputs": [],
 50 |    "source": [
 51 |     "set_example.add(20)"
 52 |    ]
 53 |   },
 54 |   {
 55 |    "cell_type": "code",
 56 |    "execution_count": 6,
 57 |    "id": "2086b4d3",
 58 |    "metadata": {},
 59 |    "outputs": [
 60 |     {
 61 |      "data": {
 62 |       "text/plain": [
 63 |        "{10, 20}"
 64 |       ]
 65 |      },
 66 |      "execution_count": 6,
 67 |      "metadata": {},
 68 |      "output_type": "execute_result"
 69 |     }
 70 |    ],
 71 |    "source": [
 72 |     "set_example"
 73 |    ]
 74 |   },
 75 |   {
 76 |    "cell_type": "code",
 77 |    "execution_count": 7,
 78 |    "id": "726a90d2",
 79 |    "metadata": {},
 80 |    "outputs": [],
 81 |    "source": [
 82 |     "set_example.add(20)"
 83 |    ]
 84 |   },
 85 |   {
 86 |    "cell_type": "code",
 87 |    "execution_count": 8,
 88 |    "id": "0789337b",
 89 |    "metadata": {},
 90 |    "outputs": [
 91 |     {
 92 |      "data": {
 93 |       "text/plain": [
 94 |        "{10, 20}"
 95 |       ]
 96 |      },
 97 |      "execution_count": 8,
 98 |      "metadata": {},
 99 |      "output_type": "execute_result"
100 |     }
101 |    ],
102 |    "source": [
103 |     "set_example"
104 |    ]
105 |   },
106 |   {
107 |    "cell_type": "code",
108 |    "execution_count": 9,
109 |    "id": "0e1e6bb1",
110 |    "metadata": {},
111 |    "outputs": [],
112 |    "source": [
113 |     "list_example = [10,10,10,20,20,20,50,50,50]"
114 |    ]
115 |   },
116 |   {
117 |    "cell_type": "code",
118 |    "execution_count": 10,
119 |    "id": "1c88971b",
120 |    "metadata": {},
121 |    "outputs": [
122 |     {
123 |      "data": {
124 |       "text/plain": [
125 |        "{10, 20, 50}"
126 |       ]
127 |      },
128 |      "execution_count": 10,
129 |      "metadata": {},
130 |      "output_type": "execute_result"
131 |     }
132 |    ],
133 |    "source": [
134 |     "set(list_example)"
135 |    ]
136 |   }
137 |  ],
138 |  "metadata": {
139 |   "kernelspec": {
140 |    "display_name": "Python 3",
141 |    "language": "python",
142 |    "name": "python3"
143 |   },
144 |   "language_info": {
145 |    "codemirror_mode": {
146 |     "name": "ipython",
147 |     "version": 3
148 |    },
149 |    "file_extension": ".py",
150 |    "mimetype": "text/x-python",
151 |    "name": "python",
152 |    "nbconvert_exporter": "python",
153 |    "pygments_lexer": "ipython3",
154 |    "version": "3.8.8"
155 |   }
156 |  },
157 |  "nbformat": 4,
158 |  "nbformat_minor": 5
159 | }
160 | 


--------------------------------------------------------------------------------
/ClassesAttributesandMethods.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "263ef060",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "class Car():\n",
 11 |     "    \n",
 12 |     "        # Class object attribute\n",
 13 |     "        machine = 'vehicle'\n",
 14 |     "        \n",
 15 |     "        def __init__(self,brand,color,price):\n",
 16 |     "            \n",
 17 |     "            self.brand = brand\n",
 18 |     "            self.color = color\n",
 19 |     "            self.price = price\n",
 20 |     "            \n",
 21 |     "        def drive(self, serial_number):\n",
 22 |     "            print('Driving the {} car, with serial number {}.'.format(self.brand, serial_number))"
 23 |    ]
 24 |   },
 25 |   {
 26 |    "cell_type": "code",
 27 |    "execution_count": 2,
 28 |    "id": "e28c7760",
 29 |    "metadata": {},
 30 |    "outputs": [],
 31 |    "source": [
 32 |     "new_car = Car(brand='Volvo',color='Black',price=30500.50)"
 33 |    ]
 34 |   },
 35 |   {
 36 |    "cell_type": "code",
 37 |    "execution_count": 3,
 38 |    "id": "21a36b80",
 39 |    "metadata": {},
 40 |    "outputs": [
 41 |     {
 42 |      "data": {
 43 |       "text/plain": [
 44 |        "__main__.Car"
 45 |       ]
 46 |      },
 47 |      "execution_count": 3,
 48 |      "metadata": {},
 49 |      "output_type": "execute_result"
 50 |     }
 51 |    ],
 52 |    "source": [
 53 |     "type(new_car)"
 54 |    ]
 55 |   },
 56 |   {
 57 |    "cell_type": "code",
 58 |    "execution_count": 4,
 59 |    "id": "bff302a0",
 60 |    "metadata": {},
 61 |    "outputs": [
 62 |     {
 63 |      "data": {
 64 |       "text/plain": [
 65 |        "'vehicle'"
 66 |       ]
 67 |      },
 68 |      "execution_count": 4,
 69 |      "metadata": {},
 70 |      "output_type": "execute_result"
 71 |     }
 72 |    ],
 73 |    "source": [
 74 |     "new_car.machine"
 75 |    ]
 76 |   },
 77 |   {
 78 |    "cell_type": "code",
 79 |    "execution_count": 5,
 80 |    "id": "403764d8",
 81 |    "metadata": {},
 82 |    "outputs": [
 83 |     {
 84 |      "name": "stdout",
 85 |      "output_type": "stream",
 86 |      "text": [
 87 |       "Driving the Volvo car, with serial number 706.\n"
 88 |      ]
 89 |     }
 90 |    ],
 91 |    "source": [
 92 |     "new_car.drive(706)"
 93 |    ]
 94 |   },
 95 |   {
 96 |    "cell_type": "code",
 97 |    "execution_count": 6,
 98 |    "id": "2b79acc0",
 99 |    "metadata": {},
100 |    "outputs": [],
101 |    "source": [
102 |     "class BMI():\n",
103 |     "    \n",
104 |     "    divider = 100\n",
105 |     "    \n",
106 |     "    def __init__(self, weight_kg=70, height_cm=180):\n",
107 |     "        \n",
108 |     "        self.weight_kg = weight_kg\n",
109 |     "        self.height_cm = height_cm\n",
110 |     "        self.example = 2\n",
111 |     "        \n",
112 |     "    # Calculates the body mass index\n",
113 |     "    def calculate_bmi(self):\n",
114 |     "        return self.weight_kg/(self.height_cm/BMI.divider)**2"
115 |    ]
116 |   },
117 |   {
118 |    "cell_type": "code",
119 |    "execution_count": 7,
120 |    "id": "ee8cd876",
121 |    "metadata": {},
122 |    "outputs": [],
123 |    "source": [
124 |     "my_bmi = BMI(60,170)"
125 |    ]
126 |   },
127 |   {
128 |    "cell_type": "code",
129 |    "execution_count": 8,
130 |    "id": "01f73510",
131 |    "metadata": {},
132 |    "outputs": [
133 |     {
134 |      "data": {
135 |       "text/plain": [
136 |        "170"
137 |       ]
138 |      },
139 |      "execution_count": 8,
140 |      "metadata": {},
141 |      "output_type": "execute_result"
142 |     }
143 |    ],
144 |    "source": [
145 |     "my_bmi.height_cm"
146 |    ]
147 |   },
148 |   {
149 |    "cell_type": "code",
150 |    "execution_count": 9,
151 |    "id": "9f914337",
152 |    "metadata": {},
153 |    "outputs": [
154 |     {
155 |      "data": {
156 |       "text/plain": [
157 |        "60"
158 |       ]
159 |      },
160 |      "execution_count": 9,
161 |      "metadata": {},
162 |      "output_type": "execute_result"
163 |     }
164 |    ],
165 |    "source": [
166 |     "my_bmi.weight_kg"
167 |    ]
168 |   },
169 |   {
170 |    "cell_type": "code",
171 |    "execution_count": 10,
172 |    "id": "d98ec585",
173 |    "metadata": {},
174 |    "outputs": [
175 |     {
176 |      "data": {
177 |       "text/plain": [
178 |        "20.761245674740486"
179 |       ]
180 |      },
181 |      "execution_count": 10,
182 |      "metadata": {},
183 |      "output_type": "execute_result"
184 |     }
185 |    ],
186 |    "source": [
187 |     "my_bmi.calculate_bmi()"
188 |    ]
189 |   },
190 |   {
191 |    "cell_type": "code",
192 |    "execution_count": 11,
193 |    "id": "bf59ea8d",
194 |    "metadata": {},
195 |    "outputs": [
196 |     {
197 |      "data": {
198 |       "text/plain": [
199 |        "2"
200 |       ]
201 |      },
202 |      "execution_count": 11,
203 |      "metadata": {},
204 |      "output_type": "execute_result"
205 |     }
206 |    ],
207 |    "source": [
208 |     "my_bmi.example"
209 |    ]
210 |   }
211 |  ],
212 |  "metadata": {
213 |   "kernelspec": {
214 |    "display_name": "Python 3",
215 |    "language": "python",
216 |    "name": "python3"
217 |   },
218 |   "language_info": {
219 |    "codemirror_mode": {
220 |     "name": "ipython",
221 |     "version": 3
222 |    },
223 |    "file_extension": ".py",
224 |    "mimetype": "text/x-python",
225 |    "name": "python",
226 |    "nbconvert_exporter": "python",
227 |    "pygments_lexer": "ipython3",
228 |    "version": "3.8.8"
229 |   }
230 |  },
231 |  "nbformat": 4,
232 |  "nbformat_minor": 5
233 | }
234 | 


--------------------------------------------------------------------------------
/ComparisonandChainingOperators.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "472f62ef",
  7 |    "metadata": {},
  8 |    "outputs": [
  9 |     {
 10 |      "data": {
 11 |       "text/plain": [
 12 |        "False"
 13 |       ]
 14 |      },
 15 |      "execution_count": 1,
 16 |      "metadata": {},
 17 |      "output_type": "execute_result"
 18 |     }
 19 |    ],
 20 |    "source": [
 21 |     "3 == 8"
 22 |    ]
 23 |   },
 24 |   {
 25 |    "cell_type": "code",
 26 |    "execution_count": 2,
 27 |    "id": "90c9b23d",
 28 |    "metadata": {},
 29 |    "outputs": [
 30 |     {
 31 |      "data": {
 32 |       "text/plain": [
 33 |        "True"
 34 |       ]
 35 |      },
 36 |      "execution_count": 2,
 37 |      "metadata": {},
 38 |      "output_type": "execute_result"
 39 |     }
 40 |    ],
 41 |    "source": [
 42 |     "3 == 3"
 43 |    ]
 44 |   },
 45 |   {
 46 |    "cell_type": "code",
 47 |    "execution_count": 3,
 48 |    "id": "58e9d882",
 49 |    "metadata": {},
 50 |    "outputs": [
 51 |     {
 52 |      "data": {
 53 |       "text/plain": [
 54 |        "False"
 55 |       ]
 56 |      },
 57 |      "execution_count": 3,
 58 |      "metadata": {},
 59 |      "output_type": "execute_result"
 60 |     }
 61 |    ],
 62 |    "source": [
 63 |     "'Cat' == 'Dog'"
 64 |    ]
 65 |   },
 66 |   {
 67 |    "cell_type": "code",
 68 |    "execution_count": 4,
 69 |    "id": "0d38d920",
 70 |    "metadata": {},
 71 |    "outputs": [
 72 |     {
 73 |      "data": {
 74 |       "text/plain": [
 75 |        "False"
 76 |       ]
 77 |      },
 78 |      "execution_count": 4,
 79 |      "metadata": {},
 80 |      "output_type": "execute_result"
 81 |     }
 82 |    ],
 83 |    "source": [
 84 |     "'Cat' == 'cat'"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": 5,
 90 |    "id": "c8d77b77",
 91 |    "metadata": {},
 92 |    "outputs": [
 93 |     {
 94 |      "data": {
 95 |       "text/plain": [
 96 |        "False"
 97 |       ]
 98 |      },
 99 |      "execution_count": 5,
100 |      "metadata": {},
101 |      "output_type": "execute_result"
102 |     }
103 |    ],
104 |    "source": [
105 |     "10 == '10'"
106 |    ]
107 |   },
108 |   {
109 |    "cell_type": "code",
110 |    "execution_count": 6,
111 |    "id": "91c58760",
112 |    "metadata": {},
113 |    "outputs": [
114 |     {
115 |      "data": {
116 |       "text/plain": [
117 |        "True"
118 |       ]
119 |      },
120 |      "execution_count": 6,
121 |      "metadata": {},
122 |      "output_type": "execute_result"
123 |     }
124 |    ],
125 |    "source": [
126 |     "8 != 9"
127 |    ]
128 |   },
129 |   {
130 |    "cell_type": "code",
131 |    "execution_count": 7,
132 |    "id": "b5de4bfb",
133 |    "metadata": {},
134 |    "outputs": [
135 |     {
136 |      "data": {
137 |       "text/plain": [
138 |        "False"
139 |       ]
140 |      },
141 |      "execution_count": 7,
142 |      "metadata": {},
143 |      "output_type": "execute_result"
144 |     }
145 |    ],
146 |    "source": [
147 |     "8 != 8"
148 |    ]
149 |   },
150 |   {
151 |    "cell_type": "code",
152 |    "execution_count": 8,
153 |    "id": "d2bfd858",
154 |    "metadata": {},
155 |    "outputs": [
156 |     {
157 |      "data": {
158 |       "text/plain": [
159 |        "True"
160 |       ]
161 |      },
162 |      "execution_count": 8,
163 |      "metadata": {},
164 |      "output_type": "execute_result"
165 |     }
166 |    ],
167 |    "source": [
168 |     "9.0 == 9"
169 |    ]
170 |   },
171 |   {
172 |    "cell_type": "code",
173 |    "execution_count": 9,
174 |    "id": "21b85f2f",
175 |    "metadata": {},
176 |    "outputs": [
177 |     {
178 |      "data": {
179 |       "text/plain": [
180 |        "True"
181 |       ]
182 |      },
183 |      "execution_count": 9,
184 |      "metadata": {},
185 |      "output_type": "execute_result"
186 |     }
187 |    ],
188 |    "source": [
189 |     "10 > 1"
190 |    ]
191 |   },
192 |   {
193 |    "cell_type": "code",
194 |    "execution_count": 10,
195 |    "id": "bf4c9e64",
196 |    "metadata": {},
197 |    "outputs": [
198 |     {
199 |      "data": {
200 |       "text/plain": [
201 |        "False"
202 |       ]
203 |      },
204 |      "execution_count": 10,
205 |      "metadata": {},
206 |      "output_type": "execute_result"
207 |     }
208 |    ],
209 |    "source": [
210 |     "1 > 10"
211 |    ]
212 |   },
213 |   {
214 |    "cell_type": "code",
215 |    "execution_count": 11,
216 |    "id": "741087a7",
217 |    "metadata": {},
218 |    "outputs": [
219 |     {
220 |      "data": {
221 |       "text/plain": [
222 |        "True"
223 |       ]
224 |      },
225 |      "execution_count": 11,
226 |      "metadata": {},
227 |      "output_type": "execute_result"
228 |     }
229 |    ],
230 |    "source": [
231 |     "1 < 10"
232 |    ]
233 |   },
234 |   {
235 |    "cell_type": "code",
236 |    "execution_count": 12,
237 |    "id": "c0d5eb90",
238 |    "metadata": {},
239 |    "outputs": [
240 |     {
241 |      "data": {
242 |       "text/plain": [
243 |        "True"
244 |       ]
245 |      },
246 |      "execution_count": 12,
247 |      "metadata": {},
248 |      "output_type": "execute_result"
249 |     }
250 |    ],
251 |    "source": [
252 |     "5 >= 4"
253 |    ]
254 |   },
255 |   {
256 |    "cell_type": "code",
257 |    "execution_count": 13,
258 |    "id": "1652ad97",
259 |    "metadata": {},
260 |    "outputs": [
261 |     {
262 |      "data": {
263 |       "text/plain": [
264 |        "True"
265 |       ]
266 |      },
267 |      "execution_count": 13,
268 |      "metadata": {},
269 |      "output_type": "execute_result"
270 |     }
271 |    ],
272 |    "source": [
273 |     "6 <= 6"
274 |    ]
275 |   },
276 |   {
277 |    "cell_type": "code",
278 |    "execution_count": 14,
279 |    "id": "a7d691fc",
280 |    "metadata": {},
281 |    "outputs": [
282 |     {
283 |      "data": {
284 |       "text/plain": [
285 |        "False"
286 |       ]
287 |      },
288 |      "execution_count": 14,
289 |      "metadata": {},
290 |      "output_type": "execute_result"
291 |     }
292 |    ],
293 |    "source": [
294 |     "3 < 6 and 9 > 14"
295 |    ]
296 |   },
297 |   {
298 |    "cell_type": "code",
299 |    "execution_count": 15,
300 |    "id": "d2309d0c",
301 |    "metadata": {},
302 |    "outputs": [
303 |     {
304 |      "data": {
305 |       "text/plain": [
306 |        "True"
307 |       ]
308 |      },
309 |      "execution_count": 15,
310 |      "metadata": {},
311 |      "output_type": "execute_result"
312 |     }
313 |    ],
314 |    "source": [
315 |     "'cat' == 'cat' and 8 == 8"
316 |    ]
317 |   },
318 |   {
319 |    "cell_type": "code",
320 |    "execution_count": 16,
321 |    "id": "87419613",
322 |    "metadata": {},
323 |    "outputs": [
324 |     {
325 |      "data": {
326 |       "text/plain": [
327 |        "True"
328 |       ]
329 |      },
330 |      "execution_count": 16,
331 |      "metadata": {},
332 |      "output_type": "execute_result"
333 |     }
334 |    ],
335 |    "source": [
336 |     "2 < 4 or 6 == 8"
337 |    ]
338 |   },
339 |   {
340 |    "cell_type": "code",
341 |    "execution_count": 17,
342 |    "id": "ad09ae21",
343 |    "metadata": {},
344 |    "outputs": [
345 |     {
346 |      "data": {
347 |       "text/plain": [
348 |        "True"
349 |       ]
350 |      },
351 |      "execution_count": 17,
352 |      "metadata": {},
353 |      "output_type": "execute_result"
354 |     }
355 |    ],
356 |    "source": [
357 |     "100 == 100"
358 |    ]
359 |   },
360 |   {
361 |    "cell_type": "code",
362 |    "execution_count": 18,
363 |    "id": "43c2113d",
364 |    "metadata": {},
365 |    "outputs": [
366 |     {
367 |      "data": {
368 |       "text/plain": [
369 |        "False"
370 |       ]
371 |      },
372 |      "execution_count": 18,
373 |      "metadata": {},
374 |      "output_type": "execute_result"
375 |     }
376 |    ],
377 |    "source": [
378 |     "not 100 == 100"
379 |    ]
380 |   },
381 |   {
382 |    "cell_type": "code",
383 |    "execution_count": 19,
384 |    "id": "63ef7051",
385 |    "metadata": {},
386 |    "outputs": [
387 |     {
388 |      "data": {
389 |       "text/plain": [
390 |        "False"
391 |       ]
392 |      },
393 |      "execution_count": 19,
394 |      "metadata": {},
395 |      "output_type": "execute_result"
396 |     }
397 |    ],
398 |    "source": [
399 |     "100 == 1"
400 |    ]
401 |   },
402 |   {
403 |    "cell_type": "code",
404 |    "execution_count": 20,
405 |    "id": "e54bcba2",
406 |    "metadata": {},
407 |    "outputs": [
408 |     {
409 |      "data": {
410 |       "text/plain": [
411 |        "True"
412 |       ]
413 |      },
414 |      "execution_count": 20,
415 |      "metadata": {},
416 |      "output_type": "execute_result"
417 |     }
418 |    ],
419 |    "source": [
420 |     "not 100 == 1"
421 |    ]
422 |   }
423 |  ],
424 |  "metadata": {
425 |   "kernelspec": {
426 |    "display_name": "Python 3",
427 |    "language": "python",
428 |    "name": "python3"
429 |   },
430 |   "language_info": {
431 |    "codemirror_mode": {
432 |     "name": "ipython",
433 |     "version": 3
434 |    },
435 |    "file_extension": ".py",
436 |    "mimetype": "text/x-python",
437 |    "name": "python",
438 |    "nbconvert_exporter": "python",
439 |    "pygments_lexer": "ipython3",
440 |    "version": "3.8.8"
441 |   }
442 |  },
443 |  "nbformat": 4,
444 |  "nbformat_minor": 5
445 | }
446 | 


--------------------------------------------------------------------------------
/CupsGameCombiningFunctions.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 3,
  6 |    "id": "51edc16f",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "test_list = [4,6,7,8,9,3,45,6]"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 4,
 16 |    "id": "b0013923",
 17 |    "metadata": {},
 18 |    "outputs": [],
 19 |    "source": [
 20 |     "from random import shuffle"
 21 |    ]
 22 |   },
 23 |   {
 24 |    "cell_type": "code",
 25 |    "execution_count": 5,
 26 |    "id": "e447ee2c",
 27 |    "metadata": {},
 28 |    "outputs": [],
 29 |    "source": [
 30 |     "shuffled_cups = shuffle(test_list)"
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "code",
 35 |    "execution_count": 6,
 36 |    "id": "034eab15",
 37 |    "metadata": {},
 38 |    "outputs": [],
 39 |    "source": [
 40 |     "shuffled_cups"
 41 |    ]
 42 |   },
 43 |   {
 44 |    "cell_type": "code",
 45 |    "execution_count": 7,
 46 |    "id": "cc0b9391",
 47 |    "metadata": {},
 48 |    "outputs": [],
 49 |    "source": [
 50 |     "def shuffle_cups(cups):\n",
 51 |     "    shuffle(cups)\n",
 52 |     "    return cups"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": 8,
 58 |    "id": "226be1c7",
 59 |    "metadata": {},
 60 |    "outputs": [],
 61 |    "source": [
 62 |     "shuffled_cups = shuffle_cups(test_list)"
 63 |    ]
 64 |   },
 65 |   {
 66 |    "cell_type": "code",
 67 |    "execution_count": 10,
 68 |    "id": "66ceb8ec",
 69 |    "metadata": {},
 70 |    "outputs": [
 71 |     {
 72 |      "data": {
 73 |       "text/plain": [
 74 |        "[6, 9, 3, 8, 45, 4, 6, 7]"
 75 |       ]
 76 |      },
 77 |      "execution_count": 10,
 78 |      "metadata": {},
 79 |      "output_type": "execute_result"
 80 |     }
 81 |    ],
 82 |    "source": [
 83 |     "test_list"
 84 |    ]
 85 |   },
 86 |   {
 87 |    "cell_type": "code",
 88 |    "execution_count": 11,
 89 |    "id": "516b2628",
 90 |    "metadata": {},
 91 |    "outputs": [],
 92 |    "source": [
 93 |     "cups = ['empty', '100$', 'empty', 'empty' ]"
 94 |    ]
 95 |   },
 96 |   {
 97 |    "cell_type": "code",
 98 |    "execution_count": 12,
 99 |    "id": "32dd769d",
100 |    "metadata": {},
101 |    "outputs": [
102 |     {
103 |      "data": {
104 |       "text/plain": [
105 |        "['empty', '100$', 'empty', 'empty']"
106 |       ]
107 |      },
108 |      "execution_count": 12,
109 |      "metadata": {},
110 |      "output_type": "execute_result"
111 |     }
112 |    ],
113 |    "source": [
114 |     "shuffle_cups(cups)"
115 |    ]
116 |   },
117 |   {
118 |    "cell_type": "code",
119 |    "execution_count": 13,
120 |    "id": "523288db",
121 |    "metadata": {},
122 |    "outputs": [],
123 |    "source": [
124 |     "def guess_a_cup():\n",
125 |     "    guess=''\n",
126 |     "    \n",
127 |     "    while guess not in ['0','1','2','3']:\n",
128 |     "        guess = input(\"Choose cup 0, 1, 2 or 3\")\n",
129 |     "    return int(guess)"
130 |    ]
131 |   },
132 |   {
133 |    "cell_type": "code",
134 |    "execution_count": 14,
135 |    "id": "c84bc81c",
136 |    "metadata": {},
137 |    "outputs": [
138 |     {
139 |      "name": "stdout",
140 |      "output_type": "stream",
141 |      "text": [
142 |       "Choose cup 0, 1, 2 or 3\n",
143 |       "Choose cup 0, 1, 2 or 3\n",
144 |       "Choose cup 0, 1, 2 or 32\n"
145 |      ]
146 |     },
147 |     {
148 |      "data": {
149 |       "text/plain": [
150 |        "2"
151 |       ]
152 |      },
153 |      "execution_count": 14,
154 |      "metadata": {},
155 |      "output_type": "execute_result"
156 |     }
157 |    ],
158 |    "source": [
159 |     "guess_a_cup()"
160 |    ]
161 |   },
162 |   {
163 |    "cell_type": "code",
164 |    "execution_count": 15,
165 |    "id": "affc9950",
166 |    "metadata": {},
167 |    "outputs": [],
168 |    "source": [
169 |     "def check_cup(cups, guess):\n",
170 |     "    if cups[guess] == '100$':\n",
171 |     "        print(\"You got 100$!\")\n",
172 |     "    else:\n",
173 |     "        print(\"The cup is empty!\")\n",
174 |     "        print(cups)"
175 |    ]
176 |   },
177 |   {
178 |    "cell_type": "code",
179 |    "execution_count": 18,
180 |    "id": "6d2f54d0",
181 |    "metadata": {},
182 |    "outputs": [
183 |     {
184 |      "name": "stdout",
185 |      "output_type": "stream",
186 |      "text": [
187 |       "Choose cup 0, 1, 2 or 32\n",
188 |       "The cup is empty!\n",
189 |       "['empty', 'empty', 'empty', '100$']\n"
190 |      ]
191 |     }
192 |    ],
193 |    "source": [
194 |     "# Start the game\n",
195 |     "cups = ['empty','empty','100$','empty']\n",
196 |     "# Shuffle cups\n",
197 |     "start_shuffling = shuffle_cups(cups)\n",
198 |     "# Guess a cup\n",
199 |     "guess = guess_a_cup()\n",
200 |     "# Check the cup\n",
201 |     "check_cup(start_shuffling, guess)"
202 |    ]
203 |   }
204 |  ],
205 |  "metadata": {
206 |   "kernelspec": {
207 |    "display_name": "Python 3",
208 |    "language": "python",
209 |    "name": "python3"
210 |   },
211 |   "language_info": {
212 |    "codemirror_mode": {
213 |     "name": "ipython",
214 |     "version": 3
215 |    },
216 |    "file_extension": ".py",
217 |    "mimetype": "text/x-python",
218 |    "name": "python",
219 |    "nbconvert_exporter": "python",
220 |    "pygments_lexer": "ipython3",
221 |    "version": "3.8.8"
222 |   }
223 |  },
224 |  "nbformat": 4,
225 |  "nbformat_minor": 5
226 | }
227 | 


--------------------------------------------------------------------------------
/IfElifandElse.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "24c7152d",
  7 |    "metadata": {},
  8 |    "outputs": [
  9 |     {
 10 |      "name": "stdout",
 11 |      "output_type": "stream",
 12 |      "text": [
 13 |       "CHARGE!\n"
 14 |      ]
 15 |     }
 16 |    ],
 17 |    "source": [
 18 |     "battery_low = True\n",
 19 |     "\n",
 20 |     "if battery_low:\n",
 21 |     "    print('CHARGE!')\n",
 22 |     "else: \n",
 23 |     "    print('Do not charge!')"
 24 |    ]
 25 |   },
 26 |   {
 27 |    "cell_type": "code",
 28 |    "execution_count": 2,
 29 |    "id": "23d7745f",
 30 |    "metadata": {},
 31 |    "outputs": [
 32 |     {
 33 |      "name": "stdout",
 34 |      "output_type": "stream",
 35 |      "text": [
 36 |       "Not in stock!\n"
 37 |      ]
 38 |     }
 39 |    ],
 40 |    "source": [
 41 |     "order = 'Pie'\n",
 42 |     "\n",
 43 |     "if order == 'Coffee':\n",
 44 |     "    print(\"Order a coffee!\")\n",
 45 |     "elif order == 'Hamburger':\n",
 46 |     "    print(\"Order a hamburger!\")\n",
 47 |     "elif order == 'Pizza':\n",
 48 |     "    print(\"Order a pizza!\")\n",
 49 |     "else:\n",
 50 |     "    print(\"Not in stock!\")"
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "code",
 55 |    "execution_count": 3,
 56 |    "id": "b464d725",
 57 |    "metadata": {},
 58 |    "outputs": [
 59 |     {
 60 |      "name": "stdout",
 61 |      "output_type": "stream",
 62 |      "text": [
 63 |       "Hey Luna!\n"
 64 |      ]
 65 |     }
 66 |    ],
 67 |    "source": [
 68 |     "cat = 'Luna'\n",
 69 |     "\n",
 70 |     "if cat == 'Goofy':\n",
 71 |     "    print('Hey Goofy!')\n",
 72 |     "elif cat == 'Luna':\n",
 73 |     "    print('Hey Luna!')\n",
 74 |     "elif cat == 'Jasper':\n",
 75 |     "    print('Hey Jasper!')\n",
 76 |     "else:\n",
 77 |     "    print(\"What is your cat's name?\")"
 78 |    ]
 79 |   }
 80 |  ],
 81 |  "metadata": {
 82 |   "kernelspec": {
 83 |    "display_name": "Python 3",
 84 |    "language": "python",
 85 |    "name": "python3"
 86 |   },
 87 |   "language_info": {
 88 |    "codemirror_mode": {
 89 |     "name": "ipython",
 90 |     "version": 3
 91 |    },
 92 |    "file_extension": ".py",
 93 |    "mimetype": "text/x-python",
 94 |    "name": "python",
 95 |    "nbconvert_exporter": "python",
 96 |    "pygments_lexer": "ipython3",
 97 |    "version": "3.8.8"
 98 |   }
 99 |  },
100 |  "nbformat": 4,
101 |  "nbformat_minor": 5
102 | }
103 | 


--------------------------------------------------------------------------------
/IndexingandSlicing.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 2,
  6 |    "id": "d948fe4a",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "text = \"This is a string\""
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 3,
 16 |    "id": "4ce42b1c",
 17 |    "metadata": {},
 18 |    "outputs": [
 19 |     {
 20 |      "data": {
 21 |       "text/plain": [
 22 |        "'T'"
 23 |       ]
 24 |      },
 25 |      "execution_count": 3,
 26 |      "metadata": {},
 27 |      "output_type": "execute_result"
 28 |     }
 29 |    ],
 30 |    "source": [
 31 |     "text[0]"
 32 |    ]
 33 |   },
 34 |   {
 35 |    "cell_type": "code",
 36 |    "execution_count": 4,
 37 |    "id": "aaac26d4",
 38 |    "metadata": {},
 39 |    "outputs": [
 40 |     {
 41 |      "data": {
 42 |       "text/plain": [
 43 |        "'s'"
 44 |       ]
 45 |      },
 46 |      "execution_count": 4,
 47 |      "metadata": {},
 48 |      "output_type": "execute_result"
 49 |     }
 50 |    ],
 51 |    "source": [
 52 |     "text[10]"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": 5,
 58 |    "id": "240d6129",
 59 |    "metadata": {},
 60 |    "outputs": [
 61 |     {
 62 |      "data": {
 63 |       "text/plain": [
 64 |        "'s'"
 65 |       ]
 66 |      },
 67 |      "execution_count": 5,
 68 |      "metadata": {},
 69 |      "output_type": "execute_result"
 70 |     }
 71 |    ],
 72 |    "source": [
 73 |     "text[-6]"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 6,
 79 |    "id": "f70a25f3",
 80 |    "metadata": {},
 81 |    "outputs": [
 82 |     {
 83 |      "data": {
 84 |       "text/plain": [
 85 |        "'a string'"
 86 |       ]
 87 |      },
 88 |      "execution_count": 6,
 89 |      "metadata": {},
 90 |      "output_type": "execute_result"
 91 |     }
 92 |    ],
 93 |    "source": [
 94 |     "text[8:]"
 95 |    ]
 96 |   },
 97 |   {
 98 |    "cell_type": "code",
 99 |    "execution_count": 7,
100 |    "id": "0c83040b",
101 |    "metadata": {},
102 |    "outputs": [
103 |     {
104 |      "data": {
105 |       "text/plain": [
106 |        "'Th'"
107 |       ]
108 |      },
109 |      "execution_count": 7,
110 |      "metadata": {},
111 |      "output_type": "execute_result"
112 |     }
113 |    ],
114 |    "source": [
115 |     "text[:2]"
116 |    ]
117 |   },
118 |   {
119 |    "cell_type": "code",
120 |    "execution_count": 8,
121 |    "id": "0cac1870",
122 |    "metadata": {},
123 |    "outputs": [
124 |     {
125 |      "data": {
126 |       "text/plain": [
127 |        "'str'"
128 |       ]
129 |      },
130 |      "execution_count": 8,
131 |      "metadata": {},
132 |      "output_type": "execute_result"
133 |     }
134 |    ],
135 |    "source": [
136 |     "text[10:13]"
137 |    ]
138 |   },
139 |   {
140 |    "cell_type": "code",
141 |    "execution_count": 13,
142 |    "id": "3dacac42",
143 |    "metadata": {},
144 |    "outputs": [
145 |     {
146 |      "data": {
147 |       "text/plain": [
148 |        "'This is a string'"
149 |       ]
150 |      },
151 |      "execution_count": 13,
152 |      "metadata": {},
153 |      "output_type": "execute_result"
154 |     }
155 |    ],
156 |    "source": [
157 |     "text[::]"
158 |    ]
159 |   },
160 |   {
161 |    "cell_type": "code",
162 |    "execution_count": 17,
163 |    "id": "cd3f2f00",
164 |    "metadata": {},
165 |    "outputs": [
166 |     {
167 |      "data": {
168 |       "text/plain": [
169 |        "'gnirts a si sihT'"
170 |       ]
171 |      },
172 |      "execution_count": 17,
173 |      "metadata": {},
174 |      "output_type": "execute_result"
175 |     }
176 |    ],
177 |    "source": [
178 |     "text[::-1]"
179 |    ]
180 |   }
181 |  ],
182 |  "metadata": {
183 |   "kernelspec": {
184 |    "display_name": "Python 3",
185 |    "language": "python",
186 |    "name": "python3"
187 |   },
188 |   "language_info": {
189 |    "codemirror_mode": {
190 |     "name": "ipython",
191 |     "version": 3
192 |    },
193 |    "file_extension": ".py",
194 |    "mimetype": "text/x-python",
195 |    "name": "python",
196 |    "nbconvert_exporter": "python",
197 |    "pygments_lexer": "ipython3",
198 |    "version": "3.8.8"
199 |   }
200 |  },
201 |  "nbformat": 4,
202 |  "nbformat_minor": 5
203 | }
204 | 


--------------------------------------------------------------------------------
/InheritancePolymorphismandAbstractClasses.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "72b0fb9f",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "class Machine():\n",
 11 |     "    \n",
 12 |     "    def __init__(self):\n",
 13 |     "        print(\"Machine started!\")\n",
 14 |     "        \n",
 15 |     "    def machine_type(self):\n",
 16 |     "        print(\"Machine type is vehicle.\")\n",
 17 |     "        \n",
 18 |     "    def drive(self):\n",
 19 |     "        print(\"Driving the machine...\")"
 20 |    ]
 21 |   },
 22 |   {
 23 |    "cell_type": "code",
 24 |    "execution_count": 2,
 25 |    "id": "e8c64973",
 26 |    "metadata": {},
 27 |    "outputs": [
 28 |     {
 29 |      "name": "stdout",
 30 |      "output_type": "stream",
 31 |      "text": [
 32 |       "Machine started!\n"
 33 |      ]
 34 |     }
 35 |    ],
 36 |    "source": [
 37 |     "machine1 = Machine()"
 38 |    ]
 39 |   },
 40 |   {
 41 |    "cell_type": "code",
 42 |    "execution_count": 3,
 43 |    "id": "a03fd253",
 44 |    "metadata": {},
 45 |    "outputs": [
 46 |     {
 47 |      "name": "stdout",
 48 |      "output_type": "stream",
 49 |      "text": [
 50 |       "Driving the machine...\n"
 51 |      ]
 52 |     }
 53 |    ],
 54 |    "source": [
 55 |     "machine1.drive()"
 56 |    ]
 57 |   },
 58 |   {
 59 |    "cell_type": "code",
 60 |    "execution_count": 4,
 61 |    "id": "a0e37d7c",
 62 |    "metadata": {},
 63 |    "outputs": [
 64 |     {
 65 |      "name": "stdout",
 66 |      "output_type": "stream",
 67 |      "text": [
 68 |       "Machine type is vehicle.\n"
 69 |      ]
 70 |     }
 71 |    ],
 72 |    "source": [
 73 |     "machine1.machine_type()"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 5,
 79 |    "id": "547ce5a7",
 80 |    "metadata": {},
 81 |    "outputs": [],
 82 |    "source": [
 83 |     "class Truck(Machine):\n",
 84 |     "    \n",
 85 |     "    def __init__(self):\n",
 86 |     "        Machine.__init__(self)\n",
 87 |     "        print(\"This is a truck!\")\n",
 88 |     "        \n",
 89 |     "    def drive(self):\n",
 90 |     "        print(\"Driving the truck...\")\n",
 91 |     "        \n",
 92 |     "    def load(self):\n",
 93 |     "        print(\"Loading the truck...\")"
 94 |    ]
 95 |   },
 96 |   {
 97 |    "cell_type": "code",
 98 |    "execution_count": 6,
 99 |    "id": "7c08b754",
100 |    "metadata": {},
101 |    "outputs": [
102 |     {
103 |      "name": "stdout",
104 |      "output_type": "stream",
105 |      "text": [
106 |       "Machine started!\n",
107 |       "This is a truck!\n"
108 |      ]
109 |     }
110 |    ],
111 |    "source": [
112 |     "truck1 = Truck()"
113 |    ]
114 |   },
115 |   {
116 |    "cell_type": "code",
117 |    "execution_count": 7,
118 |    "id": "77339a7c",
119 |    "metadata": {},
120 |    "outputs": [
121 |     {
122 |      "name": "stdout",
123 |      "output_type": "stream",
124 |      "text": [
125 |       "Driving the truck...\n"
126 |      ]
127 |     }
128 |    ],
129 |    "source": [
130 |     "truck1.drive()"
131 |    ]
132 |   },
133 |   {
134 |    "cell_type": "code",
135 |    "execution_count": 8,
136 |    "id": "c2d50563",
137 |    "metadata": {},
138 |    "outputs": [
139 |     {
140 |      "name": "stdout",
141 |      "output_type": "stream",
142 |      "text": [
143 |       "Loading the truck...\n"
144 |      ]
145 |     }
146 |    ],
147 |    "source": [
148 |     "truck1.load()"
149 |    ]
150 |   },
151 |   {
152 |    "cell_type": "code",
153 |    "execution_count": 9,
154 |    "id": "760db026",
155 |    "metadata": {},
156 |    "outputs": [],
157 |    "source": [
158 |     "class Car():\n",
159 |     "    \n",
160 |     "    def __init__(self,brand):\n",
161 |     "        self.brand = brand\n",
162 |     "        \n",
163 |     "    def drive(self):\n",
164 |     "        return 'I drive a ' + self.brand + ' car.'"
165 |    ]
166 |   },
167 |   {
168 |    "cell_type": "code",
169 |    "execution_count": 10,
170 |    "id": "6a16eae8",
171 |    "metadata": {},
172 |    "outputs": [],
173 |    "source": [
174 |     "class Truck():\n",
175 |     "    \n",
176 |     "    def __init__(self,brand):\n",
177 |     "        self.brand = brand\n",
178 |     "        \n",
179 |     "    def drive(self):\n",
180 |     "        return 'I drive a ' + self.brand + ' truck.'"
181 |    ]
182 |   },
183 |   {
184 |    "cell_type": "code",
185 |    "execution_count": 11,
186 |    "id": "4546bcf7",
187 |    "metadata": {},
188 |    "outputs": [],
189 |    "source": [
190 |     "volvo = Car('Volvo')\n",
191 |     "ford = Truck('Ford')"
192 |    ]
193 |   },
194 |   {
195 |    "cell_type": "code",
196 |    "execution_count": 12,
197 |    "id": "68698dde",
198 |    "metadata": {},
199 |    "outputs": [
200 |     {
201 |      "name": "stdout",
202 |      "output_type": "stream",
203 |      "text": [
204 |       "I drive a Ford truck.\n"
205 |      ]
206 |     }
207 |    ],
208 |    "source": [
209 |     "print(ford.drive())"
210 |    ]
211 |   },
212 |   {
213 |    "cell_type": "code",
214 |    "execution_count": 13,
215 |    "id": "4f4763bd",
216 |    "metadata": {},
217 |    "outputs": [
218 |     {
219 |      "name": "stdout",
220 |      "output_type": "stream",
221 |      "text": [
222 |       "I drive a Volvo car.\n"
223 |      ]
224 |     }
225 |    ],
226 |    "source": [
227 |     "print(volvo.drive())"
228 |    ]
229 |   },
230 |   {
231 |    "cell_type": "code",
232 |    "execution_count": 14,
233 |    "id": "e2f845ae",
234 |    "metadata": {},
235 |    "outputs": [
236 |     {
237 |      "name": "stdout",
238 |      "output_type": "stream",
239 |      "text": [
240 |       "<class '__main__.Car'>\n",
241 |       "I drive a Volvo car.\n",
242 |       "<class '__main__.Truck'>\n",
243 |       "I drive a Ford truck.\n"
244 |      ]
245 |     }
246 |    ],
247 |    "source": [
248 |     "for vehicle in [volvo, ford]:\n",
249 |     "    print(type(vehicle))\n",
250 |     "    print(vehicle.drive())"
251 |    ]
252 |   },
253 |   {
254 |    "cell_type": "code",
255 |    "execution_count": 15,
256 |    "id": "7fc78f39",
257 |    "metadata": {},
258 |    "outputs": [],
259 |    "source": [
260 |     "def vehicle_drive(vehicle):\n",
261 |     "    print(vehicle.drive())"
262 |    ]
263 |   },
264 |   {
265 |    "cell_type": "code",
266 |    "execution_count": 16,
267 |    "id": "cef94bb0",
268 |    "metadata": {},
269 |    "outputs": [
270 |     {
271 |      "name": "stdout",
272 |      "output_type": "stream",
273 |      "text": [
274 |       "I drive a Volvo car.\n"
275 |      ]
276 |     }
277 |    ],
278 |    "source": [
279 |     "vehicle_drive(volvo)"
280 |    ]
281 |   },
282 |   {
283 |    "cell_type": "code",
284 |    "execution_count": 17,
285 |    "id": "2ce55572",
286 |    "metadata": {},
287 |    "outputs": [
288 |     {
289 |      "name": "stdout",
290 |      "output_type": "stream",
291 |      "text": [
292 |       "I drive a Ford truck.\n"
293 |      ]
294 |     }
295 |    ],
296 |    "source": [
297 |     "vehicle_drive(ford)"
298 |    ]
299 |   },
300 |   {
301 |    "cell_type": "code",
302 |    "execution_count": 18,
303 |    "id": "b7b8da68",
304 |    "metadata": {},
305 |    "outputs": [],
306 |    "source": [
307 |     "class Machine():\n",
308 |     "    \n",
309 |     "    def __init__(self,brand):\n",
310 |     "        self.brand = brand\n",
311 |     "        \n",
312 |     "    def drive(self):\n",
313 |     "        raise NotImplementedError('Implement this method in a subclass.')"
314 |    ]
315 |   },
316 |   {
317 |    "cell_type": "code",
318 |    "execution_count": 19,
319 |    "id": "a07a015c",
320 |    "metadata": {},
321 |    "outputs": [],
322 |    "source": [
323 |     "class Car(Machine):\n",
324 |     "    \n",
325 |     "    def drive(self):\n",
326 |     "        print('I drive a ' + self.brand + ' car.')"
327 |    ]
328 |   },
329 |   {
330 |    "cell_type": "code",
331 |    "execution_count": 20,
332 |    "id": "00d75b38",
333 |    "metadata": {},
334 |    "outputs": [],
335 |    "source": [
336 |     "class Truck(Machine):\n",
337 |     "    \n",
338 |     "    def drive(self):\n",
339 |     "        print('I drive a ' + self.brand + ' truck.')"
340 |    ]
341 |   },
342 |   {
343 |    "cell_type": "code",
344 |    "execution_count": 21,
345 |    "id": "4bb8b47f",
346 |    "metadata": {},
347 |    "outputs": [],
348 |    "source": [
349 |     "daimler = Car('Daimler')"
350 |    ]
351 |   },
352 |   {
353 |    "cell_type": "code",
354 |    "execution_count": 22,
355 |    "id": "35a7e045",
356 |    "metadata": {},
357 |    "outputs": [],
358 |    "source": [
359 |     "chevrolet = Truck('Chevrolet')"
360 |    ]
361 |   },
362 |   {
363 |    "cell_type": "code",
364 |    "execution_count": 23,
365 |    "id": "9ee0ec92",
366 |    "metadata": {},
367 |    "outputs": [
368 |     {
369 |      "name": "stdout",
370 |      "output_type": "stream",
371 |      "text": [
372 |       "I drive a Daimler car.\n",
373 |       "None\n"
374 |      ]
375 |     }
376 |    ],
377 |    "source": [
378 |     "print(daimler.drive())"
379 |    ]
380 |   },
381 |   {
382 |    "cell_type": "code",
383 |    "execution_count": 24,
384 |    "id": "60a0eda4",
385 |    "metadata": {},
386 |    "outputs": [
387 |     {
388 |      "name": "stdout",
389 |      "output_type": "stream",
390 |      "text": [
391 |       "I drive a Chevrolet truck.\n",
392 |       "None\n"
393 |      ]
394 |     }
395 |    ],
396 |    "source": [
397 |     "print(chevrolet.drive())"
398 |    ]
399 |   }
400 |  ],
401 |  "metadata": {
402 |   "kernelspec": {
403 |    "display_name": "Python 3",
404 |    "language": "python",
405 |    "name": "python3"
406 |   },
407 |   "language_info": {
408 |    "codemirror_mode": {
409 |     "name": "ipython",
410 |     "version": 3
411 |    },
412 |    "file_extension": ".py",
413 |    "mimetype": "text/x-python",
414 |    "name": "python",
415 |    "nbconvert_exporter": "python",
416 |    "pygments_lexer": "ipython3",
417 |    "version": "3.8.8"
418 |   }
419 |  },
420 |  "nbformat": 4,
421 |  "nbformat_minor": 5
422 | }
423 | 


--------------------------------------------------------------------------------
/IntroductiontoFunctions.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 2,
  6 |    "id": "b0dd751a",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "def list_names():\n",
 11 |     "    print('Michael')\n",
 12 |     "    print('Patricia')\n",
 13 |     "    print('Mike')\n",
 14 |     "    print('Mary')\n",
 15 |     "    print('Robert')"
 16 |    ]
 17 |   },
 18 |   {
 19 |    "cell_type": "code",
 20 |    "execution_count": 3,
 21 |    "id": "c16af037",
 22 |    "metadata": {},
 23 |    "outputs": [
 24 |     {
 25 |      "name": "stdout",
 26 |      "output_type": "stream",
 27 |      "text": [
 28 |       "Michael\n",
 29 |       "Patricia\n",
 30 |       "Mike\n",
 31 |       "Mary\n",
 32 |       "Robert\n"
 33 |      ]
 34 |     }
 35 |    ],
 36 |    "source": [
 37 |     "list_names()"
 38 |    ]
 39 |   },
 40 |   {
 41 |    "cell_type": "code",
 42 |    "execution_count": 4,
 43 |    "id": "240597f3",
 44 |    "metadata": {},
 45 |    "outputs": [],
 46 |    "source": [
 47 |     "def people(name, age):\n",
 48 |     "    print(f\"{name} is {age} years old.\")"
 49 |    ]
 50 |   },
 51 |   {
 52 |    "cell_type": "code",
 53 |    "execution_count": 5,
 54 |    "id": "bc28c88d",
 55 |    "metadata": {},
 56 |    "outputs": [
 57 |     {
 58 |      "name": "stdout",
 59 |      "output_type": "stream",
 60 |      "text": [
 61 |       "Michael is 38 years old.\n"
 62 |      ]
 63 |     }
 64 |    ],
 65 |    "source": [
 66 |     "people('Michael', 38)"
 67 |    ]
 68 |   },
 69 |   {
 70 |    "cell_type": "code",
 71 |    "execution_count": 6,
 72 |    "id": "56323fdc",
 73 |    "metadata": {},
 74 |    "outputs": [
 75 |     {
 76 |      "name": "stdout",
 77 |      "output_type": "stream",
 78 |      "text": [
 79 |       "Mike is 31 years old.\n"
 80 |      ]
 81 |     }
 82 |    ],
 83 |    "source": [
 84 |     "people('Mike',31)"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": 7,
 90 |    "id": "005c8a4c",
 91 |    "metadata": {},
 92 |    "outputs": [],
 93 |    "source": [
 94 |     "def sum(value1, value2):\n",
 95 |     "    print(value1 + value2)"
 96 |    ]
 97 |   },
 98 |   {
 99 |    "cell_type": "code",
100 |    "execution_count": 8,
101 |    "id": "665ce044",
102 |    "metadata": {},
103 |    "outputs": [
104 |     {
105 |      "name": "stdout",
106 |      "output_type": "stream",
107 |      "text": [
108 |       "910\n"
109 |      ]
110 |     }
111 |    ],
112 |    "source": [
113 |     "printed_sum = sum('9','10')"
114 |    ]
115 |   },
116 |   {
117 |    "cell_type": "code",
118 |    "execution_count": 9,
119 |    "id": "ab37a46b",
120 |    "metadata": {},
121 |    "outputs": [],
122 |    "source": [
123 |     "printed_sum"
124 |    ]
125 |   },
126 |   {
127 |    "cell_type": "code",
128 |    "execution_count": 10,
129 |    "id": "3e736258",
130 |    "metadata": {},
131 |    "outputs": [
132 |     {
133 |      "data": {
134 |       "text/plain": [
135 |        "NoneType"
136 |       ]
137 |      },
138 |      "execution_count": 10,
139 |      "metadata": {},
140 |      "output_type": "execute_result"
141 |     }
142 |    ],
143 |    "source": [
144 |     "type(printed_sum)"
145 |    ]
146 |   }
147 |  ],
148 |  "metadata": {
149 |   "kernelspec": {
150 |    "display_name": "Python 3",
151 |    "language": "python",
152 |    "name": "python3"
153 |   },
154 |   "language_info": {
155 |    "codemirror_mode": {
156 |     "name": "ipython",
157 |     "version": 3
158 |    },
159 |    "file_extension": ".py",
160 |    "mimetype": "text/x-python",
161 |    "name": "python",
162 |    "nbconvert_exporter": "python",
163 |    "pygments_lexer": "ipython3",
164 |    "version": "3.8.8"
165 |   }
166 |  },
167 |  "nbformat": 4,
168 |  "nbformat_minor": 5
169 | }
170 | 


--------------------------------------------------------------------------------
/LambdaExpressions.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "982b9dd3",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "def discount(value):\n",
 11 |     "    return value-(value*0.30)"
 12 |    ]
 13 |   },
 14 |   {
 15 |    "cell_type": "code",
 16 |    "execution_count": 4,
 17 |    "id": "2a8ed740",
 18 |    "metadata": {},
 19 |    "outputs": [
 20 |     {
 21 |      "data": {
 22 |       "text/plain": [
 23 |        "7.0"
 24 |       ]
 25 |      },
 26 |      "execution_count": 4,
 27 |      "metadata": {},
 28 |      "output_type": "execute_result"
 29 |     }
 30 |    ],
 31 |    "source": [
 32 |     "discount(10)"
 33 |    ]
 34 |   },
 35 |   {
 36 |    "cell_type": "code",
 37 |    "execution_count": 5,
 38 |    "id": "d2b8eefb",
 39 |    "metadata": {},
 40 |    "outputs": [],
 41 |    "source": [
 42 |     "discount = lambda value:value-(value*0.30)"
 43 |    ]
 44 |   },
 45 |   {
 46 |    "cell_type": "code",
 47 |    "execution_count": 7,
 48 |    "id": "919366d9",
 49 |    "metadata": {},
 50 |    "outputs": [
 51 |     {
 52 |      "data": {
 53 |       "text/plain": [
 54 |        "70.0"
 55 |       ]
 56 |      },
 57 |      "execution_count": 7,
 58 |      "metadata": {},
 59 |      "output_type": "execute_result"
 60 |     }
 61 |    ],
 62 |    "source": [
 63 |     "discount(100)"
 64 |    ]
 65 |   },
 66 |   {
 67 |    "cell_type": "code",
 68 |    "execution_count": 15,
 69 |    "id": "2c5a8414",
 70 |    "metadata": {},
 71 |    "outputs": [],
 72 |    "source": [
 73 |     "numbers = [10,23,40,57,60,100]"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 16,
 79 |    "id": "e0bae82a",
 80 |    "metadata": {},
 81 |    "outputs": [
 82 |     {
 83 |      "data": {
 84 |       "text/plain": [
 85 |        "[7.0, 16.1, 28.0, 39.900000000000006, 42.0, 70.0]"
 86 |       ]
 87 |      },
 88 |      "execution_count": 16,
 89 |      "metadata": {},
 90 |      "output_type": "execute_result"
 91 |     }
 92 |    ],
 93 |    "source": [
 94 |     "list(map(lambda value:value-(value*0.30), numbers))"
 95 |    ]
 96 |   },
 97 |   {
 98 |    "cell_type": "code",
 99 |    "execution_count": 19,
100 |    "id": "da133ead",
101 |    "metadata": {},
102 |    "outputs": [],
103 |    "source": [
104 |     "def even_numbers(number):\n",
105 |     "    return number%2==0"
106 |    ]
107 |   },
108 |   {
109 |    "cell_type": "code",
110 |    "execution_count": 21,
111 |    "id": "6d268a51",
112 |    "metadata": {},
113 |    "outputs": [
114 |     {
115 |      "name": "stdout",
116 |      "output_type": "stream",
117 |      "text": [
118 |       "10\n",
119 |       "40\n",
120 |       "60\n",
121 |       "100\n"
122 |      ]
123 |     }
124 |    ],
125 |    "source": [
126 |     "for x in filter(lambda number:number%2==0, numbers):\n",
127 |     "    print (x)"
128 |    ]
129 |   },
130 |   {
131 |    "cell_type": "code",
132 |    "execution_count": 22,
133 |    "id": "4cc13d97",
134 |    "metadata": {},
135 |    "outputs": [
136 |     {
137 |      "data": {
138 |       "text/plain": [
139 |        "[10, 40, 60, 100]"
140 |       ]
141 |      },
142 |      "execution_count": 22,
143 |      "metadata": {},
144 |      "output_type": "execute_result"
145 |     }
146 |    ],
147 |    "source": [
148 |     "list(filter(lambda number:number%2==0, numbers))"
149 |    ]
150 |   }
151 |  ],
152 |  "metadata": {
153 |   "kernelspec": {
154 |    "display_name": "Python 3",
155 |    "language": "python",
156 |    "name": "python3"
157 |   },
158 |   "language_info": {
159 |    "codemirror_mode": {
160 |     "name": "ipython",
161 |     "version": 3
162 |    },
163 |    "file_extension": ".py",
164 |    "mimetype": "text/x-python",
165 |    "name": "python",
166 |    "nbconvert_exporter": "python",
167 |    "pygments_lexer": "ipython3",
168 |    "version": "3.8.8"
169 |   }
170 |  },
171 |  "nbformat": 4,
172 |  "nbformat_minor": 5
173 | }
174 | 


--------------------------------------------------------------------------------
/ListComprehensions.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 2,
  6 |    "id": "013255b4",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "name = 'Jonathan'"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 3,
 16 |    "id": "cdce4bd6",
 17 |    "metadata": {},
 18 |    "outputs": [],
 19 |    "source": [
 20 |     "letters = []\n",
 21 |     "\n",
 22 |     "for element in name:\n",
 23 |     "    letters.append(element)"
 24 |    ]
 25 |   },
 26 |   {
 27 |    "cell_type": "code",
 28 |    "execution_count": 4,
 29 |    "id": "b91f1557",
 30 |    "metadata": {},
 31 |    "outputs": [
 32 |     {
 33 |      "data": {
 34 |       "text/plain": [
 35 |        "['J', 'o', 'n', 'a', 't', 'h', 'a', 'n']"
 36 |       ]
 37 |      },
 38 |      "execution_count": 4,
 39 |      "metadata": {},
 40 |      "output_type": "execute_result"
 41 |     }
 42 |    ],
 43 |    "source": [
 44 |     "letters"
 45 |    ]
 46 |   },
 47 |   {
 48 |    "cell_type": "code",
 49 |    "execution_count": 8,
 50 |    "id": "5f25e9e1",
 51 |    "metadata": {},
 52 |    "outputs": [],
 53 |    "source": [
 54 |     "letters = [element for element in name]"
 55 |    ]
 56 |   },
 57 |   {
 58 |    "cell_type": "code",
 59 |    "execution_count": 9,
 60 |    "id": "7552fa19",
 61 |    "metadata": {},
 62 |    "outputs": [
 63 |     {
 64 |      "data": {
 65 |       "text/plain": [
 66 |        "['J', 'o', 'n', 'a', 't', 'h', 'a', 'n']"
 67 |       ]
 68 |      },
 69 |      "execution_count": 9,
 70 |      "metadata": {},
 71 |      "output_type": "execute_result"
 72 |     }
 73 |    ],
 74 |    "source": [
 75 |     "letters"
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "code",
 80 |    "execution_count": 12,
 81 |    "id": "d4a0ad6e",
 82 |    "metadata": {},
 83 |    "outputs": [],
 84 |    "source": [
 85 |     "value_list = [numbers*2 for numbers in range(1,20)]"
 86 |    ]
 87 |   },
 88 |   {
 89 |    "cell_type": "code",
 90 |    "execution_count": 13,
 91 |    "id": "e012f46b",
 92 |    "metadata": {},
 93 |    "outputs": [
 94 |     {
 95 |      "data": {
 96 |       "text/plain": [
 97 |        "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38]"
 98 |       ]
 99 |      },
100 |      "execution_count": 13,
101 |      "metadata": {},
102 |      "output_type": "execute_result"
103 |     }
104 |    ],
105 |    "source": [
106 |     "value_list"
107 |    ]
108 |   },
109 |   {
110 |    "cell_type": "code",
111 |    "execution_count": 14,
112 |    "id": "7152859f",
113 |    "metadata": {},
114 |    "outputs": [],
115 |    "source": [
116 |     "value_list = [numbers for numbers in range(1,20) if numbers%2==0]"
117 |    ]
118 |   },
119 |   {
120 |    "cell_type": "code",
121 |    "execution_count": 15,
122 |    "id": "6675883c",
123 |    "metadata": {},
124 |    "outputs": [
125 |     {
126 |      "data": {
127 |       "text/plain": [
128 |        "[2, 4, 6, 8, 10, 12, 14, 16, 18]"
129 |       ]
130 |      },
131 |      "execution_count": 15,
132 |      "metadata": {},
133 |      "output_type": "execute_result"
134 |     }
135 |    ],
136 |    "source": [
137 |     "value_list"
138 |    ]
139 |   },
140 |   {
141 |    "cell_type": "code",
142 |    "execution_count": 16,
143 |    "id": "f5289dc8",
144 |    "metadata": {},
145 |    "outputs": [],
146 |    "source": [
147 |     "values = [number if number%2==0 else 'Odd number' for number in range(1,20)]"
148 |    ]
149 |   },
150 |   {
151 |    "cell_type": "code",
152 |    "execution_count": 17,
153 |    "id": "c2174982",
154 |    "metadata": {},
155 |    "outputs": [
156 |     {
157 |      "data": {
158 |       "text/plain": [
159 |        "['Odd number',\n",
160 |        " 2,\n",
161 |        " 'Odd number',\n",
162 |        " 4,\n",
163 |        " 'Odd number',\n",
164 |        " 6,\n",
165 |        " 'Odd number',\n",
166 |        " 8,\n",
167 |        " 'Odd number',\n",
168 |        " 10,\n",
169 |        " 'Odd number',\n",
170 |        " 12,\n",
171 |        " 'Odd number',\n",
172 |        " 14,\n",
173 |        " 'Odd number',\n",
174 |        " 16,\n",
175 |        " 'Odd number',\n",
176 |        " 18,\n",
177 |        " 'Odd number']"
178 |       ]
179 |      },
180 |      "execution_count": 17,
181 |      "metadata": {},
182 |      "output_type": "execute_result"
183 |     }
184 |    ],
185 |    "source": [
186 |     "values"
187 |    ]
188 |   },
189 |   {
190 |    "cell_type": "code",
191 |    "execution_count": 18,
192 |    "id": "e462b7ff",
193 |    "metadata": {},
194 |    "outputs": [],
195 |    "source": [
196 |     "my_values = []\n",
197 |     "\n",
198 |     "for j in [2,3,4]:\n",
199 |     "    for k in [1,10,100]:\n",
200 |     "        my_values.append(j*k)"
201 |    ]
202 |   },
203 |   {
204 |    "cell_type": "code",
205 |    "execution_count": 19,
206 |    "id": "86d1721b",
207 |    "metadata": {},
208 |    "outputs": [
209 |     {
210 |      "data": {
211 |       "text/plain": [
212 |        "[2, 20, 200, 3, 30, 300, 4, 40, 400]"
213 |       ]
214 |      },
215 |      "execution_count": 19,
216 |      "metadata": {},
217 |      "output_type": "execute_result"
218 |     }
219 |    ],
220 |    "source": [
221 |     "my_values"
222 |    ]
223 |   },
224 |   {
225 |    "cell_type": "code",
226 |    "execution_count": 20,
227 |    "id": "f37587bb",
228 |    "metadata": {},
229 |    "outputs": [],
230 |    "source": [
231 |     "my_values = [j*k for j in [2,3,4] for k in [1,10,100]]"
232 |    ]
233 |   },
234 |   {
235 |    "cell_type": "code",
236 |    "execution_count": 21,
237 |    "id": "c80bb6b9",
238 |    "metadata": {},
239 |    "outputs": [
240 |     {
241 |      "data": {
242 |       "text/plain": [
243 |        "[2, 20, 200, 3, 30, 300, 4, 40, 400]"
244 |       ]
245 |      },
246 |      "execution_count": 21,
247 |      "metadata": {},
248 |      "output_type": "execute_result"
249 |     }
250 |    ],
251 |    "source": [
252 |     "my_values"
253 |    ]
254 |   }
255 |  ],
256 |  "metadata": {
257 |   "kernelspec": {
258 |    "display_name": "Python 3",
259 |    "language": "python",
260 |    "name": "python3"
261 |   },
262 |   "language_info": {
263 |    "codemirror_mode": {
264 |     "name": "ipython",
265 |     "version": 3
266 |    },
267 |    "file_extension": ".py",
268 |    "mimetype": "text/x-python",
269 |    "name": "python",
270 |    "nbconvert_exporter": "python",
271 |    "pygments_lexer": "ipython3",
272 |    "version": "3.8.8"
273 |   }
274 |  },
275 |  "nbformat": 4,
276 |  "nbformat_minor": 5
277 | }
278 | 


--------------------------------------------------------------------------------
/Lists.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "fde64feb",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "list_example = ['one', 2, 5.9]"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "id": "9d73b934",
 17 |    "metadata": {},
 18 |    "outputs": [
 19 |     {
 20 |      "data": {
 21 |       "text/plain": [
 22 |        "'one'"
 23 |       ]
 24 |      },
 25 |      "execution_count": 2,
 26 |      "metadata": {},
 27 |      "output_type": "execute_result"
 28 |     }
 29 |    ],
 30 |    "source": [
 31 |     "list_example[0]"
 32 |    ]
 33 |   },
 34 |   {
 35 |    "cell_type": "code",
 36 |    "execution_count": 3,
 37 |    "id": "9c946dc8",
 38 |    "metadata": {},
 39 |    "outputs": [
 40 |     {
 41 |      "data": {
 42 |       "text/plain": [
 43 |        "[2, 5.9]"
 44 |       ]
 45 |      },
 46 |      "execution_count": 3,
 47 |      "metadata": {},
 48 |      "output_type": "execute_result"
 49 |     }
 50 |    ],
 51 |    "source": [
 52 |     "list_example[1:]"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": 4,
 58 |    "id": "8fd0bcf8",
 59 |    "metadata": {},
 60 |    "outputs": [],
 61 |    "source": [
 62 |     "colors = ['blue', 'red', 'green']"
 63 |    ]
 64 |   },
 65 |   {
 66 |    "cell_type": "code",
 67 |    "execution_count": 5,
 68 |    "id": "04a39980",
 69 |    "metadata": {},
 70 |    "outputs": [],
 71 |    "source": [
 72 |     "new_colors = ['purple', 'grey']"
 73 |    ]
 74 |   },
 75 |   {
 76 |    "cell_type": "code",
 77 |    "execution_count": 6,
 78 |    "id": "e8a0ba69",
 79 |    "metadata": {},
 80 |    "outputs": [
 81 |     {
 82 |      "data": {
 83 |       "text/plain": [
 84 |        "['blue', 'red', 'green', 'purple', 'grey']"
 85 |       ]
 86 |      },
 87 |      "execution_count": 6,
 88 |      "metadata": {},
 89 |      "output_type": "execute_result"
 90 |     }
 91 |    ],
 92 |    "source": [
 93 |     "colors + new_colors"
 94 |    ]
 95 |   },
 96 |   {
 97 |    "cell_type": "code",
 98 |    "execution_count": 7,
 99 |    "id": "8546fcaa",
100 |    "metadata": {},
101 |    "outputs": [
102 |     {
103 |      "data": {
104 |       "text/plain": [
105 |        "['blue', 'red', 'green']"
106 |       ]
107 |      },
108 |      "execution_count": 7,
109 |      "metadata": {},
110 |      "output_type": "execute_result"
111 |     }
112 |    ],
113 |    "source": [
114 |     "colors"
115 |    ]
116 |   },
117 |   {
118 |    "cell_type": "code",
119 |    "execution_count": 8,
120 |    "id": "652f4da8",
121 |    "metadata": {},
122 |    "outputs": [],
123 |    "source": [
124 |     "concatenated_list = colors + new_colors"
125 |    ]
126 |   },
127 |   {
128 |    "cell_type": "code",
129 |    "execution_count": 9,
130 |    "id": "55e1f6b5",
131 |    "metadata": {},
132 |    "outputs": [
133 |     {
134 |      "data": {
135 |       "text/plain": [
136 |        "['blue', 'red', 'green', 'purple', 'grey']"
137 |       ]
138 |      },
139 |      "execution_count": 9,
140 |      "metadata": {},
141 |      "output_type": "execute_result"
142 |     }
143 |    ],
144 |    "source": [
145 |     "concatenated_list"
146 |    ]
147 |   },
148 |   {
149 |    "cell_type": "code",
150 |    "execution_count": 10,
151 |    "id": "be6a3491",
152 |    "metadata": {},
153 |    "outputs": [],
154 |    "source": [
155 |     "colors[0] = \"BLUE\""
156 |    ]
157 |   },
158 |   {
159 |    "cell_type": "code",
160 |    "execution_count": 11,
161 |    "id": "ec1935c8",
162 |    "metadata": {},
163 |    "outputs": [
164 |     {
165 |      "data": {
166 |       "text/plain": [
167 |        "['BLUE', 'red', 'green']"
168 |       ]
169 |      },
170 |      "execution_count": 11,
171 |      "metadata": {},
172 |      "output_type": "execute_result"
173 |     }
174 |    ],
175 |    "source": [
176 |     "colors"
177 |    ]
178 |   },
179 |   {
180 |    "cell_type": "code",
181 |    "execution_count": 12,
182 |    "id": "be24163a",
183 |    "metadata": {},
184 |    "outputs": [],
185 |    "source": [
186 |     "colors.append('brown')"
187 |    ]
188 |   },
189 |   {
190 |    "cell_type": "code",
191 |    "execution_count": 13,
192 |    "id": "1fb5e707",
193 |    "metadata": {},
194 |    "outputs": [
195 |     {
196 |      "data": {
197 |       "text/plain": [
198 |        "['BLUE', 'red', 'green', 'brown']"
199 |       ]
200 |      },
201 |      "execution_count": 13,
202 |      "metadata": {},
203 |      "output_type": "execute_result"
204 |     }
205 |    ],
206 |    "source": [
207 |     "colors"
208 |    ]
209 |   },
210 |   {
211 |    "cell_type": "code",
212 |    "execution_count": 14,
213 |    "id": "7a07a55c",
214 |    "metadata": {},
215 |    "outputs": [],
216 |    "source": [
217 |     "colors.append('gold')"
218 |    ]
219 |   },
220 |   {
221 |    "cell_type": "code",
222 |    "execution_count": 15,
223 |    "id": "2c4cf972",
224 |    "metadata": {},
225 |    "outputs": [
226 |     {
227 |      "data": {
228 |       "text/plain": [
229 |        "['BLUE', 'red', 'green', 'brown', 'gold']"
230 |       ]
231 |      },
232 |      "execution_count": 15,
233 |      "metadata": {},
234 |      "output_type": "execute_result"
235 |     }
236 |    ],
237 |    "source": [
238 |     "colors"
239 |    ]
240 |   },
241 |   {
242 |    "cell_type": "code",
243 |    "execution_count": 16,
244 |    "id": "82c7a342",
245 |    "metadata": {},
246 |    "outputs": [],
247 |    "source": [
248 |     "removed_item = colors.pop()"
249 |    ]
250 |   },
251 |   {
252 |    "cell_type": "code",
253 |    "execution_count": 17,
254 |    "id": "e9f4683b",
255 |    "metadata": {},
256 |    "outputs": [
257 |     {
258 |      "data": {
259 |       "text/plain": [
260 |        "['BLUE', 'red', 'green', 'brown']"
261 |       ]
262 |      },
263 |      "execution_count": 17,
264 |      "metadata": {},
265 |      "output_type": "execute_result"
266 |     }
267 |    ],
268 |    "source": [
269 |     "colors"
270 |    ]
271 |   },
272 |   {
273 |    "cell_type": "code",
274 |    "execution_count": 18,
275 |    "id": "9a9b1a82",
276 |    "metadata": {},
277 |    "outputs": [
278 |     {
279 |      "data": {
280 |       "text/plain": [
281 |        "'gold'"
282 |       ]
283 |      },
284 |      "execution_count": 18,
285 |      "metadata": {},
286 |      "output_type": "execute_result"
287 |     }
288 |    ],
289 |    "source": [
290 |     "removed_item"
291 |    ]
292 |   },
293 |   {
294 |    "cell_type": "code",
295 |    "execution_count": 19,
296 |    "id": "6b326ec5",
297 |    "metadata": {},
298 |    "outputs": [
299 |     {
300 |      "data": {
301 |       "text/plain": [
302 |        "'red'"
303 |       ]
304 |      },
305 |      "execution_count": 19,
306 |      "metadata": {},
307 |      "output_type": "execute_result"
308 |     }
309 |    ],
310 |    "source": [
311 |     "colors.pop(1)"
312 |    ]
313 |   },
314 |   {
315 |    "cell_type": "code",
316 |    "execution_count": 20,
317 |    "id": "c6554459",
318 |    "metadata": {},
319 |    "outputs": [],
320 |    "source": [
321 |     "numbers = [1,2,3,4]"
322 |    ]
323 |   },
324 |   {
325 |    "cell_type": "code",
326 |    "execution_count": 21,
327 |    "id": "6c0a1f98",
328 |    "metadata": {},
329 |    "outputs": [],
330 |    "source": [
331 |     "reversed_numbers = numbers.reverse()"
332 |    ]
333 |   },
334 |   {
335 |    "cell_type": "code",
336 |    "execution_count": 22,
337 |    "id": "c236b525",
338 |    "metadata": {},
339 |    "outputs": [
340 |     {
341 |      "data": {
342 |       "text/plain": [
343 |        "[4, 3, 2, 1]"
344 |       ]
345 |      },
346 |      "execution_count": 22,
347 |      "metadata": {},
348 |      "output_type": "execute_result"
349 |     }
350 |    ],
351 |    "source": [
352 |     "numbers"
353 |    ]
354 |   },
355 |   {
356 |    "cell_type": "code",
357 |    "execution_count": 23,
358 |    "id": "40d8e0a7",
359 |    "metadata": {},
360 |    "outputs": [],
361 |    "source": [
362 |     "reversed_numbers"
363 |    ]
364 |   },
365 |   {
366 |    "cell_type": "code",
367 |    "execution_count": 24,
368 |    "id": "7ebb6b1d",
369 |    "metadata": {},
370 |    "outputs": [
371 |     {
372 |      "data": {
373 |       "text/plain": [
374 |        "NoneType"
375 |       ]
376 |      },
377 |      "execution_count": 24,
378 |      "metadata": {},
379 |      "output_type": "execute_result"
380 |     }
381 |    ],
382 |    "source": [
383 |     "type(reversed_numbers)"
384 |    ]
385 |   },
386 |   {
387 |    "cell_type": "code",
388 |    "execution_count": 25,
389 |    "id": "3eb2a961",
390 |    "metadata": {},
391 |    "outputs": [],
392 |    "source": [
393 |     "numbers.reverse()\n",
394 |     "reversed_numbers = numbers"
395 |    ]
396 |   },
397 |   {
398 |    "cell_type": "code",
399 |    "execution_count": 26,
400 |    "id": "521546a3",
401 |    "metadata": {},
402 |    "outputs": [
403 |     {
404 |      "data": {
405 |       "text/plain": [
406 |        "[1, 2, 3, 4]"
407 |       ]
408 |      },
409 |      "execution_count": 26,
410 |      "metadata": {},
411 |      "output_type": "execute_result"
412 |     }
413 |    ],
414 |    "source": [
415 |     "reversed_numbers"
416 |    ]
417 |   },
418 |   {
419 |    "cell_type": "code",
420 |    "execution_count": 27,
421 |    "id": "aa58490b",
422 |    "metadata": {},
423 |    "outputs": [],
424 |    "source": [
425 |     "numbers.sort()"
426 |    ]
427 |   },
428 |   {
429 |    "cell_type": "code",
430 |    "execution_count": 28,
431 |    "id": "82fbeca7",
432 |    "metadata": {},
433 |    "outputs": [
434 |     {
435 |      "data": {
436 |       "text/plain": [
437 |        "[1, 2, 3, 4]"
438 |       ]
439 |      },
440 |      "execution_count": 28,
441 |      "metadata": {},
442 |      "output_type": "execute_result"
443 |     }
444 |    ],
445 |    "source": [
446 |     "numbers"
447 |    ]
448 |   },
449 |   {
450 |    "cell_type": "code",
451 |    "execution_count": 29,
452 |    "id": "0cb4de28",
453 |    "metadata": {},
454 |    "outputs": [],
455 |    "source": [
456 |     "colors.sort()"
457 |    ]
458 |   },
459 |   {
460 |    "cell_type": "code",
461 |    "execution_count": 30,
462 |    "id": "93dcc820",
463 |    "metadata": {},
464 |    "outputs": [
465 |     {
466 |      "data": {
467 |       "text/plain": [
468 |        "['BLUE', 'brown', 'green']"
469 |       ]
470 |      },
471 |      "execution_count": 30,
472 |      "metadata": {},
473 |      "output_type": "execute_result"
474 |     }
475 |    ],
476 |    "source": [
477 |     "colors"
478 |    ]
479 |   },
480 |   {
481 |    "cell_type": "code",
482 |    "execution_count": 31,
483 |    "id": "6af37fb8",
484 |    "metadata": {},
485 |    "outputs": [
486 |     {
487 |      "data": {
488 |       "text/plain": [
489 |        "3"
490 |       ]
491 |      },
492 |      "execution_count": 31,
493 |      "metadata": {},
494 |      "output_type": "execute_result"
495 |     }
496 |    ],
497 |    "source": [
498 |     "len(colors)"
499 |    ]
500 |   }
501 |  ],
502 |  "metadata": {
503 |   "kernelspec": {
504 |    "display_name": "Python 3",
505 |    "language": "python",
506 |    "name": "python3"
507 |   },
508 |   "language_info": {
509 |    "codemirror_mode": {
510 |     "name": "ipython",
511 |     "version": 3
512 |    },
513 |    "file_extension": ".py",
514 |    "mimetype": "text/x-python",
515 |    "name": "python",
516 |    "nbconvert_exporter": "python",
517 |    "pygments_lexer": "ipython3",
518 |    "version": "3.8.8"
519 |   }
520 |  },
521 |  "nbformat": 4,
522 |  "nbformat_minor": 5
523 | }
524 | 


--------------------------------------------------------------------------------
/LogicStatementsandTupleUnpackinginFunctions.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "67812b37",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "def is_even_list(my_list):\n",
 11 |     "    \n",
 12 |     "    even_numbers=[]\n",
 13 |     "    \n",
 14 |     "    for value in my_list:\n",
 15 |     "        if value%2==0:\n",
 16 |     "            even_numbers.append(value)\n",
 17 |     "        else:\n",
 18 |     "            pass\n",
 19 |     "    return even_numbers"
 20 |    ]
 21 |   },
 22 |   {
 23 |    "cell_type": "code",
 24 |    "execution_count": 2,
 25 |    "id": "c071c52b",
 26 |    "metadata": {},
 27 |    "outputs": [
 28 |     {
 29 |      "data": {
 30 |       "text/plain": [
 31 |        "[10, 2, 8, 40, 6, 80]"
 32 |       ]
 33 |      },
 34 |      "execution_count": 2,
 35 |      "metadata": {},
 36 |      "output_type": "execute_result"
 37 |     }
 38 |    ],
 39 |    "source": [
 40 |     "is_even_list([10,1,2,8,40,5,6,7,80])"
 41 |    ]
 42 |   },
 43 |   {
 44 |    "cell_type": "markdown",
 45 |    "id": "8df9452b",
 46 |    "metadata": {},
 47 |    "source": [
 48 |     "def is_even(value):\n",
 49 |     "    return value%2==0"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "code",
 54 |    "execution_count": 3,
 55 |    "id": "03232438",
 56 |    "metadata": {},
 57 |    "outputs": [],
 58 |    "source": [
 59 |     "def is_even(value): \n",
 60 |     "    return value%2==0"
 61 |    ]
 62 |   },
 63 |   {
 64 |    "cell_type": "code",
 65 |    "execution_count": 4,
 66 |    "id": "92546469",
 67 |    "metadata": {},
 68 |    "outputs": [
 69 |     {
 70 |      "data": {
 71 |       "text/plain": [
 72 |        "True"
 73 |       ]
 74 |      },
 75 |      "execution_count": 4,
 76 |      "metadata": {},
 77 |      "output_type": "execute_result"
 78 |     }
 79 |    ],
 80 |    "source": [
 81 |     "is_even(100)"
 82 |    ]
 83 |   },
 84 |   {
 85 |    "cell_type": "code",
 86 |    "execution_count": 5,
 87 |    "id": "58cef944",
 88 |    "metadata": {},
 89 |    "outputs": [
 90 |     {
 91 |      "data": {
 92 |       "text/plain": [
 93 |        "False"
 94 |       ]
 95 |      },
 96 |      "execution_count": 5,
 97 |      "metadata": {},
 98 |      "output_type": "execute_result"
 99 |     }
100 |    ],
101 |    "source": [
102 |     "is_even(101)"
103 |    ]
104 |   },
105 |   {
106 |    "cell_type": "code",
107 |    "execution_count": 6,
108 |    "id": "e9569544",
109 |    "metadata": {},
110 |    "outputs": [],
111 |    "source": [
112 |     "laptops = [('Dell', 800), ('HP', 600), ('Lenovo', 700)]"
113 |    ]
114 |   },
115 |   {
116 |    "cell_type": "code",
117 |    "execution_count": 7,
118 |    "id": "dd8fc715",
119 |    "metadata": {},
120 |    "outputs": [
121 |     {
122 |      "name": "stdout",
123 |      "output_type": "stream",
124 |      "text": [
125 |       "('Dell', 800)\n",
126 |       "('HP', 600)\n",
127 |       "('Lenovo', 700)\n"
128 |      ]
129 |     }
130 |    ],
131 |    "source": [
132 |     "for item in laptops:\n",
133 |     "    print(item)"
134 |    ]
135 |   },
136 |   {
137 |    "cell_type": "code",
138 |    "execution_count": 8,
139 |    "id": "e73c2713",
140 |    "metadata": {},
141 |    "outputs": [
142 |     {
143 |      "name": "stdout",
144 |      "output_type": "stream",
145 |      "text": [
146 |       "640.0\n",
147 |       "480.0\n",
148 |       "560.0\n"
149 |      ]
150 |     }
151 |    ],
152 |    "source": [
153 |     "for laptop, price in laptops:\n",
154 |     "    print(price-(0.2*price))"
155 |    ]
156 |   },
157 |   {
158 |    "cell_type": "code",
159 |    "execution_count": 9,
160 |    "id": "2003ac12",
161 |    "metadata": {},
162 |    "outputs": [],
163 |    "source": [
164 |     "exam_points = [('Luis', 78), ('Angelica', 89), ('Ottilie', 56)]"
165 |    ]
166 |   },
167 |   {
168 |    "cell_type": "code",
169 |    "execution_count": 10,
170 |    "id": "4f7e6c1b",
171 |    "metadata": {},
172 |    "outputs": [],
173 |    "source": [
174 |     "def student_rank(exam_points):\n",
175 |     "    max_points = 0\n",
176 |     "    best_student = ''\n",
177 |     "    \n",
178 |     "    for student, points in exam_points:\n",
179 |     "        if points > max_points:\n",
180 |     "            max_points = points\n",
181 |     "            best_student = student\n",
182 |     "        else:\n",
183 |     "            pass\n",
184 |     "    \n",
185 |     "    return(best_student, max_points)"
186 |    ]
187 |   },
188 |   {
189 |    "cell_type": "code",
190 |    "execution_count": 11,
191 |    "id": "455880e6",
192 |    "metadata": {},
193 |    "outputs": [],
194 |    "source": [
195 |     "best_ranked_student = student_rank(exam_points)"
196 |    ]
197 |   },
198 |   {
199 |    "cell_type": "code",
200 |    "execution_count": 12,
201 |    "id": "3d7657c6",
202 |    "metadata": {},
203 |    "outputs": [],
204 |    "source": [
205 |     "name, points = student_rank(exam_points)"
206 |    ]
207 |   },
208 |   {
209 |    "cell_type": "code",
210 |    "execution_count": 13,
211 |    "id": "00162c31",
212 |    "metadata": {},
213 |    "outputs": [
214 |     {
215 |      "data": {
216 |       "text/plain": [
217 |        "('Angelica', 89)"
218 |       ]
219 |      },
220 |      "execution_count": 13,
221 |      "metadata": {},
222 |      "output_type": "execute_result"
223 |     }
224 |    ],
225 |    "source": [
226 |     "best_ranked_student"
227 |    ]
228 |   },
229 |   {
230 |    "cell_type": "code",
231 |    "execution_count": 14,
232 |    "id": "3ddb2c37",
233 |    "metadata": {},
234 |    "outputs": [
235 |     {
236 |      "data": {
237 |       "text/plain": [
238 |        "'Angelica'"
239 |       ]
240 |      },
241 |      "execution_count": 14,
242 |      "metadata": {},
243 |      "output_type": "execute_result"
244 |     }
245 |    ],
246 |    "source": [
247 |     "name"
248 |    ]
249 |   },
250 |   {
251 |    "cell_type": "code",
252 |    "execution_count": 15,
253 |    "id": "a21d0b93",
254 |    "metadata": {},
255 |    "outputs": [
256 |     {
257 |      "data": {
258 |       "text/plain": [
259 |        "89"
260 |       ]
261 |      },
262 |      "execution_count": 15,
263 |      "metadata": {},
264 |      "output_type": "execute_result"
265 |     }
266 |    ],
267 |    "source": [
268 |     "points"
269 |    ]
270 |   }
271 |  ],
272 |  "metadata": {
273 |   "kernelspec": {
274 |    "display_name": "Python 3",
275 |    "language": "python",
276 |    "name": "python3"
277 |   },
278 |   "language_info": {
279 |    "codemirror_mode": {
280 |     "name": "ipython",
281 |     "version": 3
282 |    },
283 |    "file_extension": ".py",
284 |    "mimetype": "text/x-python",
285 |    "name": "python",
286 |    "nbconvert_exporter": "python",
287 |    "pygments_lexer": "ipython3",
288 |    "version": "3.8.8"
289 |   }
290 |  },
291 |  "nbformat": 4,
292 |  "nbformat_minor": 5
293 | }
294 | 


--------------------------------------------------------------------------------
/MapandFilterFunctions.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "827feb0d",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "def percentage(value):\n",
 11 |     "    return value*0.20"
 12 |    ]
 13 |   },
 14 |   {
 15 |    "cell_type": "code",
 16 |    "execution_count": 2,
 17 |    "id": "aa654761",
 18 |    "metadata": {},
 19 |    "outputs": [],
 20 |    "source": [
 21 |     "value_list = [5,10,35,100,1000]"
 22 |    ]
 23 |   },
 24 |   {
 25 |    "cell_type": "code",
 26 |    "execution_count": 3,
 27 |    "id": "57833924",
 28 |    "metadata": {},
 29 |    "outputs": [
 30 |     {
 31 |      "name": "stdout",
 32 |      "output_type": "stream",
 33 |      "text": [
 34 |       "1.0\n",
 35 |       "2.0\n",
 36 |       "7.0\n",
 37 |       "20.0\n",
 38 |       "200.0\n"
 39 |      ]
 40 |     }
 41 |    ],
 42 |    "source": [
 43 |     "for number in map(percentage, value_list):\n",
 44 |     "    print(number)"
 45 |    ]
 46 |   },
 47 |   {
 48 |    "cell_type": "code",
 49 |    "execution_count": 4,
 50 |    "id": "56ba6901",
 51 |    "metadata": {},
 52 |    "outputs": [
 53 |     {
 54 |      "data": {
 55 |       "text/plain": [
 56 |        "[1.0, 2.0, 7.0, 20.0, 200.0]"
 57 |       ]
 58 |      },
 59 |      "execution_count": 4,
 60 |      "metadata": {},
 61 |      "output_type": "execute_result"
 62 |     }
 63 |    ],
 64 |    "source": [
 65 |     "list(map(percentage, value_list))"
 66 |    ]
 67 |   },
 68 |   {
 69 |    "cell_type": "code",
 70 |    "execution_count": 5,
 71 |    "id": "478f90d0",
 72 |    "metadata": {},
 73 |    "outputs": [],
 74 |    "source": [
 75 |     "def even_numbers(numbers):\n",
 76 |     "    if numbers%2==0:\n",
 77 |     "        return 'Even'\n",
 78 |     "    else:\n",
 79 |     "        return 'Odd'"
 80 |    ]
 81 |   },
 82 |   {
 83 |    "cell_type": "code",
 84 |    "execution_count": 6,
 85 |    "id": "09bfefad",
 86 |    "metadata": {},
 87 |    "outputs": [
 88 |     {
 89 |      "data": {
 90 |       "text/plain": [
 91 |        "['Odd', 'Even', 'Odd', 'Even', 'Even']"
 92 |       ]
 93 |      },
 94 |      "execution_count": 6,
 95 |      "metadata": {},
 96 |      "output_type": "execute_result"
 97 |     }
 98 |    ],
 99 |    "source": [
100 |     "list(map(even_numbers,value_list))"
101 |    ]
102 |   },
103 |   {
104 |    "cell_type": "code",
105 |    "execution_count": 7,
106 |    "id": "844c1750",
107 |    "metadata": {},
108 |    "outputs": [],
109 |    "source": [
110 |     "def even_numbers(numbers):\n",
111 |     "    return numbers%2==0"
112 |    ]
113 |   },
114 |   {
115 |    "cell_type": "code",
116 |    "execution_count": 8,
117 |    "id": "70f0b810",
118 |    "metadata": {},
119 |    "outputs": [
120 |     {
121 |      "data": {
122 |       "text/plain": [
123 |        "[10, 100, 1000]"
124 |       ]
125 |      },
126 |      "execution_count": 8,
127 |      "metadata": {},
128 |      "output_type": "execute_result"
129 |     }
130 |    ],
131 |    "source": [
132 |     "list(filter(even_numbers,value_list))"
133 |    ]
134 |   }
135 |  ],
136 |  "metadata": {
137 |   "kernelspec": {
138 |    "display_name": "Python 3",
139 |    "language": "python",
140 |    "name": "python3"
141 |   },
142 |   "language_info": {
143 |    "codemirror_mode": {
144 |     "name": "ipython",
145 |     "version": 3
146 |    },
147 |    "file_extension": ".py",
148 |    "mimetype": "text/x-python",
149 |    "name": "python",
150 |    "nbconvert_exporter": "python",
151 |    "pygments_lexer": "ipython3",
152 |    "version": "3.8.8"
153 |   }
154 |  },
155 |  "nbformat": 4,
156 |  "nbformat_minor": 5
157 | }
158 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Python-Jupyter-Programs


--------------------------------------------------------------------------------
/SpecialPythonMethods.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "d0b284b7",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "class Software():\n",
 11 |     "    \n",
 12 |     "    def __init__(self,usage,language,versions):\n",
 13 |     "        \n",
 14 |     "        self.usage = usage\n",
 15 |     "        self.language = language\n",
 16 |     "        self.versions = versions\n",
 17 |     "        \n",
 18 |     "    def __str__(self):\n",
 19 |     "        return f\"Software will be used for {self.usage}, it will be in {self.language}, and will have {self.versions} versions.\"\n",
 20 |     "    \n",
 21 |     "    def __del__(self):\n",
 22 |     "        print(\"A version of the software has been removed.\")\n",
 23 |     "    \n",
 24 |     "    def __len__(self):\n",
 25 |     "        return self.versions"
 26 |    ]
 27 |   },
 28 |   {
 29 |    "cell_type": "code",
 30 |    "execution_count": 2,
 31 |    "id": "94483bc3",
 32 |    "metadata": {},
 33 |    "outputs": [],
 34 |    "source": [
 35 |     "mysoftware = Software('business automation','english', 4)"
 36 |    ]
 37 |   },
 38 |   {
 39 |    "cell_type": "code",
 40 |    "execution_count": 3,
 41 |    "id": "dcbf3d32",
 42 |    "metadata": {},
 43 |    "outputs": [
 44 |     {
 45 |      "name": "stdout",
 46 |      "output_type": "stream",
 47 |      "text": [
 48 |       "Software will be used for business automation, it will be in english, and will have 4 versions.\n"
 49 |      ]
 50 |     }
 51 |    ],
 52 |    "source": [
 53 |     "print(mysoftware)"
 54 |    ]
 55 |   },
 56 |   {
 57 |    "cell_type": "code",
 58 |    "execution_count": 4,
 59 |    "id": "b6665bb8",
 60 |    "metadata": {},
 61 |    "outputs": [
 62 |     {
 63 |      "data": {
 64 |       "text/plain": [
 65 |        "'Software will be used for business automation, it will be in english, and will have 4 versions.'"
 66 |       ]
 67 |      },
 68 |      "execution_count": 4,
 69 |      "metadata": {},
 70 |      "output_type": "execute_result"
 71 |     }
 72 |    ],
 73 |    "source": [
 74 |     "str(mysoftware)"
 75 |    ]
 76 |   },
 77 |   {
 78 |    "cell_type": "code",
 79 |    "execution_count": 5,
 80 |    "id": "11389c45",
 81 |    "metadata": {},
 82 |    "outputs": [],
 83 |    "source": [
 84 |     "# del(mysoftware)"
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": 6,
 90 |    "id": "71a888ed",
 91 |    "metadata": {},
 92 |    "outputs": [
 93 |     {
 94 |      "data": {
 95 |       "text/plain": [
 96 |        "4"
 97 |       ]
 98 |      },
 99 |      "execution_count": 6,
100 |      "metadata": {},
101 |      "output_type": "execute_result"
102 |     }
103 |    ],
104 |    "source": [
105 |     "len(mysoftware)"
106 |    ]
107 |   }
108 |  ],
109 |  "metadata": {
110 |   "kernelspec": {
111 |    "display_name": "Python 3",
112 |    "language": "python",
113 |    "name": "python3"
114 |   },
115 |   "language_info": {
116 |    "codemirror_mode": {
117 |     "name": "ipython",
118 |     "version": 3
119 |    },
120 |    "file_extension": ".py",
121 |    "mimetype": "text/x-python",
122 |    "name": "python",
123 |    "nbconvert_exporter": "python",
124 |    "pygments_lexer": "ipython3",
125 |    "version": "3.8.8"
126 |   }
127 |  },
128 |  "nbformat": 4,
129 |  "nbformat_minor": 5
130 | }
131 | 


--------------------------------------------------------------------------------
/StringMethodsandFormatting.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "8b2f27c0",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "birthplace = \"Chicago\""
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "id": "dc569fb3",
 17 |    "metadata": {},
 18 |    "outputs": [
 19 |     {
 20 |      "data": {
 21 |       "text/plain": [
 22 |        "'I was born in Chicago'"
 23 |       ]
 24 |      },
 25 |      "execution_count": 2,
 26 |      "metadata": {},
 27 |      "output_type": "execute_result"
 28 |     }
 29 |    ],
 30 |    "source": [
 31 |     "\"I was born in \" + birthplace"
 32 |    ]
 33 |   },
 34 |   {
 35 |    "cell_type": "code",
 36 |    "execution_count": 3,
 37 |    "id": "b0d1fbd1",
 38 |    "metadata": {},
 39 |    "outputs": [],
 40 |    "source": [
 41 |     "string1 = \"Hi \""
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "code",
 46 |    "execution_count": 4,
 47 |    "id": "9fffd9c6",
 48 |    "metadata": {},
 49 |    "outputs": [],
 50 |    "source": [
 51 |     "string2 = \"there!\""
 52 |    ]
 53 |   },
 54 |   {
 55 |    "cell_type": "code",
 56 |    "execution_count": 5,
 57 |    "id": "914134be",
 58 |    "metadata": {},
 59 |    "outputs": [
 60 |     {
 61 |      "data": {
 62 |       "text/plain": [
 63 |        "'Hi there!'"
 64 |       ]
 65 |      },
 66 |      "execution_count": 5,
 67 |      "metadata": {},
 68 |      "output_type": "execute_result"
 69 |     }
 70 |    ],
 71 |    "source": [
 72 |     "string1 + string2"
 73 |    ]
 74 |   },
 75 |   {
 76 |    "cell_type": "code",
 77 |    "execution_count": 6,
 78 |    "id": "b278bfa1",
 79 |    "metadata": {},
 80 |    "outputs": [],
 81 |    "source": [
 82 |     "example = \"no\""
 83 |    ]
 84 |   },
 85 |   {
 86 |    "cell_type": "code",
 87 |    "execution_count": 7,
 88 |    "id": "4a777008",
 89 |    "metadata": {},
 90 |    "outputs": [
 91 |     {
 92 |      "data": {
 93 |       "text/plain": [
 94 |        "'nonononono'"
 95 |       ]
 96 |      },
 97 |      "execution_count": 7,
 98 |      "metadata": {},
 99 |      "output_type": "execute_result"
100 |     }
101 |    ],
102 |    "source": [
103 |     "example * 5"
104 |    ]
105 |   },
106 |   {
107 |    "cell_type": "code",
108 |    "execution_count": 8,
109 |    "id": "a2870544",
110 |    "metadata": {},
111 |    "outputs": [
112 |     {
113 |      "data": {
114 |       "text/plain": [
115 |        "'11'"
116 |       ]
117 |      },
118 |      "execution_count": 8,
119 |      "metadata": {},
120 |      "output_type": "execute_result"
121 |     }
122 |    ],
123 |    "source": [
124 |     "\"1\" + \"1\""
125 |    ]
126 |   },
127 |   {
128 |    "cell_type": "code",
129 |    "execution_count": 9,
130 |    "id": "9915e8ba",
131 |    "metadata": {},
132 |    "outputs": [],
133 |    "source": [
134 |     "a = \"Hey everyone\""
135 |    ]
136 |   },
137 |   {
138 |    "cell_type": "code",
139 |    "execution_count": 10,
140 |    "id": "fe9a441d",
141 |    "metadata": {},
142 |    "outputs": [
143 |     {
144 |      "data": {
145 |       "text/plain": [
146 |        "'HEY EVERYONE'"
147 |       ]
148 |      },
149 |      "execution_count": 10,
150 |      "metadata": {},
151 |      "output_type": "execute_result"
152 |     }
153 |    ],
154 |    "source": [
155 |     "a.upper()"
156 |    ]
157 |   },
158 |   {
159 |    "cell_type": "code",
160 |    "execution_count": 11,
161 |    "id": "11a191e8",
162 |    "metadata": {},
163 |    "outputs": [
164 |     {
165 |      "data": {
166 |       "text/plain": [
167 |        "'Hey everyone'"
168 |       ]
169 |      },
170 |      "execution_count": 11,
171 |      "metadata": {},
172 |      "output_type": "execute_result"
173 |     }
174 |    ],
175 |    "source": [
176 |     "a"
177 |    ]
178 |   },
179 |   {
180 |    "cell_type": "code",
181 |    "execution_count": 12,
182 |    "id": "1851686c",
183 |    "metadata": {},
184 |    "outputs": [],
185 |    "source": [
186 |     "a = a.upper()"
187 |    ]
188 |   },
189 |   {
190 |    "cell_type": "code",
191 |    "execution_count": 13,
192 |    "id": "6d32c110",
193 |    "metadata": {},
194 |    "outputs": [
195 |     {
196 |      "data": {
197 |       "text/plain": [
198 |        "'HEY EVERYONE'"
199 |       ]
200 |      },
201 |      "execution_count": 13,
202 |      "metadata": {},
203 |      "output_type": "execute_result"
204 |     }
205 |    ],
206 |    "source": [
207 |     "a"
208 |    ]
209 |   },
210 |   {
211 |    "cell_type": "code",
212 |    "execution_count": 14,
213 |    "id": "8694903b",
214 |    "metadata": {},
215 |    "outputs": [],
216 |    "source": [
217 |     "a = a.lower()"
218 |    ]
219 |   },
220 |   {
221 |    "cell_type": "code",
222 |    "execution_count": 15,
223 |    "id": "0b26ac2b",
224 |    "metadata": {},
225 |    "outputs": [
226 |     {
227 |      "data": {
228 |       "text/plain": [
229 |        "'hey everyone'"
230 |       ]
231 |      },
232 |      "execution_count": 15,
233 |      "metadata": {},
234 |      "output_type": "execute_result"
235 |     }
236 |    ],
237 |    "source": [
238 |     "a"
239 |    ]
240 |   },
241 |   {
242 |    "cell_type": "code",
243 |    "execution_count": 16,
244 |    "id": "833f6cd0",
245 |    "metadata": {},
246 |    "outputs": [
247 |     {
248 |      "data": {
249 |       "text/plain": [
250 |        "['hey', 'everyone']"
251 |       ]
252 |      },
253 |      "execution_count": 16,
254 |      "metadata": {},
255 |      "output_type": "execute_result"
256 |     }
257 |    ],
258 |    "source": [
259 |     "a.split()"
260 |    ]
261 |   },
262 |   {
263 |    "cell_type": "code",
264 |    "execution_count": 17,
265 |    "id": "cb3d9fa3",
266 |    "metadata": {},
267 |    "outputs": [],
268 |    "source": [
269 |     "name='John'\n",
270 |     "place='Virginia'"
271 |    ]
272 |   },
273 |   {
274 |    "cell_type": "code",
275 |    "execution_count": 18,
276 |    "id": "61572d6e",
277 |    "metadata": {},
278 |    "outputs": [
279 |     {
280 |      "name": "stdout",
281 |      "output_type": "stream",
282 |      "text": [
283 |       "My name is John and I was born in Virginia.\n"
284 |      ]
285 |     }
286 |    ],
287 |    "source": [
288 |     "print(f'My name is {name} and I was born in {place}.')"
289 |    ]
290 |   }
291 |  ],
292 |  "metadata": {
293 |   "kernelspec": {
294 |    "display_name": "Python 3",
295 |    "language": "python",
296 |    "name": "python3"
297 |   },
298 |   "language_info": {
299 |    "codemirror_mode": {
300 |     "name": "ipython",
301 |     "version": 3
302 |    },
303 |    "file_extension": ".py",
304 |    "mimetype": "text/x-python",
305 |    "name": "python",
306 |    "nbconvert_exporter": "python",
307 |    "pygments_lexer": "ipython3",
308 |    "version": "3.8.8"
309 |   }
310 |  },
311 |  "nbformat": 4,
312 |  "nbformat_minor": 5
313 | }
314 | 


--------------------------------------------------------------------------------
/Strings.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "0d8e06b4",
  7 |    "metadata": {},
  8 |    "outputs": [
  9 |     {
 10 |      "data": {
 11 |       "text/plain": [
 12 |        "'Python'"
 13 |       ]
 14 |      },
 15 |      "execution_count": 1,
 16 |      "metadata": {},
 17 |      "output_type": "execute_result"
 18 |     }
 19 |    ],
 20 |    "source": [
 21 |     "'Python'"
 22 |    ]
 23 |   },
 24 |   {
 25 |    "cell_type": "code",
 26 |    "execution_count": 2,
 27 |    "id": "8577a633",
 28 |    "metadata": {},
 29 |    "outputs": [
 30 |     {
 31 |      "data": {
 32 |       "text/plain": [
 33 |        "'Python'"
 34 |       ]
 35 |      },
 36 |      "execution_count": 2,
 37 |      "metadata": {},
 38 |      "output_type": "execute_result"
 39 |     }
 40 |    ],
 41 |    "source": [
 42 |     "\"Python\""
 43 |    ]
 44 |   },
 45 |   {
 46 |    "cell_type": "code",
 47 |    "execution_count": 3,
 48 |    "id": "5f2bf126",
 49 |    "metadata": {},
 50 |    "outputs": [
 51 |     {
 52 |      "data": {
 53 |       "text/plain": [
 54 |        "'Python is a programming language'"
 55 |       ]
 56 |      },
 57 |      "execution_count": 3,
 58 |      "metadata": {},
 59 |      "output_type": "execute_result"
 60 |     }
 61 |    ],
 62 |    "source": [
 63 |     "\"Python is a programming language\""
 64 |    ]
 65 |   },
 66 |   {
 67 |    "cell_type": "code",
 68 |    "execution_count": 4,
 69 |    "id": "fa5e4dc7",
 70 |    "metadata": {},
 71 |    "outputs": [
 72 |     {
 73 |      "data": {
 74 |       "text/plain": [
 75 |        "\"I'll travel tomorrow\""
 76 |       ]
 77 |      },
 78 |      "execution_count": 4,
 79 |      "metadata": {},
 80 |      "output_type": "execute_result"
 81 |     }
 82 |    ],
 83 |    "source": [
 84 |     "\"I'll travel tomorrow\""
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "code",
 89 |    "execution_count": 6,
 90 |    "id": "99559bec",
 91 |    "metadata": {},
 92 |    "outputs": [
 93 |     {
 94 |      "name": "stdout",
 95 |      "output_type": "stream",
 96 |      "text": [
 97 |       "Python\n"
 98 |      ]
 99 |     }
100 |    ],
101 |    "source": [
102 |     "print(\"Python\")"
103 |    ]
104 |   },
105 |   {
106 |    "cell_type": "code",
107 |    "execution_count": 9,
108 |    "id": "7c95a5aa",
109 |    "metadata": {},
110 |    "outputs": [
111 |     {
112 |      "name": "stdout",
113 |      "output_type": "stream",
114 |      "text": [
115 |       "I want to output line one\n",
116 |       "I want to output line two\n"
117 |      ]
118 |     }
119 |    ],
120 |    "source": [
121 |     "print(\"I want to output line one\")\n",
122 |     "print(\"I want to output line two\")"
123 |    ]
124 |   },
125 |   {
126 |    "cell_type": "code",
127 |    "execution_count": 16,
128 |    "id": "cdd90144",
129 |    "metadata": {},
130 |    "outputs": [
131 |     {
132 |      "name": "stdout",
133 |      "output_type": "stream",
134 |      "text": [
135 |       "This is another string\n"
136 |      ]
137 |     }
138 |    ],
139 |    "source": [
140 |     "print(\"This is another string\")"
141 |    ]
142 |   },
143 |   {
144 |    "cell_type": "code",
145 |    "execution_count": 15,
146 |    "id": "7ee6b882",
147 |    "metadata": {},
148 |    "outputs": [
149 |     {
150 |      "data": {
151 |       "text/plain": [
152 |        "9"
153 |       ]
154 |      },
155 |      "execution_count": 15,
156 |      "metadata": {},
157 |      "output_type": "execute_result"
158 |     }
159 |    ],
160 |    "source": [
161 |     "len(\"My laptop\")"
162 |    ]
163 |   }
164 |  ],
165 |  "metadata": {
166 |   "kernelspec": {
167 |    "display_name": "Python 3",
168 |    "language": "python",
169 |    "name": "python3"
170 |   },
171 |   "language_info": {
172 |    "codemirror_mode": {
173 |     "name": "ipython",
174 |     "version": 3
175 |    },
176 |    "file_extension": ".py",
177 |    "mimetype": "text/x-python",
178 |    "name": "python",
179 |    "nbconvert_exporter": "python",
180 |    "pygments_lexer": "ipython3",
181 |    "version": "3.8.8"
182 |   }
183 |  },
184 |  "nbformat": 4,
185 |  "nbformat_minor": 5
186 | }
187 | 


--------------------------------------------------------------------------------
/Tuples.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "e5cd91ce",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "my_tuple = ('a','b','c','d')"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "id": "5c2273eb",
 17 |    "metadata": {},
 18 |    "outputs": [
 19 |     {
 20 |      "data": {
 21 |       "text/plain": [
 22 |        "tuple"
 23 |       ]
 24 |      },
 25 |      "execution_count": 2,
 26 |      "metadata": {},
 27 |      "output_type": "execute_result"
 28 |     }
 29 |    ],
 30 |    "source": [
 31 |     "type(my_tuple)"
 32 |    ]
 33 |   },
 34 |   {
 35 |    "cell_type": "code",
 36 |    "execution_count": 3,
 37 |    "id": "3d66446f",
 38 |    "metadata": {},
 39 |    "outputs": [
 40 |     {
 41 |      "data": {
 42 |       "text/plain": [
 43 |        "4"
 44 |       ]
 45 |      },
 46 |      "execution_count": 3,
 47 |      "metadata": {},
 48 |      "output_type": "execute_result"
 49 |     }
 50 |    ],
 51 |    "source": [
 52 |     "len(my_tuple)"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": 4,
 58 |    "id": "07352bb0",
 59 |    "metadata": {},
 60 |    "outputs": [
 61 |     {
 62 |      "data": {
 63 |       "text/plain": [
 64 |        "('a', 'b', 'c', 'd')"
 65 |       ]
 66 |      },
 67 |      "execution_count": 4,
 68 |      "metadata": {},
 69 |      "output_type": "execute_result"
 70 |     }
 71 |    ],
 72 |    "source": [
 73 |     "my_tuple"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 5,
 79 |    "id": "b80c49ce",
 80 |    "metadata": {},
 81 |    "outputs": [],
 82 |    "source": [
 83 |     "my_tuple = (1,'two',23,'b')"
 84 |    ]
 85 |   },
 86 |   {
 87 |    "cell_type": "code",
 88 |    "execution_count": 6,
 89 |    "id": "9bc4231c",
 90 |    "metadata": {},
 91 |    "outputs": [
 92 |     {
 93 |      "data": {
 94 |       "text/plain": [
 95 |        "23"
 96 |       ]
 97 |      },
 98 |      "execution_count": 6,
 99 |      "metadata": {},
100 |      "output_type": "execute_result"
101 |     }
102 |    ],
103 |    "source": [
104 |     "my_tuple[2]"
105 |    ]
106 |   },
107 |   {
108 |    "cell_type": "code",
109 |    "execution_count": 7,
110 |    "id": "842839b5",
111 |    "metadata": {},
112 |    "outputs": [
113 |     {
114 |      "data": {
115 |       "text/plain": [
116 |        "'b'"
117 |       ]
118 |      },
119 |      "execution_count": 7,
120 |      "metadata": {},
121 |      "output_type": "execute_result"
122 |     }
123 |    ],
124 |    "source": [
125 |     "my_tuple[-1]"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "code",
130 |    "execution_count": 8,
131 |    "id": "dbd120ba",
132 |    "metadata": {},
133 |    "outputs": [],
134 |    "source": [
135 |     "my_tuple = (2,4,6,2,2)"
136 |    ]
137 |   },
138 |   {
139 |    "cell_type": "code",
140 |    "execution_count": 9,
141 |    "id": "74de09b2",
142 |    "metadata": {},
143 |    "outputs": [
144 |     {
145 |      "data": {
146 |       "text/plain": [
147 |        "3"
148 |       ]
149 |      },
150 |      "execution_count": 9,
151 |      "metadata": {},
152 |      "output_type": "execute_result"
153 |     }
154 |    ],
155 |    "source": [
156 |     "my_tuple.count(2)"
157 |    ]
158 |   },
159 |   {
160 |    "cell_type": "code",
161 |    "execution_count": 10,
162 |    "id": "f55fec11",
163 |    "metadata": {},
164 |    "outputs": [
165 |     {
166 |      "data": {
167 |       "text/plain": [
168 |        "0"
169 |       ]
170 |      },
171 |      "execution_count": 10,
172 |      "metadata": {},
173 |      "output_type": "execute_result"
174 |     }
175 |    ],
176 |    "source": [
177 |     "my_tuple.index(2)"
178 |    ]
179 |   },
180 |   {
181 |    "cell_type": "code",
182 |    "execution_count": 11,
183 |    "id": "7a335cce",
184 |    "metadata": {},
185 |    "outputs": [],
186 |    "source": [
187 |     "my_list = ['one','two','three']"
188 |    ]
189 |   },
190 |   {
191 |    "cell_type": "code",
192 |    "execution_count": 12,
193 |    "id": "b749815f",
194 |    "metadata": {},
195 |    "outputs": [],
196 |    "source": [
197 |     "my_list[1] = 'MODIFIED'"
198 |    ]
199 |   },
200 |   {
201 |    "cell_type": "code",
202 |    "execution_count": 13,
203 |    "id": "4768f57c",
204 |    "metadata": {},
205 |    "outputs": [
206 |     {
207 |      "data": {
208 |       "text/plain": [
209 |        "['one', 'MODIFIED', 'three']"
210 |       ]
211 |      },
212 |      "execution_count": 13,
213 |      "metadata": {},
214 |      "output_type": "execute_result"
215 |     }
216 |    ],
217 |    "source": [
218 |     "my_list"
219 |    ]
220 |   },
221 |   {
222 |    "cell_type": "code",
223 |    "execution_count": 15,
224 |    "id": "d2a02acb",
225 |    "metadata": {},
226 |    "outputs": [],
227 |    "source": [
228 |     "# my_tuple[1] = 'MODIFIED'"
229 |    ]
230 |   }
231 |  ],
232 |  "metadata": {
233 |   "kernelspec": {
234 |    "display_name": "Python 3",
235 |    "language": "python",
236 |    "name": "python3"
237 |   },
238 |   "language_info": {
239 |    "codemirror_mode": {
240 |     "name": "ipython",
241 |     "version": 3
242 |    },
243 |    "file_extension": ".py",
244 |    "mimetype": "text/x-python",
245 |    "name": "python",
246 |    "nbconvert_exporter": "python",
247 |    "pygments_lexer": "ipython3",
248 |    "version": "3.8.8"
249 |   }
250 |  },
251 |  "nbformat": 4,
252 |  "nbformat_minor": 5
253 | }
254 | 


--------------------------------------------------------------------------------
/VariableScope.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "c3935ab6",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "dog = 'Milo'"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "id": "d4593157",
 17 |    "metadata": {},
 18 |    "outputs": [],
 19 |    "source": [
 20 |     "def dog_name():\n",
 21 |     "    dog = 'Ozzy'\n",
 22 |     "    return dog"
 23 |    ]
 24 |   },
 25 |   {
 26 |    "cell_type": "code",
 27 |    "execution_count": 3,
 28 |    "id": "6739acb0",
 29 |    "metadata": {},
 30 |    "outputs": [
 31 |     {
 32 |      "name": "stdout",
 33 |      "output_type": "stream",
 34 |      "text": [
 35 |       "Milo\n"
 36 |      ]
 37 |     }
 38 |    ],
 39 |    "source": [
 40 |     "print(dog)"
 41 |    ]
 42 |   },
 43 |   {
 44 |    "cell_type": "code",
 45 |    "execution_count": 4,
 46 |    "id": "a42ddd96",
 47 |    "metadata": {},
 48 |    "outputs": [
 49 |     {
 50 |      "name": "stdout",
 51 |      "output_type": "stream",
 52 |      "text": [
 53 |       "Ozzy\n"
 54 |      ]
 55 |     }
 56 |    ],
 57 |    "source": [
 58 |     "print(dog_name())"
 59 |    ]
 60 |   },
 61 |   {
 62 |    "cell_type": "code",
 63 |    "execution_count": 5,
 64 |    "id": "b56cb5e4",
 65 |    "metadata": {},
 66 |    "outputs": [],
 67 |    "source": [
 68 |     "variable = 'Global Scope'\n",
 69 |     "\n",
 70 |     "def variable_scope():\n",
 71 |     "    # variable = 'Enclosing Scope'\n",
 72 |     "    def another_func():\n",
 73 |     "      # variable = 'Local Scope'\n",
 74 |     "        print('Variable scope is ' + variable)\n",
 75 |     "    another_func()"
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "code",
 80 |    "execution_count": 6,
 81 |    "id": "16b3a041",
 82 |    "metadata": {},
 83 |    "outputs": [
 84 |     {
 85 |      "name": "stdout",
 86 |      "output_type": "stream",
 87 |      "text": [
 88 |       "Variable scope is Global Scope\n"
 89 |      ]
 90 |     }
 91 |    ],
 92 |    "source": [
 93 |     "variable_scope()"
 94 |    ]
 95 |   },
 96 |   {
 97 |    "cell_type": "code",
 98 |    "execution_count": 7,
 99 |    "id": "dfeebcce",
100 |    "metadata": {},
101 |    "outputs": [],
102 |    "source": [
103 |     "cat = \"Luna\"\n",
104 |     "\n",
105 |     "def cat_name(cat):\n",
106 |     "    #global cat #(without parameter)\n",
107 |     "    print(f\"My cat's name is {cat}\")\n",
108 |     "    cat = 'Chloe'\n",
109 |     "    print (f'This is Local reassignment! Cat name is now {cat}')\n",
110 |     "    #return cat"
111 |    ]
112 |   },
113 |   {
114 |    "cell_type": "code",
115 |    "execution_count": 8,
116 |    "id": "2d3f5cc3",
117 |    "metadata": {},
118 |    "outputs": [
119 |     {
120 |      "name": "stdout",
121 |      "output_type": "stream",
122 |      "text": [
123 |       "My cat's name is Luna\n",
124 |       "This is Local reassignment! Cat name is now Chloe\n"
125 |      ]
126 |     }
127 |    ],
128 |    "source": [
129 |     "cat_name(cat)"
130 |    ]
131 |   },
132 |   {
133 |    "cell_type": "code",
134 |    "execution_count": 9,
135 |    "id": "e8b2f7c2",
136 |    "metadata": {},
137 |    "outputs": [
138 |     {
139 |      "name": "stdout",
140 |      "output_type": "stream",
141 |      "text": [
142 |       "Luna\n"
143 |      ]
144 |     }
145 |    ],
146 |    "source": [
147 |     "print(cat)"
148 |    ]
149 |   },
150 |   {
151 |    "cell_type": "code",
152 |    "execution_count": 10,
153 |    "id": "08c70e61",
154 |    "metadata": {},
155 |    "outputs": [
156 |     {
157 |      "name": "stdout",
158 |      "output_type": "stream",
159 |      "text": [
160 |       "My cat's name is Luna\n",
161 |       "This is Local reassignment! Cat name is now Chloe\n"
162 |      ]
163 |     }
164 |    ],
165 |    "source": [
166 |     "cat = cat_name(cat)"
167 |    ]
168 |   }
169 |  ],
170 |  "metadata": {
171 |   "kernelspec": {
172 |    "display_name": "Python 3",
173 |    "language": "python",
174 |    "name": "python3"
175 |   },
176 |   "language_info": {
177 |    "codemirror_mode": {
178 |     "name": "ipython",
179 |     "version": 3
180 |    },
181 |    "file_extension": ".py",
182 |    "mimetype": "text/x-python",
183 |    "name": "python",
184 |    "nbconvert_exporter": "python",
185 |    "pygments_lexer": "ipython3",
186 |    "version": "3.8.8"
187 |   }
188 |  },
189 |  "nbformat": 4,
190 |  "nbformat_minor": 5
191 | }
192 | 


--------------------------------------------------------------------------------
/Variables.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 1,
  6 |    "id": "507567fe",
  7 |    "metadata": {},
  8 |    "outputs": [],
  9 |    "source": [
 10 |     "id_number = 706"
 11 |    ]
 12 |   },
 13 |   {
 14 |    "cell_type": "code",
 15 |    "execution_count": 2,
 16 |    "id": "e3ebecea",
 17 |    "metadata": {},
 18 |    "outputs": [],
 19 |    "source": [
 20 |     "id_number = \"seven zero six\""
 21 |    ]
 22 |   },
 23 |   {
 24 |    "cell_type": "code",
 25 |    "execution_count": 3,
 26 |    "id": "b5f97168",
 27 |    "metadata": {},
 28 |    "outputs": [],
 29 |    "source": [
 30 |     "example = 10"
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "code",
 35 |    "execution_count": 4,
 36 |    "id": "215f1fc6",
 37 |    "metadata": {},
 38 |    "outputs": [
 39 |     {
 40 |      "data": {
 41 |       "text/plain": [
 42 |        "10"
 43 |       ]
 44 |      },
 45 |      "execution_count": 4,
 46 |      "metadata": {},
 47 |      "output_type": "execute_result"
 48 |     }
 49 |    ],
 50 |    "source": [
 51 |     "example"
 52 |    ]
 53 |   },
 54 |   {
 55 |    "cell_type": "code",
 56 |    "execution_count": 5,
 57 |    "id": "d426d0d1",
 58 |    "metadata": {},
 59 |    "outputs": [],
 60 |    "source": [
 61 |     "example = 20"
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "code",
 66 |    "execution_count": 6,
 67 |    "id": "b076e517",
 68 |    "metadata": {},
 69 |    "outputs": [
 70 |     {
 71 |      "data": {
 72 |       "text/plain": [
 73 |        "20"
 74 |       ]
 75 |      },
 76 |      "execution_count": 6,
 77 |      "metadata": {},
 78 |      "output_type": "execute_result"
 79 |     }
 80 |    ],
 81 |    "source": [
 82 |     "example"
 83 |    ]
 84 |   },
 85 |   {
 86 |    "cell_type": "code",
 87 |    "execution_count": 7,
 88 |    "id": "04a323ca",
 89 |    "metadata": {},
 90 |    "outputs": [
 91 |     {
 92 |      "data": {
 93 |       "text/plain": [
 94 |        "40"
 95 |       ]
 96 |      },
 97 |      "execution_count": 7,
 98 |      "metadata": {},
 99 |      "output_type": "execute_result"
100 |     }
101 |    ],
102 |    "source": [
103 |     "example + example"
104 |    ]
105 |   },
106 |   {
107 |    "cell_type": "code",
108 |    "execution_count": 8,
109 |    "id": "b96c78db",
110 |    "metadata": {},
111 |    "outputs": [
112 |     {
113 |      "data": {
114 |       "text/plain": [
115 |        "20"
116 |       ]
117 |      },
118 |      "execution_count": 8,
119 |      "metadata": {},
120 |      "output_type": "execute_result"
121 |     }
122 |    ],
123 |    "source": [
124 |     "example"
125 |    ]
126 |   },
127 |   {
128 |    "cell_type": "code",
129 |    "execution_count": 13,
130 |    "id": "dbaf70d9",
131 |    "metadata": {},
132 |    "outputs": [],
133 |    "source": [
134 |     "example = example + example"
135 |    ]
136 |   },
137 |   {
138 |    "cell_type": "code",
139 |    "execution_count": 14,
140 |    "id": "78df146d",
141 |    "metadata": {},
142 |    "outputs": [
143 |     {
144 |      "data": {
145 |       "text/plain": [
146 |        "160"
147 |       ]
148 |      },
149 |      "execution_count": 14,
150 |      "metadata": {},
151 |      "output_type": "execute_result"
152 |     }
153 |    ],
154 |    "source": [
155 |     "example"
156 |    ]
157 |   },
158 |   {
159 |    "cell_type": "code",
160 |    "execution_count": 15,
161 |    "id": "0f886f49",
162 |    "metadata": {},
163 |    "outputs": [
164 |     {
165 |      "data": {
166 |       "text/plain": [
167 |        "int"
168 |       ]
169 |      },
170 |      "execution_count": 15,
171 |      "metadata": {},
172 |      "output_type": "execute_result"
173 |     }
174 |    ],
175 |    "source": [
176 |     "type(example)"
177 |    ]
178 |   },
179 |   {
180 |    "cell_type": "code",
181 |    "execution_count": 16,
182 |    "id": "7b116b6e",
183 |    "metadata": {},
184 |    "outputs": [],
185 |    "source": [
186 |     "example = 6.8"
187 |    ]
188 |   },
189 |   {
190 |    "cell_type": "code",
191 |    "execution_count": 17,
192 |    "id": "82921034",
193 |    "metadata": {},
194 |    "outputs": [
195 |     {
196 |      "data": {
197 |       "text/plain": [
198 |        "float"
199 |       ]
200 |      },
201 |      "execution_count": 17,
202 |      "metadata": {},
203 |      "output_type": "execute_result"
204 |     }
205 |    ],
206 |    "source": [
207 |     "type(example)"
208 |    ]
209 |   }
210 |  ],
211 |  "metadata": {
212 |   "kernelspec": {
213 |    "display_name": "Python 3",
214 |    "language": "python",
215 |    "name": "python3"
216 |   },
217 |   "language_info": {
218 |    "codemirror_mode": {
219 |     "name": "ipython",
220 |     "version": 3
221 |    },
222 |    "file_extension": ".py",
223 |    "mimetype": "text/x-python",
224 |    "name": "python",
225 |    "nbconvert_exporter": "python",
226 |    "pygments_lexer": "ipython3",
227 |    "version": "3.8.8"
228 |   }
229 |  },
230 |  "nbformat": 4,
231 |  "nbformat_minor": 5
232 | }
233 | 


--------------------------------------------------------------------------------