![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
29 | ]
30 | },
31 | {
32 | "cell_type": "markdown",
33 | "metadata": {
34 | "id": "aFLmdm501ukO"
35 | },
36 | "source": [
37 | "# Conditionals"
38 | ]
39 | },
40 | {
41 | "cell_type": "code",
42 | "metadata": {
43 | "id": "1JiSu2-311BW"
44 | },
45 | "source": [
46 | "if condition:\n",
47 | " pass\n",
48 | " statement\n",
49 | " statement\n",
50 | " # further statements, if necessary"
51 | ],
52 | "execution_count": null,
53 | "outputs": []
54 | },
55 | {
56 | "cell_type": "code",
57 | "metadata": {
58 | "colab": {
59 | "base_uri": "https://localhost:8080/"
60 | },
61 | "id": "jDfeCFjV11HE",
62 | "outputId": "f9a53498-3d63-4f83-e1e5-edf35596e136"
63 | },
64 | "source": [
65 | "'''\n",
66 | "The following example asks users for their nationality. The indented block will\n",
67 | "only be executed if the nationality is French or Italian. If the user enters\n",
68 | "another nationality, nothing happens.\n",
69 | "'''\n",
70 | "\n",
71 | "person = input(\"Nationality? \")\n",
72 | "if person == \"french\" or person == \"French\":\n",
73 | " print(\"Préférez-vous parler français?\")\n",
74 | "if person == \"italian\" or person == \"Italian\":\n",
75 | " print(\"Preferisci parlare italiano?\")"
76 | ],
77 | "execution_count": null,
78 | "outputs": [
79 | {
80 | "output_type": "stream",
81 | "name": "stdout",
82 | "text": [
83 | "Nationality? french\n",
84 | "Préférez-vous parler français?\n"
85 | ]
86 | }
87 | ]
88 | },
89 | {
90 | "cell_type": "code",
91 | "metadata": {
92 | "colab": {
93 | "base_uri": "https://localhost:8080/"
94 | },
95 | "id": "SlGQTpjI3pvR",
96 | "outputId": "1e045ebb-3af3-4b38-a64b-8b131918b075"
97 | },
98 | "source": [
99 | "'''\n",
100 | "This little script has a drawback. Suppose that the user enters \"french\" as\n",
101 | "a nationality. In this case, the block of the first \"if\" will be executed.\n",
102 | "Afterwards, the program checks if the second \"if\" can be executed as well.\n",
103 | "This doesn't make sense, because we know that the input \"french\" does not match\n",
104 | "the condition \"italian\" or \"Italian\".\n",
105 | "'''\n",
106 | "\n",
107 | "person = input(\"Nationality? \")\n",
108 | "if person == \"french\" or person == \"French\":\n",
109 | " print(\"Préférez-vous parler français?\")\n",
110 | "elif person == \"italian\" or person == \"Italian\":\n",
111 | " print(\"Preferisci parlare italiano?\")\n",
112 | "else:\n",
113 | " print(\"You are neither French nor Italian.\")\n",
114 | " print(\"So, let us speak English!\")\n",
115 | "\n",
116 | "\n",
117 | "# As in our example, most if statements also have \"elif\" and \"else\" branches.\n",
118 | "# This means, there may be more than one \"elif\" branches, but only one \"else\"\n",
119 | "# branch. The \"else\" branch must be at the end of the if statement. Other \"elif\"\n",
120 | "# branches can not be attached after an 'else'. 'if' statements don't need either\n",
121 | "# 'else' nor 'elif' statements."
122 | ],
123 | "execution_count": null,
124 | "outputs": [
125 | {
126 | "output_type": "stream",
127 | "name": "stdout",
128 | "text": [
129 | "Nationality? french\n",
130 | "Préférez-vous parler français?\n"
131 | ]
132 | }
133 | ]
134 | },
135 | {
136 | "cell_type": "code",
137 | "metadata": {
138 | "id": "BriU6Z1C4lsw"
139 | },
140 | "source": [
141 | "# general form:\n",
142 | "\n",
143 | "if condition_1:\n",
144 | " statement_block_1\n",
145 | "elif condition_2:\n",
146 | " statement_block_2\n",
147 | "\n",
148 | "...\n",
149 | "\n",
150 | "elif another_condition: \n",
151 | " another_statement_block\n",
152 | "else:\n",
153 | " else_block"
154 | ],
155 | "execution_count": null,
156 | "outputs": []
157 | },
158 | {
159 | "cell_type": "markdown",
160 | "metadata": {
161 | "id": "-IPYWCNg5LaY"
162 | },
163 | "source": [
164 | "#### Examples"
165 | ]
166 | },
167 | {
168 | "cell_type": "code",
169 | "metadata": {
170 | "colab": {
171 | "base_uri": "https://localhost:8080/"
172 | },
173 | "id": "PQl7NCAl43d_",
174 | "outputId": "25171e28-4da9-4a4a-ddea-c5b3d10478cf"
175 | },
176 | "source": [
177 | "'''\n",
178 | "A one-year-old dog is roughly equivalent to a 14-year-old human being\n",
179 | "A dog that is two years old corresponds in development to a 22 year old person.\n",
180 | "Each additional dog year is equivalent to five human years.\n",
181 | "\n",
182 | "The following example program in Python requires the age of the dog as the input\n",
183 | "and calculates the age in human years according to the above rule. 'input' is\n",
184 | "a statement, where the program flow stops and waits for user input printing out\n",
185 | "the message in brackets:\n",
186 | "'''\n",
187 | "\n",
188 | "age = int(input(\"Age of the dog: \"))\n",
189 | "print()\n",
190 | "if age < 0:\n",
191 | " print(\"This cannot be true!\")\n",
192 | "elif age == 0:\n",
193 | " print(\"This corresponds to 0 human years!\")\n",
194 | "elif age == 1:\n",
195 | " print(\"Roughly 14 years!\")\n",
196 | "elif age == 2:\n",
197 | " print(\"Approximately 22 years!\")\n",
198 | "else:\n",
199 | " human = 22 + (age -2) * 5\n",
200 | " print(\"Corresponds to \" + str(human) + \" human years!\")"
201 | ],
202 | "execution_count": null,
203 | "outputs": [
204 | {
205 | "output_type": "stream",
206 | "name": "stdout",
207 | "text": [
208 | "Age of the dog: 3\n",
209 | "\n",
210 | "Corresponds to 27 human years!\n"
211 | ]
212 | }
213 | ]
214 | },
215 | {
216 | "cell_type": "code",
217 | "metadata": {
218 | "id": "WhKZTK2t5tk3",
219 | "colab": {
220 | "base_uri": "https://localhost:8080/"
221 | },
222 | "outputId": "32f8b4e7-1df2-42c5-c1d2-fe1b24e6774a"
223 | },
224 | "source": [
225 | "'''\n",
226 | "We will read in three float numbers in the following program\n",
227 | "and will print out the largest value:\n",
228 | "'''\n",
229 | "\n",
230 | "x = float(input(\"1st Number: \"))\n",
231 | "y = float(input(\"2nd Number: \"))\n",
232 | "z = float(input(\"3rd Number: \"))\n",
233 | "\n",
234 | "if x > y and x > z:\n",
235 | " maximum = x\n",
236 | "elif y > x and y > z:\n",
237 | " maximum = y\n",
238 | "else:\n",
239 | " maximum = z\n",
240 | "\n",
241 | "print(\"The maximal value is: \" + str(maximum))"
242 | ],
243 | "execution_count": null,
244 | "outputs": [
245 | {
246 | "output_type": "stream",
247 | "name": "stdout",
248 | "text": [
249 | "1st Number: 5\n",
250 | "2nd Number: 7\n",
251 | "3rd Number: 9\n",
252 | "The maximal value is: 9.0\n"
253 | ]
254 | }
255 | ]
256 | },
257 | {
258 | "cell_type": "code",
259 | "metadata": {
260 | "id": "_AGCqt2V8PFc"
261 | },
262 | "source": [
263 | "7\n",
264 | "'''\n",
265 | "There are other ways to write the conditions like the following one:\n",
266 | "'''\n",
267 | "\n",
268 | "x = float(input(\"1st Number: \"))\n",
269 | "y = float(input(\"2nd Number: \"))\n",
270 | "z = float(input(\"3rd Number: \"))\n",
271 | "\n",
272 | "if x > y:\n",
273 | " if x > z:\n",
274 | " maximum = x\n",
275 | " else:\n",
276 | " maximum = z\n",
277 | "else: \n",
278 | " if y > z:\n",
279 | " maximum = y\n",
280 | " else:\n",
281 | " maximum = z\n",
282 | "\n",
283 | "print(\"The maximal value is: \" + str(maximum))"
284 | ],
285 | "execution_count": null,
286 | "outputs": []
287 | },
288 | {
289 | "cell_type": "code",
290 | "metadata": {
291 | "id": "uVOyyQOj8WR4"
292 | },
293 | "source": [
294 | "'''\n",
295 | "Another way to find the maximum can be seen in the following example. We are\n",
296 | "using the built-in function max, which calculates the maximum of a list or\n",
297 | "a tuple of numerical values:\n",
298 | "'''\n",
299 | "\n",
300 | "x = float(input(\"1st Number: \"))\n",
301 | "y = float(input(\"2nd Number: \"))\n",
302 | "z = float(input(\"3rd Number: \"))\n",
303 | "\n",
304 | "maximum = max((x,y,z))\n",
305 | "\n",
306 | "print(\"The maximal value is: \" + str(maximum))"
307 | ],
308 | "execution_count": null,
309 | "outputs": []
310 | },
311 | {
312 | "cell_type": "markdown",
313 | "metadata": {
314 | "id": "1yTmssrNBvn6"
315 | },
316 | "source": [
317 | "#### Ternary if statement"
318 | ]
319 | },
320 | {
321 | "cell_type": "code",
322 | "metadata": {
323 | "colab": {
324 | "base_uri": "https://localhost:8080/"
325 | },
326 | "id": "3rOE5us5BvOQ",
327 | "outputId": "93c0f0fb-51a1-48e5-b8fb-064332fbf474"
328 | },
329 | "source": [
330 | "'''\n",
331 | "`The maximum speed is 50 if we are within the city, otherwise it is 100.`\n",
332 | "This can be translated into ternary Python statements\n",
333 | "'''\n",
334 | "\n",
335 | "inside_city_limits = True\n",
336 | "maximum_speed = 50 if inside_city_limits else 100\n",
337 | "print(maximum_speed)"
338 | ],
339 | "execution_count": null,
340 | "outputs": [
341 | {
342 | "output_type": "stream",
343 | "name": "stdout",
344 | "text": [
345 | "50\n"
346 | ]
347 | }
348 | ]
349 | },
350 | {
351 | "cell_type": "markdown",
352 | "metadata": {
353 | "id": "kLv0oPpQChqU"
354 | },
355 | "source": [
356 | "# While loops"
357 | ]
358 | },
359 | {
360 | "cell_type": "markdown",
361 | "metadata": {
362 | "id": "1_2pWe5FGON3"
363 | },
364 | "source": [
365 | "Most loops contain a counter or more generally, variables, which change their values in the course of calculation. These variables have to be initialized before the loop is started. The counter or other variables, which can be altered in the body of the loop, are contained in the condition. Before the body of the loop is executed, the condition is evaluated. If it evaluates to False, the while loop is finished. In other words, the program flow will continue with the first statement after the while statement, i.e. on the same indentation level as the while loop. If the condition is evaluated to True, the body, - the indented block below the line with \"while\" - gets executed. After the body is finished, the condition will be evaluated again. The body of the loop will be executed as long as the condition yields True."
366 | ]
367 | },
368 | {
369 | "cell_type": "code",
370 | "metadata": {
371 | "colab": {
372 | "base_uri": "https://localhost:8080/"
373 | },
374 | "id": "PukTYSV7GNwq",
375 | "outputId": "ed8128a2-e91e-4a23-8ad4-a74d5596582a"
376 | },
377 | "source": [
378 | "# The following small script calculates the sum of the numbers from 1 to 100:\n",
379 | "\n",
380 | "n = 100\n",
381 | "\n",
382 | "total_sum = 0\n",
383 | "counter = 1\n",
384 | "while counter <= n:\n",
385 | " total_sum += counter\n",
386 | " counter += 1\n",
387 | "\n",
388 | "print(\"Sum of 1 until \" + str(n) + \" results in \" + str(total_sum))"
389 | ],
390 | "execution_count": null,
391 | "outputs": [
392 | {
393 | "output_type": "stream",
394 | "name": "stdout",
395 | "text": [
396 | "Sum of 1 until 100 results in 5050\n"
397 | ]
398 | }
399 | ]
400 | },
401 | {
402 | "cell_type": "markdown",
403 | "metadata": {
404 | "id": "lC0HDiOvGdse"
405 | },
406 | "source": [
407 | "#### The `else` part"
408 | ]
409 | },
410 | {
411 | "cell_type": "markdown",
412 | "metadata": {
413 | "id": "VSvrV9DSG0nI"
414 | },
415 | "source": [
416 | "The statements in the else part are executed, when the condition is not fulfilled anymore."
417 | ]
418 | },
419 | {
420 | "cell_type": "code",
421 | "metadata": {
422 | "id": "2_dM3Esd8e2R"
423 | },
424 | "source": [
425 | "while condition:\n",
426 | " statement_1\n",
427 | " ...\n",
428 | " statement_n\n",
429 | "else:\n",
430 | " statement_1\n",
431 | " ...\n",
432 | " statement_n"
433 | ],
434 | "execution_count": null,
435 | "outputs": []
436 | },
437 | {
438 | "cell_type": "markdown",
439 | "metadata": {
440 | "id": "xRPDQ3SKG_Re"
441 | },
442 | "source": [
443 | "But what the benefit? We need to understand a new language construction, i.e. the **break** statement"
444 | ]
445 | },
446 | {
447 | "cell_type": "markdown",
448 | "metadata": {
449 | "id": "XErrP1SiHRhr"
450 | },
451 | "source": [
452 | "#### Premature Termination of a while Loop. The break statement"
453 | ]
454 | },
455 | {
456 | "cell_type": "markdown",
457 | "metadata": {
458 | "id": "QAkZE0JpHo72"
459 | },
460 | "source": [
461 | "With the help of a break statement a while loop can be left prematurely, i.e. as soon as the control flow of the program comes to a break inside of a while loop (or other loops) the loop will be immediately left.\n",
462 | "\n",
463 | "Here comes the crucial point: **If a loop is left by break, the else part is not executed**"
464 | ]
465 | },
466 | {
467 | "cell_type": "code",
468 | "metadata": {
469 | "colab": {
470 | "base_uri": "https://localhost:8080/"
471 | },
472 | "id": "l-boUiHNHBBW",
473 | "outputId": "aa3561cd-e0a1-49fc-9279-9c06f8e1d940"
474 | },
475 | "source": [
476 | "'''\n",
477 | "This behaviour will be illustrated in the following example, a little guessing\n",
478 | "number game. A human player has to guess a number between a range of 1 to n. The\n",
479 | "player inputs his guess. The program informs the player, if this number is\n",
480 | "larger, smaller or equal to the secret number, i.e. the number which the program\n",
481 | "has randomly created. If the player wants to gives up, he or she can input a 0\n",
482 | "or a negative number. Hint: The program needs to create a random number. Therefore\n",
483 | "it's necessary to include the module \"random\".\n",
484 | "'''\n",
485 | "\n",
486 | "import random\n",
487 | "upper_bound = 20\n",
488 | "lower_bound = 1\n",
489 | "to_be_guessed = random.randint(lower_bound, upper_bound)\n",
490 | "guess = 0\n",
491 | "while guess != to_be_guessed:\n",
492 | " guess = int(input(\"New number: \"))\n",
493 | " if guess == 0: # giving up\n",
494 | " print(\"Sorry that you're giving up!\")\n",
495 | " break # break out of a loop, don't execute \"else\"\n",
496 | " if guess < lower_bound or guess > upper_bound:\n",
497 | " print(\"guess not within boundaries!\")\n",
498 | " elif guess > to_be_guessed:\n",
499 | " upper_bound = guess - 1\n",
500 | " print(\"Number too large\")\n",
501 | " elif guess < to_be_guessed:\n",
502 | " lower_bound = guess + 1\n",
503 | " print(\"Number too small\") \n",
504 | "else:\n",
505 | " print(\"Congratulations. You made it!\")"
506 | ],
507 | "execution_count": null,
508 | "outputs": [
509 | {
510 | "output_type": "stream",
511 | "name": "stdout",
512 | "text": [
513 | "New number: 5\n",
514 | "Number too small\n",
515 | "New number: 14\n",
516 | "Number too small\n",
517 | "New number: 18\n",
518 | "Congratulations. You made it!\n"
519 | ]
520 | }
521 | ]
522 | },
523 | {
524 | "cell_type": "markdown",
525 | "metadata": {
526 | "id": "gkFl4gEDTCwl"
527 | },
528 | "source": [
529 | "# For loops"
530 | ]
531 | },
532 | {
533 | "cell_type": "markdown",
534 | "metadata": {
535 | "id": "FaTl8lMmVDE-"
536 | },
537 | "source": [
538 | "Python for loop always iterates over an enumeration of a set of items.\n",
539 | "\n",
540 | "General syntax: `for in : else:`"
541 | ]
542 | },
543 | {
544 | "cell_type": "code",
545 | "metadata": {
546 | "colab": {
547 | "base_uri": "https://localhost:8080/"
548 | },
549 | "id": "Yc6zQs1rIRyY",
550 | "outputId": "48c3c72a-8bc1-486b-926f-ffada9d24a6c"
551 | },
552 | "source": [
553 | "# Example of a simple for loop in Python:\n",
554 | "\n",
555 | "languages = [\"C\", \"C++\", \"Perl\", \"Python\"] \n",
556 | "for language in languages:\n",
557 | " print(language)"
558 | ],
559 | "execution_count": null,
560 | "outputs": [
561 | {
562 | "output_type": "stream",
563 | "name": "stdout",
564 | "text": [
565 | "C\n",
566 | "C++\n",
567 | "Perl\n",
568 | "Python\n"
569 | ]
570 | }
571 | ]
572 | },
573 | {
574 | "cell_type": "markdown",
575 | "metadata": {
576 | "id": "sMbmJ1TdXjMB"
577 | },
578 | "source": [
579 | "#### `Else`"
580 | ]
581 | },
582 | {
583 | "cell_type": "code",
584 | "metadata": {
585 | "colab": {
586 | "base_uri": "https://localhost:8080/"
587 | },
588 | "id": "7buzhcY0VjZ0",
589 | "outputId": "bd6311d7-7ff8-4022-89d8-f19b1e5956a0"
590 | },
591 | "source": [
592 | "edibles = [\"bacon\", \"spam\", \"eggs\", \"nuts\"]\n",
593 | "for food in edibles:\n",
594 | " if food == \"spam\":\n",
595 | " print(\"No more spam please!\")\n",
596 | " break\n",
597 | " print(\"Great, delicious \" + food)\n",
598 | "else:\n",
599 | " print(\"I am so glad: No spam!\")\n",
600 | "print(\"Finally, I finished stuffing myself\")"
601 | ],
602 | "execution_count": null,
603 | "outputs": [
604 | {
605 | "output_type": "stream",
606 | "name": "stdout",
607 | "text": [
608 | "Great, delicious bacon\n",
609 | "No more spam please!\n",
610 | "Finally, I finished stuffing myself\n"
611 | ]
612 | }
613 | ]
614 | },
615 | {
616 | "cell_type": "markdown",
617 | "metadata": {
618 | "id": "bsuL97LXXxYX"
619 | },
620 | "source": [
621 | "`Continue` interrupt current iteration:"
622 | ]
623 | },
624 | {
625 | "cell_type": "code",
626 | "metadata": {
627 | "colab": {
628 | "base_uri": "https://localhost:8080/"
629 | },
630 | "id": "7GVJJqKfXiv_",
631 | "outputId": "31ca1288-3662-4391-b437-9e72aa7df215"
632 | },
633 | "source": [
634 | "edibles = [\"bacon\", \"spam\", \"eggs\",\"nuts\"]\n",
635 | "for food in edibles:\n",
636 | " if food == \"spam\":\n",
637 | " print(\"No more spam please!\")\n",
638 | " continue\n",
639 | " print(\"Great, delicious \" + food)\n",
640 | "\n",
641 | "print(\"Finally, I finished stuffing myself\")"
642 | ],
643 | "execution_count": null,
644 | "outputs": [
645 | {
646 | "output_type": "stream",
647 | "name": "stdout",
648 | "text": [
649 | "Great, delicious bacon\n",
650 | "No more spam please!\n",
651 | "Great, delicious eggs\n",
652 | "Great, delicious nuts\n",
653 | "Finally, I finished stuffing myself\n"
654 | ]
655 | }
656 | ]
657 | },
658 | {
659 | "cell_type": "markdown",
660 | "metadata": {
661 | "id": "HcdV6_MiYEex"
662 | },
663 | "source": [
664 | "#### The `range` function:"
665 | ]
666 | },
667 | {
668 | "cell_type": "markdown",
669 | "metadata": {
670 | "id": "K2AQuKBcbNfu"
671 | },
672 | "source": [
673 | "The built-in function `range()` is the right function to iterate over a sequence of numbers. It generates an iterator of arithmetic progressions - an object which is capable of producing the numbers of arithmetic progression. Example:"
674 | ]
675 | },
676 | {
677 | "cell_type": "code",
678 | "metadata": {
679 | "colab": {
680 | "base_uri": "https://localhost:8080/"
681 | },
682 | "id": "D1Fl_1JeX9SZ",
683 | "outputId": "f12a833d-8508-4b32-bea0-e754e453c814"
684 | },
685 | "source": [
686 | "range(5)"
687 | ],
688 | "execution_count": null,
689 | "outputs": [
690 | {
691 | "output_type": "execute_result",
692 | "data": {
693 | "text/plain": [
694 | "range(0, 5)"
695 | ]
696 | },
697 | "metadata": {},
698 | "execution_count": 19
699 | }
700 | ]
701 | },
702 | {
703 | "cell_type": "markdown",
704 | "metadata": {
705 | "id": "oK-1ILRrbkNy"
706 | },
707 | "source": [
708 | "You can use it in `for` loop:"
709 | ]
710 | },
711 | {
712 | "cell_type": "code",
713 | "metadata": {
714 | "colab": {
715 | "base_uri": "https://localhost:8080/"
716 | },
717 | "id": "djQuRj65bWAn",
718 | "outputId": "35c51493-6553-4d03-d250-86f8835d4f32"
719 | },
720 | "source": [
721 | "for i in range(5):\n",
722 | " print(i)"
723 | ],
724 | "execution_count": null,
725 | "outputs": [
726 | {
727 | "output_type": "stream",
728 | "name": "stdout",
729 | "text": [
730 | "0\n",
731 | "1\n",
732 | "2\n",
733 | "3\n",
734 | "4\n"
735 | ]
736 | }
737 | ]
738 | },
739 | {
740 | "cell_type": "markdown",
741 | "metadata": {
742 | "id": "gniXTIB-cBnk"
743 | },
744 | "source": [
745 | "To get all numbers in single container we should convert iterator to list:"
746 | ]
747 | },
748 | {
749 | "cell_type": "code",
750 | "metadata": {
751 | "colab": {
752 | "base_uri": "https://localhost:8080/"
753 | },
754 | "id": "pn74EPaXcJ8I",
755 | "outputId": "cc20c063-64d0-4703-9902-a13015cf2fe0"
756 | },
757 | "source": [
758 | "list(range(5))"
759 | ],
760 | "execution_count": null,
761 | "outputs": [
762 | {
763 | "output_type": "execute_result",
764 | "data": {
765 | "text/plain": [
766 | "[0, 1, 2, 3, 4]"
767 | ]
768 | },
769 | "metadata": {},
770 | "execution_count": 21
771 | }
772 | ]
773 | },
774 | {
775 | "cell_type": "markdown",
776 | "metadata": {
777 | "id": "Xu4KqQsYb34g"
778 | },
779 | "source": [
780 | "General case of usage `range` function:"
781 | ]
782 | },
783 | {
784 | "cell_type": "code",
785 | "metadata": {
786 | "colab": {
787 | "base_uri": "https://localhost:8080/"
788 | },
789 | "id": "-RwE4rcSbsMz",
790 | "outputId": "0ecca4fe-bacd-4f91-f9f6-9b8d0bd3e42d"
791 | },
792 | "source": [
793 | "range(4, 50, 5)"
794 | ],
795 | "execution_count": null,
796 | "outputs": [
797 | {
798 | "output_type": "execute_result",
799 | "data": {
800 | "text/plain": [
801 | "range(4, 50, 5)"
802 | ]
803 | },
804 | "metadata": {},
805 | "execution_count": 23
806 | }
807 | ]
808 | },
809 | {
810 | "cell_type": "code",
811 | "metadata": {
812 | "colab": {
813 | "base_uri": "https://localhost:8080/"
814 | },
815 | "id": "Q4lYOCpQcT2M",
816 | "outputId": "9783c1f3-9459-48be-e73d-3f1cd27da37f"
817 | },
818 | "source": [
819 | "# Lets look at all numbers:\n",
820 | "\n",
821 | "list(range(4, 50, 5))"
822 | ],
823 | "execution_count": null,
824 | "outputs": [
825 | {
826 | "output_type": "execute_result",
827 | "data": {
828 | "text/plain": [
829 | "[4, 9, 14, 19, 24, 29, 34, 39, 44, 49]"
830 | ]
831 | },
832 | "metadata": {},
833 | "execution_count": 25
834 | }
835 | ]
836 | },
837 | {
838 | "cell_type": "markdown",
839 | "metadata": {
840 | "id": "zdTDvOyUfmP6"
841 | },
842 | "source": [
843 | "#### Examples:"
844 | ]
845 | },
846 | {
847 | "cell_type": "code",
848 | "metadata": {
849 | "colab": {
850 | "base_uri": "https://localhost:8080/"
851 | },
852 | "id": "QOBssTvZcYEk",
853 | "outputId": "8522ec33-c1fd-4eb4-f716-87c0a868661c"
854 | },
855 | "source": [
856 | "# Calculation of the Pythagorean Numbers. The following program calculates all\n",
857 | "# pythagorean numbers less than a maximal number:\n",
858 | "\n",
859 | "from math import sqrt\n",
860 | "n = int(input(\"Maximal Number? \"))\n",
861 | "for a in range(1, n+1):\n",
862 | " for b in range(a, n):\n",
863 | " c_square = a**2 + b**2\n",
864 | " c = int(sqrt(c_square))\n",
865 | " if ((c_square - c**2) == 0):\n",
866 | " print(a, b, c)"
867 | ],
868 | "execution_count": null,
869 | "outputs": [
870 | {
871 | "output_type": "stream",
872 | "name": "stdout",
873 | "text": [
874 | "Maximal Number? 6\n",
875 | "3 4 5\n"
876 | ]
877 | }
878 | ]
879 | },
880 | {
881 | "cell_type": "markdown",
882 | "metadata": {
883 | "id": "Q0JVYya3gIOD"
884 | },
885 | "source": [
886 | "#### Iterating over containers with `for` loop:"
887 | ]
888 | },
889 | {
890 | "cell_type": "code",
891 | "metadata": {
892 | "colab": {
893 | "base_uri": "https://localhost:8080/"
894 | },
895 | "id": "FybbMBWIf93S",
896 | "outputId": "047207db-69a5-44b0-935c-4ce1c8240825"
897 | },
898 | "source": [
899 | "fibonacci = [0, 1, 1, 2, 3, 5, 8, 13, 21]\n",
900 | "for i in range(len(fibonacci)):\n",
901 | " print(i,fibonacci[i])\n",
902 | "print()"
903 | ],
904 | "execution_count": null,
905 | "outputs": [
906 | {
907 | "output_type": "stream",
908 | "name": "stdout",
909 | "text": [
910 | "0 0\n",
911 | "1 1\n",
912 | "2 1\n",
913 | "3 2\n",
914 | "4 3\n",
915 | "5 5\n",
916 | "6 8\n",
917 | "7 13\n",
918 | "8 21\n",
919 | "\n"
920 | ]
921 | }
922 | ]
923 | },
924 | {
925 | "cell_type": "code",
926 | "metadata": {
927 | "colab": {
928 | "base_uri": "https://localhost:8080/"
929 | },
930 | "id": "8kPqchxjgbCV",
931 | "outputId": "386cc2e8-454f-4cd6-d36f-d1d573372b1a"
932 | },
933 | "source": [
934 | "# PREFERRED:\n",
935 | "\n",
936 | "fibonacci = [0, 1, 1, 2, 3, 5, 8, 13, 21]\n",
937 | "for ix, el in enumerate(fibonacci):\n",
938 | " print(ix, el)\n",
939 | "print()"
940 | ],
941 | "execution_count": null,
942 | "outputs": [
943 | {
944 | "output_type": "stream",
945 | "name": "stdout",
946 | "text": [
947 | "0 0\n",
948 | "1 1\n",
949 | "2 1\n",
950 | "3 2\n",
951 | "4 3\n",
952 | "5 5\n",
953 | "6 8\n",
954 | "7 13\n",
955 | "8 21\n",
956 | "\n"
957 | ]
958 | }
959 | ]
960 | },
961 | {
962 | "cell_type": "markdown",
963 | "metadata": {
964 | "id": "1-nnKR_og8uq"
965 | },
966 | "source": [
967 | "#### List iteration with Side Effects"
968 | ]
969 | },
970 | {
971 | "cell_type": "markdown",
972 | "metadata": {
973 | "id": "wnkEEBmChAq3"
974 | },
975 | "source": [
976 | "If you loop over a list, it's best \n",
977 | "to avoid changing the list in the loop body.\n",
978 | "\n",
979 | "Take a look at the following example:"
980 | ]
981 | },
982 | {
983 | "cell_type": "code",
984 | "metadata": {
985 | "colab": {
986 | "base_uri": "https://localhost:8080/"
987 | },
988 | "id": "IQb9gTzmgqSK",
989 | "outputId": "cc0ba65b-c898-40b0-e7b1-c6253646eda8"
990 | },
991 | "source": [
992 | "colours = [\"red\"]\n",
993 | "for i in colours:\n",
994 | " if i == \"red\":\n",
995 | " colours = [\"black\"] + colours\n",
996 | " if i == \"black\":\n",
997 | " colours += [\"white\"]\n",
998 | "print(colours)"
999 | ],
1000 | "execution_count": null,
1001 | "outputs": [
1002 | {
1003 | "output_type": "stream",
1004 | "name": "stdout",
1005 | "text": [
1006 | "['black', 'red']\n"
1007 | ]
1008 | }
1009 | ]
1010 | },
1011 | {
1012 | "cell_type": "markdown",
1013 | "metadata": {
1014 | "id": "RNT0UpfmhQqt"
1015 | },
1016 | "source": [
1017 | "To avoid these side effects, it's best to work on a copy by using the slicing operator, as can be seen in the next example:"
1018 | ]
1019 | },
1020 | {
1021 | "cell_type": "code",
1022 | "metadata": {
1023 | "colab": {
1024 | "base_uri": "https://localhost:8080/"
1025 | },
1026 | "id": "JU7UHKjLhNc3",
1027 | "outputId": "c5acd2fa-2d50-42ae-be3b-725679b4f50b"
1028 | },
1029 | "source": [
1030 | "colours = [\"red\"]\n",
1031 | "for i in colours[:]:\n",
1032 | " if i == \"red\":\n",
1033 | " colours += [\"black\"]\n",
1034 | " if i == \"black\":\n",
1035 | " colours += [\"white\"]\n",
1036 | "print(colours)"
1037 | ],
1038 | "execution_count": null,
1039 | "outputs": [
1040 | {
1041 | "output_type": "stream",
1042 | "name": "stdout",
1043 | "text": [
1044 | "['red', 'black']\n"
1045 | ]
1046 | }
1047 | ]
1048 | },
1049 | {
1050 | "cell_type": "markdown",
1051 | "metadata": {
1052 | "id": "PPpJ_YuFhjQr"
1053 | },
1054 | "source": [
1055 | "# Float"
1056 | ]
1057 | },
1058 | {
1059 | "cell_type": "markdown",
1060 | "metadata": {
1061 | "id": "yodeZ01Ch9x-"
1062 | },
1063 | "source": [
1064 | "When dealing with floats we should avoid direct comparisons:"
1065 | ]
1066 | },
1067 | {
1068 | "cell_type": "code",
1069 | "metadata": {
1070 | "colab": {
1071 | "base_uri": "https://localhost:8080/"
1072 | },
1073 | "id": "PLXRmlS6hXD0",
1074 | "outputId": "75759f93-5621-4089-81cd-5699bf548ae4"
1075 | },
1076 | "source": [
1077 | "import math\n",
1078 | "\n",
1079 | "math.e**(math.log(5))"
1080 | ],
1081 | "execution_count": null,
1082 | "outputs": [
1083 | {
1084 | "output_type": "execute_result",
1085 | "data": {
1086 | "text/plain": [
1087 | "4.999999999999999"
1088 | ]
1089 | },
1090 | "metadata": {},
1091 | "execution_count": 31
1092 | }
1093 | ]
1094 | },
1095 | {
1096 | "cell_type": "markdown",
1097 | "metadata": {
1098 | "id": "GVJLB96YiPv_"
1099 | },
1100 | "source": [
1101 | ".. and:"
1102 | ]
1103 | },
1104 | {
1105 | "cell_type": "code",
1106 | "metadata": {
1107 | "colab": {
1108 | "base_uri": "https://localhost:8080/"
1109 | },
1110 | "id": "r_au6UatiNE9",
1111 | "outputId": "ce3668ed-17c5-45d0-81c8-26cbf279ca2f"
1112 | },
1113 | "source": [
1114 | "math.e**(math.log(5)) == 5"
1115 | ],
1116 | "execution_count": null,
1117 | "outputs": [
1118 | {
1119 | "output_type": "execute_result",
1120 | "data": {
1121 | "text/plain": [
1122 | "False"
1123 | ]
1124 | },
1125 | "metadata": {},
1126 | "execution_count": 32
1127 | }
1128 | ]
1129 | },
1130 | {
1131 | "cell_type": "markdown",
1132 | "metadata": {
1133 | "id": "NF35CQb5iXOK"
1134 | },
1135 | "source": [
1136 | "We should do the following:"
1137 | ]
1138 | },
1139 | {
1140 | "cell_type": "code",
1141 | "metadata": {
1142 | "colab": {
1143 | "base_uri": "https://localhost:8080/"
1144 | },
1145 | "id": "3m8lLccpiVnX",
1146 | "outputId": "9d8ce74f-f334-4edb-d6e9-c53cf63cbb39"
1147 | },
1148 | "source": [
1149 | "eps = 1e-5 # small epsilon\n",
1150 | "abs(math.e**(math.log(5)) - 5) < eps"
1151 | ],
1152 | "execution_count": null,
1153 | "outputs": [
1154 | {
1155 | "output_type": "execute_result",
1156 | "data": {
1157 | "text/plain": [
1158 | "True"
1159 | ]
1160 | },
1161 | "metadata": {},
1162 | "execution_count": 33
1163 | }
1164 | ]
1165 | },
1166 | {
1167 | "cell_type": "markdown",
1168 | "metadata": {
1169 | "id": "IZ6aYIqEinxs"
1170 | },
1171 | "source": [
1172 | "# Formatted output:"
1173 | ]
1174 | },
1175 | {
1176 | "cell_type": "markdown",
1177 | "metadata": {
1178 | "id": "2JvIurkrxtGL"
1179 | },
1180 | "source": [
1181 | "#### 1. The Old Way or the non-existing printf and sprintf"
1182 | ]
1183 | },
1184 | {
1185 | "cell_type": "markdown",
1186 | "metadata": {
1187 | "id": "nGsVIT5lx0E0"
1188 | },
1189 | "source": [
1190 | "For the purpose of using printf-like printing in python the modulo operator \"%\" is overloaded by the string class to perform string formatting. Therefore, it is often called string modulo (or somethimes even called modulus) operator, though it has not a lot in common with the actual modulo calculation on numbers. Another term for it is \"string interpolation\", because it interpolates various class types (like int, float and so on) into a formatted string. In many cases the string created via the string interpolation mechanism is used for outputting values in a special way. But it can also be used, for example, to create the right format to put the data into a database. \n",
1191 | "\n",
1192 | "Since Python 2.6 has been introduced, the string method format should be used instead of this old-style formatting. Unfortunately, string modulo \"%\" is still available in Python3 and what is even worse, it is still widely used. That's why we cover it in great detail in this tutorial. You should be capable of understanding it, when you encounter it in some Python code. However, it is very likely that one day this old style of formatting will be removed from the language. So you should get used to str.format().\n",
1193 | "\n",
1194 | "The following diagram depicts how the string modulo operator works:\n",
1195 | "\n",
1196 | "\n",
1197 | "\n",
1198 | "\n",
1199 | "\n",
1200 | "The format string contains placeholders. There are two of those in our example: \"%5d\" and \"%8.2f\". The general syntax for a format placeholder is\n",
1201 | "\n",
1202 | "`%[flags][width][.precision]type`\n",
1203 | "\n",
1204 | "Conversion types:\n",
1205 | "\n",
1206 | "d --- Signed integer decimal.\n",
1207 | "\n",
1208 | "i --- Signed integer decimal.\n",
1209 | "\n",
1210 | "o --- Unsigned octal.\n",
1211 | "\n",
1212 | "u --- Obsolete and equivalent to 'd', i.e. signed integer decimal.\n",
1213 | "\n",
1214 | "x --- Unsigned hexadecimal (lowercase).\n",
1215 | "\n",
1216 | "X --- Unsigned hexadecimal (uppercase).\n",
1217 | "\n",
1218 | "e --- Floating point exponential format (lowercase).\n",
1219 | "\n",
1220 | "E --- Floating point exponential format (uppercase).\n",
1221 | "\n",
1222 | "f --- Floating point decimal format.\n",
1223 | "\n",
1224 | "F --- Floating point decimal format.\n",
1225 | "\n",
1226 | "g --- Same as \"e\" if exponent is greater than -4 or less than precision, \"f\" otherwise.\n",
1227 | "\n",
1228 | "G --- Same as \"E\" if exponent is greater than -4 or less than precision, \"F\" otherwise.\n",
1229 | "\n",
1230 | "c --- Single character (accepts integer or single character string).\n",
1231 | "\n",
1232 | "r --- String (converts any python object using repr()).\n",
1233 | "\n",
1234 | "s --- String (converts any python object using str()).\n",
1235 | "\n",
1236 | "% --- No argument is converted, results in a \"%\" character in the result.\n",
1237 | "\n",
1238 | "Examples:"
1239 | ]
1240 | },
1241 | {
1242 | "cell_type": "code",
1243 | "metadata": {
1244 | "colab": {
1245 | "base_uri": "https://localhost:8080/"
1246 | },
1247 | "id": "dMwiQC2tul9U",
1248 | "outputId": "41120038-4781-4013-f9cc-8eb46877cf24"
1249 | },
1250 | "source": [
1251 | "print(\"%10.3e\"% (356.08977))\n",
1252 | "print(\"%10.3E\"% (356.08977))\n",
1253 | "print(\"%10o\"% (25))\n",
1254 | "print(\"%10.3o\"% (25))\n",
1255 | "print(\"%10.5o\"% (25))\n",
1256 | "print(\"%5x\"% (47))\n",
1257 | "print(\"%5.4x\"% (47))\n",
1258 | "print(\"%5.4X\"% (47))\n",
1259 | "print(\"Only one percentage sign: %% \" % ())"
1260 | ],
1261 | "execution_count": null,
1262 | "outputs": [
1263 | {
1264 | "output_type": "stream",
1265 | "name": "stdout",
1266 | "text": [
1267 | " 3.561e+02\n",
1268 | " 3.561E+02\n",
1269 | " 31\n",
1270 | " 031\n",
1271 | " 00031\n",
1272 | " 2f\n",
1273 | " 002f\n",
1274 | " 002F\n",
1275 | "Only one percentage sign: % \n"
1276 | ]
1277 | }
1278 | ]
1279 | },
1280 | {
1281 | "cell_type": "markdown",
1282 | "metadata": {
1283 | "id": "99-fb3p42b9c"
1284 | },
1285 | "source": [
1286 | "Even though it may look so, the formatting is not part of the print function. If you have a closer look at our examples, you will see that we passed a formatted string to the print function. Or to put it in other words: If the string modulo operator is applied to a string, it returns a string. This string in turn is passed in our examples to the print function."
1287 | ]
1288 | },
1289 | {
1290 | "cell_type": "markdown",
1291 | "metadata": {
1292 | "id": "uLISDNTW2haY"
1293 | },
1294 | "source": [
1295 | "#### 2. The Pythonic Way: The string method \"format\""
1296 | ]
1297 | },
1298 | {
1299 | "cell_type": "markdown",
1300 | "metadata": {
1301 | "id": "nj7boB7YehTr"
1302 | },
1303 | "source": [
1304 | "\n",
1305 | "\n",
1306 | "\n",
1307 | "\n",
1308 | "A positional parameter of the format method can be accessed by placing the index of the parameter after the opening brace, e.g. {0} accesses the first parameter, {1} the second one and so on. The index inside of the curly braces can be followed by a colon and a format string, which is similar to the notation of the string modulo, which we had discussed in the beginning of the chapter of our tutorial, e.g. {0:5d} If the positional parameters are used in the order in which they are written, the positional argument specifiers inside of the braces can be omitted, so '{} {} {}' corresponds to '{0} {1} {2}'. But they are needed, if you want to access them in different orders: '{2} {1} {0}'. If a brace character has to be printed, it has to be escaped by doubling it: {{ and }}.\n",
1309 | "\n",
1310 | "Additional formatting flags:\n",
1311 | "\n",
1312 | "\\# --- Used with o, x or X specifiers the value is preceded with 0, 0o, 0O, 0x or 0X respectively\n",
1313 | "\n",
1314 | "0 --- The conversion result will be zero padded for numeric values\n",
1315 | "\n",
1316 | "\\- --- The converted value is left adjusted. If no sign (minus sign e.g.) is going to be written, a blank space is inserted before the value\n",
1317 | "\n",
1318 | "\\+ --- A sign character (\"+\" or \"-\") will precede the conversion (overrides a \"space\" flag)\n",
1319 | "\n",
1320 | "Examples:"
1321 | ]
1322 | },
1323 | {
1324 | "cell_type": "code",
1325 | "metadata": {
1326 | "id": "SRl_mCj_2Lj2",
1327 | "colab": {
1328 | "base_uri": "https://localhost:8080/"
1329 | },
1330 | "outputId": "b76f7b4e-e553-45b7-deb5-1b7c9508bdab"
1331 | },
1332 | "source": [
1333 | "x = 378\n",
1334 | "print(\"The value is {:06d}\".format(x))\n",
1335 | "\n",
1336 | "x = -378\n",
1337 | "print(\"The value is {:06d}\".format(x))\n",
1338 | "\n",
1339 | "x = 9283472410989128\n",
1340 | "print(\"The value is {:,}\".format(x))\n",
1341 | "\n",
1342 | "x = 92837424798234792.2487\n",
1343 | "print(\"The value is {0:6,f}\".format(x))\n",
1344 | "\n",
1345 | "# Unless a minimum field width is defined, the field width will always be the\n",
1346 | "# same size as the data to fill it, so that the alignment option has no meaning\n",
1347 | "# in this case.\n",
1348 | "\n",
1349 | "\n",
1350 | "# Additionally, we can modify the formatting with the sign option, which is only\n",
1351 | "# valid for number types:\n",
1352 | "\n",
1353 | "# `+` - indicates that a sign should be used for both positive as well as\n",
1354 | "# negative numbers\n",
1355 | "# `-` - indicates that a sign should be used only for negative numbers, which is\n",
1356 | "# the default behavior\n",
1357 | "# `space` - indicates that a leading space should be used on positive numbers,\n",
1358 | "# and a minus sign on negative numbers"
1359 | ],
1360 | "execution_count": null,
1361 | "outputs": [
1362 | {
1363 | "output_type": "stream",
1364 | "name": "stdout",
1365 | "text": [
1366 | "The value is 000378\n",
1367 | "The value is -00378\n",
1368 | "The value is 9,283,472,410,989,128\n",
1369 | "The value is 92,837,424,798,234,800.000000\n"
1370 | ]
1371 | }
1372 | ]
1373 | },
1374 | {
1375 | "cell_type": "markdown",
1376 | "metadata": {
1377 | "id": "tFdQj4Z7k4l1"
1378 | },
1379 | "source": [
1380 | "#### Other string methods for Formatting"
1381 | ]
1382 | },
1383 | {
1384 | "cell_type": "code",
1385 | "metadata": {
1386 | "colab": {
1387 | "base_uri": "https://localhost:8080/",
1388 | "height": 37
1389 | },
1390 | "id": "7afub7n8hr0R",
1391 | "outputId": "6caa603a-dc28-49b2-c4b7-cd7e2de5fa8e"
1392 | },
1393 | "source": [
1394 | "s = \"Python\"\n",
1395 | "s.center(10)"
1396 | ],
1397 | "execution_count": null,
1398 | "outputs": [
1399 | {
1400 | "output_type": "execute_result",
1401 | "data": {
1402 | "application/vnd.google.colaboratory.intrinsic+json": {
1403 | "type": "string"
1404 | },
1405 | "text/plain": [
1406 | "' Python '"
1407 | ]
1408 | },
1409 | "metadata": {},
1410 | "execution_count": 12
1411 | }
1412 | ]
1413 | },
1414 | {
1415 | "cell_type": "code",
1416 | "metadata": {
1417 | "colab": {
1418 | "base_uri": "https://localhost:8080/",
1419 | "height": 37
1420 | },
1421 | "id": "pnOuplsMk_nk",
1422 | "outputId": "5bbbc8c9-ffa9-4acd-aad0-20bfd2a69044"
1423 | },
1424 | "source": [
1425 | "s = \"Training\"\n",
1426 | "s.ljust(12)"
1427 | ],
1428 | "execution_count": null,
1429 | "outputs": [
1430 | {
1431 | "output_type": "execute_result",
1432 | "data": {
1433 | "application/vnd.google.colaboratory.intrinsic+json": {
1434 | "type": "string"
1435 | },
1436 | "text/plain": [
1437 | "'Training '"
1438 | ]
1439 | },
1440 | "metadata": {},
1441 | "execution_count": 13
1442 | }
1443 | ]
1444 | },
1445 | {
1446 | "cell_type": "code",
1447 | "metadata": {
1448 | "colab": {
1449 | "base_uri": "https://localhost:8080/",
1450 | "height": 37
1451 | },
1452 | "id": "rd4zCt8VlLN-",
1453 | "outputId": "10b1d41f-e7e1-4d67-d5a3-2400855b2537"
1454 | },
1455 | "source": [
1456 | "s = \"Programming\"\n",
1457 | "s.rjust(15)"
1458 | ],
1459 | "execution_count": null,
1460 | "outputs": [
1461 | {
1462 | "output_type": "execute_result",
1463 | "data": {
1464 | "application/vnd.google.colaboratory.intrinsic+json": {
1465 | "type": "string"
1466 | },
1467 | "text/plain": [
1468 | "' Programming'"
1469 | ]
1470 | },
1471 | "metadata": {},
1472 | "execution_count": 14
1473 | }
1474 | ]
1475 | },
1476 | {
1477 | "cell_type": "code",
1478 | "metadata": {
1479 | "colab": {
1480 | "base_uri": "https://localhost:8080/",
1481 | "height": 37
1482 | },
1483 | "id": "8DiZQoQ6lOL6",
1484 | "outputId": "e590a777-f6b4-4033-eb96-293053e4be00"
1485 | },
1486 | "source": [
1487 | "account_number = \"43447879\"\n",
1488 | "account_number.zfill(12)"
1489 | ],
1490 | "execution_count": null,
1491 | "outputs": [
1492 | {
1493 | "output_type": "execute_result",
1494 | "data": {
1495 | "application/vnd.google.colaboratory.intrinsic+json": {
1496 | "type": "string"
1497 | },
1498 | "text/plain": [
1499 | "'000043447879'"
1500 | ]
1501 | },
1502 | "metadata": {},
1503 | "execution_count": 15
1504 | }
1505 | ]
1506 | },
1507 | {
1508 | "cell_type": "code",
1509 | "metadata": {
1510 | "colab": {
1511 | "base_uri": "https://localhost:8080/",
1512 | "height": 37
1513 | },
1514 | "id": "BiTqiZdglQ6S",
1515 | "outputId": "2ae88ac5-a026-450e-aaa0-9de8cfdee11d"
1516 | },
1517 | "source": [
1518 | "# the same as previous\n",
1519 | "\n",
1520 | "account_number.rjust(12,\"0\")"
1521 | ],
1522 | "execution_count": null,
1523 | "outputs": [
1524 | {
1525 | "output_type": "execute_result",
1526 | "data": {
1527 | "application/vnd.google.colaboratory.intrinsic+json": {
1528 | "type": "string"
1529 | },
1530 | "text/plain": [
1531 | "'000043447879'"
1532 | ]
1533 | },
1534 | "metadata": {},
1535 | "execution_count": 16
1536 | }
1537 | ]
1538 | },
1539 | {
1540 | "cell_type": "markdown",
1541 | "metadata": {
1542 | "id": "4WKZJApxlaU-"
1543 | },
1544 | "source": [
1545 | "#### f-strings - formatted string literals (since python 3.6)"
1546 | ]
1547 | },
1548 | {
1549 | "cell_type": "code",
1550 | "metadata": {
1551 | "colab": {
1552 | "base_uri": "https://localhost:8080/",
1553 | "height": 37
1554 | },
1555 | "id": "dwz6wHemlY5Q",
1556 | "outputId": "f56a8c7c-9bbe-4505-fa8f-280ae96ca7be"
1557 | },
1558 | "source": [
1559 | "price = 11.23\n",
1560 | "f\"Price in Euro: {price}\""
1561 | ],
1562 | "execution_count": null,
1563 | "outputs": [
1564 | {
1565 | "output_type": "execute_result",
1566 | "data": {
1567 | "application/vnd.google.colaboratory.intrinsic+json": {
1568 | "type": "string"
1569 | },
1570 | "text/plain": [
1571 | "'Price in Euro: 11.23'"
1572 | ]
1573 | },
1574 | "metadata": {},
1575 | "execution_count": 17
1576 | }
1577 | ]
1578 | },
1579 | {
1580 | "cell_type": "code",
1581 | "metadata": {
1582 | "colab": {
1583 | "base_uri": "https://localhost:8080/",
1584 | "height": 37
1585 | },
1586 | "id": "OYk8zsfzlp7W",
1587 | "outputId": "43b02fd8-1c51-4773-fb48-20ff398a2687"
1588 | },
1589 | "source": [
1590 | "f\"Price in Swiss Franks: {price * 1.086}\""
1591 | ],
1592 | "execution_count": null,
1593 | "outputs": [
1594 | {
1595 | "output_type": "execute_result",
1596 | "data": {
1597 | "application/vnd.google.colaboratory.intrinsic+json": {
1598 | "type": "string"
1599 | },
1600 | "text/plain": [
1601 | "'Price in Swiss Franks: 12.195780000000001'"
1602 | ]
1603 | },
1604 | "metadata": {},
1605 | "execution_count": 18
1606 | }
1607 | ]
1608 | },
1609 | {
1610 | "cell_type": "code",
1611 | "metadata": {
1612 | "colab": {
1613 | "base_uri": "https://localhost:8080/",
1614 | "height": 37
1615 | },
1616 | "id": "a6qzydhIlwTt",
1617 | "outputId": "38dc4918-a366-4d52-87bd-22cd6bf26824"
1618 | },
1619 | "source": [
1620 | "f\"Price in Swiss Franks: {price * 1.086:5.2f}\""
1621 | ],
1622 | "execution_count": null,
1623 | "outputs": [
1624 | {
1625 | "output_type": "execute_result",
1626 | "data": {
1627 | "application/vnd.google.colaboratory.intrinsic+json": {
1628 | "type": "string"
1629 | },
1630 | "text/plain": [
1631 | "'Price in Swiss Franks: 12.20'"
1632 | ]
1633 | },
1634 | "metadata": {},
1635 | "execution_count": 19
1636 | }
1637 | ]
1638 | },
1639 | {
1640 | "cell_type": "code",
1641 | "metadata": {
1642 | "id": "OBrqVAqWlyzP"
1643 | },
1644 | "source": [
1645 | ""
1646 | ],
1647 | "execution_count": null,
1648 | "outputs": []
1649 | }
1650 | ]
1651 | }
--------------------------------------------------------------------------------
/week6/Lecture_12_re.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "name": "Lecture 12. re.ipynb",
7 | "provenance": [],
8 | "collapsed_sections": [],
9 | "authorship_tag": "ABX9TyMFlKI/JE7+E1+XaO5CH0sk",
10 | "include_colab_link": true
11 | },
12 | "kernelspec": {
13 | "name": "python3",
14 | "display_name": "Python 3"
15 | },
16 | "language_info": {
17 | "name": "python"
18 | }
19 | },
20 | "cells": [
21 | {
22 | "cell_type": "markdown",
23 | "metadata": {
24 | "id": "view-in-github",
25 | "colab_type": "text"
26 | },
27 | "source": [
28 | ""
29 | ]
30 | },
31 | {
32 | "cell_type": "markdown",
33 | "metadata": {
34 | "id": "9bQhYGHAbolh"
35 | },
36 | "source": [
37 | "## re: Regular Expressions\n",
38 | "\n",
39 | "The term \"regular expression\", sometimes also called regex or regexp, has originated in theoretical computer science. In theoretical computer science, they are used to define a language family with certain characteristics, the so-called regular languages. A finite state machine (FSM), which accepts language defined by a regular expression, exists for every regular expression. You can find an implementation of a [Finite State Machine in Python](https://www.python-course.eu/finite_state_machine.php)\n",
40 | "\n",
41 | "Regular Expressions are used in programming languages to filter texts or textstrings. It's possible to check, if a text or a string matches a regular expression. A great thing about regular expressions: The syntax of regular expressions is the same for all programming and script languages, e.g. Python, Perl, Java, SED, AWK and even X#.\n",
42 | "\n",
43 | "The first programs which had incorporated the capability to use regular expressions were the Unix tools ed (editor), the stream editor sed and the filter grep ([you SHOULD know this](https://ostechnix.com/the-grep-command-tutorial-with-examples-for-beginners/)).\n",
44 | "\n",
45 | "There is another mechanism in operating systems, which shouldn't be mistaken for regular expressions. Wildcards, also known as globbing, look very similar in their syntax to regular expressions. However, the semantics differ considerably. Globbing is known from many command line shells, like the Bourne shell, the Bash shell or even DOS. In Bash e.g. the command \"ls .txt\" lists all files (or even directories) ending with the suffix .txt; in regular expression notation \".txt\" wouldn't make sense, it would have to be written as \".*.txt\"\n",
46 | "\n",
47 | "#### Introduction\n",
48 | "\n",
49 | "When we introduced the sequential data types, we got to know the \"in\" operator. We check in the following example, if the string \"easily\" is a substring of the string \"Regular expressions easily explained!\":"
50 | ]
51 | },
52 | {
53 | "cell_type": "code",
54 | "metadata": {
55 | "colab": {
56 | "base_uri": "https://localhost:8080/"
57 | },
58 | "id": "quOyWn0kZmRu",
59 | "outputId": "6292a2dc-6911-4d26-8813-b7183bd3d4a1"
60 | },
61 | "source": [
62 | "s = \"Regular expressions easily explained!\"\n",
63 | "\"easily\" in s"
64 | ],
65 | "execution_count": 1,
66 | "outputs": [
67 | {
68 | "output_type": "execute_result",
69 | "data": {
70 | "text/plain": [
71 | "True"
72 | ]
73 | },
74 | "metadata": {},
75 | "execution_count": 1
76 | }
77 | ]
78 | },
79 | {
80 | "cell_type": "markdown",
81 | "metadata": {
82 | "id": "NJUtjHbWdaA4"
83 | },
84 | "source": [
85 | "We show step by step with the following diagrams how this matching is performed: We check if the string sub = \"abc\"\n",
86 | "\n",
87 | "\n",
88 | "\n",
89 | "s contained in the string s = \"xaababcbcd\"\n",
90 | "\n",
91 | "\n",
92 | "\n",
93 | "By the way, the string sub = \"abc\" can be seen as a regular expression, just a very simple one.\n",
94 | "\n",
95 | "In the first place, we check, if the first positions of the two string match, i.e. s[0] == sub[0]. This is not satisfied in our example. We mark this fact by the colour red:\n",
96 | "\n",
97 | "\n",
98 | "\n",
99 | "Then we check, if s[1:4] == sub. In other words, we have to check at first, if sub[0] is equal to s[1]. This is true and we mark it with the colour green. Then, we have to compare the next positions. s[2] is not equal to sub[1], so we don't have to proceed further with the next position of sub and s:\n",
100 | "\n",
101 | "\n",
102 | "\n",
103 | "Now we have to check if s[2:5] and sub are equal. The first two positions are equal but not the third:\n",
104 | "\n",
105 | "\n",
106 | "\n",
107 | "The following steps should be clear without any explanations:\n",
108 | "\n",
109 | "\n",
110 | "\n",
111 | "Finally, we have a complete match with s[4:7] == sub :\n",
112 | "\n",
113 | "\n",
114 | "\n",
115 | "#### Representing Regular Expressions in Python\n",
116 | "\n",
117 | "As we have already mentioned in the previous section, we can see the variable \"sub\" from the introduction as a very simple regular expression. If you want to use regular expressions in Python, you have to import the re module, which provides methods and functions to deal with regular expressions.\n",
118 | "\n",
119 | "From other languages you might be used to representing regular expressions within Slashes \"/\", e.g. that's the way Perl, SED or AWK deals with them. In Python there is no special notation. Regular expressions are represented as normal strings.\n",
120 | "\n",
121 | "But this convenience brings along a small problem: The backslash is a special character used in regular expressions, but is also used as an escape character in strings. This implies that Python would first evaluate every backslash of a string and after this - without the necessary backslashes - it would be used as a regular expression. One way to prevent this could be writing every backslash as \"\\\\\" and this way keep it for the evaluation of the regular expression. This can cause extremely clumsy expressions. So, a regular expression to match the Windows path \"C:\\\\\\\\programs\" corresponds to a string in regular expression notation with four backslashes, i.e. \"C:\\\\\\\\\\\\\\\\programs\".\n",
122 | "\n",
123 | "The best way to overcome this problem would be marking regular expressions as raw strings. The solution to our Windows path example looks like this as a raw string:\n",
124 | "\n",
125 | "```r\"C:\\\\programs\"```\n",
126 | "\n",
127 | "Let's look at another example, which might be quite disturbing for people who are used to wildcards:\n",
128 | "\n",
129 | "```r\"^a.*\\.html$\"```\n",
130 | "\n",
131 | "The regular expression of our previous example matches all file names (strings) which start with an \"a\" and end with \".html\". We will the structure of the example above in detail explain in the following sections\n",
132 | "\n",
133 | "#### Syntax of Regular Expression\n",
134 | "\n",
135 | "```r\"cat\"``` is a regular expression, though a very simple one without any metacharacters. Our RE ```r\"cat\"``` matches, for example, the following string: \"A cat and a rat can't be friends.\"\n",
136 | "\n",
137 | "Interestingly, the previous example shows already a \"favourite\" example for a mistake, frequently made not only by beginners and novices but also by advanced users of regular expressions. The idea of this example is to match strings containing the word \"cat\". We are successful at this, but unfortunately we are matching a lot of other words as well. If we match \"cats\" in a string that might be still okay, but what about all those words containing this character sequence \"cat\"? We match words like \"education\", \"communicate\", \"falsification\", \"ramifications\", \"cattle\" and many more. This is a case of \"over matching\", i.e. we receive positive results, which are wrong according to the problem we want to solve.\n",
138 | "\n",
139 | "If we try to fix the previous RE, so that it doesn't create over matching, we might try the expression ```r\" cat \"```. These blanks prevent the matching of the above mentioned words like \"education\", \"falsification\" and \"ramification\", but we fall prey to another mistake. What about the string \"The cat, called Oscar, climbed on the roof.\"? The problem is that we don't expect a comma but only a blank surrounding the word \"cat\".\n",
140 | "\n",
141 | "Before we go on with the description of the syntax of regular expressions, we want to explain how to use them in Python:"
142 | ]
143 | },
144 | {
145 | "cell_type": "code",
146 | "metadata": {
147 | "colab": {
148 | "base_uri": "https://localhost:8080/"
149 | },
150 | "id": "4rFDTtSmdWTD",
151 | "outputId": "25080250-d517-4a56-dd20-a7dfc453dc0b"
152 | },
153 | "source": [
154 | "import re\n",
155 | "x = re.search(\"cat\", \"A cat and a rat can't be friends.\")\n",
156 | "print(x)"
157 | ],
158 | "execution_count": 2,
159 | "outputs": [
160 | {
161 | "output_type": "stream",
162 | "name": "stdout",
163 | "text": [
164 | ""
29 | ]
30 | },
31 | {
32 | "cell_type": "markdown",
33 | "metadata": {
34 | "id": "Gf_pWG1fndIo"
35 | },
36 | "source": [
37 | "#### В этом туториале мы попробуем получить ответ от [веб сервиса](http://www.cbs.dtu.dk/services/NetMHCpan/) внутри этого ноутбука, а не через браузер\n",
38 | "\n",
39 | "Импортируем нужные модули:"
40 | ]
41 | },
42 | {
43 | "cell_type": "code",
44 | "metadata": {
45 | "id": "Mt36MTr-xH4e"
46 | },
47 | "source": [
48 | "import requests"
49 | ],
50 | "execution_count": null,
51 | "outputs": []
52 | },
53 | {
54 | "cell_type": "markdown",
55 | "metadata": {
56 | "id": "qI4Ixs94nnme"
57 | },
58 | "source": [
59 | "#### Ссылка на скрипт на сервере, который обрабатывает изначальный POST запрос:\n",
60 | "\n",
61 | "Всегда, когда вы сабмитите форму в интернете, вы посылаете POST запрос скрипту адрес которого можно узнать просмотрев submitted form data. Загуглите \"how to view submitted form data\" или посмотрите вот это:\n",
62 | "\n",
63 | "https://www.youtube.com/watch?v=SvUqk683mSA\n",
64 | "\n",
65 | "https://wpscholar.com/blog/view-form-data-in-chrome/"
66 | ]
67 | },
68 | {
69 | "cell_type": "code",
70 | "metadata": {
71 | "id": "ZpcVQTtxxRu6"
72 | },
73 | "source": [
74 | "url = 'http://www.cbs.dtu.dk/cgi-bin/webface2.fcgi'"
75 | ],
76 | "execution_count": null,
77 | "outputs": []
78 | },
79 | {
80 | "cell_type": "markdown",
81 | "metadata": {
82 | "id": "WZll65hWosP8"
83 | },
84 | "source": [
85 | "#### Формируем данные формы (словарь `post_dadta` - это я его так назвал) - как их формировать смотри так же, как адрес обрабатывающего скрипта (ссылки выше) - и отправляем с помощью `requests` этот POST запрос:"
86 | ]
87 | },
88 | {
89 | "cell_type": "code",
90 | "metadata": {
91 | "id": "_krexwfv3fv3",
92 | "colab": {
93 | "base_uri": "https://localhost:8080/"
94 | },
95 | "outputId": "f8e2c555-dcb8-4492-d80a-b8582716ce76"
96 | },
97 | "source": [
98 | "post_data = {'configfile': '/usr/opt/www/pub/CBS/services/NetMHCpan-4.1/NetMHCpan.cf',\n",
99 | " 'inp': 0,\n",
100 | " 'SEQPASTE': 'NLVPMVATV',\n",
101 | " 'master': 1,\n",
102 | " 'thrs': 0.5,\n",
103 | " 'thrw': 2,\n",
104 | " 'threshold': -99\n",
105 | " }\n",
106 | "r = requests.post(url, data=post_data) # тут хранится ответ\n",
107 | "type(r) # видим, что этот ответ упакован в экземпляр класса Response,\n",
108 | " # который находится в папке (или файле) models, который находится в папке\n",
109 | " # (папка всего модуля) requests"
110 | ],
111 | "execution_count": null,
112 | "outputs": [
113 | {
114 | "output_type": "execute_result",
115 | "data": {
116 | "text/plain": [
117 | "requests.models.Response"
118 | ]
119 | },
120 | "metadata": {
121 | "tags": []
122 | },
123 | "execution_count": 73
124 | }
125 | ]
126 | },
127 | {
128 | "cell_type": "code",
129 | "metadata": {
130 | "id": "sN9wj7GVqA_d"
131 | },
132 | "source": [
133 | "# Вот кстати все методы (функции) и атрибуты (свойства),\n",
134 | "# которые есть у этого объекта:\n",
135 | "\n",
136 | "# dir(r)"
137 | ],
138 | "execution_count": 1,
139 | "outputs": []
140 | },
141 | {
142 | "cell_type": "markdown",
143 | "metadata": {
144 | "id": "qFu_C5DCrusV"
145 | },
146 | "source": [
147 | "#### Среди всех прочих есть метод `.content`, по которому получаем ответ сервера в виде строки, которая является `html` размеченным текстом\n",
148 | "\n",
149 | "На этом движке взаимодействие с пользователем устроено так: сначала вы посылаете POST запрос и получаете ответ (это мы сделали). В этом ответе вам приходит информация о `jobid` - набор символов и букв, который вы (пользователи) посылаете уже другому скрипту-обработчику уже методом GET (просто в адресной строке). Мы достаем адрес второго обработчика из `r`, оттуда же достаем `jobid` и снова используем модуль `requests` для создания уже запроса GET:"
150 | ]
151 | },
152 | {
153 | "cell_type": "code",
154 | "metadata": {
155 | "colab": {
156 | "base_uri": "https://localhost:8080/"
157 | },
158 | "id": "-BR-NRSumHSc",
159 | "outputId": "74856b19-38ed-467f-893b-82e7653fe1eb"
160 | },
161 | "source": [
162 | "link = r.content[-120:-45] # адрес второго обработчика (он такой же как и первый)\n",
163 | " # с приделанными к нему данными методом GET - в форме\n",
164 | " # 'key: value' после знака '?'\n",
165 | "print(link)\n",
166 | "jobid = link[-24:]\n",
167 | "url2 = link[:-31]\n",
168 | "print(jobid)\n",
169 | "print(url2)"
170 | ],
171 | "execution_count": null,
172 | "outputs": [
173 | {
174 | "output_type": "stream",
175 | "text": [
176 | "b'http://www.cbs.dtu.dk//cgi-bin/webface2.fcgi?jobid=6101365800005B22C53E54DA'\n",
177 | "b'6101365800005B22C53E54DA'\n",
178 | "b'http://www.cbs.dtu.dk//cgi-bin/webface2.fcgi'\n"
179 | ],
180 | "name": "stdout"
181 | }
182 | ]
183 | },
184 | {
185 | "cell_type": "markdown",
186 | "metadata": {
187 | "id": "wZoa0z_At_B0"
188 | },
189 | "source": [
190 | "#### Ну и наконец создаем новый запрос GET:\n",
191 | "\n",
192 | "Почему именно такой запрос, я узнал опять же просмотрев submitted form data в браузере, как описано по ссылкам выше"
193 | ]
194 | },
195 | {
196 | "cell_type": "code",
197 | "metadata": {
198 | "id": "WxkEswry5P-x"
199 | },
200 | "source": [
201 | "get_data = {'jobid': jobid,\n",
202 | " 'wait' : '20'\n",
203 | " }\n",
204 | "result = requests.get(url2, params=get_data)"
205 | ],
206 | "execution_count": null,
207 | "outputs": []
208 | },
209 | {
210 | "cell_type": "code",
211 | "metadata": {
212 | "id": "3Bcn_vZ65VId",
213 | "colab": {
214 | "base_uri": "https://localhost:8080/"
215 | },
216 | "outputId": "d379f2cc-a56a-4393-9099-3267c7d1a06d"
217 | },
218 | "source": [
219 | "result.content # тут находится нужный нам ответ в виде html строки"
220 | ],
221 | "execution_count": null,
222 | "outputs": [
223 | {
224 | "output_type": "execute_result",
225 | "data": {
226 | "text/plain": [
227 | "b'\\n![](\"/images/m_logo.gif\"){kind=logo} \\n | \\n | NetMHCpan Server - prediction results\\nTechnical University of Denmark\\n |