├── 001-Datatypes&Operators.ipynb ├── 002-StringsManipulationInPython.ipynb ├── 003-AdvancedDataTypesPart1.ipynb ├── 004-AdvancedDataTypesPart2.ipynb ├── 005-ControlStructure.ipynb ├── 006-Functions.ipynb ├── 007-Objects&Classes.ipynb ├── 008-Directories&Files.ipynb ├── 009-CSVFiles.ipynb ├── 010-IntroPandas.ipynb ├── 011-ReadingDataPandas.ipynb ├── 012-WorkingWithPandasDataframe.ipynb ├── 013-IntroNumpy.ipynb ├── 014-NumpyOperationsFunctions.ipynb ├── 015-PlottingLineCharts.ipynb ├── 016-BarsCharts.ipynb ├── 017-ScatterPlot.ipynb ├── 018-Histograms.ipynb ├── 019-PieChart.ipynb ├── 020-PlottingTables.ipynb ├── 021-WebScrapingPython.ipynb ├── 022-ScrapingWikipedia.ipynb ├── Covid19.csv ├── README.md ├── abc_ltd.csv ├── abc_ltd.db ├── abc_ltd.json └── xyz_ltd.csv /001-Datatypes&Operators.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Programming for Data Science Series (Lab Session 1)\n", 8 | "## Data Types\n", 9 | "### Integer\n", 10 | "* number with no decimal point\n", 11 | "* can be both positive and negative\n", 12 | "* e.g. 1, 5, 10, -500, 250,000\n", 13 | "* type(10)" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "#### Associated Tutorial for this Lab session is shown below:" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 4, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "image/jpeg": "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\n", 31 | "text/html": [ 32 | "\n", 33 | " \n", 40 | " " 41 | ], 42 | "text/plain": [ 43 | "" 44 | ] 45 | }, 46 | "execution_count": 4, 47 | "metadata": {}, 48 | "output_type": "execute_result" 49 | } 50 | ], 51 | "source": [ 52 | "from IPython.display import YouTubeVideo\n", 53 | "\n", 54 | "YouTubeVideo('-qertBBkkxs', width=800, height=450)" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 11, 60 | "metadata": {}, 61 | "outputs": [ 62 | { 63 | "data": { 64 | "text/plain": [ 65 | "int" 66 | ] 67 | }, 68 | "execution_count": 11, 69 | "metadata": {}, 70 | "output_type": "execute_result" 71 | } 72 | ], 73 | "source": [ 74 | "x = 7\n", 75 | "type(x)\n" 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "## Arithmetic Operators\n", 83 | "### Perform arithmetic operation such as:-\n", 84 | "* addition (x + y)\n", 85 | "* subtraction (x - y)\n", 86 | "* multiplication (x * y)\n", 87 | "* division (x / y)\n", 88 | "* exponentiation (x ** y)\n", 89 | "* modulo (x%y)\n", 90 | "* Integer division (x//y)\n" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 7, 96 | "metadata": {}, 97 | "outputs": [ 98 | { 99 | "name": "stdout", 100 | "output_type": "stream", 101 | "text": [ 102 | "12\n" 103 | ] 104 | } 105 | ], 106 | "source": [ 107 | "y = 5\n", 108 | "print(x + y)" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 8, 114 | "metadata": {}, 115 | "outputs": [ 116 | { 117 | "name": "stdout", 118 | "output_type": "stream", 119 | "text": [ 120 | "12\n" 121 | ] 122 | } 123 | ], 124 | "source": [ 125 | "result = x + y\n", 126 | "print(result)" 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": 9, 132 | "metadata": {}, 133 | "outputs": [ 134 | { 135 | "name": "stdout", 136 | "output_type": "stream", 137 | "text": [ 138 | "35\n" 139 | ] 140 | } 141 | ], 142 | "source": [ 143 | "print(x*y)" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 10, 149 | "metadata": {}, 150 | "outputs": [ 151 | { 152 | "name": "stdout", 153 | "output_type": "stream", 154 | "text": [ 155 | "2\n", 156 | "1.4\n" 157 | ] 158 | } 159 | ], 160 | "source": [ 161 | "print(x-y)\n", 162 | "print(x/y)" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 12, 168 | "metadata": {}, 169 | "outputs": [ 170 | { 171 | "name": "stdout", 172 | "output_type": "stream", 173 | "text": [ 174 | "16807\n" 175 | ] 176 | } 177 | ], 178 | "source": [ 179 | "print(x**y)" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 13, 185 | "metadata": {}, 186 | "outputs": [ 187 | { 188 | "name": "stdout", 189 | "output_type": "stream", 190 | "text": [ 191 | "2\n" 192 | ] 193 | } 194 | ], 195 | "source": [ 196 | "print(x%y)" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 14, 202 | "metadata": {}, 203 | "outputs": [ 204 | { 205 | "name": "stdout", 206 | "output_type": "stream", 207 | "text": [ 208 | "1\n" 209 | ] 210 | } 211 | ], 212 | "source": [ 213 | "print(x//y)" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "## Boolean\n", 221 | "### Perform logical operation such as:-\n", 222 | "* True\n", 223 | "* False\n", 224 | "* case-sensitive\n" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": 23, 230 | "metadata": {}, 231 | "outputs": [ 232 | { 233 | "data": { 234 | "text/plain": [ 235 | "bool" 236 | ] 237 | }, 238 | "execution_count": 23, 239 | "metadata": {}, 240 | "output_type": "execute_result" 241 | } 242 | ], 243 | "source": [ 244 | "a = True\n", 245 | "b = False\n", 246 | "type(a)" 247 | ] 248 | }, 249 | { 250 | "cell_type": "markdown", 251 | "metadata": {}, 252 | "source": [ 253 | "## Comparison Operators\n", 254 | "## compare the values on either sides of these operator and decide\n", 255 | "* == (x == y, check values of two operand are equal)\n", 256 | "* != (x != y, check values of two operand are not equal), same as using <>\n", 257 | "* \\> (x > y, check value of left operand is greater than the value of right operand)\n", 258 | "* < (x < y, check value of left operand is less than the value of right operand)\n", 259 | "* \\>= (x >= y, check value of left operand is greater than or equal to the value of right operand)\n", 260 | "* <= (x <= y, check value of left operand is less than or equal to the value of right operand)\n" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": 16, 266 | "metadata": {}, 267 | "outputs": [ 268 | { 269 | "name": "stdout", 270 | "output_type": "stream", 271 | "text": [ 272 | "False\n" 273 | ] 274 | } 275 | ], 276 | "source": [ 277 | "print(x==y)" 278 | ] 279 | }, 280 | { 281 | "cell_type": "code", 282 | "execution_count": 17, 283 | "metadata": {}, 284 | "outputs": [ 285 | { 286 | "name": "stdout", 287 | "output_type": "stream", 288 | "text": [ 289 | "True\n" 290 | ] 291 | } 292 | ], 293 | "source": [ 294 | "print(x!=y)" 295 | ] 296 | }, 297 | { 298 | "cell_type": "code", 299 | "execution_count": 18, 300 | "metadata": {}, 301 | "outputs": [ 302 | { 303 | "name": "stdout", 304 | "output_type": "stream", 305 | "text": [ 306 | "True\n" 307 | ] 308 | } 309 | ], 310 | "source": [ 311 | "print(x>y)" 312 | ] 313 | }, 314 | { 315 | "cell_type": "code", 316 | "execution_count": 19, 317 | "metadata": {}, 318 | "outputs": [ 319 | { 320 | "name": "stdout", 321 | "output_type": "stream", 322 | "text": [ 323 | "False\n" 324 | ] 325 | } 326 | ], 327 | "source": [ 328 | "print(x=y)" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": 21, 351 | "metadata": {}, 352 | "outputs": [ 353 | { 354 | "name": "stdout", 355 | "output_type": "stream", 356 | "text": [ 357 | "False\n" 358 | ] 359 | } 360 | ], 361 | "source": [ 362 | "print(x<=y)" 363 | ] 364 | }, 365 | { 366 | "cell_type": "markdown", 367 | "metadata": {}, 368 | "source": [ 369 | "## Logical Operators\n", 370 | "### compare the values of variables to make logical decision\n", 371 | "* e.g. x and y, and is the logical AND, return True if both operands are true\n", 372 | "* e.g. x or y, or is the logical OR, return True if any of the operands are true\n", 373 | "* e.g. not(x and y), not is the logical NOT, reverse the logical state of its operand" 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": 24, 379 | "metadata": {}, 380 | "outputs": [ 381 | { 382 | "name": "stdout", 383 | "output_type": "stream", 384 | "text": [ 385 | "False\n" 386 | ] 387 | } 388 | ], 389 | "source": [ 390 | "print(a and b)" 391 | ] 392 | }, 393 | { 394 | "cell_type": "code", 395 | "execution_count": 25, 396 | "metadata": {}, 397 | "outputs": [ 398 | { 399 | "name": "stdout", 400 | "output_type": "stream", 401 | "text": [ 402 | "True\n" 403 | ] 404 | } 405 | ], 406 | "source": [ 407 | "print(a or b)" 408 | ] 409 | }, 410 | { 411 | "cell_type": "code", 412 | "execution_count": 27, 413 | "metadata": {}, 414 | "outputs": [ 415 | { 416 | "name": "stdout", 417 | "output_type": "stream", 418 | "text": [ 419 | "True\n" 420 | ] 421 | } 422 | ], 423 | "source": [ 424 | "print(not(a and b))" 425 | ] 426 | }, 427 | { 428 | "cell_type": "markdown", 429 | "metadata": {}, 430 | "source": [ 431 | "## String\n", 432 | "* textual data, series of characters\n", 433 | "* can include any characters\n", 434 | "* use single quotes or double quotes to define a string
\n", 435 | " * e.g. type(‘hello’), using single quote to define hello as string \n", 436 | " * e.g. type(“123”), using double quote to define 123 as string\n", 437 | "* use backslash to escape if string include single or double quotes\n", 438 | "* can use addition (+) and multiplication (*) on string data type
\n", 439 | " * e.g. print(‘Hello’ + ‘World’), the output will be HelloWorld\n", 440 | " * e.g. print(‘Hello’ * 2), the output will be HelloHello\n", 441 | "* not supported to use subtraction (-) and division (/) operator on strings" 442 | ] 443 | }, 444 | { 445 | "cell_type": "code", 446 | "execution_count": 29, 447 | "metadata": {}, 448 | "outputs": [ 449 | { 450 | "name": "stdout", 451 | "output_type": "stream", 452 | "text": [ 453 | "I am a string, I can hold any characters from A to Z and 0 to 9\n" 454 | ] 455 | } 456 | ], 457 | "source": [ 458 | "text = 'I am a string, I can hold any characters from A to Z and 0 to 9'\n", 459 | "print(text)" 460 | ] 461 | }, 462 | { 463 | "cell_type": "code", 464 | "execution_count": 32, 465 | "metadata": {}, 466 | "outputs": [ 467 | { 468 | "name": "stdout", 469 | "output_type": "stream", 470 | "text": [ 471 | "I'm a string\n" 472 | ] 473 | } 474 | ], 475 | "source": [ 476 | "text = 'I\\'m a string'\n", 477 | "print(text)" 478 | ] 479 | }, 480 | { 481 | "cell_type": "code", 482 | "execution_count": 33, 483 | "metadata": {}, 484 | "outputs": [ 485 | { 486 | "name": "stdout", 487 | "output_type": "stream", 488 | "text": [ 489 | "HelloWorld\n" 490 | ] 491 | } 492 | ], 493 | "source": [ 494 | "print('Hello' + 'World')" 495 | ] 496 | }, 497 | { 498 | "cell_type": "code", 499 | "execution_count": 34, 500 | "metadata": {}, 501 | "outputs": [ 502 | { 503 | "name": "stdout", 504 | "output_type": "stream", 505 | "text": [ 506 | "HelloHelloHello\n" 507 | ] 508 | } 509 | ], 510 | "source": [ 511 | "print('Hello'*3)" 512 | ] 513 | }, 514 | { 515 | "cell_type": "code", 516 | "execution_count": 35, 517 | "metadata": {}, 518 | "outputs": [ 519 | { 520 | "ename": "TypeError", 521 | "evalue": "unsupported operand type(s) for -: 'str' and 'str'", 522 | "output_type": "error", 523 | "traceback": [ 524 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 525 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 526 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Hello'\u001b[0m \u001b[1;33m-\u001b[0m \u001b[1;34m'World'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 527 | "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'" 528 | ] 529 | } 530 | ], 531 | "source": [ 532 | "print('Hello' - 'World')" 533 | ] 534 | }, 535 | { 536 | "cell_type": "code", 537 | "execution_count": 36, 538 | "metadata": {}, 539 | "outputs": [ 540 | { 541 | "ename": "TypeError", 542 | "evalue": "unsupported operand type(s) for /: 'str' and 'str'", 543 | "output_type": "error", 544 | "traceback": [ 545 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 546 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 547 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Hello'\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;34m'World'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 548 | "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'str'" 549 | ] 550 | } 551 | ], 552 | "source": [ 553 | "print('Hello'/'World')" 554 | ] 555 | }, 556 | { 557 | "cell_type": "markdown", 558 | "metadata": {}, 559 | "source": [ 560 | "> End of Lab Session 1" 561 | ] 562 | } 563 | ], 564 | "metadata": { 565 | "kernelspec": { 566 | "display_name": "Python 3", 567 | "language": "python", 568 | "name": "python3" 569 | }, 570 | "language_info": { 571 | "codemirror_mode": { 572 | "name": "ipython", 573 | "version": 3 574 | }, 575 | "file_extension": ".py", 576 | "mimetype": "text/x-python", 577 | "name": "python", 578 | "nbconvert_exporter": "python", 579 | "pygments_lexer": "ipython3", 580 | "version": "3.6.4" 581 | } 582 | }, 583 | "nbformat": 4, 584 | "nbformat_minor": 2 585 | } 586 | -------------------------------------------------------------------------------- /002-StringsManipulationInPython.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Programming for Data Science Series (Lab Session 2)\n", 8 | "## Strings Manipulation in Python\n", 9 | "### String methods - Accessing\n", 10 | "* use len() method to get length of the string\n", 11 | "* use find() method to find the position of a character\n", 12 | "* use count() method to count how many times a character appear in a string\n", 13 | "> Note: character position start with zero, use square bracket with character position" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "#### Associated Tutorial for this Lab session is shown below:" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 1, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "image/jpeg": "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\n", 31 | "text/html": [ 32 | "\n", 33 | " \n", 40 | " " 41 | ], 42 | "text/plain": [ 43 | "" 44 | ] 45 | }, 46 | "execution_count": 1, 47 | "metadata": {}, 48 | "output_type": "execute_result" 49 | } 50 | ], 51 | "source": [ 52 | "from IPython.display import YouTubeVideo\n", 53 | "\n", 54 | "YouTubeVideo('wInQSbuvkgs', width=800, height=450)" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 1, 60 | "metadata": {}, 61 | "outputs": [ 62 | { 63 | "data": { 64 | "text/plain": [ 65 | "'C'" 66 | ] 67 | }, 68 | "execution_count": 1, 69 | "metadata": {}, 70 | "output_type": "execute_result" 71 | } 72 | ], 73 | "source": [ 74 | "string = \"Cloud number 9\"\n", 75 | "string[0]" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 2, 81 | "metadata": {}, 82 | "outputs": [ 83 | { 84 | "data": { 85 | "text/plain": [ 86 | "14" 87 | ] 88 | }, 89 | "execution_count": 2, 90 | "metadata": {}, 91 | "output_type": "execute_result" 92 | } 93 | ], 94 | "source": [ 95 | "len(string)" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 6, 101 | "metadata": {}, 102 | "outputs": [ 103 | { 104 | "data": { 105 | "text/plain": [ 106 | "2" 107 | ] 108 | }, 109 | "execution_count": 6, 110 | "metadata": {}, 111 | "output_type": "execute_result" 112 | } 113 | ], 114 | "source": [ 115 | "string.find('o')" 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": 7, 121 | "metadata": {}, 122 | "outputs": [ 123 | { 124 | "data": { 125 | "text/plain": [ 126 | "2" 127 | ] 128 | }, 129 | "execution_count": 7, 130 | "metadata": {}, 131 | "output_type": "execute_result" 132 | } 133 | ], 134 | "source": [ 135 | "string.count('u')" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "### String methods - Slicing\n", 143 | "* to get a set of letters\n", 144 | "* to get in between characters\n", 145 | "* to get all characters after first six characters\n", 146 | "* to get all characters after removing last six characters" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": 8, 152 | "metadata": {}, 153 | "outputs": [ 154 | { 155 | "data": { 156 | "text/plain": [ 157 | "'Cloud'" 158 | ] 159 | }, 160 | "execution_count": 8, 161 | "metadata": {}, 162 | "output_type": "execute_result" 163 | } 164 | ], 165 | "source": [ 166 | "string[0:5]" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": 10, 172 | "metadata": {}, 173 | "outputs": [ 174 | { 175 | "data": { 176 | "text/plain": [ 177 | "'Cloud'" 178 | ] 179 | }, 180 | "execution_count": 10, 181 | "metadata": {}, 182 | "output_type": "execute_result" 183 | } 184 | ], 185 | "source": [ 186 | "#using short-hand\n", 187 | "string[:5]" 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": 11, 193 | "metadata": {}, 194 | "outputs": [ 195 | { 196 | "data": { 197 | "text/plain": [ 198 | "'num'" 199 | ] 200 | }, 201 | "execution_count": 11, 202 | "metadata": {}, 203 | "output_type": "execute_result" 204 | } 205 | ], 206 | "source": [ 207 | "#get in between characters\n", 208 | "string[6:9]" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 12, 214 | "metadata": {}, 215 | "outputs": [ 216 | { 217 | "data": { 218 | "text/plain": [ 219 | "'number 9'" 220 | ] 221 | }, 222 | "execution_count": 12, 223 | "metadata": {}, 224 | "output_type": "execute_result" 225 | } 226 | ], 227 | "source": [ 228 | "#get all characters after first six characters\n", 229 | "string[6:]" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 13, 235 | "metadata": {}, 236 | "outputs": [ 237 | { 238 | "data": { 239 | "text/plain": [ 240 | "'Cloud nu'" 241 | ] 242 | }, 243 | "execution_count": 13, 244 | "metadata": {}, 245 | "output_type": "execute_result" 246 | } 247 | ], 248 | "source": [ 249 | "#get all characters after removing last six characters\n", 250 | "string[:-6]" 251 | ] 252 | }, 253 | { 254 | "cell_type": "markdown", 255 | "metadata": {}, 256 | "source": [ 257 | "### String methods - Transforming\n", 258 | "* split based on a character\n", 259 | "* replace character in a string\n", 260 | "* change to upper or lower case\n", 261 | "* join each character will additional character" 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": 15, 267 | "metadata": {}, 268 | "outputs": [ 269 | { 270 | "data": { 271 | "text/plain": [ 272 | "['Cloud', 'number', '9']" 273 | ] 274 | }, 275 | "execution_count": 15, 276 | "metadata": {}, 277 | "output_type": "execute_result" 278 | } 279 | ], 280 | "source": [ 281 | "#split based on space character\n", 282 | "string.split(' ')" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 17, 288 | "metadata": {}, 289 | "outputs": [ 290 | { 291 | "data": { 292 | "text/plain": [ 293 | "'Cloud number 7'" 294 | ] 295 | }, 296 | "execution_count": 17, 297 | "metadata": {}, 298 | "output_type": "execute_result" 299 | } 300 | ], 301 | "source": [ 302 | "#replace 9 with 7 in a string\n", 303 | "string.replace('9', '7')" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": 21, 309 | "metadata": {}, 310 | "outputs": [ 311 | { 312 | "data": { 313 | "text/plain": [ 314 | "'CLOUD NUMBER 9'" 315 | ] 316 | }, 317 | "execution_count": 21, 318 | "metadata": {}, 319 | "output_type": "execute_result" 320 | } 321 | ], 322 | "source": [ 323 | "#change to upper\n", 324 | "string.upper()" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": 22, 330 | "metadata": {}, 331 | "outputs": [ 332 | { 333 | "data": { 334 | "text/plain": [ 335 | "'cloud number 9'" 336 | ] 337 | }, 338 | "execution_count": 22, 339 | "metadata": {}, 340 | "output_type": "execute_result" 341 | } 342 | ], 343 | "source": [ 344 | "#change to lower\n", 345 | "string.lower()" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": 23, 351 | "metadata": {}, 352 | "outputs": [ 353 | { 354 | "data": { 355 | "text/plain": [ 356 | "'C-l-o-u-d- -n-u-m-b-e-r- -9'" 357 | ] 358 | }, 359 | "execution_count": 23, 360 | "metadata": {}, 361 | "output_type": "execute_result" 362 | } 363 | ], 364 | "source": [ 365 | "#join each character with dash\n", 366 | "'-'.join(string)" 367 | ] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": {}, 372 | "source": [ 373 | "### String methods - Checking/Testing\n", 374 | "* check if a string start/end with certain characters\n", 375 | "* check all characters are alphanumeric\n", 376 | "* check all characters are digits\n", 377 | "* check all characters are spaces" 378 | ] 379 | }, 380 | { 381 | "cell_type": "code", 382 | "execution_count": 24, 383 | "metadata": {}, 384 | "outputs": [ 385 | { 386 | "data": { 387 | "text/plain": [ 388 | "True" 389 | ] 390 | }, 391 | "execution_count": 24, 392 | "metadata": {}, 393 | "output_type": "execute_result" 394 | } 395 | ], 396 | "source": [ 397 | "#check if our string starts with Cloud\n", 398 | "string.startswith('Cloud')" 399 | ] 400 | }, 401 | { 402 | "cell_type": "code", 403 | "execution_count": 25, 404 | "metadata": {}, 405 | "outputs": [ 406 | { 407 | "data": { 408 | "text/plain": [ 409 | "False" 410 | ] 411 | }, 412 | "execution_count": 25, 413 | "metadata": {}, 414 | "output_type": "execute_result" 415 | } 416 | ], 417 | "source": [ 418 | "#check if our string ends with zero\n", 419 | "string.endswith('0')" 420 | ] 421 | }, 422 | { 423 | "cell_type": "code", 424 | "execution_count": 26, 425 | "metadata": {}, 426 | "outputs": [ 427 | { 428 | "data": { 429 | "text/plain": [ 430 | "False" 431 | ] 432 | }, 433 | "execution_count": 26, 434 | "metadata": {}, 435 | "output_type": "execute_result" 436 | } 437 | ], 438 | "source": [ 439 | "#check all characters are alphanumeric\n", 440 | "string.isalnum()" 441 | ] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": 27, 446 | "metadata": {}, 447 | "outputs": [ 448 | { 449 | "data": { 450 | "text/plain": [ 451 | "True" 452 | ] 453 | }, 454 | "execution_count": 27, 455 | "metadata": {}, 456 | "output_type": "execute_result" 457 | } 458 | ], 459 | "source": [ 460 | "anotherString = 'CloudNumber9'\n", 461 | "anotherString.isalnum()" 462 | ] 463 | }, 464 | { 465 | "cell_type": "code", 466 | "execution_count": 28, 467 | "metadata": {}, 468 | "outputs": [ 469 | { 470 | "data": { 471 | "text/plain": [ 472 | "False" 473 | ] 474 | }, 475 | "execution_count": 28, 476 | "metadata": {}, 477 | "output_type": "execute_result" 478 | } 479 | ], 480 | "source": [ 481 | "#check all characters are digits\n", 482 | "string.isdigit()" 483 | ] 484 | }, 485 | { 486 | "cell_type": "code", 487 | "execution_count": 29, 488 | "metadata": {}, 489 | "outputs": [ 490 | { 491 | "data": { 492 | "text/plain": [ 493 | "True" 494 | ] 495 | }, 496 | "execution_count": 29, 497 | "metadata": {}, 498 | "output_type": "execute_result" 499 | } 500 | ], 501 | "source": [ 502 | "digitString = '123456789'\n", 503 | "digitString.isdigit()" 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": 30, 509 | "metadata": {}, 510 | "outputs": [ 511 | { 512 | "data": { 513 | "text/plain": [ 514 | "False" 515 | ] 516 | }, 517 | "execution_count": 30, 518 | "metadata": {}, 519 | "output_type": "execute_result" 520 | } 521 | ], 522 | "source": [ 523 | "#check all characters are spaces\n", 524 | "string.isspace()" 525 | ] 526 | }, 527 | { 528 | "cell_type": "code", 529 | "execution_count": 31, 530 | "metadata": {}, 531 | "outputs": [ 532 | { 533 | "data": { 534 | "text/plain": [ 535 | "True" 536 | ] 537 | }, 538 | "execution_count": 31, 539 | "metadata": {}, 540 | "output_type": "execute_result" 541 | } 542 | ], 543 | "source": [ 544 | "spaceString = ' '\n", 545 | "spaceString.isspace()" 546 | ] 547 | }, 548 | { 549 | "cell_type": "markdown", 550 | "metadata": {}, 551 | "source": [ 552 | "> End of Lab Session 2" 553 | ] 554 | } 555 | ], 556 | "metadata": { 557 | "kernelspec": { 558 | "display_name": "Python 3", 559 | "language": "python", 560 | "name": "python3" 561 | }, 562 | "language_info": { 563 | "codemirror_mode": { 564 | "name": "ipython", 565 | "version": 3 566 | }, 567 | "file_extension": ".py", 568 | "mimetype": "text/x-python", 569 | "name": "python", 570 | "nbconvert_exporter": "python", 571 | "pygments_lexer": "ipython3", 572 | "version": "3.6.4" 573 | } 574 | }, 575 | "nbformat": 4, 576 | "nbformat_minor": 2 577 | } 578 | -------------------------------------------------------------------------------- /004-AdvancedDataTypesPart2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Programming for Data Science Series (Lab Session 4)\n", 8 | "## Advanced Data Types Part 2\n", 9 | "### Sets\n", 10 | "* collection of unique elements\n", 11 | "* duplications are removed\n", 12 | "* support in operator same as list\n", 13 | "* mutable (i.e. can change the set after its creation)\n", 14 | "* unordered (i.e. no first or last item)" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "### Associated Tutorial for this Lab session is shown below:" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 1, 27 | "metadata": {}, 28 | "outputs": [ 29 | { 30 | "data": { 31 | "image/jpeg": "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\n", 32 | "text/html": [ 33 | "\n", 34 | " \n", 41 | " " 42 | ], 43 | "text/plain": [ 44 | "" 45 | ] 46 | }, 47 | "execution_count": 1, 48 | "metadata": {}, 49 | "output_type": "execute_result" 50 | } 51 | ], 52 | "source": [ 53 | "from IPython.display import YouTubeVideo\n", 54 | "\n", 55 | "YouTubeVideo('LGESPSobxGk', width=800, height=450)" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 1, 61 | "metadata": {}, 62 | "outputs": [ 63 | { 64 | "data": { 65 | "text/plain": [ 66 | "{1, 2, 3, 4, 5}" 67 | ] 68 | }, 69 | "execution_count": 1, 70 | "metadata": {}, 71 | "output_type": "execute_result" 72 | } 73 | ], 74 | "source": [ 75 | "num_set = {1, 1, 2, 3, 4, 5}\n", 76 | "num_set" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "> Note: 1 appears twice but it was removed after all." 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 2, 89 | "metadata": {}, 90 | "outputs": [ 91 | { 92 | "ename": "TypeError", 93 | "evalue": "'set' object does not support indexing", 94 | "output_type": "error", 95 | "traceback": [ 96 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 97 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 98 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m#unordered, therefore 'set' object does not support indexing\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mnum_set\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 99 | "\u001b[1;31mTypeError\u001b[0m: 'set' object does not support indexing" 100 | ] 101 | } 102 | ], 103 | "source": [ 104 | "#unordered, therefore 'set' object does not support indexing\n", 105 | "num_set[0]" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 3, 111 | "metadata": {}, 112 | "outputs": [ 113 | { 114 | "data": { 115 | "text/plain": [ 116 | "True" 117 | ] 118 | }, 119 | "execution_count": 3, 120 | "metadata": {}, 121 | "output_type": "execute_result" 122 | } 123 | ], 124 | "source": [ 125 | "1 in num_set" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 4, 131 | "metadata": {}, 132 | "outputs": [ 133 | { 134 | "data": { 135 | "text/plain": [ 136 | "False" 137 | ] 138 | }, 139 | "execution_count": 4, 140 | "metadata": {}, 141 | "output_type": "execute_result" 142 | } 143 | ], 144 | "source": [ 145 | "6 in num_set" 146 | ] 147 | }, 148 | { 149 | "cell_type": "markdown", 150 | "metadata": {}, 151 | "source": [ 152 | "### Accesing Sets and Sets methods\n", 153 | "* can access each element inside the set by looping through\n", 154 | "* copy(), method to copy a set\n", 155 | "* new item can be added using add() method\n", 156 | "* use update() method to add multiple items\n", 157 | "* use pop(), remove() method to remove an item from set\n", 158 | "* use clear(), del() to clear and delete set" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "> Below example use for loop, for those who are not familiar with looping, please skip to Ln[6] or refer Control Structure tutotial" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 5, 171 | "metadata": {}, 172 | "outputs": [ 173 | { 174 | "name": "stdout", 175 | "output_type": "stream", 176 | "text": [ 177 | "1\n", 178 | "2\n", 179 | "3\n", 180 | "4\n", 181 | "5\n" 182 | ] 183 | } 184 | ], 185 | "source": [ 186 | "#an example of using for loop to access set\n", 187 | "for x in num_set:\n", 188 | " print(x)" 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": 6, 194 | "metadata": {}, 195 | "outputs": [ 196 | { 197 | "data": { 198 | "text/plain": [ 199 | "{1, 2, 3, 4, 5, 100}" 200 | ] 201 | }, 202 | "execution_count": 6, 203 | "metadata": {}, 204 | "output_type": "execute_result" 205 | } 206 | ], 207 | "source": [ 208 | "num_set.add(100)\n", 209 | "num_set" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": 7, 215 | "metadata": {}, 216 | "outputs": [ 217 | { 218 | "data": { 219 | "text/plain": [ 220 | "{1, 2, 3, 4, 5, 7, 8, 100}" 221 | ] 222 | }, 223 | "execution_count": 7, 224 | "metadata": {}, 225 | "output_type": "execute_result" 226 | } 227 | ], 228 | "source": [ 229 | "#use update() method to add more than one item\n", 230 | "num_set.update([7, 8])\n", 231 | "num_set" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": 8, 237 | "metadata": {}, 238 | "outputs": [ 239 | { 240 | "data": { 241 | "text/plain": [ 242 | "{2, 3, 4, 5, 7, 8, 100}" 243 | ] 244 | }, 245 | "execution_count": 8, 246 | "metadata": {}, 247 | "output_type": "execute_result" 248 | } 249 | ], 250 | "source": [ 251 | "#use remove() to remove given item\n", 252 | "num_set.remove(1)\n", 253 | "num_set" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": 9, 259 | "metadata": {}, 260 | "outputs": [ 261 | { 262 | "name": "stdout", 263 | "output_type": "stream", 264 | "text": [ 265 | "2\n" 266 | ] 267 | }, 268 | { 269 | "data": { 270 | "text/plain": [ 271 | "{3, 4, 5, 7, 8, 100}" 272 | ] 273 | }, 274 | "execution_count": 9, 275 | "metadata": {}, 276 | "output_type": "execute_result" 277 | } 278 | ], 279 | "source": [ 280 | "#using pop() will remove the item\n", 281 | "pop_item = num_set.pop()\n", 282 | "print(pop_item)\n", 283 | "num_set" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": 10, 289 | "metadata": {}, 290 | "outputs": [ 291 | { 292 | "data": { 293 | "text/plain": [ 294 | "set()" 295 | ] 296 | }, 297 | "execution_count": 10, 298 | "metadata": {}, 299 | "output_type": "execute_result" 300 | } 301 | ], 302 | "source": [ 303 | "#clear all items inside set\n", 304 | "num_set.clear()\n", 305 | "num_set" 306 | ] 307 | }, 308 | { 309 | "cell_type": "code", 310 | "execution_count": 11, 311 | "metadata": {}, 312 | "outputs": [ 313 | { 314 | "ename": "NameError", 315 | "evalue": "name 'num_set' is not defined", 316 | "output_type": "error", 317 | "traceback": [ 318 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 319 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 320 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m#the set is already deleted, therefore there is no set to show\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mnum_set\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mnum_set\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 321 | "\u001b[1;31mNameError\u001b[0m: name 'num_set' is not defined" 322 | ] 323 | } 324 | ], 325 | "source": [ 326 | "#the set is already deleted, therefore there is no set to show\n", 327 | "del num_set\n", 328 | "num_set" 329 | ] 330 | }, 331 | { 332 | "cell_type": "markdown", 333 | "metadata": {}, 334 | "source": [ 335 | "### Sets Operations\n", 336 | "* union() to join two sets\n", 337 | "* intersection() to get common element from both sets" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": 12, 343 | "metadata": {}, 344 | "outputs": [ 345 | { 346 | "data": { 347 | "text/plain": [ 348 | "{'Child', 'Daddy', 'Daughter', 'Mommy', 'Son'}" 349 | ] 350 | }, 351 | "execution_count": 12, 352 | "metadata": {}, 353 | "output_type": "execute_result" 354 | } 355 | ], 356 | "source": [ 357 | "papa = {'Daddy', 'Son', 'Child'}\n", 358 | "mama = {'Mommy', 'Daughter', 'Child'}\n", 359 | "family = papa.union(mama)\n", 360 | "family" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": 13, 366 | "metadata": {}, 367 | "outputs": [ 368 | { 369 | "data": { 370 | "text/plain": [ 371 | "{'Child'}" 372 | ] 373 | }, 374 | "execution_count": 13, 375 | "metadata": {}, 376 | "output_type": "execute_result" 377 | } 378 | ], 379 | "source": [ 380 | "common_item = papa.intersection(mama)\n", 381 | "common_item" 382 | ] 383 | }, 384 | { 385 | "cell_type": "markdown", 386 | "metadata": {}, 387 | "source": [ 388 | "> We can use update() method to join sets" 389 | ] 390 | }, 391 | { 392 | "cell_type": "code", 393 | "execution_count": 14, 394 | "metadata": {}, 395 | "outputs": [ 396 | { 397 | "name": "stdout", 398 | "output_type": "stream", 399 | "text": [ 400 | "None\n", 401 | "{1, 2, 3, 'C', 'B', 'A'}\n" 402 | ] 403 | } 404 | ], 405 | "source": [ 406 | "#using update() will alter the set one by adding all items from set two\n", 407 | "numbers = {1, 2, 3}\n", 408 | "alphabet = {'A', 'B', 'C'}\n", 409 | "alphanumeric = numbers.update(alphabet)\n", 410 | "print(alphanumeric)\n", 411 | "print(numbers)" 412 | ] 413 | }, 414 | { 415 | "cell_type": "code", 416 | "execution_count": 33, 417 | "metadata": {}, 418 | "outputs": [ 419 | { 420 | "data": { 421 | "text/plain": [ 422 | "{1, 2, 3, 'A', 'B', 'C'}" 423 | ] 424 | }, 425 | "execution_count": 33, 426 | "metadata": {}, 427 | "output_type": "execute_result" 428 | } 429 | ], 430 | "source": [ 431 | "#copy a set to create another set\n", 432 | "copy_numbers = numbers.copy()\n", 433 | "copy_numbers" 434 | ] 435 | }, 436 | { 437 | "cell_type": "markdown", 438 | "metadata": {}, 439 | "source": [ 440 | "### Dictionaries\n", 441 | "* used for storing keys and values pairs of information\n", 442 | "* mutable objects that store mappings of unique keys to values\n", 443 | "* can be accessed using key\n", 444 | "* keys not required to be same data type\n", 445 | "* support in operator same as list\n", 446 | "* mutable (i.e. can change the set after its creation)\n", 447 | "* unordered but indexed (i.e. no first or last item)" 448 | ] 449 | }, 450 | { 451 | "cell_type": "code", 452 | "execution_count": 35, 453 | "metadata": {}, 454 | "outputs": [ 455 | { 456 | "data": { 457 | "text/plain": [ 458 | "{'Apr': 30, 'Feb': 28, 'Jan': 31, 'Mar': 31}" 459 | ] 460 | }, 461 | "execution_count": 35, 462 | "metadata": {}, 463 | "output_type": "execute_result" 464 | } 465 | ], 466 | "source": [ 467 | "months = {'Jan':31, 'Feb':28, 'Mar':31, 'Apr':30}\n", 468 | "months" 469 | ] 470 | }, 471 | { 472 | "cell_type": "code", 473 | "execution_count": 36, 474 | "metadata": {}, 475 | "outputs": [ 476 | { 477 | "data": { 478 | "text/plain": [ 479 | "31" 480 | ] 481 | }, 482 | "execution_count": 36, 483 | "metadata": {}, 484 | "output_type": "execute_result" 485 | } 486 | ], 487 | "source": [ 488 | "months['Jan']" 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": 37, 494 | "metadata": {}, 495 | "outputs": [ 496 | { 497 | "name": "stdout", 498 | "output_type": "stream", 499 | "text": [ 500 | "One\n" 501 | ] 502 | } 503 | ], 504 | "source": [ 505 | "#keys not required to be same data type\n", 506 | "garbage = {1: 'One', 'Two': 2}\n", 507 | "print(garbage[1])" 508 | ] 509 | }, 510 | { 511 | "cell_type": "code", 512 | "execution_count": 38, 513 | "metadata": {}, 514 | "outputs": [ 515 | { 516 | "ename": "KeyError", 517 | "evalue": "'One'", 518 | "output_type": "error", 519 | "traceback": [ 520 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 521 | "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", 522 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m#there is no key as 'One' in this dictionary, therefore we get error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgarbage\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'One'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 523 | "\u001b[1;31mKeyError\u001b[0m: 'One'" 524 | ] 525 | } 526 | ], 527 | "source": [ 528 | "#there is no key as 'One' in this dictionary, therefore we get error\n", 529 | "print(garbage['One'])" 530 | ] 531 | }, 532 | { 533 | "cell_type": "code", 534 | "execution_count": 39, 535 | "metadata": {}, 536 | "outputs": [ 537 | { 538 | "data": { 539 | "text/plain": [ 540 | "True" 541 | ] 542 | }, 543 | "execution_count": 39, 544 | "metadata": {}, 545 | "output_type": "execute_result" 546 | } 547 | ], 548 | "source": [ 549 | "#support in operator, but only check key\n", 550 | "'Jan' in months" 551 | ] 552 | }, 553 | { 554 | "cell_type": "code", 555 | "execution_count": 40, 556 | "metadata": {}, 557 | "outputs": [ 558 | { 559 | "data": { 560 | "text/plain": [ 561 | "False" 562 | ] 563 | }, 564 | "execution_count": 40, 565 | "metadata": {}, 566 | "output_type": "execute_result" 567 | } 568 | ], 569 | "source": [ 570 | "31 in months" 571 | ] 572 | }, 573 | { 574 | "cell_type": "markdown", 575 | "metadata": {}, 576 | "source": [ 577 | "### Accessing Dictionaries and Dictionaries methods\n", 578 | "* can access each element inside the set by looping through\n", 579 | "* get(), method to access value in a dictionary by its key\n", 580 | "* copy(), method to copy a dictionary\n", 581 | "* use update() method to update\n", 582 | "* use pop() method to remove an item from dictionaries\n", 583 | "* use clear(), del() to clear and delete dictionaries" 584 | ] 585 | }, 586 | { 587 | "cell_type": "markdown", 588 | "metadata": {}, 589 | "source": [ 590 | "> Below example use for loop, for those who are not familiar with looping, please skip to Ln[45] or refer Control Structure tutotial" 591 | ] 592 | }, 593 | { 594 | "cell_type": "code", 595 | "execution_count": 41, 596 | "metadata": {}, 597 | "outputs": [ 598 | { 599 | "name": "stdout", 600 | "output_type": "stream", 601 | "text": [ 602 | "Jan\n", 603 | "Feb\n", 604 | "Mar\n", 605 | "Apr\n" 606 | ] 607 | } 608 | ], 609 | "source": [ 610 | "for x in months:\n", 611 | " print(x)" 612 | ] 613 | }, 614 | { 615 | "cell_type": "code", 616 | "execution_count": 42, 617 | "metadata": {}, 618 | "outputs": [ 619 | { 620 | "name": "stdout", 621 | "output_type": "stream", 622 | "text": [ 623 | "31\n", 624 | "28\n", 625 | "31\n", 626 | "30\n" 627 | ] 628 | } 629 | ], 630 | "source": [ 631 | "for x in months:\n", 632 | " print(months[x])" 633 | ] 634 | }, 635 | { 636 | "cell_type": "code", 637 | "execution_count": 43, 638 | "metadata": {}, 639 | "outputs": [ 640 | { 641 | "name": "stdout", 642 | "output_type": "stream", 643 | "text": [ 644 | "31\n", 645 | "28\n", 646 | "31\n", 647 | "30\n" 648 | ] 649 | } 650 | ], 651 | "source": [ 652 | "for x in months.values():\n", 653 | " print(x)" 654 | ] 655 | }, 656 | { 657 | "cell_type": "code", 658 | "execution_count": 44, 659 | "metadata": {}, 660 | "outputs": [ 661 | { 662 | "name": "stdout", 663 | "output_type": "stream", 664 | "text": [ 665 | "Jan 31\n", 666 | "Feb 28\n", 667 | "Mar 31\n", 668 | "Apr 30\n" 669 | ] 670 | } 671 | ], 672 | "source": [ 673 | "for x, y in months.items():\n", 674 | " print(x, y)" 675 | ] 676 | }, 677 | { 678 | "cell_type": "code", 679 | "execution_count": 45, 680 | "metadata": {}, 681 | "outputs": [ 682 | { 683 | "data": { 684 | "text/plain": [ 685 | "31" 686 | ] 687 | }, 688 | "execution_count": 45, 689 | "metadata": {}, 690 | "output_type": "execute_result" 691 | } 692 | ], 693 | "source": [ 694 | "#using get() method to access an item\n", 695 | "jan_number = months.get('Jan')\n", 696 | "jan_number" 697 | ] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": 46, 702 | "metadata": {}, 703 | "outputs": [ 704 | { 705 | "data": { 706 | "text/plain": [ 707 | "{'Apr': 30, 'Feb': 28, 'Jan': 31, 'Mar': 31}" 708 | ] 709 | }, 710 | "execution_count": 46, 711 | "metadata": {}, 712 | "output_type": "execute_result" 713 | } 714 | ], 715 | "source": [ 716 | "#copy a dictionary to create another dictionary\n", 717 | "copy_months = months.copy()\n", 718 | "copy_months" 719 | ] 720 | }, 721 | { 722 | "cell_type": "code", 723 | "execution_count": 47, 724 | "metadata": {}, 725 | "outputs": [ 726 | { 727 | "data": { 728 | "text/plain": [ 729 | "{'Apr': 30, 'Feb': 29, 'Jan': 31, 'Mar': 31}" 730 | ] 731 | }, 732 | "execution_count": 47, 733 | "metadata": {}, 734 | "output_type": "execute_result" 735 | } 736 | ], 737 | "source": [ 738 | "#update Feb month value to 29\n", 739 | "months['Feb']=29\n", 740 | "months" 741 | ] 742 | }, 743 | { 744 | "cell_type": "code", 745 | "execution_count": 28, 746 | "metadata": {}, 747 | "outputs": [ 748 | { 749 | "data": { 750 | "text/plain": [ 751 | "{'Apr': 30, 'Feb': 29, 'Mar': 31}" 752 | ] 753 | }, 754 | "execution_count": 28, 755 | "metadata": {}, 756 | "output_type": "execute_result" 757 | } 758 | ], 759 | "source": [ 760 | "#remove element by defining key\n", 761 | "months.pop('Jan')\n", 762 | "months" 763 | ] 764 | }, 765 | { 766 | "cell_type": "code", 767 | "execution_count": 29, 768 | "metadata": {}, 769 | "outputs": [ 770 | { 771 | "data": { 772 | "text/plain": [ 773 | "{}" 774 | ] 775 | }, 776 | "execution_count": 29, 777 | "metadata": {}, 778 | "output_type": "execute_result" 779 | } 780 | ], 781 | "source": [ 782 | "#clear elements inside dictionaries\n", 783 | "months.clear()\n", 784 | "months" 785 | ] 786 | }, 787 | { 788 | "cell_type": "code", 789 | "execution_count": 30, 790 | "metadata": {}, 791 | "outputs": [ 792 | { 793 | "ename": "NameError", 794 | "evalue": "name 'months' is not defined", 795 | "output_type": "error", 796 | "traceback": [ 797 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 798 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 799 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mmonths\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mmonths\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 800 | "\u001b[1;31mNameError\u001b[0m: name 'months' is not defined" 801 | ] 802 | } 803 | ], 804 | "source": [ 805 | "#delete a dictionary permantly\n", 806 | "del months\n", 807 | "months #it is already deleted" 808 | ] 809 | } 810 | ], 811 | "metadata": { 812 | "kernelspec": { 813 | "display_name": "Python 3", 814 | "language": "python", 815 | "name": "python3" 816 | }, 817 | "language_info": { 818 | "codemirror_mode": { 819 | "name": "ipython", 820 | "version": 3 821 | }, 822 | "file_extension": ".py", 823 | "mimetype": "text/x-python", 824 | "name": "python", 825 | "nbconvert_exporter": "python", 826 | "pygments_lexer": "ipython3", 827 | "version": "3.6.4" 828 | } 829 | }, 830 | "nbformat": 4, 831 | "nbformat_minor": 2 832 | } 833 | -------------------------------------------------------------------------------- /006-Functions.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Programming for Data Science Series (Lab Session 6)\n", 8 | "## Functions\n", 9 | "### Defining Function\n", 10 | "* Must have a name\n", 11 | "* Use def keyword in Python followed by the name of the function and also with open and close bracket\n", 12 | "* When we use a function, we say “we call a function”" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": {}, 18 | "source": [ 19 | "### Associated Tutorial for this Lab session is shown below:" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 1, 25 | "metadata": {}, 26 | "outputs": [ 27 | { 28 | "data": { 29 | "image/jpeg": "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\n", 30 | "text/html": [ 31 | "\n", 32 | " \n", 39 | " " 40 | ], 41 | "text/plain": [ 42 | "" 43 | ] 44 | }, 45 | "execution_count": 1, 46 | "metadata": {}, 47 | "output_type": "execute_result" 48 | } 49 | ], 50 | "source": [ 51 | "from IPython.display import YouTubeVideo\n", 52 | "\n", 53 | "YouTubeVideo('QON866-cYEE', width=800, height=450)" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 1, 59 | "metadata": {}, 60 | "outputs": [ 61 | { 62 | "name": "stdout", 63 | "output_type": "stream", 64 | "text": [ 65 | "Hello\n" 66 | ] 67 | } 68 | ], 69 | "source": [ 70 | "def say_hello():\n", 71 | " print('Hello')\n", 72 | "say_hello()" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 3, 78 | "metadata": {}, 79 | "outputs": [ 80 | { 81 | "name": "stdout", 82 | "output_type": "stream", 83 | "text": [ 84 | "Hello\n", 85 | "Hello\n", 86 | "Hello\n" 87 | ] 88 | } 89 | ], 90 | "source": [ 91 | "say_hello()\n", 92 | "say_hello()\n", 93 | "say_hello()" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "### Arguments/Parameters\n", 101 | "* Parameters are values provided to perform some task within a function\n", 102 | "* A function can accept no or more than one parameters" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 4, 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "name": "stdout", 112 | "output_type": "stream", 113 | "text": [ 114 | "23.437499999999996\n" 115 | ] 116 | } 117 | ], 118 | "source": [ 119 | "def calculate_bmi(weight, height):\n", 120 | " print(weight/(height*height))\n", 121 | "\n", 122 | "calculate_bmi(60, 1.6)" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "### Defaulting Arguments/Parameters\n", 130 | "* Notice that if a function have more than one parameters, then separated each parameters by commas\n", 131 | "* Can assign default values to each parameters (arguments)\n", 132 | "* If no arguments were passed into the function, default arguments will be used" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": 7, 138 | "metadata": {}, 139 | "outputs": [ 140 | { 141 | "name": "stdout", 142 | "output_type": "stream", 143 | "text": [ 144 | "23.437499999999996\n" 145 | ] 146 | } 147 | ], 148 | "source": [ 149 | "def calculate_bmi(weight, height=1.6):\n", 150 | " print(weight/(height*height))\n", 151 | "\n", 152 | "calculate_bmi(60)" 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "metadata": {}, 158 | "source": [ 159 | "### Return value(s)\n", 160 | "* Return values are the values return from a function (usually after performing a particular task)\n", 161 | "* A python function can return more than one values" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": 8, 167 | "metadata": {}, 168 | "outputs": [ 169 | { 170 | "name": "stdout", 171 | "output_type": "stream", 172 | "text": [ 173 | "23.437499999999996\n" 174 | ] 175 | } 176 | ], 177 | "source": [ 178 | "def calculate_bmi(weight, height):\n", 179 | " bmi = (weight/(height*height))\n", 180 | " return bmi\n", 181 | "\n", 182 | "print(calculate_bmi(60, 1.6))" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "> Note: Arguments/Parameters can pass using two different methods\n", 190 | "* By position\n", 191 | "* By name" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 9, 197 | "metadata": {}, 198 | "outputs": [ 199 | { 200 | "name": "stdout", 201 | "output_type": "stream", 202 | "text": [ 203 | "23.437499999999996\n" 204 | ] 205 | } 206 | ], 207 | "source": [ 208 | "print(calculate_bmi(height=1.6, weight=60))" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 10, 214 | "metadata": {}, 215 | "outputs": [ 216 | { 217 | "name": "stdout", 218 | "output_type": "stream", 219 | "text": [ 220 | "58\n", 221 | "60\n", 222 | "55\n" 223 | ] 224 | } 225 | ], 226 | "source": [ 227 | "students = {58: 1.5, 60:1.6, 55:1.7}\n", 228 | "for s in students:\n", 229 | " print(s)" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 12, 235 | "metadata": {}, 236 | "outputs": [ 237 | { 238 | "name": "stdout", 239 | "output_type": "stream", 240 | "text": [ 241 | "1.5\n", 242 | "1.6\n", 243 | "1.7\n" 244 | ] 245 | } 246 | ], 247 | "source": [ 248 | "for s in students:\n", 249 | " print(students[s])" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": 16, 255 | "metadata": {}, 256 | "outputs": [ 257 | { 258 | "name": "stdout", 259 | "output_type": "stream", 260 | "text": [ 261 | "25.77777777777778\n", 262 | "23.437499999999996\n", 263 | "19.031141868512112\n" 264 | ] 265 | } 266 | ], 267 | "source": [ 268 | "for s in students:\n", 269 | " print(calculate_bmi(s, students[s]))" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": 17, 275 | "metadata": {}, 276 | "outputs": [ 277 | { 278 | "name": "stdout", 279 | "output_type": "stream", 280 | "text": [ 281 | "[25.78, 23.44, 19.03]\n" 282 | ] 283 | } 284 | ], 285 | "source": [ 286 | "bmi = []\n", 287 | "for s in students:\n", 288 | " bmi.append(round(calculate_bmi(s, students[s]), 2))\n", 289 | "print(bmi)" 290 | ] 291 | }, 292 | { 293 | "cell_type": "markdown", 294 | "metadata": {}, 295 | "source": [ 296 | "### Return more than one value\n", 297 | "* If more than values to be returned, used commas to separate each value\n", 298 | "* Also can assign multiple return values into multiple variables" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": 18, 304 | "metadata": {}, 305 | "outputs": [ 306 | { 307 | "name": "stdout", 308 | "output_type": "stream", 309 | "text": [ 310 | "65 1.62\n" 311 | ] 312 | } 313 | ], 314 | "source": [ 315 | "def change_values(weight, height):\n", 316 | " weight = weight+5\n", 317 | " height = height+0.02\n", 318 | " return weight, height\n", 319 | "new_weight, new_height = change_values(60, 1.6)\n", 320 | "print(new_weight, new_height)" 321 | ] 322 | }, 323 | { 324 | "cell_type": "markdown", 325 | "metadata": {}, 326 | "source": [ 327 | "### Variable Scope\n", 328 | "* Scope means which part of the program can access variables\n", 329 | "* If a variable is declared inside a function, then it can be only used inside that function\n", 330 | "* If a variable is declared outside a function, then it can be used from both inside and outside of a function" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 19, 336 | "metadata": {}, 337 | "outputs": [ 338 | { 339 | "name": "stdout", 340 | "output_type": "stream", 341 | "text": [ 342 | "10\n" 343 | ] 344 | }, 345 | { 346 | "ename": "NameError", 347 | "evalue": "name 'x' is not defined", 348 | "output_type": "error", 349 | "traceback": [ 350 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 351 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 352 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvariable_scope\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 353 | "\u001b[1;31mNameError\u001b[0m: name 'x' is not defined" 354 | ] 355 | } 356 | ], 357 | "source": [ 358 | "def variable_scope():\n", 359 | " x=10\n", 360 | " return x\n", 361 | "print(variable_scope())\n", 362 | "print(x)" 363 | ] 364 | }, 365 | { 366 | "cell_type": "code", 367 | "execution_count": 26, 368 | "metadata": {}, 369 | "outputs": [ 370 | { 371 | "name": "stdout", 372 | "output_type": "stream", 373 | "text": [ 374 | "5\n", 375 | "5\n" 376 | ] 377 | } 378 | ], 379 | "source": [ 380 | "x=5\n", 381 | "def variable_scope():\n", 382 | " return x\n", 383 | "print(variable_scope()) #x is accessible inside the function even without passing it\n", 384 | "print(x)" 385 | ] 386 | }, 387 | { 388 | "cell_type": "markdown", 389 | "metadata": {}, 390 | "source": [ 391 | "> Note that variable declare outside has its values, unless we assigned new value to it!" 392 | ] 393 | }, 394 | { 395 | "cell_type": "code", 396 | "execution_count": 24, 397 | "metadata": {}, 398 | "outputs": [ 399 | { 400 | "name": "stdout", 401 | "output_type": "stream", 402 | "text": [ 403 | "10\n", 404 | "5\n" 405 | ] 406 | } 407 | ], 408 | "source": [ 409 | "x=5\n", 410 | "def variable_scope(x):\n", 411 | " x = x + 5\n", 412 | " return x\n", 413 | "print(variable_scope(x))\n", 414 | "print(x)" 415 | ] 416 | }, 417 | { 418 | "cell_type": "code", 419 | "execution_count": null, 420 | "metadata": {}, 421 | "outputs": [], 422 | "source": [] 423 | } 424 | ], 425 | "metadata": { 426 | "kernelspec": { 427 | "display_name": "Python 3", 428 | "language": "python", 429 | "name": "python3" 430 | }, 431 | "language_info": { 432 | "codemirror_mode": { 433 | "name": "ipython", 434 | "version": 3 435 | }, 436 | "file_extension": ".py", 437 | "mimetype": "text/x-python", 438 | "name": "python", 439 | "nbconvert_exporter": "python", 440 | "pygments_lexer": "ipython3", 441 | "version": "3.6.4" 442 | } 443 | }, 444 | "nbformat": 4, 445 | "nbformat_minor": 2 446 | } 447 | -------------------------------------------------------------------------------- /007-Objects&Classes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Programming for Data Science Series (Lab Session 7)\n", 8 | "## Objects & Classes\n", 9 | "### Class\n", 10 | "* Blueprint (design) for creating an object\n", 11 | "* We can build any number of house we wish to if we have a design\n", 12 | "* Therefore, we can created any number of object from a class\n", 13 | "* Use class keyword and give it a name, then put colon" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "### Associated Tutorial for this Lab session is shown below:" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 1, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "image/jpeg": "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\n", 31 | "text/html": [ 32 | "\n", 33 | " \n", 40 | " " 41 | ], 42 | "text/plain": [ 43 | "" 44 | ] 45 | }, 46 | "execution_count": 1, 47 | "metadata": {}, 48 | "output_type": "execute_result" 49 | } 50 | ], 51 | "source": [ 52 | "from IPython.display import YouTubeVideo\n", 53 | "\n", 54 | "YouTubeVideo('kg0KsH8shBk', width=800, height=450)" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 1, 60 | "metadata": {}, 61 | "outputs": [ 62 | { 63 | "name": "stdout", 64 | "output_type": "stream", 65 | "text": [ 66 | "Toyota car is driving\n" 67 | ] 68 | } 69 | ], 70 | "source": [ 71 | "class Car:\n", 72 | " brand = 'Toyota'\n", 73 | " def drive(self):\n", 74 | " print(self.brand, 'car is driving')\n", 75 | "\n", 76 | "my_new_car = Car()\n", 77 | "my_new_car.drive()" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 16, 83 | "metadata": {}, 84 | "outputs": [ 85 | { 86 | "name": "stdout", 87 | "output_type": "stream", 88 | "text": [ 89 | "Toyota\n" 90 | ] 91 | } 92 | ], 93 | "source": [ 94 | "print(my_new_car.brand)" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 38, 100 | "metadata": {}, 101 | "outputs": [ 102 | { 103 | "name": "stdout", 104 | "output_type": "stream", 105 | "text": [ 106 | "Toyota car is driving\n" 107 | ] 108 | } 109 | ], 110 | "source": [ 111 | "class Car:\n", 112 | " \n", 113 | " def drive(self):\n", 114 | " print(self.brand, 'car is driving')\n", 115 | " \n", 116 | " def get_speed(self):\n", 117 | " print(self.speed, 'is my top-speed')\n", 118 | " \n", 119 | " def get_gear(self):\n", 120 | " print(self.gear, 'gear')\n", 121 | "\n", 122 | "toyota = Car()\n", 123 | "toyota.brand = 'Toyota'\n", 124 | "toyota.drive()" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 39, 130 | "metadata": {}, 131 | "outputs": [ 132 | { 133 | "name": "stdout", 134 | "output_type": "stream", 135 | "text": [ 136 | "150 is my top-speed\n", 137 | "Auto gear\n" 138 | ] 139 | } 140 | ], 141 | "source": [ 142 | "toyota.speed = 150\n", 143 | "toyota.gear = 'Auto'\n", 144 | "toyota.get_speed()\n", 145 | "toyota.get_gear()" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": 40, 151 | "metadata": {}, 152 | "outputs": [ 153 | { 154 | "name": "stdout", 155 | "output_type": "stream", 156 | "text": [ 157 | "BMW car is driving\n", 158 | "200 is my top-speed\n", 159 | "Manual gear\n" 160 | ] 161 | } 162 | ], 163 | "source": [ 164 | "bmw = Car()\n", 165 | "bmw.brand = 'BMW'\n", 166 | "bmw.speed = 200\n", 167 | "bmw.gear = 'Manual'\n", 168 | "bmw.drive()\n", 169 | "bmw.get_speed()\n", 170 | "bmw.get_gear()" 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": 41, 176 | "metadata": {}, 177 | "outputs": [ 178 | { 179 | "name": "stdout", 180 | "output_type": "stream", 181 | "text": [ 182 | "Honda car is driving\n", 183 | "180 is my top-speed\n", 184 | "Manual gear\n" 185 | ] 186 | } 187 | ], 188 | "source": [ 189 | "honda = Car()\n", 190 | "honda.brand = 'Honda'\n", 191 | "honda.speed = 180\n", 192 | "honda.gear = 'Manual'\n", 193 | "honda.drive()\n", 194 | "honda.get_speed()\n", 195 | "honda.get_gear()" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 42, 201 | "metadata": {}, 202 | "outputs": [ 203 | { 204 | "name": "stdout", 205 | "output_type": "stream", 206 | "text": [ 207 | "Mazda car is driving\n", 208 | "175 is my top-speed\n", 209 | "Auto gear\n" 210 | ] 211 | } 212 | ], 213 | "source": [ 214 | "mazda = Car()\n", 215 | "mazda.brand = 'Mazda'\n", 216 | "mazda.speed = 175\n", 217 | "mazda.gear = 'Auto'\n", 218 | "mazda.drive()\n", 219 | "mazda.get_speed()\n", 220 | "mazda.get_gear()" 221 | ] 222 | }, 223 | { 224 | "cell_type": "markdown", 225 | "metadata": {}, 226 | "source": [ 227 | "### Constructor\n", 228 | "* Used to perform initialization of the data\n", 229 | "* __init__ is a method to create constructor of a class" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 43, 235 | "metadata": {}, 236 | "outputs": [ 237 | { 238 | "name": "stdout", 239 | "output_type": "stream", 240 | "text": [ 241 | "I made a new car Nissan White 140 Auto\n" 242 | ] 243 | } 244 | ], 245 | "source": [ 246 | "class SuperCar:\n", 247 | " def __init__(self, brand, color, speed, gear):\n", 248 | " self.brand = brand\n", 249 | " self.color = color\n", 250 | " self.speed = speed\n", 251 | " self.gear = gear\n", 252 | "\n", 253 | " def make_car(self):\n", 254 | " print ('I made a new car', self.brand, self.color, self.speed, self.gear)\n", 255 | " \n", 256 | " def get_speed(self):\n", 257 | " print(self.speed, 'is my top-speed')\n", 258 | " \n", 259 | " def get_gear(self):\n", 260 | " print(self.gear, 'gear')\n", 261 | " \n", 262 | "nissan = SuperCar('Nissan', 'White', 140, 'Auto')\n", 263 | "nissan.make_car()" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 44, 269 | "metadata": {}, 270 | "outputs": [ 271 | { 272 | "name": "stdout", 273 | "output_type": "stream", 274 | "text": [ 275 | "I made a new car Audi Black 220 Manual\n" 276 | ] 277 | } 278 | ], 279 | "source": [ 280 | "audi = SuperCar('Audi', 'Black', 220, 'Manual')\n", 281 | "audi.make_car()" 282 | ] 283 | }, 284 | { 285 | "cell_type": "code", 286 | "execution_count": 35, 287 | "metadata": {}, 288 | "outputs": [ 289 | { 290 | "name": "stdout", 291 | "output_type": "stream", 292 | "text": [ 293 | "200 is my top-speed\n" 294 | ] 295 | } 296 | ], 297 | "source": [ 298 | "nissan.get_speed()" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": 46, 304 | "metadata": {}, 305 | "outputs": [ 306 | { 307 | "name": "stdout", 308 | "output_type": "stream", 309 | "text": [ 310 | "220 is my top-speed\n" 311 | ] 312 | } 313 | ], 314 | "source": [ 315 | "audi.get_speed()" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": null, 321 | "metadata": {}, 322 | "outputs": [], 323 | "source": [] 324 | } 325 | ], 326 | "metadata": { 327 | "kernelspec": { 328 | "display_name": "Python 3", 329 | "language": "python", 330 | "name": "python3" 331 | }, 332 | "language_info": { 333 | "codemirror_mode": { 334 | "name": "ipython", 335 | "version": 3 336 | }, 337 | "file_extension": ".py", 338 | "mimetype": "text/x-python", 339 | "name": "python", 340 | "nbconvert_exporter": "python", 341 | "pygments_lexer": "ipython3", 342 | "version": "3.6.4" 343 | } 344 | }, 345 | "nbformat": 4, 346 | "nbformat_minor": 2 347 | } 348 | -------------------------------------------------------------------------------- /013-IntroNumpy.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Programming for Data Science Series (Lab Session 13)\n", 8 | "## Introduction to Numpy\n", 9 | "### Objectives\n", 10 | "* Understand what is Numpy\n", 11 | "* Familiarize with Python Scientific Library for numerical computation \n", 12 | "* How to create Numpy array\n", 13 | "* How to access array elements\n", 14 | "* How to transform Numpy array\n", 15 | "* Space saving opportunity in Numpy" 16 | ] 17 | }, 18 | { 19 | "cell_type": "markdown", 20 | "metadata": {}, 21 | "source": [ 22 | "### Associated Tutorial for this Lab session is shown below:" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": 1, 28 | "metadata": {}, 29 | "outputs": [ 30 | { 31 | "data": { 32 | "image/jpeg": "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\n", 33 | "text/html": [ 34 | "\n", 35 | " \n", 42 | " " 43 | ], 44 | "text/plain": [ 45 | "" 46 | ] 47 | }, 48 | "execution_count": 1, 49 | "metadata": {}, 50 | "output_type": "execute_result" 51 | } 52 | ], 53 | "source": [ 54 | "from IPython.display import YouTubeVideo\n", 55 | "\n", 56 | "YouTubeVideo('2MYZOHW-Dhk', width=800, height=450)" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "!pip install numpy" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 2, 69 | "metadata": {}, 70 | "outputs": [ 71 | { 72 | "name": "stdout", 73 | "output_type": "stream", 74 | "text": [ 75 | "Collecting pip\n", 76 | " Using cached https://files.pythonhosted.org/packages/54/0c/d01aa759fdc501a58f431eb594a17495f15b88da142ce14b5845662c13f3/pip-20.0.2-py2.py3-none-any.whl\n", 77 | "Installing collected packages: pip\n", 78 | " Found existing installation: pip 9.0.1\n", 79 | " Uninstalling pip-9.0.1:\n", 80 | " Successfully uninstalled pip-9.0.1\n", 81 | "Successfully installed pip-20.0.2\n" 82 | ] 83 | } 84 | ], 85 | "source": [ 86 | "!python -m pip install --upgrade pip" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "The following code will install Numpy libray for python (if not installed previously)" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 3, 99 | "metadata": {}, 100 | "outputs": [ 101 | { 102 | "name": "stdout", 103 | "output_type": "stream", 104 | "text": [ 105 | "Requirement already satisfied: numpy in c:\\programdata\\anaconda3\\lib\\site-packages (1.14.2)\n" 106 | ] 107 | } 108 | ], 109 | "source": [ 110 | "!pip install numpy" 111 | ] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": {}, 116 | "source": [ 117 | "### Creating Numpy Array" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": 2, 123 | "metadata": {}, 124 | "outputs": [ 125 | { 126 | "name": "stdout", 127 | "output_type": "stream", 128 | "text": [ 129 | "[1 2 3 4 5 6]\n" 130 | ] 131 | } 132 | ], 133 | "source": [ 134 | "import numpy as np\n", 135 | "a = np.array([1,2,3,4,5,6])\n", 136 | "print(a)" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 5, 142 | "metadata": {}, 143 | "outputs": [ 144 | { 145 | "name": "stdout", 146 | "output_type": "stream", 147 | "text": [ 148 | "[[1 3 5]\n", 149 | " [2 4 6]]\n" 150 | ] 151 | } 152 | ], 153 | "source": [ 154 | "b = np.array([[ 1, 3, 5 ] , [ 2, 4, 6 ]])\n", 155 | "print(b)" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "### Numpy Attributes\n", 163 | "* Check type of elements\n", 164 | " * e.g. a.dtype\n", 165 | "* Check number of dimension\n", 166 | " * e.g. a.ndim\n", 167 | "* Check shape of array. It returns length of array along each dimension\n", 168 | " * e.g. a.shape\n", 169 | "* Get bytes per element\n", 170 | " * e.g. a.itemsize\n", 171 | "* Get bytes used by data portion of the array\n", 172 | " * e.g. a.nbytes" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 6, 178 | "metadata": {}, 179 | "outputs": [ 180 | { 181 | "data": { 182 | "text/plain": [ 183 | "dtype('int32')" 184 | ] 185 | }, 186 | "execution_count": 6, 187 | "metadata": {}, 188 | "output_type": "execute_result" 189 | } 190 | ], 191 | "source": [ 192 | "a.dtype" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": 7, 198 | "metadata": {}, 199 | "outputs": [ 200 | { 201 | "data": { 202 | "text/plain": [ 203 | "1" 204 | ] 205 | }, 206 | "execution_count": 7, 207 | "metadata": {}, 208 | "output_type": "execute_result" 209 | } 210 | ], 211 | "source": [ 212 | "a.ndim" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 8, 218 | "metadata": {}, 219 | "outputs": [ 220 | { 221 | "data": { 222 | "text/plain": [ 223 | "(6,)" 224 | ] 225 | }, 226 | "execution_count": 8, 227 | "metadata": {}, 228 | "output_type": "execute_result" 229 | } 230 | ], 231 | "source": [ 232 | "a.shape" 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": 9, 238 | "metadata": {}, 239 | "outputs": [ 240 | { 241 | "data": { 242 | "text/plain": [ 243 | "(2, 3)" 244 | ] 245 | }, 246 | "execution_count": 9, 247 | "metadata": {}, 248 | "output_type": "execute_result" 249 | } 250 | ], 251 | "source": [ 252 | "b.shape" 253 | ] 254 | }, 255 | { 256 | "cell_type": "code", 257 | "execution_count": 10, 258 | "metadata": {}, 259 | "outputs": [ 260 | { 261 | "data": { 262 | "text/plain": [ 263 | "4" 264 | ] 265 | }, 266 | "execution_count": 10, 267 | "metadata": {}, 268 | "output_type": "execute_result" 269 | } 270 | ], 271 | "source": [ 272 | "a.itemsize" 273 | ] 274 | }, 275 | { 276 | "cell_type": "code", 277 | "execution_count": 15, 278 | "metadata": {}, 279 | "outputs": [ 280 | { 281 | "data": { 282 | "text/plain": [ 283 | "24" 284 | ] 285 | }, 286 | "execution_count": 15, 287 | "metadata": {}, 288 | "output_type": "execute_result" 289 | } 290 | ], 291 | "source": [ 292 | "a.nbytes" 293 | ] 294 | }, 295 | { 296 | "cell_type": "markdown", 297 | "metadata": {}, 298 | "source": [ 299 | "### Indexing, Slicing\n", 300 | "* Use square bracket to get any item by respective index\n", 301 | "* Use multiple square brackets for multi-dimensional array\n", 302 | "* Range selection is also possible with colon" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": 16, 308 | "metadata": {}, 309 | "outputs": [ 310 | { 311 | "data": { 312 | "text/plain": [ 313 | "array([1, 3, 5])" 314 | ] 315 | }, 316 | "execution_count": 16, 317 | "metadata": {}, 318 | "output_type": "execute_result" 319 | } 320 | ], 321 | "source": [ 322 | "x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n", 323 | "x[1:7:2]" 324 | ] 325 | }, 326 | { 327 | "cell_type": "code", 328 | "execution_count": 17, 329 | "metadata": {}, 330 | "outputs": [ 331 | { 332 | "data": { 333 | "text/plain": [ 334 | "3" 335 | ] 336 | }, 337 | "execution_count": 17, 338 | "metadata": {}, 339 | "output_type": "execute_result" 340 | } 341 | ], 342 | "source": [ 343 | "b[0][1]" 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": 18, 349 | "metadata": {}, 350 | "outputs": [ 351 | { 352 | "data": { 353 | "text/plain": [ 354 | "6" 355 | ] 356 | }, 357 | "execution_count": 18, 358 | "metadata": {}, 359 | "output_type": "execute_result" 360 | } 361 | ], 362 | "source": [ 363 | "b[1][2]" 364 | ] 365 | }, 366 | { 367 | "cell_type": "code", 368 | "execution_count": 19, 369 | "metadata": {}, 370 | "outputs": [ 371 | { 372 | "ename": "IndexError", 373 | "evalue": "index 3 is out of bounds for axis 0 with size 3", 374 | "output_type": "error", 375 | "traceback": [ 376 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 377 | "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", 378 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mb\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 379 | "\u001b[1;31mIndexError\u001b[0m: index 3 is out of bounds for axis 0 with size 3" 380 | ] 381 | } 382 | ], 383 | "source": [ 384 | "b[1][3]" 385 | ] 386 | }, 387 | { 388 | "cell_type": "markdown", 389 | "metadata": {}, 390 | "source": [ 391 | "### Shape Transformation\n", 392 | "* Use np.reshape method to transform shape of the numpy array\n", 393 | "* Use np.swapaxes method to interchange axes of two array\n", 394 | "* Use np.flatten to get one dimensional flatten array" 395 | ] 396 | }, 397 | { 398 | "cell_type": "code", 399 | "execution_count": 20, 400 | "metadata": {}, 401 | "outputs": [ 402 | { 403 | "data": { 404 | "text/plain": [ 405 | "array([[1, 3],\n", 406 | " [5, 2],\n", 407 | " [4, 6]])" 408 | ] 409 | }, 410 | "execution_count": 20, 411 | "metadata": {}, 412 | "output_type": "execute_result" 413 | } 414 | ], 415 | "source": [ 416 | "b.reshape(3,2)" 417 | ] 418 | }, 419 | { 420 | "cell_type": "code", 421 | "execution_count": 25, 422 | "metadata": {}, 423 | "outputs": [ 424 | { 425 | "data": { 426 | "text/plain": [ 427 | "array([[1, 3, 5],\n", 428 | " [2, 4, 6]])" 429 | ] 430 | }, 431 | "execution_count": 25, 432 | "metadata": {}, 433 | "output_type": "execute_result" 434 | } 435 | ], 436 | "source": [ 437 | "b" 438 | ] 439 | }, 440 | { 441 | "cell_type": "code", 442 | "execution_count": 26, 443 | "metadata": {}, 444 | "outputs": [ 445 | { 446 | "data": { 447 | "text/plain": [ 448 | "array([[1, 2],\n", 449 | " [3, 4],\n", 450 | " [5, 6]])" 451 | ] 452 | }, 453 | "execution_count": 26, 454 | "metadata": {}, 455 | "output_type": "execute_result" 456 | } 457 | ], 458 | "source": [ 459 | "b.swapaxes(0,1)" 460 | ] 461 | }, 462 | { 463 | "cell_type": "code", 464 | "execution_count": 27, 465 | "metadata": {}, 466 | "outputs": [ 467 | { 468 | "data": { 469 | "text/plain": [ 470 | "array([[1, 3, 5],\n", 471 | " [2, 4, 6]])" 472 | ] 473 | }, 474 | "execution_count": 27, 475 | "metadata": {}, 476 | "output_type": "execute_result" 477 | } 478 | ], 479 | "source": [ 480 | "b" 481 | ] 482 | }, 483 | { 484 | "cell_type": "code", 485 | "execution_count": 29, 486 | "metadata": {}, 487 | "outputs": [ 488 | { 489 | "data": { 490 | "text/plain": [ 491 | "array([[1, 2],\n", 492 | " [3, 4],\n", 493 | " [5, 6]])" 494 | ] 495 | }, 496 | "execution_count": 29, 497 | "metadata": {}, 498 | "output_type": "execute_result" 499 | } 500 | ], 501 | "source": [ 502 | "b.swapaxes(1,0)" 503 | ] 504 | }, 505 | { 506 | "cell_type": "code", 507 | "execution_count": 34, 508 | "metadata": {}, 509 | "outputs": [ 510 | { 511 | "data": { 512 | "text/plain": [ 513 | "array([1, 3, 5, 2, 4, 6])" 514 | ] 515 | }, 516 | "execution_count": 34, 517 | "metadata": {}, 518 | "output_type": "execute_result" 519 | } 520 | ], 521 | "source": [ 522 | "c = b.flatten()\n", 523 | "c" 524 | ] 525 | }, 526 | { 527 | "cell_type": "code", 528 | "execution_count": 38, 529 | "metadata": {}, 530 | "outputs": [ 531 | { 532 | "data": { 533 | "text/plain": [ 534 | "array([1, 2, 3, 4, 5, 6])" 535 | ] 536 | }, 537 | "execution_count": 38, 538 | "metadata": {}, 539 | "output_type": "execute_result" 540 | } 541 | ], 542 | "source": [ 543 | "np.sort(c)" 544 | ] 545 | }, 546 | { 547 | "cell_type": "markdown", 548 | "metadata": {}, 549 | "source": [ 550 | "### Space saving using dtype\n", 551 | "* int32 and float64 consume more memory (compare to int8)\n", 552 | "* If precision is not required, then use dtype to reduce space\n", 553 | "* Smaller size also improve speed of operations\n", 554 | "* Significant performance improved if working with Big Data" 555 | ] 556 | }, 557 | { 558 | "cell_type": "code", 559 | "execution_count": 3, 560 | "metadata": {}, 561 | "outputs": [ 562 | { 563 | "name": "stdout", 564 | "output_type": "stream", 565 | "text": [ 566 | "int32\n", 567 | "4000\n" 568 | ] 569 | } 570 | ], 571 | "source": [ 572 | "data = np.arange(0,1000)\n", 573 | "print(data.dtype)\n", 574 | "print(data.nbytes)" 575 | ] 576 | }, 577 | { 578 | "cell_type": "code", 579 | "execution_count": 7, 580 | "metadata": {}, 581 | "outputs": [ 582 | { 583 | "name": "stdout", 584 | "output_type": "stream", 585 | "text": [ 586 | "int8 \n", 587 | "1000\n" 588 | ] 589 | } 590 | ], 591 | "source": [ 592 | "sdata = np.arange(0,1000, dtype='int8')\n", 593 | "print(sdata.dtype, type(sdata[1]))\n", 594 | "print(sdata.nbytes)" 595 | ] 596 | }, 597 | { 598 | "cell_type": "markdown", 599 | "metadata": {}, 600 | "source": [] 601 | } 602 | ], 603 | "metadata": { 604 | "kernelspec": { 605 | "display_name": "Python 3", 606 | "language": "python", 607 | "name": "python3" 608 | }, 609 | "language_info": { 610 | "codemirror_mode": { 611 | "name": "ipython", 612 | "version": 3 613 | }, 614 | "file_extension": ".py", 615 | "mimetype": "text/x-python", 616 | "name": "python", 617 | "nbconvert_exporter": "python", 618 | "pygments_lexer": "ipython3", 619 | "version": "3.6.4" 620 | } 621 | }, 622 | "nbformat": 4, 623 | "nbformat_minor": 2 624 | } 625 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Programming for Data Science (Free education in Burmese Language by Myanmar Data Science) 2 |

This repository includes the exercise files from our course "Programming for Data Science" series which can be found at https://www.youtube.com/watch?v=jOZNjVVZIVs&list=PLD_eiqVVLZDi9GZZJDC8Zx4-3Np8LHs52

3 |

For all the lab session to practice along, please refer to the Lab sessions playlist at https://www.youtube.com/watch?v=FXPPJCnuJuE&list=PLD_eiqVVLZDh0FDc1UwCUCFsNMKlxOiv3

4 | -------------------------------------------------------------------------------- /abc_ltd.csv: -------------------------------------------------------------------------------- 1 | Name,Department,Salary 2 | Win Win,Engineering,250000 3 | Sein Sein,IT,300000 4 | Aung Aung,Finance,200000 5 | Ni Ni,HR,150000 6 | Maung Ba,Finance,205000 7 | Maung Hla,HR,155000 8 | -------------------------------------------------------------------------------- /abc_ltd.db: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/myanmards/programming-series/8e9ce91a4891dea12270cebdf770f5338f4b24c1/abc_ltd.db -------------------------------------------------------------------------------- /abc_ltd.json: -------------------------------------------------------------------------------- 1 | [ 2 | { 3 | "Name": "Win Win", 4 | "Department": "Engineering", 5 | "Salary": 250000 6 | }, 7 | { 8 | "Name": "Sein Sein", 9 | "Department": "IT", 10 | "Salary": 300000 11 | }, 12 | { 13 | "Name": "Aung Aung", 14 | "Department": "Finance", 15 | "Salary": 200000 16 | }, 17 | { 18 | "Name": "Ni Ni", 19 | "Department": "HR", 20 | "Salary": 150000 21 | }, 22 | { 23 | "Name": "Maung Ba", 24 | "Department": "Finance", 25 | "Salary": 205000 26 | }, 27 | { 28 | "Name": "Maung Hla", 29 | "Department": "HR", 30 | "Salary": 155000 31 | } 32 | ] -------------------------------------------------------------------------------- /xyz_ltd.csv: -------------------------------------------------------------------------------- 1 | Name,Department,Salary 2 | Soe Soe,Engineering,250000 3 | Ko Ko,IT,300000 4 | Maung Maung,Finance,200000 5 | Hla Hla,HR,150000 6 | Kyaw Kyaw,Finance,205000 7 | San San,HR,155000 8 | --------------------------------------------------------------------------------