|
22 | 22 | "\n", |
23 | 23 | "#### 1) [Args and Kwargs](#ch1)\n", |
24 | 24 | "#### 2) [Generators](#ch2)\n", |
25 | | - "#### 2) [Map, Reduce, Filter](#ch3)" |
| 25 | + "#### 3) [Map, Reduce, Filter](#ch3)\n", |
| 26 | + "#### 4) [Sets](#ch4)" |
26 | 27 | ] |
27 | 28 | }, |
28 | 29 | { |
|
1048 | 1049 | "source": [ |
1049 | 1050 | "### Filter\n", |
1050 | 1051 | "As the name suggests, a filter method literally filters out the elements defined.\n", |
1051 | | - "Let's filter " |
| 1052 | + "Let's filter only the negative numbers." |
1052 | 1053 | ] |
1053 | 1054 | }, |
1054 | 1055 | { |
1055 | 1056 | "cell_type": "code", |
1056 | | - "execution_count": 73, |
| 1057 | + "execution_count": 81, |
1057 | 1058 | "metadata": {}, |
1058 | 1059 | "outputs": [], |
1059 | 1060 | "source": [ |
|
1063 | 1064 | }, |
1064 | 1065 | { |
1065 | 1066 | "cell_type": "code", |
1066 | | - "execution_count": 74, |
| 1067 | + "execution_count": 82, |
1067 | 1068 | "metadata": {}, |
1068 | 1069 | "outputs": [ |
1069 | 1070 | { |
|
1072 | 1073 | "-5" |
1073 | 1074 | ] |
1074 | 1075 | }, |
1075 | | - "execution_count": 74, |
| 1076 | + "execution_count": 82, |
1076 | 1077 | "metadata": {}, |
1077 | 1078 | "output_type": "execute_result" |
1078 | 1079 | } |
|
1083 | 1084 | }, |
1084 | 1085 | { |
1085 | 1086 | "cell_type": "code", |
1086 | | - "execution_count": 75, |
| 1087 | + "execution_count": 83, |
1087 | 1088 | "metadata": {}, |
1088 | 1089 | "outputs": [ |
1089 | 1090 | { |
|
1092 | 1093 | "-4" |
1093 | 1094 | ] |
1094 | 1095 | }, |
1095 | | - "execution_count": 75, |
| 1096 | + "execution_count": 83, |
1096 | 1097 | "metadata": {}, |
1097 | 1098 | "output_type": "execute_result" |
1098 | 1099 | } |
|
1103 | 1104 | }, |
1104 | 1105 | { |
1105 | 1106 | "cell_type": "code", |
1106 | | - "execution_count": 76, |
| 1107 | + "execution_count": 84, |
1107 | 1108 | "metadata": {}, |
1108 | 1109 | "outputs": [ |
1109 | 1110 | { |
|
1112 | 1113 | "-3" |
1113 | 1114 | ] |
1114 | 1115 | }, |
1115 | | - "execution_count": 76, |
| 1116 | + "execution_count": 84, |
1116 | 1117 | "metadata": {}, |
1117 | 1118 | "output_type": "execute_result" |
1118 | 1119 | } |
|
1123 | 1124 | }, |
1124 | 1125 | { |
1125 | 1126 | "cell_type": "code", |
1126 | | - "execution_count": 77, |
| 1127 | + "execution_count": 85, |
1127 | 1128 | "metadata": {}, |
1128 | 1129 | "outputs": [ |
1129 | 1130 | { |
|
1132 | 1133 | "-2" |
1133 | 1134 | ] |
1134 | 1135 | }, |
1135 | | - "execution_count": 77, |
| 1136 | + "execution_count": 85, |
1136 | 1137 | "metadata": {}, |
1137 | 1138 | "output_type": "execute_result" |
1138 | 1139 | } |
|
1143 | 1144 | }, |
1144 | 1145 | { |
1145 | 1146 | "cell_type": "code", |
1146 | | - "execution_count": 78, |
| 1147 | + "execution_count": 86, |
1147 | 1148 | "metadata": {}, |
1148 | 1149 | "outputs": [ |
1149 | 1150 | { |
|
1152 | 1153 | "-1" |
1153 | 1154 | ] |
1154 | 1155 | }, |
1155 | | - "execution_count": 78, |
| 1156 | + "execution_count": 86, |
1156 | 1157 | "metadata": {}, |
1157 | 1158 | "output_type": "execute_result" |
1158 | 1159 | } |
|
1163 | 1164 | }, |
1164 | 1165 | { |
1165 | 1166 | "cell_type": "code", |
1166 | | - "execution_count": 79, |
| 1167 | + "execution_count": 87, |
1167 | 1168 | "metadata": {}, |
1168 | 1169 | "outputs": [ |
1169 | 1170 | { |
|
1173 | 1174 | "traceback": [ |
1174 | 1175 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", |
1175 | 1176 | "\u001b[0;31mStopIteration\u001b[0m Traceback (most recent call last)", |
1176 | | - "\u001b[0;32m<ipython-input-79-373734c2136e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mless_than_zero\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", |
| 1177 | + "\u001b[0;32m<ipython-input-87-373734c2136e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mless_than_zero\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", |
1177 | 1178 | "\u001b[0;31mStopIteration\u001b[0m: " |
1178 | 1179 | ] |
1179 | 1180 | } |
|
1189 | 1190 | "Cause that's it. The filtered list only contains `[-5, -4, -3, -2, -1]`" |
1190 | 1191 | ] |
1191 | 1192 | }, |
| 1193 | + { |
| 1194 | + "cell_type": "markdown", |
| 1195 | + "metadata": {}, |
| 1196 | + "source": [ |
| 1197 | + "<a id=\"ch4\"></a>\n", |
| 1198 | + "## Chapter 4 - Sets\n", |
| 1199 | + "\n", |
| 1200 | + "A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.<br>\n", |
| 1201 | + "Curly braces or the `set()` function can be used to create sets. Note: to create an empty set you have to use `set()`, not {}; the latter creates an empty dictionary" |
| 1202 | + ] |
| 1203 | + }, |
| 1204 | + { |
| 1205 | + "cell_type": "code", |
| 1206 | + "execution_count": 75, |
| 1207 | + "metadata": {}, |
| 1208 | + "outputs": [ |
| 1209 | + { |
| 1210 | + "data": { |
| 1211 | + "text/plain": [ |
| 1212 | + "{'apple', 'banana', 'orange', 'pear'}" |
| 1213 | + ] |
| 1214 | + }, |
| 1215 | + "execution_count": 75, |
| 1216 | + "metadata": {}, |
| 1217 | + "output_type": "execute_result" |
| 1218 | + } |
| 1219 | + ], |
| 1220 | + "source": [ |
| 1221 | + "basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\n", |
| 1222 | + "basket" |
| 1223 | + ] |
| 1224 | + }, |
| 1225 | + { |
| 1226 | + "cell_type": "code", |
| 1227 | + "execution_count": 84, |
| 1228 | + "metadata": {}, |
| 1229 | + "outputs": [], |
| 1230 | + "source": [ |
| 1231 | + "# Demonstrate set operations on unique letters from two words\n", |
| 1232 | + "a = set('abracadabra')\n", |
| 1233 | + "b = set('alacazam')" |
| 1234 | + ] |
| 1235 | + }, |
| 1236 | + { |
| 1237 | + "cell_type": "code", |
| 1238 | + "execution_count": 85, |
| 1239 | + "metadata": {}, |
| 1240 | + "outputs": [ |
| 1241 | + { |
| 1242 | + "data": { |
| 1243 | + "text/plain": [ |
| 1244 | + "{'a', 'b', 'c', 'd', 'r'}" |
| 1245 | + ] |
| 1246 | + }, |
| 1247 | + "execution_count": 85, |
| 1248 | + "metadata": {}, |
| 1249 | + "output_type": "execute_result" |
| 1250 | + } |
| 1251 | + ], |
| 1252 | + "source": [ |
| 1253 | + "a" |
| 1254 | + ] |
| 1255 | + }, |
| 1256 | + { |
| 1257 | + "cell_type": "code", |
| 1258 | + "execution_count": 86, |
| 1259 | + "metadata": {}, |
| 1260 | + "outputs": [ |
| 1261 | + { |
| 1262 | + "data": { |
| 1263 | + "text/plain": [ |
| 1264 | + "{'a', 'c', 'l', 'm', 'z'}" |
| 1265 | + ] |
| 1266 | + }, |
| 1267 | + "execution_count": 86, |
| 1268 | + "metadata": {}, |
| 1269 | + "output_type": "execute_result" |
| 1270 | + } |
| 1271 | + ], |
| 1272 | + "source": [ |
| 1273 | + "b" |
| 1274 | + ] |
| 1275 | + }, |
| 1276 | + { |
| 1277 | + "cell_type": "code", |
| 1278 | + "execution_count": 87, |
| 1279 | + "metadata": {}, |
| 1280 | + "outputs": [ |
| 1281 | + { |
| 1282 | + "data": { |
| 1283 | + "text/plain": [ |
| 1284 | + "{'b', 'd', 'r'}" |
| 1285 | + ] |
| 1286 | + }, |
| 1287 | + "execution_count": 87, |
| 1288 | + "metadata": {}, |
| 1289 | + "output_type": "execute_result" |
| 1290 | + } |
| 1291 | + ], |
| 1292 | + "source": [ |
| 1293 | + "a-b # letters in a but not in b" |
| 1294 | + ] |
| 1295 | + }, |
| 1296 | + { |
| 1297 | + "cell_type": "code", |
| 1298 | + "execution_count": 88, |
| 1299 | + "metadata": {}, |
| 1300 | + "outputs": [ |
| 1301 | + { |
| 1302 | + "data": { |
| 1303 | + "text/plain": [ |
| 1304 | + "{'l', 'm', 'z'}" |
| 1305 | + ] |
| 1306 | + }, |
| 1307 | + "execution_count": 88, |
| 1308 | + "metadata": {}, |
| 1309 | + "output_type": "execute_result" |
| 1310 | + } |
| 1311 | + ], |
| 1312 | + "source": [ |
| 1313 | + "b-a # letters in b but not in a" |
| 1314 | + ] |
| 1315 | + }, |
| 1316 | + { |
| 1317 | + "cell_type": "code", |
| 1318 | + "execution_count": 89, |
| 1319 | + "metadata": {}, |
| 1320 | + "outputs": [ |
| 1321 | + { |
| 1322 | + "data": { |
| 1323 | + "text/plain": [ |
| 1324 | + "{'a', 'c'}" |
| 1325 | + ] |
| 1326 | + }, |
| 1327 | + "execution_count": 89, |
| 1328 | + "metadata": {}, |
| 1329 | + "output_type": "execute_result" |
| 1330 | + } |
| 1331 | + ], |
| 1332 | + "source": [ |
| 1333 | + "a & b # letters in both a and b" |
| 1334 | + ] |
| 1335 | + }, |
| 1336 | + { |
| 1337 | + "cell_type": "code", |
| 1338 | + "execution_count": 90, |
| 1339 | + "metadata": {}, |
| 1340 | + "outputs": [ |
| 1341 | + { |
| 1342 | + "data": { |
| 1343 | + "text/plain": [ |
| 1344 | + "{'a', 'b', 'c', 'd', 'l', 'm', 'r', 'z'}" |
| 1345 | + ] |
| 1346 | + }, |
| 1347 | + "execution_count": 90, |
| 1348 | + "metadata": {}, |
| 1349 | + "output_type": "execute_result" |
| 1350 | + } |
| 1351 | + ], |
| 1352 | + "source": [ |
| 1353 | + "a | b # letters in a or b or both" |
| 1354 | + ] |
| 1355 | + }, |
| 1356 | + { |
| 1357 | + "cell_type": "code", |
| 1358 | + "execution_count": 91, |
| 1359 | + "metadata": {}, |
| 1360 | + "outputs": [ |
| 1361 | + { |
| 1362 | + "data": { |
| 1363 | + "text/plain": [ |
| 1364 | + "{'b', 'd', 'l', 'm', 'r', 'z'}" |
| 1365 | + ] |
| 1366 | + }, |
| 1367 | + "execution_count": 91, |
| 1368 | + "metadata": {}, |
| 1369 | + "output_type": "execute_result" |
| 1370 | + } |
| 1371 | + ], |
| 1372 | + "source": [ |
| 1373 | + "a ^ b # letters in a or b but not both" |
| 1374 | + ] |
| 1375 | + }, |
| 1376 | + { |
| 1377 | + "cell_type": "code", |
| 1378 | + "execution_count": 93, |
| 1379 | + "metadata": {}, |
| 1380 | + "outputs": [ |
| 1381 | + { |
| 1382 | + "data": { |
| 1383 | + "text/plain": [ |
| 1384 | + "{'d', 'r'}" |
| 1385 | + ] |
| 1386 | + }, |
| 1387 | + "execution_count": 93, |
| 1388 | + "metadata": {}, |
| 1389 | + "output_type": "execute_result" |
| 1390 | + } |
| 1391 | + ], |
| 1392 | + "source": [ |
| 1393 | + "# Set comprehension\n", |
| 1394 | + "a = {x for x in 'abracadabra' if x not in 'abc'}\n", |
| 1395 | + "a" |
| 1396 | + ] |
| 1397 | + }, |
| 1398 | + { |
| 1399 | + "cell_type": "code", |
| 1400 | + "execution_count": 94, |
| 1401 | + "metadata": {}, |
| 1402 | + "outputs": [ |
| 1403 | + { |
| 1404 | + "data": { |
| 1405 | + "text/plain": [ |
| 1406 | + "{'a', 'h', 'k', 's'}" |
| 1407 | + ] |
| 1408 | + }, |
| 1409 | + "execution_count": 94, |
| 1410 | + "metadata": {}, |
| 1411 | + "output_type": "execute_result" |
| 1412 | + } |
| 1413 | + ], |
| 1414 | + "source": [ |
| 1415 | + "a = \"akash\"\n", |
| 1416 | + "set(a)" |
| 1417 | + ] |
| 1418 | + }, |
| 1419 | + { |
| 1420 | + "cell_type": "markdown", |
| 1421 | + "metadata": {}, |
| 1422 | + "source": [ |
| 1423 | + "Remove duplicates from the list." |
| 1424 | + ] |
| 1425 | + }, |
1192 | 1426 | { |
1193 | 1427 | "cell_type": "code", |
1194 | 1428 | "execution_count": null, |
1195 | 1429 | "metadata": {}, |
1196 | 1430 | "outputs": [], |
1197 | | - "source": [] |
| 1431 | + "source": [ |
| 1432 | + "duplicated_list = [1,2,2,4,6,3,9,6,9,7]\n", |
| 1433 | + "final_list = set([x for x in duplicated_list if duplicated_list.co])" |
| 1434 | + ] |
1198 | 1435 | } |
1199 | 1436 | ], |
1200 | 1437 | "metadata": { |
|
0 commit comments