├── LICENSE ├── Labs ├── Lab1.ipynb ├── Lab2.ipynb ├── Lab3.ipynb ├── Lab3_argparse.ipynb ├── Lab3_numpy.ipynb ├── Lab4.ipynb ├── Lab4_symbolic.ipynb ├── Lab5.ipynb └── img │ └── Lab1 │ └── ChatGPT.png ├── Lectures ├── 00_podstawy.ipynb ├── 01_typy_liczbowe.ipynb ├── 02_funkcje.ipynb ├── 03_napisy.ipynb ├── 04_kolekcje.ipynb ├── 05_obiektowość_i_dziedziczenie.ipynb ├── 06_klasy_specjalne.ipynb ├── 07_wyjątki.ipynb ├── 08_generatory_i_iteratory.ipynb ├── 09_context_manager.ipynb ├── 10_pliki.ipynb ├── 11_dekoratory.ipynb ├── 12_type_hints.ipynb ├── 13_moduły_i_pakiety.ipynb ├── 14_idiomy_i_wzorce_projektowe.ipynb ├── 15_wątki_i_procesy.ipynb ├── 16_wyrażenia_regularne.ipynb ├── 17_django.ipynb ├── 50_misc.ipynb └── img │ ├── AdafruitTrinket.jpg │ ├── JSON.jpg │ ├── Observer.webp │ ├── OccamsRazor.jpeg │ ├── cl_atr.png │ ├── guido1.jpg │ ├── img040.gif │ ├── img041.gif │ ├── long_words.jpg │ ├── obj_atr.png │ └── okay-thats-it-everyone-out-of-the-gene-pool.jpg └── README.md /LICENSE: -------------------------------------------------------------------------------- 1 | © 2013 Krzysztof Dorosz, AGH 2 | 3 | Wszystkie kontrybucje do materiałów wiążą się automatycznie 4 | z udzieleniem nieodpłatnie i bezterminowo pełnych praw na 5 | wszystkich polach eksploatacji dla wyżej wymienionego autora. 6 | -------------------------------------------------------------------------------- /Labs/Lab1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "2e0620b4", 6 | "metadata": { 7 | "slideshow": { 8 | "slide_type": "slide" 9 | } 10 | }, 11 | "source": [ 12 | "# Język Python - Laboratorium 1." 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "id": "fa8fb2bd", 18 | "metadata": {}, 19 | "source": [ 20 | "### dr inż. Zbigniew Kaleta\n", 21 | "#### zkaleta@agh.edu.pl\n", 22 | "#### 4.60 @ D17\n", 23 | "#### Zapraszam do kontaktu mailowego" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "id": "0034ca74", 29 | "metadata": { 30 | "slideshow": { 31 | "slide_type": "slide" 32 | } 33 | }, 34 | "source": [ 35 | "## Zasady oceny\n", 36 | "\n", 37 | "### Kryteria oceniania\n", 38 | "- zakres funkcjonalności\n", 39 | "- intuicyjność użytkowania\n", 40 | "- czytelność kodu\n", 41 | "- adekwatność użytych rozwiązań\n", 42 | "- sposób pracy (terminowość)\n", 43 | "\n", 44 | "Wszystkie kryteria są oceniane w skali 2, 3, 4, 5.\n", 45 | "\n", 46 | "Jeśli 2 lub więcej kryteriów jest ocenione na 2, to ocena za projekt wynosi 2.0.\n", 47 | "\n", 48 | "W przeciwnym przypadku jest średnią ocen za wszystkie kryteria, zaokrągloną do najbliższej oceny regulaminowej.\n", 49 | "\n", 50 | "Ocena może zostać podniesiona o 0.5 na zasadzie vox populi, pod warunkiem że jest pozytywna.\n", 51 | "\n", 52 | "Będzie możliwość wykonania dodatkowego zadania na koniec semestru w celu podniesienia oceny o 0.5.\n", 53 | "\n", 54 | "Dopuszczalna jest jedna nieusprawiedliwiona nieobecność." 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "id": "d418da0c", 60 | "metadata": { 61 | "slideshow": { 62 | "slide_type": "slide" 63 | } 64 | }, 65 | "source": [ 66 | "## Harmonogram zajęć\n", 67 | "\n", 68 | "*Slajd celowo pozostawiony pusty*" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "id": "7e97e4ea", 74 | "metadata": { 75 | "slideshow": { 76 | "slide_type": "slide" 77 | } 78 | }, 79 | "source": [ 80 | "### Harmonogram projektu" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "id": "55cc6d7f", 86 | "metadata": { 87 | "slideshow": { 88 | "slide_type": "subslide" 89 | } 90 | }, 91 | "source": [ 92 | "Harmonogram **trzeba** oddać w postaci **papierowej** na 2. zajęciach.\n", 93 | "\n", 94 | "Proszę oddać taki harmonogram, jaki Państwo by sami chcieli dostać." 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "id": "9b5338c8", 100 | "metadata": { 101 | "slideshow": { 102 | "slide_type": "slide" 103 | } 104 | }, 105 | "source": [ 106 | "#### Dobry harmonogram\n", 107 | "\n", 108 | "Jan Kowalski, Zbigniew Nowak\n", 109 | "\n", 110 | "#### Tetris\n", 111 | "\n", 112 | "||Jan Kowalski|Zbigniew Nowak|\n", 113 | "|--|:--|:--|\n", 114 | "|3.|Obsługa menu głównego|Obsługa spadania klocków|\n", 115 | "|4.|Lista najwyższych wyników|Obracanie klocków|\n", 116 | "|5.|Poziomy trudności|Likwidowanie rządków i liczenie punktów|\n", 117 | "|6.|Wczytywanie skórek|Klocki specjalne|\n", 118 | "|7.|Finalne poprawki|Finalne poprawki|" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "id": "77996c41", 124 | "metadata": { 125 | "slideshow": { 126 | "slide_type": "subslide" 127 | } 128 | }, 129 | "source": [ 130 | "#### Zły harmonogram\n", 131 | "\n", 132 | "- mechanika gry tetris z klockami specjalnymi i poziomami trudności\n", 133 | "- lista najwyższych wyników\n", 134 | "- skórki\n", 135 | "- menu główne" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "id": "24c7c913", 141 | "metadata": { 142 | "slideshow": { 143 | "slide_type": "slide" 144 | } 145 | }, 146 | "source": [ 147 | "### Prezentacja projektu grupie\n", 148 | "\n", 149 | "Na 6. zajęciach każdy zespół będzie miał 75 // liczba_zespołów minut na zaprezentowanie swojego projektu grupie.\n", 150 | "\n", 151 | "Wszystkie chwyty dozwolone.\n", 152 | "\n", 153 | "Jeden projekt, wybrany w głosowaniu, będzie miał ocenę podniesioną o 0.5 (jeśli to możliwe).\n", 154 | "\n", 155 | "Należy też przygotować 1 slajd \"reklamujący\" swój projekt.\n", 156 | "\n", 157 | "https://www.jetbrains.com/pycharm/\n", 158 | "\n", 159 | "https://www.office.com/?cosmicflight=cosmicredirect\n", 160 | "\n", 161 | "https://visualstudio.microsoft.com/\n", 162 | "\n", 163 | "https://www.gimp.org/\n" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "id": "b16c83e4", 169 | "metadata": { 170 | "slideshow": { 171 | "slide_type": "slide" 172 | } 173 | }, 174 | "source": [ 175 | "### Podsumowanie projektu\n", 176 | "\n", 177 | "Na ostatnich zajęciach **każdy** (każda osoba, nie zespół) oddaje krótkie podsumowanie projektu, zawierające swój indywidualny wkład i wyciągnięte wnioski (co było zrobione dobrze, a co można było zrobić lepiej - nie chodzi o to co można jeszcze poprawić w tym projekcie, tylko co zrobić inaczej (albo właśnie tak samo) w następnym).\n", 178 | "\n", 179 | "Oddanie podsumowania jest warunkiem **sine qua non** uzyskania pozytywnej oceny." 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "id": "3e3fd721", 185 | "metadata": { 186 | "slideshow": { 187 | "slide_type": "slide" 188 | } 189 | }, 190 | "source": [ 191 | "## Git\n", 192 | "\n", 193 | "https://try.github.io/\n", 194 | "\n", 195 | "https://gitexercises.fracz.com/\n", 196 | "\n", 197 | "https://www.youtube.com/watch?v=USjZcfj8yxE\n", 198 | "\n", 199 | ".gitignore" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "id": "8ed74bda", 205 | "metadata": { 206 | "slideshow": { 207 | "slide_type": "slide" 208 | } 209 | }, 210 | "source": [ 211 | "## PyPI i Pip" 212 | ] 213 | }, 214 | { 215 | "cell_type": "markdown", 216 | "id": "d34e9a47", 217 | "metadata": { 218 | "slideshow": { 219 | "slide_type": "fragment" 220 | } 221 | }, 222 | "source": [ 223 | "$ pip3 install <package-name>" 224 | ] 225 | }, 226 | { 227 | "cell_type": "markdown", 228 | "id": "71520b04", 229 | "metadata": {}, 230 | "source": [ 231 | "$ pip3 install --user <package-name>" 232 | ] 233 | }, 234 | { 235 | "cell_type": "markdown", 236 | "id": "f2a6ddc6", 237 | "metadata": { 238 | "slideshow": { 239 | "slide_type": "fragment" 240 | } 241 | }, 242 | "source": [ 243 | "$ pip3 install --user git+https://<URL>" 244 | ] 245 | }, 246 | { 247 | "cell_type": "markdown", 248 | "id": "9ff92644", 249 | "metadata": { 250 | "slideshow": { 251 | "slide_type": "fragment" 252 | } 253 | }, 254 | "source": [ 255 | "$ pip3 install --upgrade <package-name>" 256 | ] 257 | }, 258 | { 259 | "cell_type": "markdown", 260 | "id": "cd425973", 261 | "metadata": { 262 | "slideshow": { 263 | "slide_type": "fragment" 264 | } 265 | }, 266 | "source": [ 267 | "$ pip3 uninstall --yes <package-name>" 268 | ] 269 | }, 270 | { 271 | "cell_type": "markdown", 272 | "id": "11bbba35", 273 | "metadata": { 274 | "slideshow": { 275 | "slide_type": "subslide" 276 | } 277 | }, 278 | "source": [ 279 | "$ pip3 freeze > requirements.txt" 280 | ] 281 | }, 282 | { 283 | "cell_type": "markdown", 284 | "id": "c7fc7827", 285 | "metadata": { 286 | "slideshow": { 287 | "slide_type": "fragment" 288 | } 289 | }, 290 | "source": [ 291 | "$ pip3 install -r requirements.txt" 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "id": "d0a0e29c", 297 | "metadata": { 298 | "slideshow": { 299 | "slide_type": "subslide" 300 | } 301 | }, 302 | "source": [ 303 | "#### Patrz także:\n", 304 | "- conda\n", 305 | "- pipenv\n", 306 | "- poetry\n", 307 | "- hatch" 308 | ] 309 | }, 310 | { 311 | "cell_type": "markdown", 312 | "id": "1d3f98e3", 313 | "metadata": { 314 | "slideshow": { 315 | "slide_type": "subslide" 316 | } 317 | }, 318 | "source": [ 319 | "https://janakiev.com/blog/jupyter-virtual-envs/" 320 | ] 321 | }, 322 | { 323 | "cell_type": "markdown", 324 | "id": "eea8a3fc", 325 | "metadata": { 326 | "slideshow": { 327 | "slide_type": "slide" 328 | } 329 | }, 330 | "source": [ 331 | "## Virtualenv" 332 | ] 333 | }, 334 | { 335 | "cell_type": "markdown", 336 | "id": "065e87b8", 337 | "metadata": {}, 338 | "source": [ 339 | "[https://virtualenv.pypa.io/en/latest/]" 340 | ] 341 | }, 342 | { 343 | "cell_type": "markdown", 344 | "id": "4a20fb69", 345 | "metadata": {}, 346 | "source": [ 347 | "Virtualenv to narzędzie do tworzenia i zarządzania środowiskami wirtualnymi (duh) w Pythonie. Każde środowisko może mieć własny interpreter i zestaw bibliotek.\n", 348 | "Część viertualenv'a została włączona do standardu Pythona jako moduł venv." 349 | ] 350 | }, 351 | { 352 | "cell_type": "markdown", 353 | "id": "48944708", 354 | "metadata": { 355 | "slideshow": { 356 | "slide_type": "subslide" 357 | } 358 | }, 359 | "source": [ 360 | "$ virtualenv <dirname>" 361 | ] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "id": "06cf6769", 366 | "metadata": { 367 | "slideshow": { 368 | "slide_type": "fragment" 369 | } 370 | }, 371 | "source": [ 372 | "$ virtualenv --python /usr/bin/python3 --system-site-packages --always-copy <dirname>\n", 373 | "\n", 374 | "--relocatable" 375 | ] 376 | }, 377 | { 378 | "cell_type": "markdown", 379 | "id": "185d9984", 380 | "metadata": { 381 | "slideshow": { 382 | "slide_type": "fragment" 383 | } 384 | }, 385 | "source": [ 386 | "$ source <dirname>/bin/activate" 387 | ] 388 | }, 389 | { 390 | "cell_type": "markdown", 391 | "id": "08566927", 392 | "metadata": { 393 | "slideshow": { 394 | "slide_type": "fragment" 395 | } 396 | }, 397 | "source": [ 398 | "$ deactivate" 399 | ] 400 | }, 401 | { 402 | "cell_type": "markdown", 403 | "id": "9bd462e1", 404 | "metadata": { 405 | "slideshow": { 406 | "slide_type": "slide" 407 | } 408 | }, 409 | "source": [ 410 | "## Importowanie i funkcja dir" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": null, 416 | "id": "9dad90c4", 417 | "metadata": { 418 | "scrolled": true 419 | }, 420 | "outputs": [], 421 | "source": [ 422 | "import math\n", 423 | "from math import sqrt\n", 424 | "\n", 425 | "print(\"Global\", dir(), end=\"\\n\\n\")\n", 426 | "print(\"Module\", dir(math), end=\"\\n\\n\")\n", 427 | "print(\"?\", dir('math'), end=\"\\n\\n\")\n", 428 | "\n", 429 | "def f():\n", 430 | " a = 3\n", 431 | " print(\"Local\", dir())\n", 432 | " b = 4\n", 433 | "\n", 434 | "f()" 435 | ] 436 | }, 437 | { 438 | "cell_type": "markdown", 439 | "id": "b77e8eb5", 440 | "metadata": { 441 | "slideshow": { 442 | "slide_type": "slide" 443 | } 444 | }, 445 | "source": [ 446 | "## Błędy w programie\n", 447 | "\n", 448 | "*Slajd celowo pozostawiony pusty*" 449 | ] 450 | }, 451 | { 452 | "cell_type": "markdown", 453 | "id": "993851f0", 454 | "metadata": { 455 | "slideshow": { 456 | "slide_type": "slide" 457 | } 458 | }, 459 | "source": [ 460 | "## Materiały\n", 461 | "\n", 462 | "https://github.com/agh-glk/python-lecture" 463 | ] 464 | }, 465 | { 466 | "cell_type": "markdown", 467 | "id": "669c89ca", 468 | "metadata": { 469 | "slideshow": { 470 | "slide_type": "slide" 471 | } 472 | }, 473 | "source": [ 474 | "## Tematy projektów\n", 475 | "- gry\n", 476 | "- aplikacje webowe (Django/Flask)\n", 477 | "- aplikacje narzędziowe\n", 478 | "- biblioteki\n", 479 | "- aplikacje mobilne (?)" 480 | ] 481 | }, 482 | { 483 | "cell_type": "markdown", 484 | "id": "73c0f634", 485 | "metadata": { 486 | "slideshow": { 487 | "slide_type": "subslide" 488 | } 489 | }, 490 | "source": [ 491 | "### Ciekawe tematy z poprzednich lat:\n", 492 | "- system do przeprowadzania turniejów sumo\n", 493 | "- Szachy vs. World\n", 494 | "- program do tworzenia drzew genealogicznych z myślą o postępowaniach spadkowych\n", 495 | "- program do projektowania tras na ściance wspinaczkowej\n", 496 | "- program do komponowania i śledzenia treningów\n", 497 | "- panel dla nauczyciela tańca\n", 498 | "- aplikacja do śledzenia diety\n", 499 | "- frontend dla systemu akademika\n", 500 | "- aplikacja typu kalendarz / lista rzeczy do zrobienia" 501 | ] 502 | }, 503 | { 504 | "cell_type": "markdown", 505 | "id": "31119a5c", 506 | "metadata": { 507 | "slideshow": { 508 | "slide_type": "subslide" 509 | } 510 | }, 511 | "source": [ 512 | "Uwaga na frameworki i biblioteki" 513 | ] 514 | }, 515 | { 516 | "cell_type": "markdown", 517 | "id": "59615bf6", 518 | "metadata": { 519 | "slideshow": { 520 | "slide_type": "subslide" 521 | } 522 | }, 523 | "source": [ 524 | "![Czy można używać Chata GPT?](img/Lab1/ChatGPT.png)" 525 | ] 526 | }, 527 | { 528 | "cell_type": "markdown", 529 | "id": "a4f5546b", 530 | "metadata": {}, 531 | "source": [ 532 | "## Curriculum vitae\n", 533 | "\n", 534 | "### John Iksinsky\n", 535 | "\n", 536 | "#### Języki programowania:\n", 537 | "- wszystkie\n", 538 | "\n", 539 | "#### Umiejętności:\n", 540 | "- przeklejanie poleceń do ChataGPT\n", 541 | "- szybkie naciskanie tabulatora\n", 542 | "- metoda Copy'ego-Paste'a" 543 | ] 544 | } 545 | ], 546 | "metadata": { 547 | "kernelspec": { 548 | "display_name": "Python 3 (ipykernel)", 549 | "language": "python", 550 | "name": "python3" 551 | }, 552 | "language_info": { 553 | "codemirror_mode": { 554 | "name": "ipython", 555 | "version": 3 556 | }, 557 | "file_extension": ".py", 558 | "mimetype": "text/x-python", 559 | "name": "python", 560 | "nbconvert_exporter": "python", 561 | "pygments_lexer": "ipython3", 562 | "version": "3.12.3" 563 | } 564 | }, 565 | "nbformat": 4, 566 | "nbformat_minor": 5 567 | } 568 | -------------------------------------------------------------------------------- /Labs/Lab2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python - Laboratorium 2." 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "slide" 19 | } 20 | }, 21 | "source": [ 22 | "## Logowanie wykonania programu" 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "https://docs.python.org/3/howto/logging.html" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [ 38 | "import logging\n", 39 | "print(\"Hello, logging\")" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": null, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "logging.critical(\"A\")\n", 49 | "logging.error(\"B\")\n", 50 | "logging.warning(\"C\")\n", 51 | "logging.info(\"D\")\n", 52 | "logging.debug(\"E\")" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": { 59 | "slideshow": { 60 | "slide_type": "subslide" 61 | } 62 | }, 63 | "outputs": [], 64 | "source": [ 65 | "logging.basicConfig(level=logging.DEBUG)" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "logging.critical(\"A\")\n", 75 | "logging.error(\"B\")\n", 76 | "logging.warning(\"C\")\n", 77 | "logging.info(\"D\")\n", 78 | "logging.debug(\"E\")" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": { 85 | "slideshow": { 86 | "slide_type": "subslide" 87 | } 88 | }, 89 | "outputs": [], 90 | "source": [ 91 | "from importlib import reload\n", 92 | "reload(logging)\n", 93 | "logging.basicConfig(level=logging.DEBUG, style=\"{\", format=\"{levelname}:{levelno}:{message}:{module}:{funcName}\")" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [ 102 | "logging.critical(\"A\")\n", 103 | "logging.error(\"B\")\n", 104 | "logging.warning(\"C\")\n", 105 | "def foo():\n", 106 | " logging.info(\"D\")\n", 107 | " logging.debug(\"E\")\n", 108 | "foo()" 109 | ] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "metadata": { 114 | "slideshow": { 115 | "slide_type": "subslide" 116 | } 117 | }, 118 | "source": [ 119 | "Inne konfigurowalne opcje:\n", 120 | "- filename\n", 121 | "- filemode - ustawione na \"w\" powoduje nadpisanie pliku\n", 122 | "- format\n", 123 | "- style - `%`, `{` lub `$` (tak jak printf, str.format oraz string.Template)\n", 124 | "- datefmt - format daty https://docs.python.org/2/library/datetime.html#strftime-strptime-behavior\n", 125 | "\n", 126 | "https://docs.python.org/3/library/logging.html#logging.basicConfig\n", 127 | "\n", 128 | "Format może zawierać\n", 129 | "- levelname, levelno - poziom (%s)\n", 130 | "- message (%s)\n", 131 | "- asctime - czas wydarzenia w czytelnej postaci (%s)\n", 132 | "- created - czas wydarzenia w nieczytelnej postaci (%f)\n", 133 | "- module, filename\n", 134 | "- funcName\n", 135 | "- lineno - numer linii (%d)\n", 136 | "\n", 137 | "https://docs.python.org/3/library/logging.html#logrecord-attributes" 138 | ] 139 | }, 140 | { 141 | "cell_type": "markdown", 142 | "metadata": { 143 | "slideshow": { 144 | "slide_type": "slide" 145 | } 146 | }, 147 | "source": [ 148 | "## Testy jednostkowe" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "https://docs.python.org/3/library/unittest.html" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": null, 161 | "metadata": { 162 | "slideshow": { 163 | "slide_type": "subslide" 164 | } 165 | }, 166 | "outputs": [], 167 | "source": [ 168 | "assert False, \"False is not True\"" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": null, 174 | "metadata": { 175 | "slideshow": { 176 | "slide_type": "subslide" 177 | } 178 | }, 179 | "outputs": [], 180 | "source": [ 181 | "import unittest\n", 182 | "\n", 183 | "class MyTest(unittest.TestCase):\n", 184 | " def test_equality(self):\n", 185 | " self.assertEqual(1, 2 - 1)\n", 186 | " self.assertAlmostEqual(0.3, 0.1 + 0.1 + 0.1)\n", 187 | " self.assertTupleEqual((1, 2), (2, 1)[::-1])\n", 188 | " \n", 189 | " def test_truth(self):\n", 190 | " self.assertTrue(True)\n", 191 | " self.assertFalse(False)\n", 192 | " \n", 193 | " def test_exception(self):\n", 194 | " self.assertRaises(TypeError, sorted, 1)\n", 195 | "\n", 196 | "# if __name__ == \"__main__\":\n", 197 | "# unittest.main()" 198 | ] 199 | }, 200 | { 201 | "cell_type": "raw", 202 | "metadata": {}, 203 | "source": [ 204 | "python some_test.py\n", 205 | "python -m unittest some_test.py" 206 | ] 207 | } 208 | ], 209 | "metadata": { 210 | "celltoolbar": "Slideshow", 211 | "kernelspec": { 212 | "display_name": "Python 3 (ipykernel)", 213 | "language": "python", 214 | "name": "python3" 215 | }, 216 | "language_info": { 217 | "codemirror_mode": { 218 | "name": "ipython", 219 | "version": 3 220 | }, 221 | "file_extension": ".py", 222 | "mimetype": "text/x-python", 223 | "name": "python", 224 | "nbconvert_exporter": "python", 225 | "pygments_lexer": "ipython3", 226 | "version": "3.12.3" 227 | } 228 | }, 229 | "nbformat": 4, 230 | "nbformat_minor": 2 231 | } 232 | -------------------------------------------------------------------------------- /Labs/Lab3.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Język Python - Laboratorium 3.\n", 8 | "## Numpy" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "http://cs231n.github.io/python-numpy-tutorial/ -> sekcja Numpy\n", 16 | "\n", 17 | "https://docs.scipy.org/doc/numpy/user/quickstart.html" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": null, 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "import numpy as np" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "### Macierze (i wektory)" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "v = np.array([1, 3, 2])\n", 43 | "print(v)" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": null, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [ 52 | "v = np.array([1, 3, \"hello\"])\n", 53 | "print(v)\n", 54 | "print(type(v)) # elementy muszą mieć wspólny typ\n", 55 | "print(v.dtype)" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "v[1] = 4 # konwersja jest możliwa, więc działa\n", 65 | "print(v)" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "v = np.array([1, 3, 2])\n", 75 | "print(v)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "v[1] = \"hello\" # konwersja nie jest możliwa\n", 85 | "print(v)" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [ 94 | "v[3] = 1 # wyjście poza zakres - analogicznie do list" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "print(v.ndim)\n", 104 | "print(v.shape)" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": null, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | "v = v.reshape((1, 3)) # (1, 3) to nie to samo co (3,)\n", 114 | "print(v)\n", 115 | "print(v.ndim)\n", 116 | "v = v.reshape((3, 1)) # (3, 1) tym bardziej\n", 117 | "print(v)\n", 118 | "print(v.ndim)" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "A = np.ones((4,4)) # == np.full((4,4), 1)\n", 128 | "print(A)" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": null, 134 | "metadata": {}, 135 | "outputs": [], 136 | "source": [ 137 | "np.empty((2,4), dtype=np.complex) # pusta = cokolwiek było w pamięci" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [ 146 | "M = np.eye(4) # macierz jednostkowa\n", 147 | "print(M)" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [ 156 | "M[0, 1] = 2 # można też M[0][1], tylko po co?\n", 157 | "M[1, 2] = 4\n", 158 | "print(M)" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": null, 164 | "metadata": {}, 165 | "outputs": [], 166 | "source": [ 167 | "np.arange(10).reshape((3,-1)) # arange to array range, nie mylić z arrange" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "### Typy danych\n", 175 | "- int\n", 176 | "- int0, int8, int16, int32, int64\n", 177 | "- float\n", 178 | "- float_, float16, float32, float64, float128\n", 179 | "- complex\n", 180 | "- complex64, complex128, complex256\n", 181 | "- bool\n", 182 | "- bool_, bool8\n" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": null, 188 | "metadata": {}, 189 | "outputs": [], 190 | "source": [ 191 | "v[1] = 2**64 # ograniczenie C\n", 192 | "print(v)" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": null, 198 | "metadata": {}, 199 | "outputs": [], 200 | "source": [ 201 | "np.bool is bool" 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "### Operacje na macierzach" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": null, 214 | "metadata": {}, 215 | "outputs": [], 216 | "source": [ 217 | "M + 1" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": null, 223 | "metadata": {}, 224 | "outputs": [], 225 | "source": [ 226 | "3 * M" 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": null, 232 | "metadata": {}, 233 | "outputs": [], 234 | "source": [ 235 | "print(A)" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": {}, 242 | "outputs": [], 243 | "source": [ 244 | "M + A" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": null, 250 | "metadata": {}, 251 | "outputs": [], 252 | "source": [ 253 | "M * A" 254 | ] 255 | }, 256 | { 257 | "cell_type": "markdown", 258 | "metadata": {}, 259 | "source": [ 260 | "np.exp, np.sin, np.cos, np.abs" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": null, 266 | "metadata": {}, 267 | "outputs": [], 268 | "source": [ 269 | "np.exp(np.eye(3))" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": null, 275 | "metadata": {}, 276 | "outputs": [], 277 | "source": [ 278 | "M.dot(A)" 279 | ] 280 | }, 281 | { 282 | "cell_type": "code", 283 | "execution_count": null, 284 | "metadata": {}, 285 | "outputs": [], 286 | "source": [ 287 | "M @ A" 288 | ] 289 | }, 290 | { 291 | "cell_type": "code", 292 | "execution_count": null, 293 | "metadata": {}, 294 | "outputs": [], 295 | "source": [ 296 | "M.T" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": null, 302 | "metadata": {}, 303 | "outputs": [], 304 | "source": [ 305 | "M *= np.arange(4).reshape((1, 4))\n", 306 | "print(M)" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": null, 312 | "metadata": {}, 313 | "outputs": [], 314 | "source": [ 315 | "A *= np.array([1, 2, 3, 5])\n", 316 | "print(A)" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": null, 322 | "metadata": { 323 | "scrolled": true 324 | }, 325 | "outputs": [], 326 | "source": [ 327 | "A == M # nie używać w if'ach" 328 | ] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": null, 333 | "metadata": {}, 334 | "outputs": [], 335 | "source": [ 336 | "if A == M:\n", 337 | " print(\"Są równe\")" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": null, 343 | "metadata": {}, 344 | "outputs": [], 345 | "source": [ 346 | "np.all(A == M)" 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": null, 352 | "metadata": {}, 353 | "outputs": [], 354 | "source": [ 355 | "np.any(A == M)" 356 | ] 357 | }, 358 | { 359 | "cell_type": "markdown", 360 | "metadata": {}, 361 | "source": [ 362 | "### Wydajność" 363 | ] 364 | }, 365 | { 366 | "cell_type": "code", 367 | "execution_count": null, 368 | "metadata": { 369 | "scrolled": true 370 | }, 371 | "outputs": [], 372 | "source": [ 373 | "from itertools import product\n", 374 | "import time\n", 375 | "\n", 376 | "SIZE = 10000\n", 377 | "\n", 378 | "X = np.arange(SIZE**2).reshape((SIZE, SIZE))\n", 379 | "print(X)\n", 380 | "start_time = time.time()\n", 381 | "for i, j in product(range(SIZE), range(SIZE)):\n", 382 | " X[i, j] *= 2\n", 383 | "end_time = time.time()\n", 384 | "print(X)\n", 385 | "print(\"Run time = {}\".format(end_time - start_time))" 386 | ] 387 | }, 388 | { 389 | "cell_type": "code", 390 | "execution_count": null, 391 | "metadata": {}, 392 | "outputs": [], 393 | "source": [ 394 | "Y = np.arange(SIZE**2).reshape((SIZE, SIZE))\n", 395 | "start_time = time.time()\n", 396 | "Y *= 2\n", 397 | "end_time = time.time()\n", 398 | "print(\"Run time = {}\".format(end_time - start_time))\n", 399 | "np.all(X == Y)" 400 | ] 401 | }, 402 | { 403 | "cell_type": "markdown", 404 | "metadata": {}, 405 | "source": [ 406 | "### Indeksowanie" 407 | ] 408 | }, 409 | { 410 | "cell_type": "code", 411 | "execution_count": null, 412 | "metadata": {}, 413 | "outputs": [], 414 | "source": [ 415 | "M[1, :]" 416 | ] 417 | }, 418 | { 419 | "cell_type": "code", 420 | "execution_count": null, 421 | "metadata": {}, 422 | "outputs": [], 423 | "source": [ 424 | "M[1:3, :]" 425 | ] 426 | }, 427 | { 428 | "cell_type": "code", 429 | "execution_count": null, 430 | "metadata": {}, 431 | "outputs": [], 432 | "source": [ 433 | "M[1:2, :]" 434 | ] 435 | }, 436 | { 437 | "cell_type": "code", 438 | "execution_count": null, 439 | "metadata": {}, 440 | "outputs": [], 441 | "source": [ 442 | "M[:, 2]" 443 | ] 444 | }, 445 | { 446 | "cell_type": "code", 447 | "execution_count": null, 448 | "metadata": {}, 449 | "outputs": [], 450 | "source": [ 451 | "N = np.empty((3, 3, 3))\n", 452 | "print(N[..., 1])" 453 | ] 454 | }, 455 | { 456 | "cell_type": "code", 457 | "execution_count": null, 458 | "metadata": {}, 459 | "outputs": [], 460 | "source": [ 461 | "A.sum()" 462 | ] 463 | }, 464 | { 465 | "cell_type": "code", 466 | "execution_count": null, 467 | "metadata": {}, 468 | "outputs": [], 469 | "source": [ 470 | "np.arange(16).reshape((4,4)).sum(axis=0)" 471 | ] 472 | }, 473 | { 474 | "cell_type": "markdown", 475 | "metadata": {}, 476 | "source": [ 477 | "### Ciekawostki" 478 | ] 479 | }, 480 | { 481 | "cell_type": "markdown", 482 | "metadata": {}, 483 | "source": [ 484 | "https://docs.scipy.org/doc/numpy/user/quickstart.html#indexing-with-arrays-of-indices" 485 | ] 486 | }, 487 | { 488 | "cell_type": "code", 489 | "execution_count": null, 490 | "metadata": {}, 491 | "outputs": [], 492 | "source": [ 493 | "palette = np.array( [ [0, 0, 0], # black\n", 494 | " [255, 0, 0], # red\n", 495 | " [0, 255, 0], # green\n", 496 | " [0, 0, 255], # blue\n", 497 | " [255, 255, 255] ] ) # white" 498 | ] 499 | }, 500 | { 501 | "cell_type": "code", 502 | "execution_count": null, 503 | "metadata": {}, 504 | "outputs": [], 505 | "source": [ 506 | "image = np.array( [ [ 0, 1, 2, 0 ], # each value corresponds to a color in the palette\n", 507 | " [ 0, 3, 4, 0 ] ] )" 508 | ] 509 | }, 510 | { 511 | "cell_type": "code", 512 | "execution_count": null, 513 | "metadata": {}, 514 | "outputs": [], 515 | "source": [ 516 | "palette[image] # the (2,4,3) color image" 517 | ] 518 | }, 519 | { 520 | "cell_type": "markdown", 521 | "metadata": {}, 522 | "source": [ 523 | "### Algebra liniowa" 524 | ] 525 | }, 526 | { 527 | "cell_type": "code", 528 | "execution_count": null, 529 | "metadata": {}, 530 | "outputs": [], 531 | "source": [ 532 | "A = np.array([[1, 2], [3, 4]])\n", 533 | "print(np.linalg.det(A))" 534 | ] 535 | }, 536 | { 537 | "cell_type": "code", 538 | "execution_count": null, 539 | "metadata": {}, 540 | "outputs": [], 541 | "source": [ 542 | "B = np.linalg.inv(A)\n", 543 | "print(B)\n", 544 | "print(A.dot(B))\n", 545 | "print(B.dot(A))" 546 | ] 547 | }, 548 | { 549 | "cell_type": "code", 550 | "execution_count": null, 551 | "metadata": {}, 552 | "outputs": [], 553 | "source": [ 554 | "np.linalg.eig(A)" 555 | ] 556 | }, 557 | { 558 | "cell_type": "markdown", 559 | "metadata": {}, 560 | "source": [ 561 | "### Losowość\n", 562 | "\n", 563 | "https://numpy.org/doc/stable/reference/random/generator.html#distributions" 564 | ] 565 | }, 566 | { 567 | "cell_type": "code", 568 | "execution_count": null, 569 | "metadata": {}, 570 | "outputs": [], 571 | "source": [ 572 | "dir(np.random.default_rng())" 573 | ] 574 | }, 575 | { 576 | "cell_type": "code", 577 | "execution_count": null, 578 | "metadata": {}, 579 | "outputs": [], 580 | "source": [ 581 | "np.random.default_rng().gamma(1, 1, 100)" 582 | ] 583 | }, 584 | { 585 | "cell_type": "markdown", 586 | "metadata": {}, 587 | "source": [ 588 | "## Zadania:\n", 589 | "- Napisz program, który konwertuje pozycję odczytaną z GPSu na pozycję do wyświetlenia na mapie na ekranie (możesz założyć równoległość południków)\n", 590 | "- Zaimplementuj algorytm PageRank: (http://www.ams.org/samplings/feature-column/fcarc-pagerank, http://www.rose-hulman.edu/%7Ebryan/googleFinalVersionFixed.pdf)" 591 | ] 592 | } 593 | ], 594 | "metadata": { 595 | "kernelspec": { 596 | "display_name": "aspectPairsML", 597 | "language": "python", 598 | "name": "aspectpairsml" 599 | }, 600 | "language_info": { 601 | "codemirror_mode": { 602 | "name": "ipython", 603 | "version": 3 604 | }, 605 | "file_extension": ".py", 606 | "mimetype": "text/x-python", 607 | "name": "python", 608 | "nbconvert_exporter": "python", 609 | "pygments_lexer": "ipython3", 610 | "version": "3.9.5" 611 | } 612 | }, 613 | "nbformat": 4, 614 | "nbformat_minor": 2 615 | } 616 | -------------------------------------------------------------------------------- /Labs/Lab3_argparse.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python - Laboratorium 3." 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": { 17 | "slideshow": { 18 | "slide_type": "slide" 19 | } 20 | }, 21 | "source": [ 22 | "## Parametry z linii poleceń" 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "### Zadanie\n", 30 | "\n", 31 | "Dany jest program z dziedziny uczenia maszynowego. Należy napisać kod, który wczyta z linii poleceń następujące parametry:\n", 32 | "- dane treningowe\n", 33 | "- dane testowe\n", 34 | "- opcjonalnie plik wyjściowy (domyślnie wyniki będą wypisywane na ekran)\n", 35 | "- opcjonalnie plik z modelem (przyjmujemy, że jest jakiś plik, którego używamy domyślnie)\n", 36 | "- algorytm (do wyboru spośród RNN, LSTM i CNN)\n", 37 | "- ile przykładów negatywnych należy wygenerować (dowolna nieujemna liczba całkowita)\n", 38 | "- rozmiar warstwy ukrytej (do wyboru spośród 100, 150 i 300)" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "python ml.py --algorithm RNN --negative 10 --hidden 100 train.csv test.csv" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": { 51 | "slideshow": { 52 | "slide_type": "subslide" 53 | } 54 | }, 55 | "source": [ 56 | "### sys.argv\n", 57 | "- porównywanie stringów (operator `==`)\n", 58 | "- operator `in`\n", 59 | "- metoda `index`" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": { 65 | "slideshow": { 66 | "slide_type": "subslide" 67 | } 68 | }, 69 | "source": [ 70 | "### argparse\n", 71 | "\n", 72 | "- pobiera i analizuje argumenty wywołania\n", 73 | "- zastępuje przestarzały moduł optparse\n", 74 | "- alternatywa dla getopt (vide: C) oraz ręcznego analizowania zmiennej sys.argv\n", 75 | "- zarządza:\n", 76 | " - parametrami pozycyjnymi\n", 77 | " - parametrami opcjonalnymi (flagami) w wersji krótkiej i długiej\n", 78 | " - tekstem pomocy informującym o prawidłowym użyciu (w reakcji na opcję -h/--help)\n", 79 | " - komunikatem o błędnym wywołaniu" 80 | ] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": null, 85 | "metadata": { 86 | "slideshow": { 87 | "slide_type": "subslide" 88 | } 89 | }, 90 | "outputs": [], 91 | "source": [ 92 | "import sys # potrzebne dla ręcznej modyfikacji sys.argv; w przypadku uruchamiania z konsoli można usunąć\n", 93 | "import argparse\n", 94 | "\n", 95 | "# nie róbcie tego w domu\n", 96 | "def exit(*args, **kwargs):\n", 97 | " print(\"Program exited with {} and {}\".format(args, kwargs))\n", 98 | " \n", 99 | "sys.exit = exit" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": null, 105 | "metadata": { 106 | "slideshow": { 107 | "slide_type": "subslide" 108 | } 109 | }, 110 | "outputs": [], 111 | "source": [ 112 | "sys.argv = ['script.py','-h']\n", 113 | "parser = argparse.ArgumentParser()\n", 114 | "parser.parse_args()" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": null, 120 | "metadata": { 121 | "slideshow": { 122 | "slide_type": "fragment" 123 | } 124 | }, 125 | "outputs": [], 126 | "source": [ 127 | "sys.argv = ['script.py', '-c']\n", 128 | "parser = argparse.ArgumentParser()\n", 129 | "parser.parse_args()" 130 | ] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": { 135 | "slideshow": { 136 | "slide_type": "subslide" 137 | } 138 | }, 139 | "source": [ 140 | "- Argumenty pozycyjne są rozróżniane na podstawie miejsca w linii komend, gdzie występują\n", 141 | "- Argumenty opcjonalne (flagi) są rozróżniane na podstawie nazwy lub jej jednoznacznego prefixu\n", 142 | "- Jedne i drugie dodajemy wywołując komendę add_argument i przekazując jej nazwę argumentu\n", 143 | "- Dostęp do pobranych parametrów odbywa się poprzez obiekt Namespace, zwrócony przez metodę parse_args\n", 144 | " - zwrócony obiekt ma pola, których nazwy odpowiadają pierwszej długiej nazwie (lub pierwsze w ogóle, jesli nie ma długiej - dotyczy argumentów opcjonalnych)" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": null, 150 | "metadata": {}, 151 | "outputs": [], 152 | "source": [ 153 | "sys.argv = ['script.py', 'file.txt']\n", 154 | "parser = argparse.ArgumentParser()\n", 155 | "parser.add_argument(\"input_file\")\n", 156 | "args = parser.parse_args()\n", 157 | "print(args.input_file)" 158 | ] 159 | }, 160 | { 161 | "cell_type": "markdown", 162 | "metadata": { 163 | "slideshow": { 164 | "slide_type": "subslide" 165 | } 166 | }, 167 | "source": [ 168 | "Parametr `nargs` oznacza liczbę argumentów danego typu. Może przyjmować następujące wartości:\n", 169 | "\n", 170 | " - liczbę - program wymaga dokładnie takiej liczby parametrów\n", 171 | " - \"?\" - parametr jest opcjonalny (może wystąpić raz lub nie wystąpić)\n", 172 | " - \"*\" - parametr może wystąpić dowolną liczbę razy, lub nie wystąpić\n", 173 | " - \"+\" - parametr może wystąpić dowolną liczbę razy, ale minimum jeden\n", 174 | " - argparse.REMAINDER - parametr będzie zawierał wszystko \"zbędne\" z linii komend (np. celem przekazania do innego programu); musi to być ostatni parametr dodany do parsera\n", 175 | "\n", 176 | "Domyślnie równe 1\n", 177 | "\n", 178 | "Flaga nie jest parametrem" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": { 185 | "slideshow": { 186 | "slide_type": "subslide" 187 | } 188 | }, 189 | "outputs": [], 190 | "source": [ 191 | "sys.argv = ['script.py', 'file.txt', 'file1.txt', 'file2.txt']\n", 192 | "parser = argparse.ArgumentParser()\n", 193 | "parser.add_argument(\"input_files\", nargs=\"+\", help=\"Tekst pomocy\")\n", 194 | "parser.add_argument(\"output_file\")\n", 195 | "args = parser.parse_args()\n", 196 | "print(args.input_files, args.output_file)" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": { 203 | "slideshow": { 204 | "slide_type": "fragment" 205 | } 206 | }, 207 | "outputs": [], 208 | "source": [ 209 | "sys.argv = ['script.py', '-h']\n", 210 | "parser.parse_args()" 211 | ] 212 | }, 213 | { 214 | "cell_type": "markdown", 215 | "metadata": { 216 | "slideshow": { 217 | "slide_type": "subslide" 218 | } 219 | }, 220 | "source": [ 221 | "Parametr `action` oznacza akcję do wykonania:\n", 222 | "\n", 223 | " - \"store\" - zapisz przekazaną wartość (domyślnie)\n", 224 | " - \"store_const\", \"store_true\", \"store_false\" - zapisz stałą wartość (dla store_const należy dodać parametr const, okreslający wartość do zapisania)\n", 225 | " - \"append\" - dopisz wartość do listy\n", 226 | " - \"count\" - zlicz wystąpienia" 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": null, 232 | "metadata": { 233 | "slideshow": { 234 | "slide_type": "-" 235 | } 236 | }, 237 | "outputs": [], 238 | "source": [ 239 | "parser = argparse.ArgumentParser()\n", 240 | "parser.add_argument(\"-v\", \"--verbose\", action='store_true')\n", 241 | "\n", 242 | "sys.argv = ['script.py', '-v']\n", 243 | "print(parser.parse_args())\n", 244 | "\n", 245 | "sys.argv = ['script.py']\n", 246 | "print(parser.parse_args())" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": null, 252 | "metadata": { 253 | "slideshow": { 254 | "slide_type": "subslide" 255 | } 256 | }, 257 | "outputs": [], 258 | "source": [ 259 | "parser = argparse.ArgumentParser()\n", 260 | "parser.add_argument(\"-v\", \"-V\", \"--verbose\", action=\"count\", help=\"Makes output of program more verbose\")\n", 261 | "\n", 262 | "sys.argv = ['script.py','-vv','--ver']\n", 263 | "print(parser.parse_args())\n", 264 | "\n", 265 | "print(\"---\")\n", 266 | "\n", 267 | "sys.argv = ['script.py','-h']\n", 268 | "print(parser.parse_args())" 269 | ] 270 | }, 271 | { 272 | "cell_type": "markdown", 273 | "metadata": { 274 | "slideshow": { 275 | "slide_type": "subslide" 276 | } 277 | }, 278 | "source": [ 279 | "Parametr `default`" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": null, 285 | "metadata": { 286 | "slideshow": { 287 | "slide_type": "-" 288 | } 289 | }, 290 | "outputs": [], 291 | "source": [ 292 | "parser = argparse.ArgumentParser()\n", 293 | "parser.add_argument(\"-o\", \"--output_file\", default=\"a.out\")\n", 294 | "\n", 295 | "sys.argv = ['script.py', '-o', 'output.file']\n", 296 | "print(parser.parse_args())\n", 297 | "print(\"---\")\n", 298 | "\n", 299 | "sys.argv = ['script.py']\n", 300 | "print(parser.parse_args())\n", 301 | "print(\"---\")\n", 302 | "\n", 303 | "sys.argv = ['script.py', '-o']\n", 304 | "print(parser.parse_args())" 305 | ] 306 | }, 307 | { 308 | "cell_type": "markdown", 309 | "metadata": { 310 | "slideshow": { 311 | "slide_type": "subslide" 312 | } 313 | }, 314 | "source": [ 315 | "`type` określa typ argumentu (albo argumentów). Najczęściej używamy `int` albo `float`, ale możemy definiować własne.\n", 316 | "\n", 317 | "Właściwie możemy użyć też `list`, `tuple` itp. ale jest to mało użyteczne (jak działa konwersja stringa na krotkę?).\n", 318 | "\n", 319 | "Może to być też nazwa klasy, pod warunkiem, że konstruktor przyjmuje jednego stringa." 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": null, 325 | "metadata": {}, 326 | "outputs": [], 327 | "source": [ 328 | "parser = argparse.ArgumentParser()\n", 329 | "parser.add_argument(\"-d\")\n", 330 | "\n", 331 | "sys.argv = ['script.py','-d', '3']\n", 332 | "args = parser.parse_args() \n", 333 | "print(args)\n", 334 | "print(type(args.d))\n", 335 | "\n", 336 | "parser = argparse.ArgumentParser()\n", 337 | "parser.add_argument(\"-d\", type=int)\n", 338 | "\n", 339 | "sys.argv = ['script.py','-d', '3']\n", 340 | "args = parser.parse_args() \n", 341 | "print(args)\n", 342 | "print(type(args.d))\n", 343 | "\n", 344 | "sys.argv = ['script.py','-d', '3.5']\n", 345 | "print(parser.parse_args())" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": null, 351 | "metadata": { 352 | "slideshow": { 353 | "slide_type": "subslide" 354 | } 355 | }, 356 | "outputs": [], 357 | "source": [ 358 | "def filename(arg):\n", 359 | " try:\n", 360 | " with open(arg, \"r\"):\n", 361 | " pass\n", 362 | " except OSError:\n", 363 | " raise argparse.ArgumentTypeError(\"File {!r} cannot be opened\".format(arg))\n", 364 | " return arg\n", 365 | " \n", 366 | "parser = argparse.ArgumentParser()\n", 367 | "parser.add_argument(\"infile\", type=filename)\n", 368 | "print(parser.parse_args(['no_such_file.txt']))" 369 | ] 370 | }, 371 | { 372 | "cell_type": "code", 373 | "execution_count": null, 374 | "metadata": { 375 | "scrolled": true, 376 | "slideshow": { 377 | "slide_type": "subslide" 378 | } 379 | }, 380 | "outputs": [], 381 | "source": [ 382 | "def filename(arg):\n", 383 | " with open(arg, \"r\"):\n", 384 | " return arg\n", 385 | " \n", 386 | "parser = argparse.ArgumentParser()\n", 387 | "parser.add_argument(\"infile\", type=filename)\n", 388 | "print(parser.parse_args(['no_such_file.txt']))" 389 | ] 390 | }, 391 | { 392 | "cell_type": "markdown", 393 | "metadata": { 394 | "slideshow": { 395 | "slide_type": "subslide" 396 | } 397 | }, 398 | "source": [ 399 | "Inne opcjonalne parametry dla `add_argument`\n", 400 | "- `metavar` - alternatywna nazwa argumentu do wyświetlenia w tekście pomocy, np. do tłumaczenia na inny język (w Jupyter notebook'u nie działa)\n", 401 | "- `choices` - lista wartości jakie może przyjmować argument" 402 | ] 403 | }, 404 | { 405 | "cell_type": "markdown", 406 | "metadata": { 407 | "slideshow": { 408 | "slide_type": "subslide" 409 | } 410 | }, 411 | "source": [ 412 | "`add_mutually_exclusive_group` - tworzy grupę parametrów, które nie mogą współwystępować" 413 | ] 414 | }, 415 | { 416 | "cell_type": "code", 417 | "execution_count": null, 418 | "metadata": {}, 419 | "outputs": [], 420 | "source": [ 421 | "import sys\n", 422 | "import argparse\n", 423 | "\n", 424 | "parser = argparse.ArgumentParser()\n", 425 | "group = parser.add_mutually_exclusive_group()\n", 426 | "group.add_argument(\"-v\", \"--verbose\", action=\"store_true\")\n", 427 | "group.add_argument(\"-q\", \"--quiet\", action=\"store_true\")\n", 428 | "print(parser.parse_args([])) # można przekazać listę parametrów do funkcji parse_args\n", 429 | "print(parser.parse_args(['-q']))\n", 430 | "print(parser.parse_args(['-q','-v']))" 431 | ] 432 | }, 433 | { 434 | "cell_type": "markdown", 435 | "metadata": { 436 | "slideshow": { 437 | "slide_type": "subslide" 438 | } 439 | }, 440 | "source": [ 441 | "### Tap (Typed Argument Parser)" 442 | ] 443 | }, 444 | { 445 | "cell_type": "markdown", 446 | "metadata": {}, 447 | "source": [ 448 | "https://pypi.org/project/typed-argument-parser/\n", 449 | "\n", 450 | "Można instalować jako typed-argument-parser, **nie tap**" 451 | ] 452 | }, 453 | { 454 | "cell_type": "code", 455 | "execution_count": null, 456 | "metadata": {}, 457 | "outputs": [], 458 | "source": [ 459 | "from tap import Tap as TypedArgumentParser\n", 460 | "\n", 461 | "class MyArgs(TypedArgumentParser):\n", 462 | " a: float = 1 # acceleration\n", 463 | " pi: int = 3.14 # what value of pi should we use\n", 464 | " input_filename: str # file to read\n", 465 | " \n", 466 | "args = MyArgs().parse_args([\"--input_filename\", \"log.log\"])\n", 467 | "print(args)" 468 | ] 469 | }, 470 | { 471 | "cell_type": "markdown", 472 | "metadata": { 473 | "slideshow": { 474 | "slide_type": "subslide" 475 | } 476 | }, 477 | "source": [ 478 | "### Click" 479 | ] 480 | }, 481 | { 482 | "cell_type": "code", 483 | "execution_count": null, 484 | "metadata": {}, 485 | "outputs": [], 486 | "source": [ 487 | "import sys\n", 488 | "\n", 489 | "sys.argv = \"main.py --help\".split()\n", 490 | "\n", 491 | "# źródło: https://click.palletsprojects.com/en/7.x/\n", 492 | "\n", 493 | "import click\n", 494 | "\n", 495 | "@click.command()\n", 496 | "@click.option('--count', default=1, help='Number of greetings.')\n", 497 | "@click.option('--name', prompt='Your name',\n", 498 | " help='The person to greet.')\n", 499 | "def hello(count, name):\n", 500 | " \"\"\"Simple program that greets NAME for a total of COUNT times.\"\"\"\n", 501 | " for x in range(count):\n", 502 | " click.echo('Hello %s!' % name)\n", 503 | "\n", 504 | "if __name__ == '__main__':\n", 505 | " hello()" 506 | ] 507 | }, 508 | { 509 | "cell_type": "markdown", 510 | "metadata": { 511 | "slideshow": { 512 | "slide_type": "subslide" 513 | } 514 | }, 515 | "source": [ 516 | "https://towardsdatascience.com/how-to-write-python-command-line-interfaces-like-a-pro-f782450caf0d" 517 | ] 518 | } 519 | ], 520 | "metadata": { 521 | "celltoolbar": "Slideshow", 522 | "kernelspec": { 523 | "display_name": "Python 3 (ipykernel)", 524 | "language": "python", 525 | "name": "python3" 526 | }, 527 | "language_info": { 528 | "codemirror_mode": { 529 | "name": "ipython", 530 | "version": 3 531 | }, 532 | "file_extension": ".py", 533 | "mimetype": "text/x-python", 534 | "name": "python", 535 | "nbconvert_exporter": "python", 536 | "pygments_lexer": "ipython3", 537 | "version": "3.9.5" 538 | } 539 | }, 540 | "nbformat": 4, 541 | "nbformat_minor": 2 542 | } 543 | -------------------------------------------------------------------------------- /Labs/Lab4.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python - Laboratorium 4.\n", 12 | "## Numpy" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": {}, 18 | "source": [ 19 | "http://cs231n.github.io/python-numpy-tutorial/ -> sekcja Numpy\n", 20 | "\n", 21 | "https://docs.scipy.org/doc/numpy/user/quickstart.html" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": { 28 | "slideshow": { 29 | "slide_type": "subslide" 30 | } 31 | }, 32 | "outputs": [], 33 | "source": [ 34 | "import numpy as np" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": { 40 | "slideshow": { 41 | "slide_type": "slide" 42 | } 43 | }, 44 | "source": [ 45 | "### Macierze (i wektory)" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": null, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "v = np.array([1, 3, 2])\n", 55 | "print(v)\n", 56 | "print(v.dtype)" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": { 63 | "slideshow": { 64 | "slide_type": "-" 65 | } 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "v = np.array([1, 3, \"hello\"])\n", 70 | "print(v)\n", 71 | "print(type(v))\n", 72 | "print(v.dtype)" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "v[1] = 4\n", 82 | "print(v)" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": { 89 | "slideshow": { 90 | "slide_type": "subslide" 91 | } 92 | }, 93 | "outputs": [], 94 | "source": [ 95 | "v = np.array([1, 3, 2])\n", 96 | "print(v)" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": null, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [ 105 | "v[1] = \"hello\"\n", 106 | "print(v)" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "v[3] = 1" 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": null, 121 | "metadata": { 122 | "slideshow": { 123 | "slide_type": "subslide" 124 | } 125 | }, 126 | "outputs": [], 127 | "source": [ 128 | "print(v.ndim)\n", 129 | "print(v.shape)" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": { 136 | "slideshow": { 137 | "slide_type": "-" 138 | } 139 | }, 140 | "outputs": [], 141 | "source": [ 142 | "v = v.reshape((1, 3))\n", 143 | "# v = v.reshape((1, -1))\n", 144 | "print(v)\n", 145 | "print(v.ndim)\n", 146 | "v = v.reshape((3, 1))\n", 147 | "print(v)\n", 148 | "print(v.ndim)" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": null, 154 | "metadata": { 155 | "slideshow": { 156 | "slide_type": "skip" 157 | } 158 | }, 159 | "outputs": [], 160 | "source": [ 161 | "A = np.ones((4,4)) # == np.full((4,4), 1)\n", 162 | "print(A)" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": null, 168 | "metadata": { 169 | "slideshow": { 170 | "slide_type": "skip" 171 | } 172 | }, 173 | "outputs": [], 174 | "source": [ 175 | "np.empty((2,4), dtype=np.complex)" 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": null, 181 | "metadata": { 182 | "slideshow": { 183 | "slide_type": "skip" 184 | } 185 | }, 186 | "outputs": [], 187 | "source": [ 188 | "M = np.eye(4)\n", 189 | "print(M)" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": { 196 | "slideshow": { 197 | "slide_type": "skip" 198 | } 199 | }, 200 | "outputs": [], 201 | "source": [ 202 | "np.arange(10).reshape((3,-1))" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": { 208 | "slideshow": { 209 | "slide_type": "slide" 210 | } 211 | }, 212 | "source": [ 213 | "### Typy danych\n", 214 | "- int\n", 215 | "- int0, int8, int16, int32, int64\n", 216 | "- float\n", 217 | "- float_, float16, float32, float64, float128\n", 218 | "- complex\n", 219 | "- complex64, complex128, complex256\n", 220 | "- bool\n", 221 | "- bool_, bool8\n" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "metadata": { 228 | "slideshow": { 229 | "slide_type": "fragment" 230 | } 231 | }, 232 | "outputs": [], 233 | "source": [ 234 | "np.bool is bool" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": null, 240 | "metadata": { 241 | "slideshow": { 242 | "slide_type": "fragment" 243 | } 244 | }, 245 | "outputs": [], 246 | "source": [ 247 | "v[1] = 2**64\n", 248 | "print(v)" 249 | ] 250 | }, 251 | { 252 | "cell_type": "markdown", 253 | "metadata": { 254 | "slideshow": { 255 | "slide_type": "slide" 256 | } 257 | }, 258 | "source": [ 259 | "### Operacje na macierzach" 260 | ] 261 | }, 262 | { 263 | "cell_type": "code", 264 | "execution_count": null, 265 | "metadata": {}, 266 | "outputs": [], 267 | "source": [ 268 | "M = np.eye(4)\n", 269 | "M[0, 1] = 2\n", 270 | "M[1][2] = 4\n", 271 | "print(M)" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": null, 277 | "metadata": { 278 | "slideshow": { 279 | "slide_type": "-" 280 | } 281 | }, 282 | "outputs": [], 283 | "source": [ 284 | "M + 1" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": null, 290 | "metadata": { 291 | "slideshow": { 292 | "slide_type": "-" 293 | } 294 | }, 295 | "outputs": [], 296 | "source": [ 297 | "3 * M" 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": null, 303 | "metadata": { 304 | "slideshow": { 305 | "slide_type": "subslide" 306 | } 307 | }, 308 | "outputs": [], 309 | "source": [ 310 | "A = np.ones((4,4))\n", 311 | "print(A)" 312 | ] 313 | }, 314 | { 315 | "cell_type": "code", 316 | "execution_count": null, 317 | "metadata": {}, 318 | "outputs": [], 319 | "source": [ 320 | "M + A" 321 | ] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": null, 326 | "metadata": { 327 | "slideshow": { 328 | "slide_type": "-" 329 | } 330 | }, 331 | "outputs": [], 332 | "source": [ 333 | "M * A" 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": null, 339 | "metadata": { 340 | "slideshow": { 341 | "slide_type": "subslide" 342 | } 343 | }, 344 | "outputs": [], 345 | "source": [ 346 | "M.dot(A)" 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": null, 352 | "metadata": { 353 | "slideshow": { 354 | "slide_type": "fragment" 355 | } 356 | }, 357 | "outputs": [], 358 | "source": [ 359 | "M @ A" 360 | ] 361 | }, 362 | { 363 | "cell_type": "code", 364 | "execution_count": null, 365 | "metadata": { 366 | "slideshow": { 367 | "slide_type": "subslide" 368 | } 369 | }, 370 | "outputs": [], 371 | "source": [ 372 | "M.T" 373 | ] 374 | }, 375 | { 376 | "cell_type": "markdown", 377 | "metadata": { 378 | "slideshow": { 379 | "slide_type": "fragment" 380 | } 381 | }, 382 | "source": [ 383 | "np.exp, np.sin, np.cos, np.abs" 384 | ] 385 | }, 386 | { 387 | "cell_type": "code", 388 | "execution_count": null, 389 | "metadata": { 390 | "slideshow": { 391 | "slide_type": "-" 392 | } 393 | }, 394 | "outputs": [], 395 | "source": [ 396 | "np.exp(np.eye(3))" 397 | ] 398 | }, 399 | { 400 | "cell_type": "code", 401 | "execution_count": null, 402 | "metadata": { 403 | "slideshow": { 404 | "slide_type": "subslide" 405 | } 406 | }, 407 | "outputs": [], 408 | "source": [ 409 | "A == M" 410 | ] 411 | }, 412 | { 413 | "cell_type": "code", 414 | "execution_count": null, 415 | "metadata": { 416 | "slideshow": { 417 | "slide_type": "fragment" 418 | } 419 | }, 420 | "outputs": [], 421 | "source": [ 422 | "bool(A)" 423 | ] 424 | }, 425 | { 426 | "cell_type": "code", 427 | "execution_count": null, 428 | "metadata": { 429 | "slideshow": { 430 | "slide_type": "fragment" 431 | } 432 | }, 433 | "outputs": [], 434 | "source": [ 435 | "np.all(A == M)" 436 | ] 437 | }, 438 | { 439 | "cell_type": "code", 440 | "execution_count": null, 441 | "metadata": { 442 | "slideshow": { 443 | "slide_type": "fragment" 444 | } 445 | }, 446 | "outputs": [], 447 | "source": [ 448 | "np.any(A == M)" 449 | ] 450 | }, 451 | { 452 | "cell_type": "code", 453 | "execution_count": null, 454 | "metadata": { 455 | "slideshow": { 456 | "slide_type": "subslide" 457 | } 458 | }, 459 | "outputs": [], 460 | "source": [ 461 | "M *= np.arange(4).reshape((1,4))\n", 462 | "print(M)" 463 | ] 464 | }, 465 | { 466 | "cell_type": "code", 467 | "execution_count": null, 468 | "metadata": { 469 | "slideshow": { 470 | "slide_type": "fragment" 471 | } 472 | }, 473 | "outputs": [], 474 | "source": [ 475 | "A *= np.array([1,2,3,5])\n", 476 | "print(A)" 477 | ] 478 | }, 479 | { 480 | "cell_type": "markdown", 481 | "metadata": { 482 | "slideshow": { 483 | "slide_type": "slide" 484 | } 485 | }, 486 | "source": [ 487 | "#### Broadcasting" 488 | ] 489 | }, 490 | { 491 | "cell_type": "code", 492 | "execution_count": null, 493 | "metadata": {}, 494 | "outputs": [], 495 | "source": [ 496 | "x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\n", 497 | "v = np.array([1, 0, 1])\n", 498 | "y = x + v\n", 499 | "print(y)" 500 | ] 501 | }, 502 | { 503 | "cell_type": "code", 504 | "execution_count": null, 505 | "metadata": {}, 506 | "outputs": [], 507 | "source": [ 508 | "x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\n", 509 | "v = np.array([[1, 0, 1, 0]]).T\n", 510 | "y = x + v\n", 511 | "print(y)" 512 | ] 513 | }, 514 | { 515 | "cell_type": "code", 516 | "execution_count": null, 517 | "metadata": {}, 518 | "outputs": [], 519 | "source": [ 520 | "x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\n", 521 | "v = np.array([[1, 0, 1], [0, 1, 0]])\n", 522 | "y = x + v\n", 523 | "print(y)" 524 | ] 525 | }, 526 | { 527 | "cell_type": "markdown", 528 | "metadata": { 529 | "slideshow": { 530 | "slide_type": "slide" 531 | } 532 | }, 533 | "source": [ 534 | "#### Iterowanie" 535 | ] 536 | }, 537 | { 538 | "cell_type": "code", 539 | "execution_count": null, 540 | "metadata": {}, 541 | "outputs": [], 542 | "source": [ 543 | "for row in M:\n", 544 | " print(row)" 545 | ] 546 | }, 547 | { 548 | "cell_type": "markdown", 549 | "metadata": { 550 | "slideshow": { 551 | "slide_type": "slide" 552 | } 553 | }, 554 | "source": [ 555 | "### Indeksowanie" 556 | ] 557 | }, 558 | { 559 | "cell_type": "code", 560 | "execution_count": null, 561 | "metadata": {}, 562 | "outputs": [], 563 | "source": [ 564 | "M[1, :]" 565 | ] 566 | }, 567 | { 568 | "cell_type": "code", 569 | "execution_count": null, 570 | "metadata": {}, 571 | "outputs": [], 572 | "source": [ 573 | "M[1:3, :]" 574 | ] 575 | }, 576 | { 577 | "cell_type": "code", 578 | "execution_count": null, 579 | "metadata": {}, 580 | "outputs": [], 581 | "source": [ 582 | "M[1:2, :]" 583 | ] 584 | }, 585 | { 586 | "cell_type": "code", 587 | "execution_count": null, 588 | "metadata": {}, 589 | "outputs": [], 590 | "source": [ 591 | "M[:, 2]" 592 | ] 593 | }, 594 | { 595 | "cell_type": "code", 596 | "execution_count": null, 597 | "metadata": {}, 598 | "outputs": [], 599 | "source": [ 600 | "N = np.empty((3, 3, 3))\n", 601 | "print(N[..., 1])" 602 | ] 603 | }, 604 | { 605 | "cell_type": "code", 606 | "execution_count": null, 607 | "metadata": { 608 | "slideshow": { 609 | "slide_type": "subslide" 610 | } 611 | }, 612 | "outputs": [], 613 | "source": [ 614 | "A.sum()" 615 | ] 616 | }, 617 | { 618 | "cell_type": "code", 619 | "execution_count": null, 620 | "metadata": { 621 | "slideshow": { 622 | "slide_type": "fragment" 623 | } 624 | }, 625 | "outputs": [], 626 | "source": [ 627 | "A" 628 | ] 629 | }, 630 | { 631 | "cell_type": "code", 632 | "execution_count": null, 633 | "metadata": { 634 | "slideshow": { 635 | "slide_type": "fragment" 636 | } 637 | }, 638 | "outputs": [], 639 | "source": [ 640 | "A.sum(axis=0)" 641 | ] 642 | }, 643 | { 644 | "cell_type": "code", 645 | "execution_count": null, 646 | "metadata": { 647 | "slideshow": { 648 | "slide_type": "fragment" 649 | } 650 | }, 651 | "outputs": [], 652 | "source": [ 653 | "A[:, 0]" 654 | ] 655 | }, 656 | { 657 | "cell_type": "code", 658 | "execution_count": null, 659 | "metadata": { 660 | "scrolled": true, 661 | "slideshow": { 662 | "slide_type": "fragment" 663 | } 664 | }, 665 | "outputs": [], 666 | "source": [ 667 | "C = np.arange(27).reshape((3, 3, 3))\n", 668 | "C.sum(axis=0)" 669 | ] 670 | }, 671 | { 672 | "cell_type": "markdown", 673 | "metadata": { 674 | "slideshow": { 675 | "slide_type": "slide" 676 | } 677 | }, 678 | "source": [ 679 | "### Ciekawostki" 680 | ] 681 | }, 682 | { 683 | "cell_type": "markdown", 684 | "metadata": {}, 685 | "source": [ 686 | "https://docs.scipy.org/doc/numpy/user/quickstart.html#indexing-with-arrays-of-indices" 687 | ] 688 | }, 689 | { 690 | "cell_type": "code", 691 | "execution_count": null, 692 | "metadata": {}, 693 | "outputs": [], 694 | "source": [ 695 | "palette = np.array( [ [0,0,0], # black\n", 696 | " [255,0,0], # red\n", 697 | " [0,255,0], # green\n", 698 | " [0,0,255], # blue\n", 699 | " [255,255,255] ] ) # white" 700 | ] 701 | }, 702 | { 703 | "cell_type": "code", 704 | "execution_count": null, 705 | "metadata": {}, 706 | "outputs": [], 707 | "source": [ 708 | "image = np.array( [ [ 0, 1, 2, 0 ], # each value corresponds to a color in the palette\n", 709 | " [ 0, 3, 4, 0 ] ] )" 710 | ] 711 | }, 712 | { 713 | "cell_type": "code", 714 | "execution_count": null, 715 | "metadata": {}, 716 | "outputs": [], 717 | "source": [ 718 | "palette[image] # the (2,4,3) color image" 719 | ] 720 | }, 721 | { 722 | "cell_type": "markdown", 723 | "metadata": { 724 | "slideshow": { 725 | "slide_type": "slide" 726 | } 727 | }, 728 | "source": [ 729 | "### Algebra liniowa" 730 | ] 731 | }, 732 | { 733 | "cell_type": "code", 734 | "execution_count": null, 735 | "metadata": {}, 736 | "outputs": [], 737 | "source": [ 738 | "A = np.array([[1.0, 2], [3, 4]])\n", 739 | "print(np.linalg.det(A))" 740 | ] 741 | }, 742 | { 743 | "cell_type": "code", 744 | "execution_count": null, 745 | "metadata": { 746 | "scrolled": true 747 | }, 748 | "outputs": [], 749 | "source": [ 750 | "B = np.linalg.inv(A)\n", 751 | "print(B)\n", 752 | "print(A.dot(B))\n", 753 | "print(B.dot(A))" 754 | ] 755 | }, 756 | { 757 | "cell_type": "code", 758 | "execution_count": null, 759 | "metadata": { 760 | "scrolled": true 761 | }, 762 | "outputs": [], 763 | "source": [ 764 | "np.linalg.eig(A)" 765 | ] 766 | }, 767 | { 768 | "cell_type": "markdown", 769 | "metadata": { 770 | "slideshow": { 771 | "slide_type": "slide" 772 | } 773 | }, 774 | "source": [ 775 | "### Losowość" 776 | ] 777 | }, 778 | { 779 | "cell_type": "code", 780 | "execution_count": null, 781 | "metadata": {}, 782 | "outputs": [], 783 | "source": [ 784 | "[name for name in dir(np.random) if name[0] != \"_\"]" 785 | ] 786 | }, 787 | { 788 | "cell_type": "markdown", 789 | "metadata": { 790 | "slideshow": { 791 | "slide_type": "slide" 792 | } 793 | }, 794 | "source": [ 795 | "## Zadania:\n", 796 | "- Napisz program, który konwertuje pozycję odczytaną z GPSu na pozycję do wyświetlenia na mapie na ekranie (możesz założyć równoległość południków)\n", 797 | "- Zaimplementuj algorytm PageRank: (http://www.ams.org/samplings/feature-column/fcarc-pagerank, http://www.rose-hulman.edu/%7Ebryan/googleFinalVersionFixed.pdf)" 798 | ] 799 | } 800 | ], 801 | "metadata": { 802 | "celltoolbar": "Slideshow", 803 | "kernelspec": { 804 | "display_name": "aspectPairsML", 805 | "language": "python", 806 | "name": "aspectpairsml" 807 | }, 808 | "language_info": { 809 | "codemirror_mode": { 810 | "name": "ipython", 811 | "version": 3 812 | }, 813 | "file_extension": ".py", 814 | "mimetype": "text/x-python", 815 | "name": "python", 816 | "nbconvert_exporter": "python", 817 | "pygments_lexer": "ipython3", 818 | "version": "3.8.5" 819 | } 820 | }, 821 | "nbformat": 4, 822 | "nbformat_minor": 2 823 | } 824 | -------------------------------------------------------------------------------- /Labs/Lab4_symbolic.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python - Laboratorium 4." 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "## Obliczenia symboliczne" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "### Zadanie\n", 26 | "Napisać program sprowadzający wyrażenie logiczne do najprostszej postaci.\n", 27 | "\n", 28 | "Wyrażenie może zawierać:\n", 29 | "- zmienne logiczne (ciąg znaków alfanumerycznych)\n", 30 | "- operatory: koniunkcji, alternatywy, alternatywy wykluczającej, negacji, implikacji i równoważności\n", 31 | "- stałe logiczne (0 lub 1)\n", 32 | "- spacje\n", 33 | "\n", 34 | "Wyjściem programu ma być wyrażenie logiczne równoważne danemu\n" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": { 40 | "slideshow": { 41 | "slide_type": "slide" 42 | } 43 | }, 44 | "source": [ 45 | "### Składowe wyrażenia logicznego" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "### Sprawdzanie poprawności wyrażenia" 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "### Generowanie wartościowań" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "### Zamiana na odwrotną notację polską" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "### Ewaluacja wyrażeń" 74 | ] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": {}, 79 | "source": [ 80 | "### Sprawdzenie czy wyrażenie jest tautologią" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": {}, 86 | "source": [ 87 | "### Działanie interaktywne" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": null, 93 | "metadata": {}, 94 | "outputs": [], 95 | "source": [] 96 | } 97 | ], 98 | "metadata": { 99 | "kernelspec": { 100 | "display_name": "Python 3", 101 | "language": "python", 102 | "name": "python3" 103 | }, 104 | "language_info": { 105 | "codemirror_mode": { 106 | "name": "ipython", 107 | "version": 3 108 | }, 109 | "file_extension": ".py", 110 | "mimetype": "text/x-python", 111 | "name": "python", 112 | "nbconvert_exporter": "python", 113 | "pygments_lexer": "ipython3", 114 | "version": "3.6.9" 115 | } 116 | }, 117 | "nbformat": 4, 118 | "nbformat_minor": 1 119 | } 120 | -------------------------------------------------------------------------------- /Labs/img/Lab1/ChatGPT.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Labs/img/Lab1/ChatGPT.png -------------------------------------------------------------------------------- /Lectures/01_typy_liczbowe.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "editable": true, 7 | "slideshow": { 8 | "slide_type": "slide" 9 | }, 10 | "tags": [] 11 | }, 12 | "source": [ 13 | "# Język Python\n", 14 | "## Typy liczbowe" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": { 20 | "editable": true, 21 | "slideshow": { 22 | "slide_type": "subslide" 23 | }, 24 | "tags": [] 25 | }, 26 | "source": [ 27 | "### Typy niemodyfikowalne\n", 28 | "![caption](img/img041.gif)" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": { 35 | "editable": true, 36 | "slideshow": { 37 | "slide_type": "subslide" 38 | }, 39 | "tags": [] 40 | }, 41 | "outputs": [], 42 | "source": [ 43 | "a = 1000\n", 44 | "b = a\n", 45 | "a += 1\n", 46 | "print(a, b)" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": { 52 | "slideshow": { 53 | "slide_type": "subslide" 54 | } 55 | }, 56 | "source": [ 57 | "### Typy modyfikowalne\n", 58 | "![caption](img/img040.gif) " 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": { 65 | "editable": true, 66 | "slideshow": { 67 | "slide_type": "subslide" 68 | }, 69 | "tags": [] 70 | }, 71 | "outputs": [], 72 | "source": [ 73 | "a = [1, 2, 3]\n", 74 | "b = a\n", 75 | "a += [4]\n", 76 | "print(a, b)" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": { 83 | "editable": true, 84 | "slideshow": { 85 | "slide_type": "subslide" 86 | }, 87 | "tags": [] 88 | }, 89 | "outputs": [], 90 | "source": [ 91 | "a = [1, 2, 3]\n", 92 | "b = a\n", 93 | "a = a + [4]\n", 94 | "print(a, b)" 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": { 100 | "slideshow": { 101 | "slide_type": "subslide" 102 | } 103 | }, 104 | "source": [ 105 | "## Liczby całkowite\n", 106 | "\n", 107 | "- typ:\n", 108 | "- zakres:\n", 109 | "- operatory:\n", 110 | "- sposoby zapisu:" 111 | ] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": { 116 | "slideshow": { 117 | "slide_type": "subslide" 118 | } 119 | }, 120 | "source": [ 121 | "## Liczby całkowite\n", 122 | "\n", 123 | "- typ: `int`\n", 124 | "- zakres: nieograniczony\n", 125 | "- operatory: `+`, `-`, `*`, `/`, `//`, `%`, `**`, `&`, `|`, `^`, `~`, `<<`, `>>`\n", 126 | "- sposoby zapisu: 100, 0b100, 0o100, 0x100, 1_000_000" 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": null, 132 | "metadata": { 133 | "slideshow": { 134 | "slide_type": "fragment" 135 | } 136 | }, 137 | "outputs": [], 138 | "source": [ 139 | "print(int(\"010101\"))\n", 140 | "print(int(\"010101\", 2))\n", 141 | "print(int(\"010101\", 40))" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": null, 147 | "metadata": { 148 | "slideshow": { 149 | "slide_type": "subslide" 150 | } 151 | }, 152 | "outputs": [], 153 | "source": [ 154 | "print(hex(12))\n", 155 | "print(oct(12))\n", 156 | "print(bin(12))" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": { 163 | "slideshow": { 164 | "slide_type": "subslide" 165 | } 166 | }, 167 | "outputs": [], 168 | "source": [ 169 | "print(4 / 2)\n", 170 | "print(3 / 2)" 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": { 177 | "slideshow": { 178 | "slide_type": "fragment" 179 | } 180 | }, 181 | "outputs": [], 182 | "source": [ 183 | "10**1000/2" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": null, 189 | "metadata": { 190 | "slideshow": { 191 | "slide_type": "fragment" 192 | } 193 | }, 194 | "outputs": [], 195 | "source": [ 196 | "10**1000//2" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": { 203 | "slideshow": { 204 | "slide_type": "fragment" 205 | } 206 | }, 207 | "outputs": [], 208 | "source": [ 209 | "print(int(-4/3), int(-5/3), int(4/3), int(5/3))\n", 210 | "print(-4//3, -5//3, 4//3, 5//3)" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": null, 216 | "metadata": { 217 | "slideshow": { 218 | "slide_type": "subslide" 219 | } 220 | }, 221 | "outputs": [], 222 | "source": [ 223 | "import math\n", 224 | "print(math.ceil(-4/3), math.ceil(-5/3), math.ceil(4/3), math.ceil(5/3))\n", 225 | "print(math.floor(-4/3), math.floor(-5/3), math.floor(4/3), math.floor(5/3))\n", 226 | "print(math.trunc(-4/3), math.trunc(-5/3), math.trunc(4/3), math.trunc(5/3))\n", 227 | "print(round(-4/3), round(-5/3), round(4/3), round(5/3))" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": null, 233 | "metadata": { 234 | "slideshow": { 235 | "slide_type": "fragment" 236 | } 237 | }, 238 | "outputs": [], 239 | "source": [ 240 | "print(round(1.5), round(-1.5))\n", 241 | "print(round(2.5), round(-2.5))" 242 | ] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "metadata": { 247 | "slideshow": { 248 | "slide_type": "fragment" 249 | } 250 | }, 251 | "source": [ 252 | "Więcej o zaokrągleniach: https://realpython.com/python-rounding/" 253 | ] 254 | }, 255 | { 256 | "cell_type": "markdown", 257 | "metadata": { 258 | "slideshow": { 259 | "slide_type": "slide" 260 | } 261 | }, 262 | "source": [ 263 | "## Liczby zmiennoprzecinkowe\n", 264 | "\n", 265 | "- typ: \n", 266 | "- zakres: \n", 267 | "- operatory:\n", 268 | "- sposoby zapisu:" 269 | ] 270 | }, 271 | { 272 | "cell_type": "markdown", 273 | "metadata": { 274 | "slideshow": { 275 | "slide_type": "subslide" 276 | } 277 | }, 278 | "source": [ 279 | "## Liczby zmiennoprzecinkowe\n", 280 | "\n", 281 | "- typ: `float`\n", 282 | "- zakres: +-(2.22e-308 ~ 1.8e308), epsilon 2e-16\n", 283 | "- operatory: `+`, `-`, `*`, `/`, `//`, `%`, `**`\n", 284 | "- sposoby zapisu: 1.23, 1.23e12, 1.23E-12" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": null, 290 | "metadata": { 291 | "slideshow": { 292 | "slide_type": "fragment" 293 | } 294 | }, 295 | "outputs": [], 296 | "source": [ 297 | "print(1 + 1e-15 == 1)\n", 298 | "print(1 + 1e-16 == 1)" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": null, 304 | "metadata": { 305 | "slideshow": { 306 | "slide_type": "fragment" 307 | } 308 | }, 309 | "outputs": [], 310 | "source": [ 311 | "import sys\n", 312 | "sys.float_info" 313 | ] 314 | }, 315 | { 316 | "cell_type": "code", 317 | "execution_count": null, 318 | "metadata": { 319 | "slideshow": { 320 | "slide_type": "subslide" 321 | } 322 | }, 323 | "outputs": [], 324 | "source": [ 325 | "print(1.5 // 0.2)\n", 326 | "print(5.6 // 1.5)\n", 327 | "print(5.6 % 1.5)\n", 328 | "print(round(1.55555, 2)) \n", 329 | "print(round(155.555, -1))" 330 | ] 331 | }, 332 | { 333 | "cell_type": "code", 334 | "execution_count": null, 335 | "metadata": { 336 | "slideshow": { 337 | "slide_type": "fragment" 338 | } 339 | }, 340 | "outputs": [], 341 | "source": [ 342 | "print(round(155.555, 0))\n", 343 | "print(round(155.555))" 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": null, 349 | "metadata": { 350 | "slideshow": { 351 | "slide_type": "slide" 352 | } 353 | }, 354 | "outputs": [], 355 | "source": [ 356 | "type(1j)" 357 | ] 358 | } 359 | ], 360 | "metadata": { 361 | "celltoolbar": "Slideshow", 362 | "kernelspec": { 363 | "display_name": "Python 3 (ipykernel)", 364 | "language": "python", 365 | "name": "python3" 366 | }, 367 | "language_info": { 368 | "codemirror_mode": { 369 | "name": "ipython", 370 | "version": 3 371 | }, 372 | "file_extension": ".py", 373 | "mimetype": "text/x-python", 374 | "name": "python", 375 | "nbconvert_exporter": "python", 376 | "pygments_lexer": "ipython3", 377 | "version": "3.12.3" 378 | } 379 | }, 380 | "nbformat": 4, 381 | "nbformat_minor": 4 382 | } 383 | -------------------------------------------------------------------------------- /Lectures/06_klasy_specjalne.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Klasy \"specjalne\"" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": { 18 | "slideshow": { 19 | "slide_type": "slide" 20 | } 21 | }, 22 | "source": [ 23 | "## Dataclasses\n", 24 | "\n", 25 | "https://docs.python.org/3/library/dataclasses.html" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": { 32 | "slideshow": { 33 | "slide_type": "subslide" 34 | } 35 | }, 36 | "outputs": [], 37 | "source": [ 38 | "from dataclasses import dataclass\n", 39 | "\n", 40 | "@dataclass\n", 41 | "class InventoryItem:\n", 42 | " \"\"\"Class for keeping track of an item in inventory.\"\"\"\n", 43 | " name: str\n", 44 | " unit_price: float\n", 45 | " quantity_on_hand: int = 0\n", 46 | "\n", 47 | " def total_cost(self) -> float:\n", 48 | " return self.unit_price * self.quantity_on_hand" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": { 55 | "slideshow": { 56 | "slide_type": "subslide" 57 | } 58 | }, 59 | "outputs": [], 60 | "source": [ 61 | "item = InventoryItem(\"can of spam\", 2.50, 30)" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": { 68 | "slideshow": { 69 | "slide_type": "subslide" 70 | } 71 | }, 72 | "outputs": [], 73 | "source": [ 74 | "repr(item)" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": { 81 | "slideshow": { 82 | "slide_type": "subslide" 83 | } 84 | }, 85 | "outputs": [], 86 | "source": [ 87 | "item.quantity_on_hand = 28\n", 88 | "repr(item)" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": { 95 | "slideshow": { 96 | "slide_type": "subslide" 97 | } 98 | }, 99 | "outputs": [], 100 | "source": [ 101 | "item2 = InventoryItem(\"can of spam\", 2.50, 28)\n", 102 | "print(item == item2)\n", 103 | "print(item is item2)" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": { 110 | "slideshow": { 111 | "slide_type": "subslide" 112 | } 113 | }, 114 | "outputs": [], 115 | "source": [ 116 | "from dataclasses import dataclass\n", 117 | "\n", 118 | "@dataclass(frozen=True)\n", 119 | "class InventoryItem:\n", 120 | " \"\"\"Class for keeping track of an item in inventory.\"\"\"\n", 121 | " name: str\n", 122 | " unit_price: float\n", 123 | " quantity_on_hand: int = 0\n", 124 | "\n", 125 | " def total_cost(self) -> float:\n", 126 | " return self.unit_price * self.quantity_on_hand\n", 127 | "\n", 128 | "item = InventoryItem(\"can of spam\", 2.50, 30)\n", 129 | "print(item)\n", 130 | "item.quantity_on_hand = 28" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": { 136 | "slideshow": { 137 | "slide_type": "slide" 138 | } 139 | }, 140 | "source": [ 141 | "## Klasy abstrakcyjne?\n", 142 | "\n", 143 | "https://docs.python.org/3/library/abc.html" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "metadata": { 150 | "slideshow": { 151 | "slide_type": "subslide" 152 | } 153 | }, 154 | "outputs": [], 155 | "source": [ 156 | "from abc import ABC, abstractmethod\n", 157 | "\n", 158 | "class A(ABC):\n", 159 | " \n", 160 | " @abstractmethod\n", 161 | " def f():\n", 162 | " pass\n", 163 | " \n", 164 | "a = A()" 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": null, 170 | "metadata": { 171 | "slideshow": { 172 | "slide_type": "subslide" 173 | } 174 | }, 175 | "outputs": [], 176 | "source": [ 177 | "class B(A):\n", 178 | " pass\n", 179 | "\n", 180 | "b = B()" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": null, 186 | "metadata": { 187 | "slideshow": { 188 | "slide_type": "fragment" 189 | } 190 | }, 191 | "outputs": [], 192 | "source": [ 193 | "class B(A):\n", 194 | " \n", 195 | " def f(self):\n", 196 | " pass\n", 197 | " \n", 198 | "b = B()" 199 | ] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "metadata": { 204 | "slideshow": { 205 | "slide_type": "slide" 206 | } 207 | }, 208 | "source": [ 209 | "## Enumeracje\n", 210 | "\n", 211 | "https://docs.python.org/3/library/enum.html" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": null, 217 | "metadata": { 218 | "slideshow": { 219 | "slide_type": "fragment" 220 | } 221 | }, 222 | "outputs": [], 223 | "source": [ 224 | "from enum import Enum\n", 225 | "\n", 226 | "class MapDirection(Enum):\n", 227 | " NORTH = (0, 1)\n", 228 | " EAST = (1, 0)\n", 229 | " SOUTH = (0, -1)\n", 230 | " WEST = (-1, 0)\n", 231 | " \n", 232 | "MapDirection.NORTH" 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": null, 238 | "metadata": { 239 | "slideshow": { 240 | "slide_type": "fragment" 241 | } 242 | }, 243 | "outputs": [], 244 | "source": [ 245 | "from enum import Enum\n", 246 | "\n", 247 | "class MapDirection1:\n", 248 | " NORTH = (0, 1)\n", 249 | " EAST = (1, 0)\n", 250 | " SOUTH = (0, -1)\n", 251 | " WEST = (-1, 0)\n", 252 | " \n", 253 | "MapDirection1.NORTH" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": null, 259 | "metadata": { 260 | "slideshow": { 261 | "slide_type": "subslide" 262 | } 263 | }, 264 | "outputs": [], 265 | "source": [ 266 | "print(MapDirection.NORTH.name)\n", 267 | "print(MapDirection.NORTH.value)\n", 268 | "print(MapDirection.NORTH._name_)\n", 269 | "print(MapDirection.NORTH._value_)\n", 270 | "print(MapDirection.NORTH == (0, 1))" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": null, 276 | "metadata": { 277 | "slideshow": { 278 | "slide_type": "fragment" 279 | } 280 | }, 281 | "outputs": [], 282 | "source": [ 283 | "for direction in MapDirection:\n", 284 | " print(direction)" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": null, 290 | "metadata": { 291 | "slideshow": { 292 | "slide_type": "fragment" 293 | } 294 | }, 295 | "outputs": [], 296 | "source": [ 297 | "MapDirection['NORTH']" 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": null, 303 | "metadata": { 304 | "slideshow": { 305 | "slide_type": "subslide" 306 | } 307 | }, 308 | "outputs": [], 309 | "source": [ 310 | "print(MapDirection((0, 1)))\n", 311 | "print(MapDirection((1, 1)))" 312 | ] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": { 317 | "slideshow": { 318 | "slide_type": "subslide" 319 | } 320 | }, 321 | "source": [ 322 | "- enumeracje są hashowalne\n", 323 | "- zduplikowanie wartości tworzy alias" 324 | ] 325 | }, 326 | { 327 | "cell_type": "code", 328 | "execution_count": null, 329 | "metadata": { 330 | "slideshow": { 331 | "slide_type": "subslide" 332 | } 333 | }, 334 | "outputs": [], 335 | "source": [ 336 | "from enum import Enum, auto, unique\n", 337 | "\n", 338 | "@unique\n", 339 | "class Month(Enum):\n", 340 | " JAN = auto()\n", 341 | " FEB = auto()\n", 342 | " MAR = auto()\n", 343 | " # (...)\n", 344 | " \n", 345 | "print(Month.JAN.value)" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": null, 351 | "metadata": { 352 | "slideshow": { 353 | "slide_type": "subslide" 354 | } 355 | }, 356 | "outputs": [], 357 | "source": [ 358 | "from enum import Flag\n", 359 | "\n", 360 | "class Perm(Flag):\n", 361 | " READ = 4\n", 362 | " WRITE = 2\n", 363 | " EXEC = 1\n", 364 | " \n", 365 | "print(Perm.READ)\n", 366 | "RW = Perm.READ | Perm.WRITE\n", 367 | "print(RW)\n", 368 | "print(type(RW))\n", 369 | "print(RW.value)\n", 370 | "print(RW in Perm)\n", 371 | "print(Perm.READ & Perm.WRITE)\n", 372 | "print(Perm(7))" 373 | ] 374 | }, 375 | { 376 | "cell_type": "markdown", 377 | "metadata": { 378 | "slideshow": { 379 | "slide_type": "subslide" 380 | } 381 | }, 382 | "source": [ 383 | "Patrz także: IntEnum, IntFlag" 384 | ] 385 | }, 386 | { 387 | "cell_type": "code", 388 | "execution_count": null, 389 | "metadata": { 390 | "slideshow": { 391 | "slide_type": "fragment" 392 | } 393 | }, 394 | "outputs": [], 395 | "source": [ 396 | "Perm.READ > Perm.WRITE" 397 | ] 398 | }, 399 | { 400 | "cell_type": "markdown", 401 | "metadata": { 402 | "slideshow": { 403 | "slide_type": "slide" 404 | } 405 | }, 406 | "source": [ 407 | "## Mixin\n", 408 | "\n", 409 | "https://stackoverflow.com/questions/533631/what-is-a-mixin-and-why-are-they-useful" 410 | ] 411 | }, 412 | { 413 | "cell_type": "code", 414 | "execution_count": null, 415 | "metadata": { 416 | "slideshow": { 417 | "slide_type": "subslide" 418 | } 419 | }, 420 | "outputs": [], 421 | "source": [ 422 | "class FooMixin():\n", 423 | "\n", 424 | " def foo(self):\n", 425 | " print(\"fooo\")" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": null, 431 | "metadata": { 432 | "slideshow": { 433 | "slide_type": "subslide" 434 | } 435 | }, 436 | "outputs": [], 437 | "source": [ 438 | "class Point2D():\n", 439 | " \n", 440 | " def __init__(self, x, y):\n", 441 | " self.x = x\n", 442 | " self.y = y\n", 443 | " \n", 444 | " def r(self):\n", 445 | " return (self.x**2 + self.y**2)**0.5" 446 | ] 447 | }, 448 | { 449 | "cell_type": "code", 450 | "execution_count": null, 451 | "metadata": { 452 | "slideshow": { 453 | "slide_type": "subslide" 454 | } 455 | }, 456 | "outputs": [], 457 | "source": [ 458 | "p1 = Point2D(2, 2)\n", 459 | "p1.r()" 460 | ] 461 | }, 462 | { 463 | "cell_type": "code", 464 | "execution_count": null, 465 | "metadata": { 466 | "slideshow": { 467 | "slide_type": "subslide" 468 | } 469 | }, 470 | "outputs": [], 471 | "source": [ 472 | "class Point2Dmix(FooMixin, Point2D):\n", 473 | " pass\n", 474 | "\n", 475 | "p2 = Point2Dmix(3, 3)\n", 476 | "p2.foo()\n", 477 | "p2.r()" 478 | ] 479 | }, 480 | { 481 | "cell_type": "markdown", 482 | "metadata": { 483 | "slideshow": { 484 | "slide_type": "subslide" 485 | } 486 | }, 487 | "source": [ 488 | "https://docs.python.org/3.5/library/socketserver.html" 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": null, 494 | "metadata": {}, 495 | "outputs": [], 496 | "source": [ 497 | "import socketserver\n", 498 | "\n", 499 | "class TCPServer(socketserver.TCPServer):\n", 500 | " pass\n", 501 | "\n", 502 | "s = dir(TCPServer)" 503 | ] 504 | }, 505 | { 506 | "cell_type": "code", 507 | "execution_count": null, 508 | "metadata": { 509 | "slideshow": { 510 | "slide_type": "subslide" 511 | } 512 | }, 513 | "outputs": [], 514 | "source": [ 515 | "class ThreadingTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):\n", 516 | " pass\n", 517 | "\n", 518 | "class ForkingTCPServer(socketserver.ForkingMixIn, socketserver.TCPServer):\n", 519 | " pass\n", 520 | "\n", 521 | "t = dir(ForkingTCPServer)\n", 522 | "set(t) - set(s)" 523 | ] 524 | }, 525 | { 526 | "cell_type": "code", 527 | "execution_count": null, 528 | "metadata": { 529 | "slideshow": { 530 | "slide_type": "subslide" 531 | } 532 | }, 533 | "outputs": [], 534 | "source": [ 535 | "class ThreadingUDPServer(socketserver.ThreadingMixIn, socketserver.UDPServer):\n", 536 | " pass\n", 537 | "\n", 538 | "class ForkingUDPServer(socketserver.ForkingMixIn, socketserver.UDPServer):\n", 539 | " pass" 540 | ] 541 | }, 542 | { 543 | "cell_type": "markdown", 544 | "metadata": { 545 | "slideshow": { 546 | "slide_type": "subslide" 547 | } 548 | }, 549 | "source": [ 550 | "## Metaklasy" 551 | ] 552 | }, 553 | { 554 | "cell_type": "markdown", 555 | "metadata": {}, 556 | "source": [ 557 | "Metaclasses are deeper magic than 99% of users should ever worry about. If you wonder whether you need them, you don't (the people who actually need them know with certainty that they need them, and don't need an explanation about why).\n", 558 | " -- Tim Peters" 559 | ] 560 | } 561 | ], 562 | "metadata": { 563 | "celltoolbar": "Slideshow", 564 | "kernelspec": { 565 | "display_name": "Python 3 (ipykernel)", 566 | "language": "python", 567 | "name": "python3" 568 | }, 569 | "language_info": { 570 | "codemirror_mode": { 571 | "name": "ipython", 572 | "version": 3 573 | }, 574 | "file_extension": ".py", 575 | "mimetype": "text/x-python", 576 | "name": "python", 577 | "nbconvert_exporter": "python", 578 | "pygments_lexer": "ipython3", 579 | "version": "3.12.3" 580 | } 581 | }, 582 | "nbformat": 4, 583 | "nbformat_minor": 4 584 | } 585 | -------------------------------------------------------------------------------- /Lectures/07_wyjątki.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Wyjątki" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": null, 18 | "metadata": { 19 | "slideshow": { 20 | "slide_type": "subslide" 21 | } 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "5 + '5'" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": { 32 | "slideshow": { 33 | "slide_type": "fragment" 34 | } 35 | }, 36 | "outputs": [], 37 | "source": [ 38 | "try:\n", 39 | " 5 + '5'\n", 40 | "except TypeError:\n", 41 | " print('no-no')" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": { 48 | "slideshow": { 49 | "slide_type": "subslide" 50 | } 51 | }, 52 | "outputs": [], 53 | "source": [ 54 | "try:\n", 55 | " 5 + '5'\n", 56 | "except TypeError as e:\n", 57 | " print(type(e), e)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": { 64 | "slideshow": { 65 | "slide_type": "fragment" 66 | } 67 | }, 68 | "outputs": [], 69 | "source": [ 70 | "# %%python2\n", 71 | "\n", 72 | "# try:\n", 73 | "# [][0]\n", 74 | "# except IndexError, e:\n", 75 | "# print(e)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": { 82 | "slideshow": { 83 | "slide_type": "subslide" 84 | } 85 | }, 86 | "outputs": [], 87 | "source": [ 88 | "try:\n", 89 | " dict()[3]\n", 90 | "except TypeError as e:\n", 91 | " print(type(e), e)\n", 92 | "except KeyError as e:\n", 93 | " print(\"it's only key error\")" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": { 100 | "slideshow": { 101 | "slide_type": "fragment" 102 | } 103 | }, 104 | "outputs": [], 105 | "source": [ 106 | "try:\n", 107 | " 5 + '5'\n", 108 | "except (TypeError, KeyError) as e:\n", 109 | " print(type(e), e)" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": { 116 | "slideshow": { 117 | "slide_type": "fragment" 118 | } 119 | }, 120 | "outputs": [], 121 | "source": [ 122 | "try:\n", 123 | " 5 + '5'\n", 124 | "except TypeError, KeyError as e:\n", 125 | " print(type(e), e)" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": { 132 | "slideshow": { 133 | "slide_type": "subslide" 134 | } 135 | }, 136 | "outputs": [], 137 | "source": [ 138 | "class WrongAnswerError(Exception):\n", 139 | " pass\n", 140 | "\n", 141 | "try:\n", 142 | " raise WrongAnswerError(\"wrong wrong wrong\")\n", 143 | " print(\"Hello\")\n", 144 | "except WrongAnswerError:\n", 145 | " print('good good good')\n", 146 | "else:\n", 147 | " print(\"Uhm...\")\n", 148 | "finally:\n", 149 | " print('bye!')" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": null, 155 | "metadata": { 156 | "slideshow": { 157 | "slide_type": "subslide" 158 | } 159 | }, 160 | "outputs": [], 161 | "source": [ 162 | "try:\n", 163 | " pass\n", 164 | "except WrongAnswerError:\n", 165 | " print('good good good')\n", 166 | "else:\n", 167 | " print('Uhm...')\n", 168 | "finally:\n", 169 | " print('bye!')" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": null, 175 | "metadata": { 176 | "slideshow": { 177 | "slide_type": "subslide" 178 | } 179 | }, 180 | "outputs": [], 181 | "source": [ 182 | "try:\n", 183 | " pass\n", 184 | "except WrongAnswerError:\n", 185 | " print('good good good')\n", 186 | "else:\n", 187 | " raise WrongAnswerError('wrong wrong wrong!')\n", 188 | "finally:\n", 189 | " print('bye!')" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": { 196 | "slideshow": { 197 | "slide_type": "subslide" 198 | } 199 | }, 200 | "outputs": [], 201 | "source": [ 202 | "def f():\n", 203 | " try:\n", 204 | " return 1\n", 205 | " pass\n", 206 | " except KeyError:\n", 207 | " pass\n", 208 | " else:\n", 209 | " print(\"else\")\n", 210 | " return 3\n", 211 | " finally:\n", 212 | " print(\"finally\")\n", 213 | " # return 2\n", 214 | " \n", 215 | "f()" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": null, 221 | "metadata": { 222 | "slideshow": { 223 | "slide_type": "subslide" 224 | } 225 | }, 226 | "outputs": [], 227 | "source": [ 228 | "def f():\n", 229 | " try:\n", 230 | " raise KeyError\n", 231 | " except KeyError:\n", 232 | " return 1\n", 233 | " finally:\n", 234 | " return 2\n", 235 | " \n", 236 | "f()" 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": null, 242 | "metadata": { 243 | "slideshow": { 244 | "slide_type": "subslide" 245 | } 246 | }, 247 | "outputs": [], 248 | "source": [ 249 | "def f():\n", 250 | " try:\n", 251 | " raise TypeError\n", 252 | " finally:\n", 253 | " raise KeyError\n", 254 | "try:\n", 255 | " f()\n", 256 | "except TypeError:\n", 257 | " pass" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": null, 263 | "metadata": { 264 | "slideshow": { 265 | "slide_type": "subslide" 266 | } 267 | }, 268 | "outputs": [], 269 | "source": [ 270 | "class A:\n", 271 | " pass\n", 272 | "\n", 273 | "raise A" 274 | ] 275 | }, 276 | { 277 | "cell_type": "raw", 278 | "metadata": { 279 | "slideshow": { 280 | "slide_type": "fragment" 281 | } 282 | }, 283 | "source": [ 284 | "exception Exception\n", 285 | "\n", 286 | " All built-in, non-system-exiting exceptions are derived from this class. All user-defined exceptions should also be derived from this class." 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": { 293 | "slideshow": { 294 | "slide_type": "subslide" 295 | } 296 | }, 297 | "outputs": [], 298 | "source": [ 299 | "BaseException.__bases__" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": null, 305 | "metadata": { 306 | "slideshow": { 307 | "slide_type": "fragment" 308 | } 309 | }, 310 | "outputs": [], 311 | "source": [ 312 | "Exception.__bases__" 313 | ] 314 | }, 315 | { 316 | "cell_type": "code", 317 | "execution_count": null, 318 | "metadata": { 319 | "slideshow": { 320 | "slide_type": "fragment" 321 | } 322 | }, 323 | "outputs": [], 324 | "source": [ 325 | "TypeError.__bases__" 326 | ] 327 | }, 328 | { 329 | "cell_type": "code", 330 | "execution_count": null, 331 | "metadata": { 332 | "slideshow": { 333 | "slide_type": "fragment" 334 | } 335 | }, 336 | "outputs": [], 337 | "source": [ 338 | "KeyboardInterrupt.__bases__" 339 | ] 340 | }, 341 | { 342 | "cell_type": "code", 343 | "execution_count": null, 344 | "metadata": { 345 | "slideshow": { 346 | "slide_type": "fragment" 347 | } 348 | }, 349 | "outputs": [], 350 | "source": [ 351 | "try:\n", 352 | " raise BaseException()\n", 353 | "except:\n", 354 | " print(\"Caught\")" 355 | ] 356 | }, 357 | { 358 | "cell_type": "markdown", 359 | "metadata": { 360 | "slideshow": { 361 | "slide_type": "subslide" 362 | } 363 | }, 364 | "source": [ 365 | "https://docs.python.org/3/library/exceptions.html#exception-hierarchy" 366 | ] 367 | }, 368 | { 369 | "cell_type": "markdown", 370 | "metadata": {}, 371 | "source": [ 372 | "- TypeError\n", 373 | "- ValueError\n", 374 | "- IndexError\n", 375 | "- KeyError\n", 376 | "- NameError\n", 377 | "- AttributeError" 378 | ] 379 | }, 380 | { 381 | "cell_type": "markdown", 382 | "metadata": { 383 | "slideshow": { 384 | "slide_type": "slide" 385 | } 386 | }, 387 | "source": [ 388 | "## Asercje" 389 | ] 390 | }, 391 | { 392 | "cell_type": "code", 393 | "execution_count": null, 394 | "metadata": { 395 | "slideshow": { 396 | "slide_type": "subslide" 397 | } 398 | }, 399 | "outputs": [], 400 | "source": [ 401 | "assert 0 > 1, \"Komunikat\"" 402 | ] 403 | }, 404 | { 405 | "cell_type": "code", 406 | "execution_count": null, 407 | "metadata": { 408 | "slideshow": { 409 | "slide_type": "fragment" 410 | } 411 | }, 412 | "outputs": [], 413 | "source": [ 414 | "AssertionError.__bases__" 415 | ] 416 | }, 417 | { 418 | "cell_type": "code", 419 | "execution_count": null, 420 | "metadata": { 421 | "slideshow": { 422 | "slide_type": "fragment" 423 | } 424 | }, 425 | "outputs": [], 426 | "source": [ 427 | "try:\n", 428 | " assert 0 > 1\n", 429 | "except:\n", 430 | " pass" 431 | ] 432 | }, 433 | { 434 | "cell_type": "markdown", 435 | "metadata": { 436 | "slideshow": { 437 | "slide_type": "slide" 438 | } 439 | }, 440 | "source": [ 441 | "## Sockety w C" 442 | ] 443 | }, 444 | { 445 | "cell_type": "raw", 446 | "metadata": { 447 | "slideshow": { 448 | "slide_type": "subslide" 449 | } 450 | }, 451 | "source": [ 452 | "#include \n", 453 | "#include \n", 454 | "#include \n", 455 | "#include \n", 456 | "#include \n", 457 | "#include \n", 458 | "#include \n", 459 | "#include \n", 460 | "#include \n", 461 | "#include \n", 462 | "\n", 463 | "int main(int argc, char *argv[]) {\n", 464 | " int sockfd = 0, n = 0;\n", 465 | " char recvBuff[1024];\n", 466 | " struct sockaddr_in serv_addr; \n", 467 | "\n", 468 | " if(argc != 2) {\n", 469 | " printf(\"\\n Usage: %s \\n\",argv[0]);\n", 470 | " return 1;\n", 471 | " } \n", 472 | "\n", 473 | " memset(recvBuff, '0',sizeof(recvBuff));\n", 474 | " if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {\n", 475 | " printf(\"\\n Error : Could not create socket \\n\");\n", 476 | " return 1;\n", 477 | " } \n", 478 | "\n", 479 | " memset(&serv_addr, '0', sizeof(serv_addr)); \n", 480 | "\n", 481 | " serv_addr.sin_family = AF_INET;\n", 482 | " serv_addr.sin_port = htons(5000); \n", 483 | "\n", 484 | " if(inet_pton(AF_INET, argv[1], &serv_addr.sin_addr)<=0) {\n", 485 | " printf(\"\\n inet_pton error occured\\n\");\n", 486 | " return 1;\n", 487 | " } \n", 488 | "\n", 489 | " if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {\n", 490 | " printf(\"\\n Error : Connect Failed \\n\");\n", 491 | " return 1;\n", 492 | " } \n", 493 | "\n", 494 | " while ( (n = read(sockfd, recvBuff, sizeof(recvBuff)-1)) > 0) {\n", 495 | " recvBuff[n] = 0;\n", 496 | " if(fputs(recvBuff, stdout) == EOF) {\n", 497 | " printf(\"\\n Error : Fputs error\\n\");\n", 498 | " }\n", 499 | " } \n", 500 | "\n", 501 | " if(n < 0) {\n", 502 | " printf(\"\\n Read error \\n\");\n", 503 | " } \n", 504 | "\n", 505 | " return 0;\n", 506 | "}" 507 | ] 508 | }, 509 | { 510 | "cell_type": "markdown", 511 | "metadata": {}, 512 | "source": [ 513 | "[https://www.thegeekstuff.com/2011/12/c-socket-programming/?utm_source=feedburner]" 514 | ] 515 | }, 516 | { 517 | "cell_type": "markdown", 518 | "metadata": { 519 | "slideshow": { 520 | "slide_type": "slide" 521 | } 522 | }, 523 | "source": [ 524 | "## Ostrzeżenia\n", 525 | "\n", 526 | "https://www.geeksforgeeks.org/warnings-in-python/" 527 | ] 528 | }, 529 | { 530 | "cell_type": "code", 531 | "execution_count": null, 532 | "metadata": { 533 | "slideshow": { 534 | "slide_type": "subslide" 535 | } 536 | }, 537 | "outputs": [], 538 | "source": [ 539 | "from warnings import warn, filters, filterwarnings\n", 540 | "\n", 541 | "filters" 542 | ] 543 | }, 544 | { 545 | "cell_type": "code", 546 | "execution_count": null, 547 | "metadata": { 548 | "slideshow": { 549 | "slide_type": "fragment" 550 | } 551 | }, 552 | "outputs": [], 553 | "source": [ 554 | "filterwarnings(\"always\", category=SyntaxWarning, append=False) # append=False (domyślnie) dodaje filtr na początek listy, True - na koniec" 555 | ] 556 | }, 557 | { 558 | "cell_type": "code", 559 | "execution_count": null, 560 | "metadata": { 561 | "slideshow": { 562 | "slide_type": "subslide" 563 | } 564 | }, 565 | "outputs": [], 566 | "source": [ 567 | "warn(SyntaxWarning(\"This syntax is bad, don't do it\"))\n", 568 | "warn(SyntaxWarning(\"This syntax is bad, don't do it\"))" 569 | ] 570 | }, 571 | { 572 | "cell_type": "code", 573 | "execution_count": null, 574 | "metadata": { 575 | "slideshow": { 576 | "slide_type": "fragment" 577 | } 578 | }, 579 | "outputs": [], 580 | "source": [ 581 | "raise SyntaxWarning(\"Not good\")" 582 | ] 583 | }, 584 | { 585 | "cell_type": "markdown", 586 | "metadata": { 587 | "slideshow": { 588 | "slide_type": "slide" 589 | } 590 | }, 591 | "source": [ 592 | "## Wyjątki w telegraficznym skrócie\n", 593 | "\n", 594 | "- sygnalizują awarię\n", 595 | "- muszą dziedziczyć z `BaseException`, a zwykle dziedziczą z `Exception`\n", 596 | "- blok `try` zawiera kod \"niebezpieczny\"\n", 597 | "- blok `except` wykonuje się, jeżeli wystąpi wyjątek podany w jego nagłówku\n", 598 | "- blok `else` wykonuje się, jeżeli sterowanie dojdzie do końca bloku `try`\n", 599 | "- blok `finally` wykonuje się ZAWSZE po zakończeniu bloków `try`, `except` i `else` (którekolwiek się wykonają i jakkolwiek się skończą)\n", 600 | "- wyjątek rzucamy słowem kluczowym `raise`" 601 | ] 602 | } 603 | ], 604 | "metadata": { 605 | "celltoolbar": "Slideshow", 606 | "kernelspec": { 607 | "display_name": "Python 3 (ipykernel)", 608 | "language": "python", 609 | "name": "python3" 610 | }, 611 | "language_info": { 612 | "codemirror_mode": { 613 | "name": "ipython", 614 | "version": 3 615 | }, 616 | "file_extension": ".py", 617 | "mimetype": "text/x-python", 618 | "name": "python", 619 | "nbconvert_exporter": "python", 620 | "pygments_lexer": "ipython3", 621 | "version": "3.12.3" 622 | } 623 | }, 624 | "nbformat": 4, 625 | "nbformat_minor": 4 626 | } 627 | -------------------------------------------------------------------------------- /Lectures/09_context_manager.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Context Manager" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": { 18 | "slideshow": { 19 | "slide_type": "subslide" 20 | } 21 | }, 22 | "source": [ 23 | "### Problem:\n", 24 | " \n", 25 | " set things up\n", 26 | " do something\n", 27 | " tear things down" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "f = open(\"00_podstawy.ipynb\")\n", 37 | "f.readlines()\n", 38 | "f.close()" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": { 44 | "slideshow": { 45 | "slide_type": "subslide" 46 | } 47 | }, 48 | "source": [ 49 | "### Rozwiązanie 1.\n", 50 | "\n", 51 | " set things up\n", 52 | " try:\n", 53 | " do something\n", 54 | " finally:\n", 55 | " tear things down" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "f = open(\"00_podstawy.ipynb\")\n", 65 | "try:\n", 66 | " f.readlines()\n", 67 | "finally:\n", 68 | " f.close()" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": null, 74 | "metadata": { 75 | "slideshow": { 76 | "slide_type": "fragment" 77 | } 78 | }, 79 | "outputs": [], 80 | "source": [ 81 | "try:\n", 82 | " f = open(\"00_podstawy.ipynb\")\n", 83 | " f.readlines()\n", 84 | "finally:\n", 85 | " if f:\n", 86 | " f.close()" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": { 92 | "slideshow": { 93 | "slide_type": "subslide" 94 | } 95 | }, 96 | "source": [ 97 | "### Rozwiązanie 2.\n", 98 | "\n", 99 | " def controlled_execution(callback):\n", 100 | " set things up\n", 101 | " try:\n", 102 | " callback(thing)\n", 103 | " finally:\n", 104 | " tear things down\n", 105 | "\n", 106 | " def my_function(thing):\n", 107 | " do something\n", 108 | "\n", 109 | " controlled_execution(my_function)" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": { 116 | "slideshow": { 117 | "slide_type": "-" 118 | } 119 | }, 120 | "outputs": [], 121 | "source": [ 122 | "def foo():\n", 123 | " print(\"X\")\n", 124 | " raise IndexError()\n", 125 | " \n", 126 | "def controlled_execution(f):\n", 127 | " print(\"Enter\")\n", 128 | " try:\n", 129 | " f()\n", 130 | " finally:\n", 131 | " print(\"Exit\")\n", 132 | " \n", 133 | "controlled_execution(foo)" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "metadata": { 139 | "slideshow": { 140 | "slide_type": "subslide" 141 | } 142 | }, 143 | "source": [ 144 | "### Rozwiązanie 3.\n", 145 | "\n", 146 | " def controlled_execution():\n", 147 | " set things up\n", 148 | " try:\n", 149 | " yield thing\n", 150 | " finally:\n", 151 | " tear things down\n", 152 | "\n", 153 | " for thing in controlled_execution():\n", 154 | " do something with thing" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": null, 160 | "metadata": { 161 | "slideshow": { 162 | "slide_type": "-" 163 | } 164 | }, 165 | "outputs": [], 166 | "source": [ 167 | "def controlled_execution(filename):\n", 168 | " print(\"Enter\")\n", 169 | " f = open(filename)\n", 170 | " try:\n", 171 | " yield f\n", 172 | " finally:\n", 173 | " f.close()\n", 174 | " print(\"Exit\")\n", 175 | "\n", 176 | "\n", 177 | "for x in controlled_execution(\"00_podstawy.ipynb\"):\n", 178 | " print(\"X\")\n", 179 | " raise KeyError()" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": { 185 | "slideshow": { 186 | "slide_type": "subslide" 187 | } 188 | }, 189 | "source": [ 190 | "### Rozwiązanie 4.\n", 191 | "\n", 192 | " class controlled_execution:\n", 193 | " def __enter__(self):\n", 194 | " set things up\n", 195 | " return thing\n", 196 | " \n", 197 | " def __exit__(self, type, value, traceback):\n", 198 | " tear things down\n", 199 | "\n", 200 | " with controlled_execution() as thing:\n", 201 | " do something with thing" 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": { 207 | "slideshow": { 208 | "slide_type": "subslide" 209 | } 210 | }, 211 | "source": [ 212 | " with expression [as (targets)]:\n", 213 | " code block with context of \"targets\"\n", 214 | "\n", 215 | "* Możliwość utworzenia dynamicznego (w runtime) kontekstu dla wykonania sekcji kodu\n", 216 | "* Przykłady użycia: \n", 217 | " * czytanie z pliku - w kontekście otwarcia i zamknięcia pliku\n", 218 | " * zakładanie i zwalnianie blokad (\"lock\")\n", 219 | " * zmiana i odtworzenie globalnego stanu\n", 220 | "* Obiekt context managera musi implementować protokół: ``__enter__()`` i ``__exit__()``\n", 221 | "* [PEP 343](http://www.python.org/dev/peps/pep-0343/)" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "metadata": { 228 | "slideshow": { 229 | "slide_type": "subslide" 230 | } 231 | }, 232 | "outputs": [], 233 | "source": [ 234 | "with open('00_podstawy.ipynb') as notebook:\n", 235 | " print(notebook.read(50))" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": { 242 | "slideshow": { 243 | "slide_type": "fragment" 244 | } 245 | }, 246 | "outputs": [], 247 | "source": [ 248 | "notebook" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": null, 254 | "metadata": { 255 | "slideshow": { 256 | "slide_type": "fragment" 257 | } 258 | }, 259 | "outputs": [], 260 | "source": [ 261 | "notebook.read(50)" 262 | ] 263 | }, 264 | { 265 | "cell_type": "raw", 266 | "metadata": { 267 | "slideshow": { 268 | "slide_type": "subslide" 269 | } 270 | }, 271 | "source": [ 272 | "Konstrukcja:\n", 273 | "\n", 274 | " with EXPR as VAR:\n", 275 | " BLOCK\n", 276 | "\n", 277 | "tłumaczy się jako:\n", 278 | "\n", 279 | " mgr = (EXPR)\n", 280 | " exit = type(mgr).__exit__ # Not calling it yet\n", 281 | " value = type(mgr).__enter__(mgr)\n", 282 | " exc = True\n", 283 | " try:\n", 284 | " try:\n", 285 | " VAR = value # Only if \"as VAR\" is present\n", 286 | " BLOCK\n", 287 | " except:\n", 288 | " # The exceptional case is handled here\n", 289 | " exc = False\n", 290 | " if not exit(mgr, *sys.exc_info()):\n", 291 | " raise\n", 292 | " # The exception is swallowed if exit() returns true\n", 293 | " finally:\n", 294 | " # The normal and non-local-goto cases are handled here\n", 295 | " if exc:\n", 296 | " exit(mgr, None, None, None)" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": null, 302 | "metadata": { 303 | "slideshow": { 304 | "slide_type": "subslide" 305 | } 306 | }, 307 | "outputs": [], 308 | "source": [ 309 | "class MyContextManager:\n", 310 | " \n", 311 | " def __enter__(self):\n", 312 | " print(\"Context prepared\")\n", 313 | " return self\n", 314 | " \n", 315 | " def __exit__(self, exc_type, exc_value, traceback):\n", 316 | " print(\"Context closed \", exc_type, exc_value, traceback)\n", 317 | "\n", 318 | " \n", 319 | "with MyContextManager() as f:\n", 320 | " print(\"Hello\", f)" 321 | ] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": null, 326 | "metadata": { 327 | "slideshow": { 328 | "slide_type": "subslide" 329 | } 330 | }, 331 | "outputs": [], 332 | "source": [ 333 | "class MyContextManager:\n", 334 | " \n", 335 | " def __enter__(self):\n", 336 | " print(\"Context prepared\")\n", 337 | " \n", 338 | " def __exit__(self, exc_type, exc_value, traceback):\n", 339 | " print(\"Context closed \", exc_type, exc_value, traceback)\n", 340 | " return True\n", 341 | "\n", 342 | " \n", 343 | "with MyContextManager():\n", 344 | " print(\"X\")\n", 345 | " raise KeyError()\n", 346 | " print(\"Y\")" 347 | ] 348 | }, 349 | { 350 | "cell_type": "markdown", 351 | "metadata": { 352 | "slideshow": { 353 | "slide_type": "slide" 354 | } 355 | }, 356 | "source": [ 357 | "## Context manager z użyciem dekoratora" 358 | ] 359 | }, 360 | { 361 | "cell_type": "code", 362 | "execution_count": null, 363 | "metadata": { 364 | "slideshow": { 365 | "slide_type": "subslide" 366 | } 367 | }, 368 | "outputs": [], 369 | "source": [ 370 | "from contextlib import contextmanager\n", 371 | "\n", 372 | "@contextmanager\n", 373 | "def tag(name):\n", 374 | " print(\"<%s>\" % name,)\n", 375 | " try:\n", 376 | " yield\n", 377 | " finally:\n", 378 | " print(\"\" % name,)\n", 379 | "\n", 380 | "with tag(\"div\"):\n", 381 | " with tag(\"a\"):\n", 382 | " print(\"foo\",)" 383 | ] 384 | }, 385 | { 386 | "cell_type": "code", 387 | "execution_count": null, 388 | "metadata": { 389 | "slideshow": { 390 | "slide_type": "subslide" 391 | } 392 | }, 393 | "outputs": [], 394 | "source": [ 395 | "with tag(\"h1\"):\n", 396 | " 1 + '1'\n", 397 | " \n", 398 | "print()" 399 | ] 400 | }, 401 | { 402 | "cell_type": "markdown", 403 | "metadata": { 404 | "slideshow": { 405 | "slide_type": "subslide" 406 | } 407 | }, 408 | "source": [ 409 | "Przykład z tymczasowym folderem (za http://stackoverflow.com/questions/3012488/what-is-the-python-with-statement-designed-for)" 410 | ] 411 | }, 412 | { 413 | "cell_type": "code", 414 | "execution_count": null, 415 | "metadata": {}, 416 | "outputs": [], 417 | "source": [ 418 | "from tempfile import mkdtemp\n", 419 | "from shutil import rmtree\n", 420 | "\n", 421 | "@contextmanager\n", 422 | "def temporary_dir(*args, **kwds):\n", 423 | " name = mkdtemp(*args, **kwds)\n", 424 | " try:\n", 425 | " yield name\n", 426 | " finally:\n", 427 | " rmtree(name)\n", 428 | "\n", 429 | "with temporary_dir(\".temp\") as dirname:\n", 430 | " print(\"doing sth with\", dirname)" 431 | ] 432 | }, 433 | { 434 | "cell_type": "markdown", 435 | "metadata": { 436 | "slideshow": { 437 | "slide_type": "slide" 438 | } 439 | }, 440 | "source": [ 441 | "## Context Manager w telegraficznym skrócie\n", 442 | "\n", 443 | "- zapewnia automatyczne posprzątanie niezależnie od ew. wyjątków\n", 444 | "- użycie: `with context_manager as cm: `\n", 445 | "- definicja: klasa z metodami `__enter__(self)` i `__exit__(self, exc_type, exc_value, traceback)`\n", 446 | "- do zmiennej `cm` zostanie przypisana wartość zwrócona przez `__enter__`\n", 447 | "- `__exit__` zwraca wartość bool'owską, czy traktować ew. wyjątek jako obsłużony" 448 | ] 449 | } 450 | ], 451 | "metadata": { 452 | "celltoolbar": "Slideshow", 453 | "kernelspec": { 454 | "display_name": "Python 3 (ipykernel)", 455 | "language": "python", 456 | "name": "python3" 457 | }, 458 | "language_info": { 459 | "codemirror_mode": { 460 | "name": "ipython", 461 | "version": 3 462 | }, 463 | "file_extension": ".py", 464 | "mimetype": "text/x-python", 465 | "name": "python", 466 | "nbconvert_exporter": "python", 467 | "pygments_lexer": "ipython3", 468 | "version": "3.12.3" 469 | } 470 | }, 471 | "nbformat": 4, 472 | "nbformat_minor": 4 473 | } 474 | -------------------------------------------------------------------------------- /Lectures/10_pliki.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Pliki" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": null, 18 | "metadata": { 19 | "slideshow": { 20 | "slide_type": "subslide" 21 | } 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "from pprint import pprint\n", 26 | "with open('00_podstawy.ipynb') as notebook:\n", 27 | " lines = notebook.readlines()\n", 28 | " pprint(lines)" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": { 35 | "slideshow": { 36 | "slide_type": "subslide" 37 | } 38 | }, 39 | "outputs": [], 40 | "source": [ 41 | "with open('00_podstawy.ipynb') as notebook:\n", 42 | " for line in notebook:\n", 43 | " pprint(line)\n", 44 | " break" 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "metadata": { 50 | "slideshow": { 51 | "slide_type": "fragment" 52 | } 53 | }, 54 | "source": [ 55 | "Czy pliki __zawsze__ otwieramy w bloku `with`?" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": { 61 | "slideshow": { 62 | "slide_type": "subslide" 63 | } 64 | }, 65 | "source": [ 66 | "Sposoby czytania z pliku:\n", 67 | " - `read()` - wczytuje cały plik do jednego napisu\n", 68 | " - `read(n)` - wczytuje maksymalnie n bajtów do napisu\n", 69 | " - `readline()` - wczytuje do końca linii (lub końca pliku)\n", 70 | " - `readlines()` - wczytuje cały plik do listy napisów - każda linia to osobny napis\n", 71 | " - iteracja po obiekcie pliku - działa jak `readlines`, ale bez konieczności wczytania całości do pamięci - istotne w przypadku dużych plików" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": { 78 | "slideshow": { 79 | "slide_type": "subslide" 80 | } 81 | }, 82 | "outputs": [], 83 | "source": [ 84 | "with open('output.txt', 'w') as outfile:\n", 85 | " outfile.write(\"Hello \")\n", 86 | " outfile.write(\"world!\\nWhat a lovely day!\\n\")\n", 87 | " outfile.writelines([\"This is test file.\\n\", \"And also a text file.\\n\"]) # <- please note the newline characters" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": { 93 | "slideshow": { 94 | "slide_type": "subslide" 95 | } 96 | }, 97 | "source": [ 98 | "Tryby otwarcia pliku:\n", 99 | " - `\"r\"` - domyślny, otwarcie do odczytu\n", 100 | " - `\"w\"` - otwarcie do zapisu; jeżeli plik istniał, jego dotychczasowa zawartość zostaje usunięta\n", 101 | " - `\"a\"` - otwarcie do dopisywania; dotychczasowa zawartość zostaje zachowana, a nowa pojawia się na końcu\n", 102 | " - `\"rb\"`, `\"wb\"`, `\"ab\"` - analogicznie, ale dla plików binarnych\n", 103 | " \n", 104 | "Sposoby zapisu do pliku:\n", 105 | " - `write()` - przyjmuje pojedynczy napis\n", 106 | " - `writelines()` - przyjmuje listę napisów\n", 107 | " \n", 108 | "W obu przypadkach liczba napisów nie przekłada się na liczę linii - znaki końca linii (`\"\\n\"`) musimy wstawiać samodzielnie" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": null, 114 | "metadata": { 115 | "slideshow": { 116 | "slide_type": "subslide" 117 | } 118 | }, 119 | "outputs": [], 120 | "source": [ 121 | "f = open(\"output.txt\", \"w\")\n", 122 | "help(f)\n", 123 | "f.close()" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": { 129 | "slideshow": { 130 | "slide_type": "slide" 131 | } 132 | }, 133 | "source": [ 134 | "## CSV\n", 135 | "\n", 136 | "https://docs.python.org/3/library/csv.html" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": { 143 | "slideshow": { 144 | "slide_type": "subslide" 145 | } 146 | }, 147 | "outputs": [], 148 | "source": [ 149 | "import csv\n", 150 | "\n", 151 | "with open('Plant_1_Generation_Data.csv') as csv_file:\n", 152 | " reader = csv.reader(csv_file)\n", 153 | " for ind, row in enumerate(reader):\n", 154 | " print(row)\n", 155 | " if ind >= 3:\n", 156 | " break" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": { 163 | "slideshow": { 164 | "slide_type": "subslide" 165 | } 166 | }, 167 | "outputs": [], 168 | "source": [ 169 | "import csv\n", 170 | "\n", 171 | "with open('Plant_1_Generation_Data.csv') as csv_file:\n", 172 | " reader = csv.DictReader(csv_file)\n", 173 | " for ind, row in enumerate(reader):\n", 174 | " print(row)\n", 175 | " if ind >= 3:\n", 176 | " break" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": null, 182 | "metadata": { 183 | "slideshow": { 184 | "slide_type": "subslide" 185 | } 186 | }, 187 | "outputs": [], 188 | "source": [ 189 | "import pandas as pd\n", 190 | "\n", 191 | "df = pd.read_csv('Plant_1_Generation_Data.csv')\n", 192 | "df[:3]" 193 | ] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": { 198 | "slideshow": { 199 | "slide_type": "slide" 200 | } 201 | }, 202 | "source": [ 203 | "## JSON\n", 204 | "\n", 205 | "https://docs.python.org/3/library/json.html" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": null, 211 | "metadata": { 212 | "slideshow": { 213 | "slide_type": "subslide" 214 | } 215 | }, 216 | "outputs": [], 217 | "source": [ 218 | "import json\n", 219 | "\n", 220 | "data = [\"This\", \"is\", \"a\", [\"list\", \"of\", \"strings\"]]\n", 221 | "data" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "metadata": { 228 | "slideshow": { 229 | "slide_type": "subslide" 230 | } 231 | }, 232 | "outputs": [], 233 | "source": [ 234 | "with open(\"/tmp/data.json\", \"w\") as outfile:\n", 235 | " json.dump(data, outfile)" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": { 242 | "slideshow": { 243 | "slide_type": "subslide" 244 | } 245 | }, 246 | "outputs": [], 247 | "source": [ 248 | "with open(\"/tmp/data.json\", \"r\") as infile:\n", 249 | " data2 = json.load(infile)\n", 250 | "\n", 251 | "data2 " 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": { 258 | "slideshow": { 259 | "slide_type": "subslide" 260 | } 261 | }, 262 | "outputs": [], 263 | "source": [ 264 | "for x, y in zip(Xs, Ys):\n", 265 | " outfile.write(f'{{ \"translation\": {{ \"before\": \"{y}\", \"after\": \"{x}\" }} }}\\n')" 266 | ] 267 | }, 268 | { 269 | "cell_type": "markdown", 270 | "metadata": { 271 | "slideshow": { 272 | "slide_type": "fragment" 273 | } 274 | }, 275 | "source": [ 276 | "What could possibly go wrong?" 277 | ] 278 | }, 279 | { 280 | "cell_type": "code", 281 | "execution_count": null, 282 | "metadata": { 283 | "slideshow": { 284 | "slide_type": "fragment" 285 | } 286 | }, 287 | "outputs": [], 288 | "source": [ 289 | "for x, y in zip(Xs, Ys):\n", 290 | " outfile.write(json.dumps({\"translation\": {\"before\": y, \"after\": x}}) + \"\\n\")" 291 | ] 292 | }, 293 | { 294 | "cell_type": "markdown", 295 | "metadata": { 296 | "slideshow": { 297 | "slide_type": "subslide" 298 | } 299 | }, 300 | "source": [ 301 | "![Who's JSON](img/JSON.jpg)" 302 | ] 303 | }, 304 | { 305 | "cell_type": "markdown", 306 | "metadata": { 307 | "slideshow": { 308 | "slide_type": "slide" 309 | } 310 | }, 311 | "source": [ 312 | "## Dane binarne\n", 313 | "\n", 314 | "https://docs.python.org/3/library/pickle.html" 315 | ] 316 | }, 317 | { 318 | "cell_type": "code", 319 | "execution_count": null, 320 | "metadata": { 321 | "slideshow": { 322 | "slide_type": "subslide" 323 | } 324 | }, 325 | "outputs": [], 326 | "source": [ 327 | "import pickle\n", 328 | "\n", 329 | "data = [\"This\", \"is\", \"a\", [\"list\", \"of\", \"strings\"], {\"Kind\", \"of\"}]" 330 | ] 331 | }, 332 | { 333 | "cell_type": "code", 334 | "execution_count": null, 335 | "metadata": { 336 | "slideshow": { 337 | "slide_type": "subslide" 338 | } 339 | }, 340 | "outputs": [], 341 | "source": [ 342 | "with open(\"/tmp/list_of_strings.bin\", \"wb\") as outfile: # uwaga na tryb dostępu\n", 343 | " pickle.dump(data, outfile)" 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": null, 349 | "metadata": {}, 350 | "outputs": [], 351 | "source": [ 352 | "with open(\"/tmp/list_of_strings.bin\", \"rb\") as infile:\n", 353 | " data2 = pickle.load(infile)\n", 354 | "data2" 355 | ] 356 | }, 357 | { 358 | "cell_type": "code", 359 | "execution_count": null, 360 | "metadata": { 361 | "slideshow": { 362 | "slide_type": "subslide" 363 | } 364 | }, 365 | "outputs": [], 366 | "source": [ 367 | "import joblib\n", 368 | "\n", 369 | "data = [\"This\", \"is\", \"a\", [\"list\", \"of\", \"strings\"], {\"Kind\", \"of\"}]" 370 | ] 371 | }, 372 | { 373 | "cell_type": "code", 374 | "execution_count": null, 375 | "metadata": { 376 | "slideshow": { 377 | "slide_type": "subslide" 378 | } 379 | }, 380 | "outputs": [], 381 | "source": [ 382 | "with open(\"/tmp/list_of_strings.bin\", \"wb\") as outfile: # uwaga na tryb dostępu\n", 383 | " joblib.dump(data, outfile)" 384 | ] 385 | }, 386 | { 387 | "cell_type": "code", 388 | "execution_count": null, 389 | "metadata": {}, 390 | "outputs": [], 391 | "source": [ 392 | "with open(\"/tmp/list_of_strings.bin\", \"rb\") as infile:\n", 393 | " data2 = joblib.load(infile)\n", 394 | "data2" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": { 400 | "slideshow": { 401 | "slide_type": "slide" 402 | } 403 | }, 404 | "source": [ 405 | "## Inne biblioteki:\n", 406 | " - xlrd, xlwt - obsługa plików xls\n", 407 | " - Beautiful Soup - obługa XMLa (jest też wbudowany moduł xml)\n", 408 | " - PIL/Pillow - pliki graficzne\n", 409 | " - pyyaml\n", 410 | " - ..." 411 | ] 412 | }, 413 | { 414 | "cell_type": "markdown", 415 | "metadata": { 416 | "slideshow": { 417 | "slide_type": "slide" 418 | } 419 | }, 420 | "source": [ 421 | "## Pliki w telegraficznym skrócie\n", 422 | "\n", 423 | "* Najczęściej otwierane w bloku `with`.\n", 424 | "* Tryby dostępu: `\"r\"`, `\"w\"`, `\"a\"`, `\"rb\"`, `\"wb\"`, `\"ab\"`\n", 425 | "* Plik otwarty do odczytu jest iterowalny po liniach.\n", 426 | "* Biblioteki do obsługi różnych formatów: `json`, `csv`, `pyyaml`...\n", 427 | "* Zapis/odczyt obiektów Pythonowych za pomocą bibliotek `pickle` lub `joblib`." 428 | ] 429 | } 430 | ], 431 | "metadata": { 432 | "celltoolbar": "Slideshow", 433 | "kernelspec": { 434 | "display_name": "Python 3 (ipykernel)", 435 | "language": "python", 436 | "name": "python3" 437 | }, 438 | "language_info": { 439 | "codemirror_mode": { 440 | "name": "ipython", 441 | "version": 3 442 | }, 443 | "file_extension": ".py", 444 | "mimetype": "text/x-python", 445 | "name": "python", 446 | "nbconvert_exporter": "python", 447 | "pygments_lexer": "ipython3", 448 | "version": "3.12.3" 449 | } 450 | }, 451 | "nbformat": 4, 452 | "nbformat_minor": 4 453 | } 454 | -------------------------------------------------------------------------------- /Lectures/11_dekoratory.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Dekoratory" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": null, 18 | "metadata": { 19 | "slideshow": { 20 | "slide_type": "subslide" 21 | } 22 | }, 23 | "outputs": [], 24 | "source": [ 25 | "def say_even_more(*args, **kwargs):\n", 26 | " print(args) # krotka\n", 27 | " print(kwargs) # słownik" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": { 34 | "slideshow": { 35 | "slide_type": "subslide" 36 | } 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "import logging\n", 41 | "logging.basicConfig(level=logging.DEBUG)\n", 42 | "\n", 43 | "def logged(f):\n", 44 | " def logged_f(*args, **kwargs):\n", 45 | " logging.debug(\"Called {!r} with params {} and {}\".format(f.__name__, args, kwargs))\n", 46 | " ret_val = f(*args, **kwargs)\n", 47 | " logging.debug(\"{!r} returned {!r}\".format(f.__name__, ret_val))\n", 48 | " return ret_val\n", 49 | " return logged_f" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": { 56 | "slideshow": { 57 | "slide_type": "fragment" 58 | } 59 | }, 60 | "outputs": [], 61 | "source": [ 62 | "say_even_more = logged(say_even_more)" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": null, 68 | "metadata": { 69 | "slideshow": { 70 | "slide_type": "fragment" 71 | } 72 | }, 73 | "outputs": [], 74 | "source": [ 75 | "say_even_more(1, 2)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": { 82 | "slideshow": { 83 | "slide_type": "subslide" 84 | } 85 | }, 86 | "outputs": [], 87 | "source": [ 88 | "@logged\n", 89 | "def g(n):\n", 90 | " print(\"Another simple method printing {}.\".format(n))" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": { 97 | "slideshow": { 98 | "slide_type": "fragment" 99 | } 100 | }, 101 | "outputs": [], 102 | "source": [ 103 | "g(2)" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": { 110 | "slideshow": { 111 | "slide_type": "subslide" 112 | } 113 | }, 114 | "outputs": [], 115 | "source": [ 116 | "def synchronized(f):\n", 117 | " pass" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": { 124 | "slideshow": { 125 | "slide_type": "subslide" 126 | } 127 | }, 128 | "outputs": [], 129 | "source": [ 130 | "# Example ...\n", 131 | "@synchronized\n", 132 | "@logged\n", 133 | "def myfunc(arg1, arg2, *args):\n", 134 | " # ...do something\n", 135 | " pass" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": { 142 | "slideshow": { 143 | "slide_type": "subslide" 144 | } 145 | }, 146 | "outputs": [], 147 | "source": [ 148 | "def entry_exit(f):\n", 149 | " def new_f():\n", 150 | " print(\"Entering\", f.__name__)\n", 151 | " f()\n", 152 | " print(\"Exited\", f.__name__)\n", 153 | " return new_f" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": { 160 | "slideshow": { 161 | "slide_type": "fragment" 162 | } 163 | }, 164 | "outputs": [], 165 | "source": [ 166 | "@entry_exit\n", 167 | "def func1():\n", 168 | " print(\"inside func1()\")\n", 169 | "func1()" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": null, 175 | "metadata": { 176 | "slideshow": { 177 | "slide_type": "subslide" 178 | } 179 | }, 180 | "outputs": [], 181 | "source": [ 182 | "class EntryExit:\n", 183 | " \n", 184 | " def __init__(self, f):\n", 185 | " self.f = f\n", 186 | " self.n = 0\n", 187 | " \n", 188 | " def __call__(self):\n", 189 | " self.n += 1\n", 190 | " print(\"Entering\", self.f.__name__, self.n, \"time\" + (\"s\" if self.n > 1 else \"\"))\n", 191 | " self.f()\n", 192 | " print(\"Exited\", self.f.__name__)\n", 193 | "\n", 194 | "@EntryExit\n", 195 | "def func1():\n", 196 | " print(\"inside func1()\")" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": { 203 | "slideshow": { 204 | "slide_type": "fragment" 205 | } 206 | }, 207 | "outputs": [], 208 | "source": [ 209 | "type(func1)" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": null, 215 | "metadata": { 216 | "slideshow": { 217 | "slide_type": "fragment" 218 | } 219 | }, 220 | "outputs": [], 221 | "source": [ 222 | "func1()" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": null, 228 | "metadata": { 229 | "slideshow": { 230 | "slide_type": "subslide" 231 | } 232 | }, 233 | "outputs": [], 234 | "source": [ 235 | "from random import randint\n", 236 | "\n", 237 | "@moving_avg(10)\n", 238 | "def foo():\n", 239 | " return randint(1, 100)\n", 240 | "\n", 241 | "print([foo() for _ in range(20)])" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": { 248 | "slideshow": { 249 | "slide_type": "subslide" 250 | } 251 | }, 252 | "outputs": [], 253 | "source": [ 254 | "def foo():\n", 255 | " return randint(1, 100)\n", 256 | "\n", 257 | "dec = moving_avg(4)\n", 258 | "foo = dec(foo)" 259 | ] 260 | }, 261 | { 262 | "cell_type": "code", 263 | "execution_count": null, 264 | "metadata": { 265 | "slideshow": { 266 | "slide_type": "fragment" 267 | } 268 | }, 269 | "outputs": [], 270 | "source": [ 271 | "def moving_avg(window_size):\n", 272 | " def decorator(f):\n", 273 | " window = []\n", 274 | " def decorated(*args, **kwargs):\n", 275 | " nonlocal window\n", 276 | " window += [f(*args, **kwargs)]\n", 277 | " window = window[-window_size:]\n", 278 | " return sum(window)/len(window)\n", 279 | " return decorated\n", 280 | " return decorator" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": null, 286 | "metadata": { 287 | "slideshow": { 288 | "slide_type": "subslide" 289 | } 290 | }, 291 | "outputs": [], 292 | "source": [ 293 | "class Decorator:\n", 294 | " \n", 295 | " def __init__(self, arg):\n", 296 | " self.arg = arg\n", 297 | " \n", 298 | " def __call__(self, cls):\n", 299 | " class Wrapped(cls):\n", 300 | " classattr = self.arg\n", 301 | " def new_method(self, value):\n", 302 | " return value * 2\n", 303 | " return Wrapped" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": null, 309 | "metadata": { 310 | "slideshow": { 311 | "slide_type": "fragment" 312 | } 313 | }, 314 | "outputs": [], 315 | "source": [ 316 | "@Decorator(\"decorated class\")\n", 317 | "class TestClass:\n", 318 | " \n", 319 | " def new_method(self, value):\n", 320 | " return value * 3\n", 321 | " \n", 322 | "t = TestClass()\n", 323 | "\n", 324 | "print(t.new_method(5))" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": null, 330 | "metadata": { 331 | "slideshow": { 332 | "slide_type": "fragment" 333 | } 334 | }, 335 | "outputs": [], 336 | "source": [ 337 | "t.classattr" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": null, 343 | "metadata": { 344 | "slideshow": { 345 | "slide_type": "subslide" 346 | } 347 | }, 348 | "outputs": [], 349 | "source": [ 350 | "def my_decorator(f):\n", 351 | " def wrapper(*args, **kwargs):\n", 352 | " print('Calling decorated function')\n", 353 | " return f(*args, **kwargs)\n", 354 | " return wrapper\n", 355 | "\n", 356 | "@my_decorator\n", 357 | "def example():\n", 358 | " \"\"\"Docstring\"\"\"\n", 359 | " print('Called example function')" 360 | ] 361 | }, 362 | { 363 | "cell_type": "code", 364 | "execution_count": null, 365 | "metadata": { 366 | "slideshow": { 367 | "slide_type": "subslide" 368 | } 369 | }, 370 | "outputs": [], 371 | "source": [ 372 | "example()" 373 | ] 374 | }, 375 | { 376 | "cell_type": "code", 377 | "execution_count": null, 378 | "metadata": { 379 | "slideshow": { 380 | "slide_type": "fragment" 381 | } 382 | }, 383 | "outputs": [], 384 | "source": [ 385 | "print(example.__doc__)" 386 | ] 387 | }, 388 | { 389 | "cell_type": "code", 390 | "execution_count": null, 391 | "metadata": { 392 | "slideshow": { 393 | "slide_type": "fragment" 394 | } 395 | }, 396 | "outputs": [], 397 | "source": [ 398 | "print(example.__name__)" 399 | ] 400 | }, 401 | { 402 | "cell_type": "code", 403 | "execution_count": null, 404 | "metadata": { 405 | "slideshow": { 406 | "slide_type": "subslide" 407 | } 408 | }, 409 | "outputs": [], 410 | "source": [ 411 | "def my_decorator(f):\n", 412 | " def wrapper(*args, **kwargs):\n", 413 | " print('Calling decorated function') \n", 414 | " return f(*args, **kwargs)\n", 415 | " wrapper.__doc__ = f.__doc__\n", 416 | " wrapper.__name__ = f.__name__\n", 417 | " return wrapper\n", 418 | "\n", 419 | "@my_decorator\n", 420 | "def example():\n", 421 | " \"\"\"Docstring\"\"\"\n", 422 | " print('Called example function')" 423 | ] 424 | }, 425 | { 426 | "cell_type": "code", 427 | "execution_count": null, 428 | "metadata": { 429 | "slideshow": { 430 | "slide_type": "fragment" 431 | } 432 | }, 433 | "outputs": [], 434 | "source": [ 435 | "example()\n", 436 | "print(example.__doc__)\n", 437 | "print(example.__name__)" 438 | ] 439 | }, 440 | { 441 | "cell_type": "markdown", 442 | "metadata": { 443 | "slideshow": { 444 | "slide_type": "fragment" 445 | } 446 | }, 447 | "source": [ 448 | "Bazinga!" 449 | ] 450 | }, 451 | { 452 | "cell_type": "code", 453 | "execution_count": null, 454 | "metadata": { 455 | "slideshow": { 456 | "slide_type": "subslide" 457 | } 458 | }, 459 | "outputs": [], 460 | "source": [ 461 | "from functools import wraps\n", 462 | "\n", 463 | "def my_decorator(f):\n", 464 | " @wraps(f)\n", 465 | " def wrapper(*args, **kwds):\n", 466 | " print('Calling decorated function')\n", 467 | " return f(*args, **kwds)\n", 468 | " return wrapper\n", 469 | "\n", 470 | "@my_decorator\n", 471 | "def example():\n", 472 | " \"\"\"Docstring\"\"\"\n", 473 | " print('Called example function')" 474 | ] 475 | }, 476 | { 477 | "cell_type": "code", 478 | "execution_count": null, 479 | "metadata": { 480 | "slideshow": { 481 | "slide_type": "fragment" 482 | } 483 | }, 484 | "outputs": [], 485 | "source": [ 486 | "print(example.__doc__)\n", 487 | "print(example.__name__)" 488 | ] 489 | }, 490 | { 491 | "cell_type": "markdown", 492 | "metadata": { 493 | "slideshow": { 494 | "slide_type": "subslide" 495 | } 496 | }, 497 | "source": [ 498 | "* przy pisaniu dekoratorów **powinniśmy** dekorować funkcję dekorującą dekoratorem *wraps* z funkcją dekorowaną jako argument\n", 499 | "* przypiszemy nowej funkcji wszystkie potrzebne atrybuty starej funkcji, żeby mogła ją całkowicie podmienić " 500 | ] 501 | }, 502 | { 503 | "cell_type": "markdown", 504 | "metadata": { 505 | "slideshow": { 506 | "slide_type": "slide" 507 | } 508 | }, 509 | "source": [ 510 | "## Dekoratory w telegraficznym skrócie\n", 511 | "\n", 512 | "* Możliwość wzbogacenia funkcji lub klasy w przezroczysty dla użytkownika sposób.\n", 513 | "* `@dekorator`" 514 | ] 515 | } 516 | ], 517 | "metadata": { 518 | "celltoolbar": "Slideshow", 519 | "kernelspec": { 520 | "display_name": "Python 3 (ipykernel)", 521 | "language": "python", 522 | "name": "python3" 523 | }, 524 | "language_info": { 525 | "codemirror_mode": { 526 | "name": "ipython", 527 | "version": 3 528 | }, 529 | "file_extension": ".py", 530 | "mimetype": "text/x-python", 531 | "name": "python", 532 | "nbconvert_exporter": "python", 533 | "pygments_lexer": "ipython3", 534 | "version": "3.12.3" 535 | } 536 | }, 537 | "nbformat": 4, 538 | "nbformat_minor": 4 539 | } 540 | -------------------------------------------------------------------------------- /Lectures/12_type_hints.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Type hints" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": { 18 | "slideshow": { 19 | "slide_type": "slide" 20 | } 21 | }, 22 | "source": [ 23 | "https://docs.python.org/3/library/typing.html\n", 24 | "\n", 25 | "PEP 483, 484, 526, 544, 586, 589 i 591\n", 26 | "\n", 27 | "Python 3.6+" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": { 34 | "slideshow": { 35 | "slide_type": "fragment" 36 | } 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "a: \"hello\" = 1\n", 41 | "print(a)\n", 42 | "print(__annotations__)" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": null, 48 | "metadata": { 49 | "slideshow": { 50 | "slide_type": "fragment" 51 | } 52 | }, 53 | "outputs": [], 54 | "source": [ 55 | "def foo(a: \"in\") -> \"out\":\n", 56 | " pass\n", 57 | "\n", 58 | "foo.__annotations__" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": { 65 | "slideshow": { 66 | "slide_type": "subslide" 67 | } 68 | }, 69 | "outputs": [], 70 | "source": [ 71 | "from typing import List, Dict, NewType, Any\n", 72 | "\n", 73 | "Vector = List[float]\n", 74 | "# 3.9+: Vector = list[float]" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": { 81 | "slideshow": { 82 | "slide_type": "fragment" 83 | } 84 | }, 85 | "outputs": [], 86 | "source": [ 87 | "a: Vector = []" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": null, 93 | "metadata": { 94 | "slideshow": { 95 | "slide_type": "subslide" 96 | } 97 | }, 98 | "outputs": [], 99 | "source": [ 100 | "b: int\n", 101 | "b" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": { 108 | "slideshow": { 109 | "slide_type": "fragment" 110 | } 111 | }, 112 | "outputs": [], 113 | "source": [ 114 | "c: int\n", 115 | "c: float\n", 116 | "\n", 117 | "print(__annotations__)" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": { 124 | "slideshow": { 125 | "slide_type": "fragment" 126 | } 127 | }, 128 | "outputs": [], 129 | "source": [ 130 | "d: int = \"Don't tell me, how to live my life!\"" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": { 137 | "slideshow": { 138 | "slide_type": "subslide" 139 | } 140 | }, 141 | "outputs": [], 142 | "source": [ 143 | "def mean(d: dict[Any, float]) -> float:\n", 144 | " return sum(d.values()) / len(d)" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": null, 150 | "metadata": { 151 | "slideshow": { 152 | "slide_type": "subslide" 153 | } 154 | }, 155 | "outputs": [], 156 | "source": [ 157 | "ID = NewType('ID', int)\n", 158 | "\n", 159 | "user_id: ID = ID(14)" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": { 165 | "slideshow": { 166 | "slide_type": "subslide" 167 | } 168 | }, 169 | "source": [ 170 | "Duck types:\n", 171 | "- Mapping\n", 172 | "- MutableMapping\n", 173 | "- Sequence\n", 174 | "- Iterable\n", 175 | "- Callable (Callable[..., float])" 176 | ] 177 | }, 178 | { 179 | "cell_type": "markdown", 180 | "metadata": { 181 | "slideshow": { 182 | "slide_type": "subslide" 183 | } 184 | }, 185 | "source": [ 186 | "- Optional\n", 187 | "- Any\n", 188 | "- Union (Union[int, float] -> int | float)\n", 189 | "- None\n", 190 | "- TypeVar" 191 | ] 192 | } 193 | ], 194 | "metadata": { 195 | "celltoolbar": "Slideshow", 196 | "kernelspec": { 197 | "display_name": "Python 3 (ipykernel)", 198 | "language": "python", 199 | "name": "python3" 200 | }, 201 | "language_info": { 202 | "codemirror_mode": { 203 | "name": "ipython", 204 | "version": 3 205 | }, 206 | "file_extension": ".py", 207 | "mimetype": "text/x-python", 208 | "name": "python", 209 | "nbconvert_exporter": "python", 210 | "pygments_lexer": "ipython3", 211 | "version": "3.12.3" 212 | } 213 | }, 214 | "nbformat": 4, 215 | "nbformat_minor": 4 216 | } 217 | -------------------------------------------------------------------------------- /Lectures/13_moduły_i_pakiety.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Moduły i pakiety" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": { 18 | "slideshow": { 19 | "slide_type": "subslide" 20 | } 21 | }, 22 | "source": [ 23 | "## Wyrażenie import" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": { 29 | "slideshow": { 30 | "slide_type": "subslide" 31 | } 32 | }, 33 | "source": [ 34 | "* Zmienna `__name__` zawiera nazwę bieżącego modułu" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": { 40 | "slideshow": { 41 | "slide_type": "subslide" 42 | } 43 | }, 44 | "source": [ 45 | " #!/usr/bin/python3\n", 46 | " # Filename: using_name.py\n", 47 | " \n", 48 | " if __name__ == '__main__':\n", 49 | " print('This program is being run by itself')\n", 50 | " else:\n", 51 | " print('I am module {!r} imported from another module'.format(__name__))" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": { 57 | "slideshow": { 58 | "slide_type": "subslide" 59 | } 60 | }, 61 | "source": [ 62 | "Przykładowe uruchomienia:\n", 63 | " \n", 64 | " $ python3 using_name.py\n", 65 | " This program is being run by itself\n", 66 | " \n", 67 | " $ python3\n", 68 | " >>> import using_name\n", 69 | " I am module 'using_name' imported from another module\n", 70 | " >>>" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": { 76 | "slideshow": { 77 | "slide_type": "subslide" 78 | } 79 | }, 80 | "source": [ 81 | "* **import**\n", 82 | " * dołącza plik z $PYTHONPATH: .:/usr/local/lib/python\n", 83 | " \n", 84 | "* **import test**\n", 85 | " * Do x w test odwołujemy się przez \"test.x\"\n", 86 | " \n", 87 | "* **from test import x**\n", 88 | " * Do x w test odwołujemy się przez \"x\"\n", 89 | " * Nie mamy dostępu do innych składowych, ani do samego \"test\"\n", 90 | " \n", 91 | "* **import test.x.y** \n", 92 | " * Do y odwołujemy się przez \"test.x.y\" \n", 93 | "* **from test.x import y**\n", 94 | " * Do y odwołujemy się przez \"y\"\n", 95 | "* from test import \\*\n", 96 | " * Wczytuje wszystko z test. Do x w test odwołujemy się przez \"x\" (nie zalecane)\n", 97 | " \n", 98 | "* **import test as theTest** \n", 99 | " * Do x w test odwołujemy się przez \"theTest.x\"\n", 100 | "* **from test import x as my_x**\n", 101 | " * Do x odwołujemy się przez \"my_x\" \n", 102 | " \n" 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": { 108 | "slideshow": { 109 | "slide_type": "subslide" 110 | } 111 | }, 112 | "source": [ 113 | "* Symbol zaimportowany zostaje dołączony do przestrzeni nazw\n", 114 | "* Importowanie modułu (dowolnym sposobem) wykonuje **cały** jego kod\n", 115 | "* Kolekcja modułów (pakiet) znajduje się w katalogu\n", 116 | "* Pakiet musi zawierać plik \\_\\_init\\_\\_.py\n", 117 | "* Pakiet może zawierać podpakiety" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": { 124 | "slideshow": { 125 | "slide_type": "subslide" 126 | } 127 | }, 128 | "outputs": [], 129 | "source": [ 130 | "src/main.py src/__init__.py\n", 131 | "\n", 132 | "# python src/main.py\n", 133 | "python -m src.main" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "metadata": { 139 | "slideshow": { 140 | "slide_type": "subslide" 141 | } 142 | }, 143 | "source": [ 144 | "* **from .other_module import func** lub **from ..other_module import func**\n", 145 | " * do używania wewnątrz pakietu do importowania innych modułów z tego samego pakietu" 146 | ] 147 | }, 148 | { 149 | "cell_type": "markdown", 150 | "metadata": { 151 | "slideshow": { 152 | "slide_type": "subslide" 153 | } 154 | }, 155 | "source": [ 156 | " sound/ Top-level package\n", 157 | " __init__.py Initialize the sound package\n", 158 | " formats/ Subpackage for format conversions\n", 159 | " __init__.py\n", 160 | " wavread.py\n", 161 | " wavwrite.py\n", 162 | " aiffread.py\n", 163 | " aiffwrite.py\n", 164 | " auread.py\n", 165 | " auwrite.py\n", 166 | "\n", 167 | " >>> from sound.formats import wavwrite" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": { 173 | "slideshow": { 174 | "slide_type": "skip" 175 | } 176 | }, 177 | "source": [ 178 | "## dir()" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": { 185 | "slideshow": { 186 | "slide_type": "skip" 187 | } 188 | }, 189 | "outputs": [], 190 | "source": [ 191 | "import sys\n", 192 | "dir(sys) # get list of attributes for sys module" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": null, 198 | "metadata": { 199 | "slideshow": { 200 | "slide_type": "skip" 201 | } 202 | }, 203 | "outputs": [], 204 | "source": [ 205 | "%sx pwd" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": null, 211 | "metadata": { 212 | "slideshow": { 213 | "slide_type": "skip" 214 | } 215 | }, 216 | "outputs": [], 217 | "source": [ 218 | "%sx ls" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": { 225 | "slideshow": { 226 | "slide_type": "subslide" 227 | } 228 | }, 229 | "outputs": [], 230 | "source": [ 231 | "%sx mkdir -p agh" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": null, 237 | "metadata": { 238 | "slideshow": { 239 | "slide_type": "fragment" 240 | } 241 | }, 242 | "outputs": [], 243 | "source": [ 244 | "%cd agh" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": null, 250 | "metadata": { 251 | "slideshow": { 252 | "slide_type": "skip" 253 | } 254 | }, 255 | "outputs": [], 256 | "source": [ 257 | "%sx pwd" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": null, 263 | "metadata": { 264 | "slideshow": { 265 | "slide_type": "subslide" 266 | } 267 | }, 268 | "outputs": [], 269 | "source": [ 270 | "%%writefile __init__.py\n", 271 | "print(\"I am init\")" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": null, 277 | "metadata": { 278 | "slideshow": { 279 | "slide_type": "fragment" 280 | } 281 | }, 282 | "outputs": [], 283 | "source": [ 284 | "%%writefile student.py\n", 285 | "\n", 286 | "print(\"Importing student\")\n", 287 | "\n", 288 | "def _opinion():\n", 289 | " return \" rocks!\"\n", 290 | "\n", 291 | "def scream():\n", 292 | " print(\"AGH\" + _opinion())\n", 293 | " \n", 294 | "print(\"Name:\", __name__)" 295 | ] 296 | }, 297 | { 298 | "cell_type": "code", 299 | "execution_count": null, 300 | "metadata": { 301 | "slideshow": { 302 | "slide_type": "fragment" 303 | } 304 | }, 305 | "outputs": [], 306 | "source": [ 307 | "%cd .." 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": null, 313 | "metadata": { 314 | "slideshow": { 315 | "slide_type": "subslide" 316 | } 317 | }, 318 | "outputs": [], 319 | "source": [ 320 | "from agh import student\n", 321 | "student.scream()" 322 | ] 323 | }, 324 | { 325 | "cell_type": "code", 326 | "execution_count": null, 327 | "metadata": { 328 | "slideshow": { 329 | "slide_type": "fragment" 330 | } 331 | }, 332 | "outputs": [], 333 | "source": [ 334 | "from agh.student import scream\n", 335 | "scream()" 336 | ] 337 | }, 338 | { 339 | "cell_type": "code", 340 | "execution_count": null, 341 | "metadata": { 342 | "slideshow": { 343 | "slide_type": "fragment" 344 | } 345 | }, 346 | "outputs": [], 347 | "source": [ 348 | "from agh import student.scream" 349 | ] 350 | }, 351 | { 352 | "cell_type": "code", 353 | "execution_count": null, 354 | "metadata": { 355 | "slideshow": { 356 | "slide_type": "subslide" 357 | } 358 | }, 359 | "outputs": [], 360 | "source": [ 361 | "import agh.student\n", 362 | "\n", 363 | "agh.student.scream()" 364 | ] 365 | }, 366 | { 367 | "cell_type": "code", 368 | "execution_count": null, 369 | "metadata": { 370 | "slideshow": { 371 | "slide_type": "subslide" 372 | } 373 | }, 374 | "outputs": [], 375 | "source": [ 376 | "%run agh/student.py" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": null, 382 | "metadata": { 383 | "slideshow": { 384 | "slide_type": "fragment" 385 | } 386 | }, 387 | "outputs": [], 388 | "source": [ 389 | "student.scream()" 390 | ] 391 | }, 392 | { 393 | "cell_type": "code", 394 | "execution_count": null, 395 | "metadata": { 396 | "slideshow": { 397 | "slide_type": "fragment" 398 | } 399 | }, 400 | "outputs": [], 401 | "source": [ 402 | "student._opinion()" 403 | ] 404 | }, 405 | { 406 | "cell_type": "code", 407 | "execution_count": null, 408 | "metadata": { 409 | "slideshow": { 410 | "slide_type": "subslide" 411 | } 412 | }, 413 | "outputs": [], 414 | "source": [ 415 | "dir()" 416 | ] 417 | }, 418 | { 419 | "cell_type": "code", 420 | "execution_count": null, 421 | "metadata": { 422 | "slideshow": { 423 | "slide_type": "subslide" 424 | } 425 | }, 426 | "outputs": [], 427 | "source": [ 428 | "%reset" 429 | ] 430 | }, 431 | { 432 | "cell_type": "code", 433 | "execution_count": null, 434 | "metadata": { 435 | "slideshow": { 436 | "slide_type": "subslide" 437 | } 438 | }, 439 | "outputs": [], 440 | "source": [ 441 | "python -m tetris.gui.main\n", 442 | "python tetris/gui/main.py" 443 | ] 444 | }, 445 | { 446 | "cell_type": "code", 447 | "execution_count": null, 448 | "metadata": { 449 | "slideshow": { 450 | "slide_type": "subslide" 451 | } 452 | }, 453 | "outputs": [], 454 | "source": [ 455 | "dir()" 456 | ] 457 | }, 458 | { 459 | "cell_type": "markdown", 460 | "metadata": {}, 461 | "source": [ 462 | "## Moduły i pakiety w telegraficznym skrócie\n", 463 | "\n", 464 | "* `import` dołącza moduł z bieżącego katalogu, lub `$PYTHONPATH` (szczegóły w `sys.path`).\n", 465 | "* Moduł to plik `.py`.\n", 466 | "* Pakiet to katalog z modułami, zwyczajowo z modułem `__init__.py`.\n", 467 | "* Przed pierwszym importem z danego modułu wykonuje się cały jego kod (niezależnie od postaci importu)." 468 | ] 469 | } 470 | ], 471 | "metadata": { 472 | "celltoolbar": "Slideshow", 473 | "kernelspec": { 474 | "display_name": "Python 3 (ipykernel)", 475 | "language": "python", 476 | "name": "python3" 477 | }, 478 | "language_info": { 479 | "codemirror_mode": { 480 | "name": "ipython", 481 | "version": 3 482 | }, 483 | "file_extension": ".py", 484 | "mimetype": "text/x-python", 485 | "name": "python", 486 | "nbconvert_exporter": "python", 487 | "pygments_lexer": "ipython3", 488 | "version": "3.12.3" 489 | } 490 | }, 491 | "nbformat": 4, 492 | "nbformat_minor": 4 493 | } 494 | -------------------------------------------------------------------------------- /Lectures/15_wątki_i_procesy.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Wątki i procesy" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": {}, 18 | "source": [ 19 | "https://docs.python.org/3/library/threading.html" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": { 25 | "slideshow": { 26 | "slide_type": "fragment" 27 | } 28 | }, 29 | "source": [ 30 | "A programmer had a problem.\n", 31 | "\n", 32 | "\"I know! I will solve it with threads!\" - he thought to himself.\n", 33 | "\n", 34 | "has Now problems. two he" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": { 40 | "slideshow": { 41 | "slide_type": "subslide" 42 | } 43 | }, 44 | "source": [ 45 | "### Tworzenie i uruchamianie wątku" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": null, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "import threading\n", 55 | "\n", 56 | "class Thread1(threading.Thread):\n", 57 | " def run(self):\n", 58 | " for i in range(int(1e6)):\n", 59 | " if i % 1e4 == 0:\n", 60 | " print(i)\n", 61 | " \n", 62 | "t1 = Thread1()\n", 63 | "t2 = Thread1()\n", 64 | "\n", 65 | "t1.start()\n", 66 | "t2.start()\n", 67 | "print(\"Finished\")" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": { 74 | "slideshow": { 75 | "slide_type": "subslide" 76 | } 77 | }, 78 | "outputs": [], 79 | "source": [ 80 | "p = threading.Thread(target=print, args=('bob', 'john'), kwargs={'sep': '\\t'})\n", 81 | "p.start()" 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": { 87 | "slideshow": { 88 | "slide_type": "subslide" 89 | } 90 | }, 91 | "source": [ 92 | "A gdyby tak:" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": null, 98 | "metadata": {}, 99 | "outputs": [], 100 | "source": [ 101 | "@threaded\n", 102 | "def f():\n", 103 | " pass\n", 104 | "\n", 105 | "f()" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": { 111 | "slideshow": { 112 | "slide_type": "subslide" 113 | } 114 | }, 115 | "source": [ 116 | "### Synchronizacja wątków" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": { 122 | "slideshow": { 123 | "slide_type": "fragment" 124 | } 125 | }, 126 | "source": [ 127 | "#### Lock" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [ 136 | "import threading\n", 137 | "import time\n", 138 | "\n", 139 | "queue = list(range(10))\n", 140 | "lock = threading.Lock()\n", 141 | "\n", 142 | "class Consumer(threading.Thread):\n", 143 | " def run(self):\n", 144 | " running = True\n", 145 | " while running:\n", 146 | " lock.acquire()\n", 147 | " if not queue:\n", 148 | " running = False\n", 149 | " else:\n", 150 | " elem = queue.pop()\n", 151 | " lock.release()\n", 152 | " time.sleep(2) # do something with elem\n", 153 | " lock.acquire()\n", 154 | " print(self.name, elem)\n", 155 | " lock.release()\n", 156 | " \n", 157 | "t1 = Consumer()\n", 158 | "t2 = Consumer()\n", 159 | "t1.start()\n", 160 | "t2.start()\n", 161 | "t1.join()\n", 162 | "t2.join()\n", 163 | "print(\"Finished\")" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": null, 169 | "metadata": { 170 | "slideshow": { 171 | "slide_type": "subslide" 172 | } 173 | }, 174 | "outputs": [], 175 | "source": [ 176 | "import threading\n", 177 | "import time\n", 178 | "\n", 179 | "queue = list(range(10))\n", 180 | "lock = threading.Lock()\n", 181 | "\n", 182 | "class Consumer(threading.Thread):\n", 183 | " def run(self):\n", 184 | " while True:\n", 185 | " with lock:\n", 186 | " if not queue:\n", 187 | " break\n", 188 | " else:\n", 189 | " elem = queue.pop()\n", 190 | " time.sleep(3) # do something with elem\n", 191 | " with lock:\n", 192 | " print(self.name, elem)\n", 193 | " \n", 194 | "t1 = Consumer()\n", 195 | "t2 = Consumer()\n", 196 | "t1.start()\n", 197 | "t2.start()\n", 198 | "t1.join()\n", 199 | "t2.join()\n", 200 | "print(\"Finished\")" 201 | ] 202 | }, 203 | { 204 | "cell_type": "markdown", 205 | "metadata": { 206 | "slideshow": { 207 | "slide_type": "subslide" 208 | } 209 | }, 210 | "source": [ 211 | "`Lock`:\n", 212 | "* może zostać zwolniony przez **dowolny wątek**\n", 213 | "* próba ponownego zajęcia przez ten sam wątek blokuje go *ad infinitum*\n", 214 | "* nie można zwolnić, jeżeli nie został zajęty\n", 215 | "* można spróbować zająć w trybie nieblokującym\n", 216 | "* nie jest automatycznie zwalniany\n", 217 | "\n", 218 | "Polecam `RLock`:\n", 219 | "* może zostać zwolniony tylko przez wątek, który go posiada\n", 220 | "* można go zajmować wielokrotnie, ale należy zwolnić tyle samo razy\n", 221 | "* jest zwalniany automatycznie po zakończeniu wątku" 222 | ] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": { 227 | "slideshow": { 228 | "slide_type": "subslide" 229 | } 230 | }, 231 | "source": [ 232 | "A gdyby tak:" 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": null, 238 | "metadata": {}, 239 | "outputs": [], 240 | "source": [ 241 | "@synchronized\n", 242 | "def f():\n", 243 | " pass" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": null, 249 | "metadata": { 250 | "slideshow": { 251 | "slide_type": "subslide" 252 | } 253 | }, 254 | "outputs": [], 255 | "source": [ 256 | "type(threading.Lock())" 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": null, 262 | "metadata": { 263 | "slideshow": { 264 | "slide_type": "subslide" 265 | } 266 | }, 267 | "outputs": [], 268 | "source": [ 269 | "import threading\n", 270 | "import time\n", 271 | "\n", 272 | "lock = threading.RLock()\n", 273 | "\n", 274 | "class Thread1(threading.Thread):\n", 275 | " def run(self, *args):\n", 276 | " print(lock.acquire(False))\n", 277 | "# print(lock.acquire(timeout=3)) # alt\n", 278 | " time.sleep(1)\n", 279 | " lock.release()\n", 280 | " \n", 281 | " \n", 282 | "Thread1().start()\n", 283 | "# time.sleep(2)\n", 284 | "Thread1().start()" 285 | ] 286 | }, 287 | { 288 | "cell_type": "markdown", 289 | "metadata": { 290 | "slideshow": { 291 | "slide_type": "subslide" 292 | } 293 | }, 294 | "source": [ 295 | "#### Condition" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": {}, 302 | "outputs": [], 303 | "source": [ 304 | "import threading\n", 305 | "import time\n", 306 | "\n", 307 | "cv = threading.Condition()\n", 308 | "\n", 309 | "l = []\n", 310 | "\n", 311 | "class Consumer(threading.Thread):\n", 312 | " def run(self):\n", 313 | " '''Consume one item'''\n", 314 | " with cv:\n", 315 | " while True:\n", 316 | " while not l:\n", 317 | " cv.wait()\n", 318 | " print(l.pop(0))\n", 319 | "\n", 320 | "class Producer(threading.Thread):\n", 321 | " def run(self):\n", 322 | " '''Produce one item'''\n", 323 | " global l\n", 324 | " for i in range(10):\n", 325 | " with cv:\n", 326 | " l += [i]\n", 327 | " cv.notify()\n", 328 | " time.sleep(1)\n", 329 | "\n", 330 | "Consumer().start()\n", 331 | "time.sleep(2)\n", 332 | "Producer().start()" 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": null, 338 | "metadata": { 339 | "slideshow": { 340 | "slide_type": "subslide" 341 | } 342 | }, 343 | "outputs": [], 344 | "source": [ 345 | "print(l)" 346 | ] 347 | }, 348 | { 349 | "cell_type": "markdown", 350 | "metadata": { 351 | "slideshow": { 352 | "slide_type": "subslide" 353 | } 354 | }, 355 | "source": [ 356 | "#### Inne" 357 | ] 358 | }, 359 | { 360 | "cell_type": "markdown", 361 | "metadata": {}, 362 | "source": [ 363 | "* `Semaphore`\n", 364 | "* `BoundedSemaphore`\n", 365 | "* `Event`\n", 366 | "* `Timer`\n", 367 | "* `Barrier`" 368 | ] 369 | }, 370 | { 371 | "cell_type": "markdown", 372 | "metadata": { 373 | "slideshow": { 374 | "slide_type": "subslide" 375 | } 376 | }, 377 | "source": [ 378 | "### Wydajność" 379 | ] 380 | }, 381 | { 382 | "cell_type": "code", 383 | "execution_count": null, 384 | "metadata": { 385 | "slideshow": { 386 | "slide_type": "-" 387 | } 388 | }, 389 | "outputs": [], 390 | "source": [ 391 | "import threading\n", 392 | "import time\n", 393 | "\n", 394 | "class Thread1(threading.Thread):\n", 395 | " def run(self):\n", 396 | " for i in range(int(1e6)):\n", 397 | " a = i**2\n", 398 | " b = i**3\n", 399 | " c = i**4\n", 400 | " \n", 401 | "t1 = Thread1()\n", 402 | "t2 = Thread1()\n", 403 | "\n", 404 | "start = time.time()\n", 405 | "\n", 406 | "t1.start()\n", 407 | "t2.start()\n", 408 | "print(\"Finished\")\n", 409 | "\n", 410 | "t1.join()\n", 411 | "t2.join()\n", 412 | "\n", 413 | "finish = time.time()\n", 414 | "print(finish - start)" 415 | ] 416 | }, 417 | { 418 | "cell_type": "code", 419 | "execution_count": null, 420 | "metadata": { 421 | "slideshow": { 422 | "slide_type": "subslide" 423 | } 424 | }, 425 | "outputs": [], 426 | "source": [ 427 | "import threading\n", 428 | "import time\n", 429 | "\n", 430 | "class Thread1(threading.Thread):\n", 431 | " def run(self):\n", 432 | " for i in range(int(1e6)):\n", 433 | " a = i**2\n", 434 | " b = i**3\n", 435 | " c = i**4\n", 436 | " \n", 437 | "t1 = Thread1()\n", 438 | "t2 = Thread1()\n", 439 | "\n", 440 | "start = time.time()\n", 441 | "\n", 442 | "t1.run()\n", 443 | "t2.run()\n", 444 | "print(\"Finished\")\n", 445 | "\n", 446 | "finish = time.time()\n", 447 | "print(finish - start)" 448 | ] 449 | }, 450 | { 451 | "cell_type": "markdown", 452 | "metadata": { 453 | "slideshow": { 454 | "slide_type": "slide" 455 | } 456 | }, 457 | "source": [ 458 | "## Procesy" 459 | ] 460 | }, 461 | { 462 | "cell_type": "markdown", 463 | "metadata": {}, 464 | "source": [ 465 | "https://docs.python.org/3/library/multiprocessing.html" 466 | ] 467 | }, 468 | { 469 | "cell_type": "markdown", 470 | "metadata": { 471 | "slideshow": { 472 | "slide_type": "subslide" 473 | } 474 | }, 475 | "source": [ 476 | "### Wydajność" 477 | ] 478 | }, 479 | { 480 | "cell_type": "code", 481 | "execution_count": null, 482 | "metadata": {}, 483 | "outputs": [], 484 | "source": [ 485 | "import multiprocessing\n", 486 | "import time\n", 487 | "\n", 488 | "class Thread1(multiprocessing.Process):\n", 489 | " def run(self):\n", 490 | " for i in range(int(1e6)):\n", 491 | " a = i**2\n", 492 | " b = i**3\n", 493 | " c = i**4\n", 494 | " \n", 495 | "t1 = Thread1()\n", 496 | "t2 = Thread1()\n", 497 | "\n", 498 | "start = time.time()\n", 499 | "\n", 500 | "t1.run()\n", 501 | "t2.run()\n", 502 | "print(\"Finished\")\n", 503 | "\n", 504 | "finish = time.time()\n", 505 | "print(finish - start)" 506 | ] 507 | }, 508 | { 509 | "cell_type": "code", 510 | "execution_count": null, 511 | "metadata": { 512 | "slideshow": { 513 | "slide_type": "subslide" 514 | } 515 | }, 516 | "outputs": [], 517 | "source": [ 518 | "import multiprocessing\n", 519 | "import time\n", 520 | "\n", 521 | "class Thread1(multiprocessing.Process):\n", 522 | " def run(self):\n", 523 | " for i in range(int(1e6)):\n", 524 | " a = i**2\n", 525 | " b = i**3\n", 526 | " c = i**4\n", 527 | " \n", 528 | "t1 = Thread1()\n", 529 | "t2 = Thread1()\n", 530 | "\n", 531 | "start = time.time()\n", 532 | "\n", 533 | "t1.start()\n", 534 | "t2.start()\n", 535 | "print(\"Finished\")\n", 536 | "\n", 537 | "t1.join()\n", 538 | "t2.join()\n", 539 | "finish = time.time()\n", 540 | "print(finish - start)" 541 | ] 542 | }, 543 | { 544 | "cell_type": "markdown", 545 | "metadata": { 546 | "slideshow": { 547 | "slide_type": "subslide" 548 | } 549 | }, 550 | "source": [ 551 | "Procesy są cięższe i mniej wygodne w użyciu, ale omijają GIL." 552 | ] 553 | }, 554 | { 555 | "cell_type": "code", 556 | "execution_count": null, 557 | "metadata": { 558 | "slideshow": { 559 | "slide_type": "subslide" 560 | } 561 | }, 562 | "outputs": [], 563 | "source": [ 564 | "import multiprocessing\n", 565 | "import time\n", 566 | "\n", 567 | "queue = list(range(10))\n", 568 | "lock = multiprocessing.Lock()\n", 569 | "\n", 570 | "class Consumer(multiprocessing.Process):\n", 571 | " def run(self):\n", 572 | " while True:\n", 573 | " with lock:\n", 574 | " if not queue:\n", 575 | " break\n", 576 | " else:\n", 577 | " elem = queue.pop()\n", 578 | " time.sleep(2) # do something with elem\n", 579 | " with lock:\n", 580 | " print(self.pid, elem)\n", 581 | " \n", 582 | "t1 = Consumer()\n", 583 | "t2 = Consumer()\n", 584 | "t1.start()\n", 585 | "t2.start()" 586 | ] 587 | }, 588 | { 589 | "cell_type": "markdown", 590 | "metadata": { 591 | "slideshow": { 592 | "slide_type": "subslide" 593 | } 594 | }, 595 | "source": [ 596 | "Przydatne klasy:\n", 597 | "- Lock\n", 598 | "- Queue\n", 599 | "- JoinableQueue\n", 600 | "- Pipe\n", 601 | "- Value\n", 602 | "- Array" 603 | ] 604 | }, 605 | { 606 | "cell_type": "markdown", 607 | "metadata": { 608 | "slideshow": { 609 | "slide_type": "slide" 610 | } 611 | }, 612 | "source": [ 613 | "## Wątki w telegraficznym skrócie\n", 614 | "\n", 615 | "- moduł `threading`\n", 616 | "- dziedziczymy z `Thread` i nadpisujemy `run(self)`\n", 617 | "- albo instancjonujemy `Thread` i przekazujemy funkcję do konstruktora\n", 618 | "- uruchamiamy metodą `start()`\n", 619 | "- Global Interpreter Lock zabija wydajność... chyba że C\n", 620 | "- do synchronizacji: `RLock`, `Condition`, `Semaphore`, `BoundedSemaphore`, `Event`, `Timer`, `Barrier`" 621 | ] 622 | }, 623 | { 624 | "cell_type": "markdown", 625 | "metadata": { 626 | "slideshow": { 627 | "slide_type": "slide" 628 | } 629 | }, 630 | "source": [ 631 | "## Procesy w telegraficznym skrócie\n", 632 | "\n", 633 | "- moduł `multiprocessing`\n", 634 | "- dziedziczymy z `Process` i nadpisujemy `run(self)`\n", 635 | "- albo instancjonujemy `Process` i przekazujemy funkcję do konstruktora\n", 636 | "- uruchamiamy metodą `start()`\n", 637 | "- nie dotyczy ich GIL... ale działają w osobnej przestrzeni, więc komunikacja musi być jawna\n", 638 | "- przydatne klasy: `Lock`, `Queue`, `JoinableQueue`, `Pipe`, `Value`, `Array`" 639 | ] 640 | } 641 | ], 642 | "metadata": { 643 | "celltoolbar": "Slideshow", 644 | "kernelspec": { 645 | "display_name": "Python 3 (ipykernel)", 646 | "language": "python", 647 | "name": "python3" 648 | }, 649 | "language_info": { 650 | "codemirror_mode": { 651 | "name": "ipython", 652 | "version": 3 653 | }, 654 | "file_extension": ".py", 655 | "mimetype": "text/x-python", 656 | "name": "python", 657 | "nbconvert_exporter": "python", 658 | "pygments_lexer": "ipython3", 659 | "version": "3.12.3" 660 | } 661 | }, 662 | "nbformat": 4, 663 | "nbformat_minor": 4 664 | } 665 | -------------------------------------------------------------------------------- /Lectures/16_wyrażenia_regularne.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Wyrażenia regularne" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": {}, 18 | "source": [ 19 | "https://docs.python.org/3/library/re.html" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": null, 25 | "metadata": { 26 | "slideshow": { 27 | "slide_type": "subslide" 28 | } 29 | }, 30 | "outputs": [], 31 | "source": [ 32 | "\"ABC123\".isupper()" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": { 39 | "slideshow": { 40 | "slide_type": "fragment" 41 | } 42 | }, 43 | "outputs": [], 44 | "source": [ 45 | "import regex # re\n", 46 | "print(regex.fullmatch('[A-Z]+', \"ABC123\"))\n", 47 | "print(regex.fullmatch('[A-Z]+', \"ABC\"))" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": null, 53 | "metadata": { 54 | "slideshow": { 55 | "slide_type": "fragment" 56 | } 57 | }, 58 | "outputs": [], 59 | "source": [ 60 | "s = '\\\\'\n", 61 | "print(regex.fullmatch('\\\\\\\\', s))" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": { 68 | "slideshow": { 69 | "slide_type": "fragment" 70 | } 71 | }, 72 | "outputs": [], 73 | "source": [ 74 | "print(s)" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": { 81 | "slideshow": { 82 | "slide_type": "fragment" 83 | } 84 | }, 85 | "outputs": [], 86 | "source": [ 87 | "print('\\n')\n", 88 | "print(r'\\n')" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": { 94 | "slideshow": { 95 | "slide_type": "subslide" 96 | } 97 | }, 98 | "source": [ 99 | "Najważniejsze funkcje:\n", 100 | "* match / fullmatch\n", 101 | "* search\n", 102 | "* findall / finditer\n", 103 | "* sub\n", 104 | "* split" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": null, 110 | "metadata": { 111 | "slideshow": { 112 | "slide_type": "skip" 113 | } 114 | }, 115 | "outputs": [], 116 | "source": [ 117 | "match = regex.match(r'[a-z]+(.[a-z]+)+', \"agh.edu.pl\")\n", 118 | "print(match)" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": { 125 | "slideshow": { 126 | "slide_type": "skip" 127 | } 128 | }, 129 | "outputs": [], 130 | "source": [ 131 | "regex.match(r'[a-z]+(.[a-z]+)+', \"agh\")" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": null, 137 | "metadata": { 138 | "slideshow": { 139 | "slide_type": "skip" 140 | } 141 | }, 142 | "outputs": [], 143 | "source": [ 144 | "match.groups()" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": null, 150 | "metadata": { 151 | "slideshow": { 152 | "slide_type": "subslide" 153 | } 154 | }, 155 | "outputs": [], 156 | "source": [ 157 | "match = regex.match(r'[a-z]+(\\.[a-z]+)+', \"Website: agh.edu.pl\")\n", 158 | "print(match)\n", 159 | "match = regex.search(r'[a-z]+(\\.[a-z]+)+', \"Website: agh.edu.pl\")\n", 160 | "print(match)" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": null, 166 | "metadata": { 167 | "slideshow": { 168 | "slide_type": "fragment" 169 | } 170 | }, 171 | "outputs": [], 172 | "source": [ 173 | "match = regex.match(r'[a-z]+(\\.[a-z]+)+', \"koło.pl\")\n", 174 | "print(match)\n", 175 | "match = regex.match(r'\\p{Ll}+(\\.\\w+)+', \"koło.pl\")\n", 176 | "print(match)\n", 177 | "match = regex.match(r'\\w+(\\.\\w+)+', \"koło.pl\")\n", 178 | "print(match)" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": {}, 185 | "outputs": [], 186 | "source": [ 187 | "for s in (\"ko_ło.pl\", \"koło11.pl\"):\n", 188 | " print(regex.match(r'\\p{Ll}+(\\.\\w+)+', s))\n", 189 | " print(regex.match(r'\\w+(\\.\\w+)+', s))" 190 | ] 191 | }, 192 | { 193 | "cell_type": "markdown", 194 | "metadata": {}, 195 | "source": [ 196 | "Klasy znaków Unicode: https://www.fileformat.info/info/unicode/category/index.htm" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": {}, 203 | "outputs": [], 204 | "source": [ 205 | "print(regex.findall('a', 'baca'))\n", 206 | "print(regex.finditer('a', 'baca'))\n", 207 | "print(*regex.finditer('a', 'baca'))" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": { 213 | "slideshow": { 214 | "slide_type": "subslide" 215 | } 216 | }, 217 | "source": [ 218 | "Wyrażenie regularne może zawierać:\n", 219 | "* znaki\n", 220 | "* klasy znaków: `.`, `[a-z]`, `\\w`\n", 221 | "* operatory powtórzenia: `*`, `+`, `?`, `*?`, `+?`, `??`, `{m}`, `{m,n}`, `{m,n}?`\n", 222 | "* operator alternatywy: `|`\n", 223 | "* początek/koniec napisu: `^`/`$`\n", 224 | "* grupy: `(...)`\n", 225 | "* kontekst: `(?=...)`,`(?!...)`, `(?<=...)`, `(?...)`\n", 227 | "* grupy nieprzechwytujące: `(?:...)`\n", 228 | "* referencje wsteczne: `(?P=grupa)`, `\\1`, `\\99`\n", 229 | "* ..." 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": null, 235 | "metadata": { 236 | "slideshow": { 237 | "slide_type": "subslide" 238 | } 239 | }, 240 | "outputs": [], 241 | "source": [ 242 | "regex.sub(r\"([a-z])\", r\"_\\1\", \"abcd\")" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": {}, 249 | "outputs": [], 250 | "source": [ 251 | "print(regex.match(r'([abc])b\\1', 'aba'))\n", 252 | "print(regex.match(r'([abc])b\\1', 'abc'))" 253 | ] 254 | }, 255 | { 256 | "cell_type": "code", 257 | "execution_count": null, 258 | "metadata": { 259 | "slideshow": { 260 | "slide_type": "subslide" 261 | } 262 | }, 263 | "outputs": [], 264 | "source": [ 265 | "regex.split(\"c(?=d)\", \"abcdefcgh\")" 266 | ] 267 | }, 268 | { 269 | "cell_type": "markdown", 270 | "metadata": { 271 | "slideshow": { 272 | "slide_type": "subslide" 273 | } 274 | }, 275 | "source": [ 276 | "regex.I - case insensitive\n", 277 | "\n", 278 | "regex.M - multiline ($ może oznaczać koniec linii, a nie tylko koniec łańcucha)\n", 279 | "\n", 280 | "regex.S - kropka może oznaczać też koniec linii" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": null, 286 | "metadata": { 287 | "slideshow": { 288 | "slide_type": "subslide" 289 | } 290 | }, 291 | "outputs": [], 292 | "source": [ 293 | "regex.match('\\w+', \"犬いぬ\")" 294 | ] 295 | }, 296 | { 297 | "cell_type": "markdown", 298 | "metadata": { 299 | "slideshow": { 300 | "slide_type": "subslide" 301 | } 302 | }, 303 | "source": [ 304 | "\\w - word character\n", 305 | "\n", 306 | "\\s - whitespace\n", 307 | "\n", 308 | "\\d - digit\n", 309 | "\n", 310 | "\\b - word boundary (albo backspace)" 311 | ] 312 | }, 313 | { 314 | "cell_type": "markdown", 315 | "metadata": {}, 316 | "source": [ 317 | "## Wyrażenia regularne w telegraficznym skrócie\n", 318 | "\n", 319 | "* Moduł `re` albo lepiej `regex`.\n", 320 | "* Dość ciężkie.\n", 321 | "* Najważniejsze operacje: `match`, `fullmatch`, `search`, `findall`, `finditer`, `sub`, `split`\n", 322 | "* Najważniejsze składniki: znaki, klasy znaków (`[a-z]`, `\\w`), granice (`^`, `$`), powtórzenia (`+`,`*`, `?`), grupy (w nawiasach).\n", 323 | "* Najczęściej zapisywane w r-stringach." 324 | ] 325 | } 326 | ], 327 | "metadata": { 328 | "celltoolbar": "Slideshow", 329 | "kernelspec": { 330 | "display_name": "Python 3 (ipykernel)", 331 | "language": "python", 332 | "name": "python3" 333 | }, 334 | "language_info": { 335 | "codemirror_mode": { 336 | "name": "ipython", 337 | "version": 3 338 | }, 339 | "file_extension": ".py", 340 | "mimetype": "text/x-python", 341 | "name": "python", 342 | "nbconvert_exporter": "python", 343 | "pygments_lexer": "ipython3", 344 | "version": "3.12.3" 345 | } 346 | }, 347 | "nbformat": 4, 348 | "nbformat_minor": 4 349 | } 350 | -------------------------------------------------------------------------------- /Lectures/17_django.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Django" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": {}, 18 | "source": [ 19 | "https://www.djangoproject.com/\n", 20 | "\n", 21 | "Fragmenty kodu za: https://matthewdaly.co.uk/blog/2013/12/28/django-blog-tutorial-the-next-generation-part-1/" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": { 27 | "slideshow": { 28 | "slide_type": "subslide" 29 | } 30 | }, 31 | "source": [ 32 | "** The Web framework for perfectionists with deadlines **" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": { 38 | "slideshow": { 39 | "slide_type": "subslide" 40 | } 41 | }, 42 | "source": [ 43 | "* DRY - Don't Repeat Yourself. \"Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.\" http://c2.com/cgi/wiki?DontRepeatYourself\n", 44 | "* MVC vs MVT - django często określane jest mianem MVT - Model View Template\n", 45 | "* ORM - Object Relational Mapper (modele django)\n", 46 | "* Routing URL oparty na wyrażeniach regularnych\n", 47 | "* System szablonów \n", 48 | "* Cache'ing \n", 49 | "* Lokalizacja i tłumaczenia\n", 50 | "* Automatyczny panel admina" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": { 56 | "slideshow": { 57 | "slide_type": "subslide" 58 | } 59 | }, 60 | "source": [ 61 | "## Aplikacje" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "Projekt składa się z aplikacji.\n", 69 | "\n", 70 | "Projekty i aplikacje łączy zależność 'wiele do wielu'.\n", 71 | "\n", 72 | "Plik `settings.py` określa aplikacje zainstalowane w projekcie." 73 | ] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "metadata": { 78 | "slideshow": { 79 | "slide_type": "subslide" 80 | } 81 | }, 82 | "source": [ 83 | "## ORM (Object-Relational Mapping)" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | "Plik `models.py` w katalogu aplikacji." 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": { 97 | "slideshow": { 98 | "slide_type": "fragment" 99 | } 100 | }, 101 | "outputs": [], 102 | "source": [ 103 | "from django.db import models\n", 104 | "\n", 105 | "# Create your models here.\n", 106 | "\n", 107 | "class Post(models.Model):\n", 108 | " title = models.CharField(max_length=200)\n", 109 | " pub_date = models.DateTimeField()\n", 110 | " text = models.TextField()" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": { 117 | "slideshow": { 118 | "slide_type": "subslide" 119 | } 120 | }, 121 | "outputs": [], 122 | "source": [ 123 | "from django.db import models\n", 124 | "[cls for cls in dir(models) if cls.endswith(\"Field\")]" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": { 130 | "slideshow": { 131 | "slide_type": "subslide" 132 | } 133 | }, 134 | "source": [ 135 | "## Routing URL" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": { 142 | "slideshow": { 143 | "slide_type": "-" 144 | } 145 | }, 146 | "outputs": [], 147 | "source": [ 148 | "#plik urls.py projektu\n", 149 | "\n", 150 | "from django.conf.urls import include, url\n", 151 | "\n", 152 | "from django.contrib import admin\n", 153 | "\n", 154 | "urlpatterns = [\n", 155 | " url(r'^admin/', include(admin.site.urls)),\n", 156 | " url(r'^.*$', include('blogengine.urls')),\n", 157 | "]" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": { 164 | "slideshow": { 165 | "slide_type": "subslide" 166 | } 167 | }, 168 | "outputs": [], 169 | "source": [ 170 | "# plik urls.py aplikacji\n", 171 | "\n", 172 | "from django.conf.urls import patterns, url\n", 173 | "from django.views.generic import ListView\n", 174 | "\n", 175 | "from blogengine.models import Post\n", 176 | "from blogengine import views\n", 177 | "\n", 178 | "urlpatterns = [\n", 179 | " url('^$', ListView.as_view(model=Post,)),\n", 180 | " url('^(?P\\d+)$', views.post_view, name='postview')\n", 181 | "]" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": { 187 | "slideshow": { 188 | "slide_type": "subslide" 189 | } 190 | }, 191 | "source": [ 192 | "## Widoki" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": null, 198 | "metadata": {}, 199 | "outputs": [], 200 | "source": [ 201 | "# w pliku views.py aplikacji\n", 202 | "\n", 203 | "@login_required(login_url='/user/login/')\n", 204 | "def post_view(request, id):\n", 205 | " post = Post.objects.filter(id=id)[0]\n", 206 | " context = {'post': post}\n", 207 | " return render(request, 'views/post.html', context)" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": { 213 | "slideshow": { 214 | "slide_type": "subslide" 215 | } 216 | }, 217 | "source": [ 218 | "## Szablony" 219 | ] 220 | }, 221 | { 222 | "cell_type": "raw", 223 | "metadata": {}, 224 | "source": [ 225 | "\n", 226 | "\n", 227 | "\n", 228 | " \n", 229 | " My Django Blog\n", 230 | " \n", 231 | " \n", 232 | " {% for post in object_list %}\n", 233 | "

{{ post.title }}

\n", 234 | "

{{ post.pub_date }}

\n", 235 | " {{ post.text }}\n", 236 | " {% endfor %}\n", 237 | " \n", 238 | "" 239 | ] 240 | }, 241 | { 242 | "cell_type": "markdown", 243 | "metadata": { 244 | "slideshow": { 245 | "slide_type": "subslide" 246 | } 247 | }, 248 | "source": [ 249 | "Alternatywnie:" 250 | ] 251 | }, 252 | { 253 | "cell_type": "raw", 254 | "metadata": {}, 255 | "source": [ 256 | "\n", 257 | "\n", 258 | "\n", 259 | " \n", 260 | " My Django Blog\n", 261 | " \n", 262 | " \n", 263 | " {% block content %}\n", 264 | " {% endblock %}\n", 265 | " \n", 266 | "" 267 | ] 268 | }, 269 | { 270 | "cell_type": "raw", 271 | "metadata": { 272 | "slideshow": { 273 | "slide_type": "subslide" 274 | } 275 | }, 276 | "source": [ 277 | "\n", 278 | "\n", 279 | "{% extends \"base.html\" %}\n", 280 | "\n", 281 | "{% block content %}\n", 282 | " {% for post in object_list %}\n", 283 | "

{{ post.title }}

\n", 284 | "

{{ post.pub_date }}

\n", 285 | " {{ post.text }}\n", 286 | " {% endfor %}\n", 287 | "{% endblock %}" 288 | ] 289 | } 290 | ], 291 | "metadata": { 292 | "celltoolbar": "Slideshow", 293 | "kernelspec": { 294 | "display_name": "Python 3 (ipykernel)", 295 | "language": "python", 296 | "name": "python3" 297 | }, 298 | "language_info": { 299 | "codemirror_mode": { 300 | "name": "ipython", 301 | "version": 3 302 | }, 303 | "file_extension": ".py", 304 | "mimetype": "text/x-python", 305 | "name": "python", 306 | "nbconvert_exporter": "python", 307 | "pygments_lexer": "ipython3", 308 | "version": "3.12.3" 309 | } 310 | }, 311 | "nbformat": 4, 312 | "nbformat_minor": 4 313 | } 314 | -------------------------------------------------------------------------------- /Lectures/50_misc.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Język Python\n", 12 | "## Różności" 13 | ] 14 | }, 15 | { 16 | "cell_type": "markdown", 17 | "metadata": { 18 | "slideshow": { 19 | "slide_type": "slide" 20 | } 21 | }, 22 | "source": [ 23 | "## Kilka słów o logicznych typach danych" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": { 29 | "slideshow": { 30 | "slide_type": "subslide" 31 | } 32 | }, 33 | "source": [ 34 | "Do umieszczenia w repozytorium przed zwolnieniem się z firmy (za https://gist.github.com/aras-p/6224951)\n", 35 | " \n", 36 | " #define true ((rand()&15)!=15)\n", 37 | " \n", 38 | " #define if(x) if ((x) && (rand() < RAND_MAX * 0.99))" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": { 44 | "slideshow": { 45 | "slide_type": "subslide" 46 | } 47 | }, 48 | "source": [ 49 | "Słowa kluczowe - traktowane specjalnie przez parser" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": { 56 | "slideshow": { 57 | "slide_type": "subslide" 58 | } 59 | }, 60 | "outputs": [], 61 | "source": [ 62 | "from keyword import kwlist\n", 63 | "\n", 64 | "print(kwlist)" 65 | ] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "metadata": { 70 | "slideshow": { 71 | "slide_type": "subslide" 72 | } 73 | }, 74 | "source": [ 75 | "Nie można użyć słów kluczowych do nazywania zmiennych i funkcji" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": { 82 | "slideshow": { 83 | "slide_type": "fragment" 84 | } 85 | }, 86 | "outputs": [], 87 | "source": [ 88 | "for = 8\n", 89 | "while = \"aaa\"" 90 | ] 91 | }, 92 | { 93 | "cell_type": "markdown", 94 | "metadata": { 95 | "slideshow": { 96 | "slide_type": "subslide" 97 | } 98 | }, 99 | "source": [ 100 | "Wbudowane - typy, funkcje, wyjątki. Traktowane przez parser jak identyfikatory tworzone przez programistę. Można (o zgrozo) używać ich w przypisaniach." 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": null, 106 | "metadata": { 107 | "slideshow": { 108 | "slide_type": "fragment" 109 | } 110 | }, 111 | "outputs": [], 112 | "source": [ 113 | "print(dir(__builtins__))" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": { 120 | "slideshow": { 121 | "slide_type": "fragment" 122 | } 123 | }, 124 | "outputs": [], 125 | "source": [ 126 | "int = \"ojej\"\n", 127 | "len = lambda x : 137" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": { 134 | "slideshow": { 135 | "slide_type": "subslide" 136 | } 137 | }, 138 | "outputs": [], 139 | "source": [ 140 | "print(len([0, 1, 2, 3]))\n", 141 | "'True' in dir(__builtins__)" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": { 147 | "slideshow": { 148 | "slide_type": "subslide" 149 | } 150 | }, 151 | "source": [ 152 | "* Porównania\n", 153 | "\n", 154 | " * Python2 (od 2.3): wbudowany typ `bool`, dwie wartości ``True`` i ``False`` **nie będące słowami kluczowymi**\n", 155 | " * Python3: wbudowana klasa `bool`, dwie możliwe wartości będące obiektami tej klasy: ``True`` i ``False`` - **słowa kluczowe**\n", 156 | " \n", 157 | " http://python-history.blogspot.com/2013/11/story-of-none-true-false.html" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": { 164 | "slideshow": { 165 | "slide_type": "fragment" 166 | } 167 | }, 168 | "outputs": [], 169 | "source": [ 170 | "%%python3\n", 171 | "True = 0" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": null, 177 | "metadata": { 178 | "slideshow": { 179 | "slide_type": "subslide" 180 | } 181 | }, 182 | "outputs": [], 183 | "source": [ 184 | "%%python2\n", 185 | "True = 0\n", 186 | "\n", 187 | "if True: print(\"OK\")" 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": null, 193 | "metadata": { 194 | "slideshow": { 195 | "slide_type": "subslide" 196 | } 197 | }, 198 | "outputs": [], 199 | "source": [ 200 | "%%python2\n", 201 | "def guess(number=23):\n", 202 | " running = True\n", 203 | "\n", 204 | " while running:\n", 205 | " guess = int(raw_input('Enter an integer : '))\n", 206 | "\n", 207 | " if guess == number:\n", 208 | " print 'Congratulations, you guessed it.'\n", 209 | " running = False # this causes the while loop to stop\n", 210 | " elif guess < number:\n", 211 | " print('No, it is a little higher than that.')\n", 212 | " else:\n", 213 | " print('No, it is a little lower than that.')\n", 214 | " else:\n", 215 | " print('The while loop is over.')\n", 216 | " # Do anything else you want to do here\n", 217 | " print('Done')\n", 218 | "\n", 219 | "True = 0\n", 220 | "guess()" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": { 227 | "slideshow": { 228 | "slide_type": "skip" 229 | } 230 | }, 231 | "outputs": [], 232 | "source": [ 233 | "%reset" 234 | ] 235 | }, 236 | { 237 | "cell_type": "markdown", 238 | "metadata": { 239 | "slideshow": { 240 | "slide_type": "subslide" 241 | } 242 | }, 243 | "source": [ 244 | "Porównania:\n", 245 | "\n", 246 | "* nie używać \"``== True``\" ani \"`is True`\" do sprawdzania prawdziwości\n", 247 | "\n", 248 | " * Dobrze: ``if greeting:``\n", 249 | " * Źle: ``if greeting == True:``\n", 250 | " * Jeszcze gorzej: ``if greeting is True:``" 251 | ] 252 | }, 253 | { 254 | "cell_type": "markdown", 255 | "metadata": { 256 | "slideshow": { 257 | "slide_type": "slide" 258 | } 259 | }, 260 | "source": [ 261 | "## Programowanie funkcyjne" 262 | ] 263 | }, 264 | { 265 | "cell_type": "markdown", 266 | "metadata": { 267 | "slideshow": { 268 | "slide_type": "subslide" 269 | } 270 | }, 271 | "source": [ 272 | "* filter - filtrowanie kolekcji\n", 273 | "* map - modyfikacja kolekcji\n", 274 | "* reduce - redukowanie kolekcji (wyliczanie wartości z jej elementów), w Python3 w module functools" 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": null, 280 | "metadata": { 281 | "slideshow": { 282 | "slide_type": "subslide" 283 | } 284 | }, 285 | "outputs": [], 286 | "source": [ 287 | "l = list(range(10))\n", 288 | "print(list(filter(lambda x: not x%2, l)))\n", 289 | "print([x for x in l if not x%2])" 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": null, 295 | "metadata": { 296 | "slideshow": { 297 | "slide_type": "fragment" 298 | } 299 | }, 300 | "outputs": [], 301 | "source": [ 302 | "print(list(map(lambda x: x**2, l)))\n", 303 | "print([x**2 for x in l])" 304 | ] 305 | }, 306 | { 307 | "cell_type": "markdown", 308 | "metadata": { 309 | "slideshow": { 310 | "slide_type": "subslide" 311 | } 312 | }, 313 | "source": [ 314 | "Zamiast reduce:\n", 315 | "- sum\n", 316 | "- set.union\n", 317 | "- set.intersection" 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": null, 323 | "metadata": { 324 | "slideshow": { 325 | "slide_type": "subslide" 326 | } 327 | }, 328 | "outputs": [], 329 | "source": [ 330 | "l = [[x, x+1] for x in range(4)]\n", 331 | "print(l)\n", 332 | "sum(l, start=[])" 333 | ] 334 | }, 335 | { 336 | "cell_type": "markdown", 337 | "metadata": { 338 | "slideshow": { 339 | "slide_type": "skip" 340 | } 341 | }, 342 | "source": [ 343 | "Policzyć, ile owoców wspólnie mają Merry i Tom:" 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": null, 349 | "metadata": { 350 | "slideshow": { 351 | "slide_type": "skip" 352 | } 353 | }, 354 | "outputs": [], 355 | "source": [ 356 | "fruits = {\n", 357 | " 'Merry': [\n", 358 | " ('apple', 5),\n", 359 | " ('orange', 3),\n", 360 | " ],\n", 361 | " 'John': [\n", 362 | " ('berries', 1),\n", 363 | " ('orange', 10),\n", 364 | " ],\n", 365 | " 'Tom' : [\n", 366 | " ('peach', 2),\n", 367 | " ],\n", 368 | "}\n", 369 | "list(fruits.items())" 370 | ] 371 | }, 372 | { 373 | "cell_type": "markdown", 374 | "metadata": { 375 | "slideshow": { 376 | "slide_type": "skip" 377 | } 378 | }, 379 | "source": [ 380 | "Filtrujemy \"bazę\" z owoców Johna:" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": null, 386 | "metadata": { 387 | "slideshow": { 388 | "slide_type": "skip" 389 | } 390 | }, 391 | "outputs": [], 392 | "source": [ 393 | "f = filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n", 394 | "list(f)" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": { 400 | "slideshow": { 401 | "slide_type": "skip" 402 | } 403 | }, 404 | "source": [ 405 | "Usuwamy imiona, nie są nam już potrzebne:" 406 | ] 407 | }, 408 | { 409 | "cell_type": "code", 410 | "execution_count": null, 411 | "metadata": { 412 | "slideshow": { 413 | "slide_type": "skip" 414 | } 415 | }, 416 | "outputs": [], 417 | "source": [ 418 | "mapa1 = map(lambda y: y[1], \n", 419 | " filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n", 420 | ")\n", 421 | "list(mapa1)" 422 | ] 423 | }, 424 | { 425 | "cell_type": "markdown", 426 | "metadata": { 427 | "slideshow": { 428 | "slide_type": "skip" 429 | } 430 | }, 431 | "source": [ 432 | "Alternatywnie" 433 | ] 434 | }, 435 | { 436 | "cell_type": "code", 437 | "execution_count": null, 438 | "metadata": { 439 | "slideshow": { 440 | "slide_type": "skip" 441 | } 442 | }, 443 | "outputs": [], 444 | "source": [ 445 | "[val for name, val in fruits.items() if name in {'Merry','Tom'}]" 446 | ] 447 | }, 448 | { 449 | "cell_type": "markdown", 450 | "metadata": { 451 | "slideshow": { 452 | "slide_type": "skip" 453 | } 454 | }, 455 | "source": [ 456 | "Sklejamy listę list w jedną listę:" 457 | ] 458 | }, 459 | { 460 | "cell_type": "code", 461 | "execution_count": null, 462 | "metadata": { 463 | "slideshow": { 464 | "slide_type": "skip" 465 | } 466 | }, 467 | "outputs": [], 468 | "source": [ 469 | "from itertools import chain\n", 470 | "list(chain(\n", 471 | " *map(lambda y: y[1], \n", 472 | " filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n", 473 | " )\n", 474 | "))" 475 | ] 476 | }, 477 | { 478 | "cell_type": "markdown", 479 | "metadata": { 480 | "slideshow": { 481 | "slide_type": "skip" 482 | } 483 | }, 484 | "source": [ 485 | "Mapujemy listę tupli na listę liczb" 486 | ] 487 | }, 488 | { 489 | "cell_type": "code", 490 | "execution_count": null, 491 | "metadata": { 492 | "slideshow": { 493 | "slide_type": "skip" 494 | } 495 | }, 496 | "outputs": [], 497 | "source": [ 498 | "mapa2 = map(lambda f: f[1], \n", 499 | " chain(\n", 500 | " *map(lambda y: y[1], \n", 501 | " filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n", 502 | " )\n", 503 | " )\n", 504 | ")\n", 505 | "list(mapa2)" 506 | ] 507 | }, 508 | { 509 | "cell_type": "markdown", 510 | "metadata": { 511 | "slideshow": { 512 | "slide_type": "skip" 513 | } 514 | }, 515 | "source": [ 516 | "Finalnie redukujemy listę do sumy elementów:" 517 | ] 518 | }, 519 | { 520 | "cell_type": "code", 521 | "execution_count": null, 522 | "metadata": { 523 | "slideshow": { 524 | "slide_type": "skip" 525 | } 526 | }, 527 | "outputs": [], 528 | "source": [ 529 | "sum( \n", 530 | " map(lambda f: f[1], \n", 531 | " chain(\n", 532 | " *map(lambda y: y[1], \n", 533 | " filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n", 534 | " )\n", 535 | " )\n", 536 | " )\n", 537 | ")" 538 | ] 539 | }, 540 | { 541 | "cell_type": "markdown", 542 | "metadata": { 543 | "slideshow": { 544 | "slide_type": "skip" 545 | } 546 | }, 547 | "source": [ 548 | "Możemy także użyć gotowego operatora dodawania z modułu operator:" 549 | ] 550 | }, 551 | { 552 | "cell_type": "code", 553 | "execution_count": null, 554 | "metadata": { 555 | "slideshow": { 556 | "slide_type": "skip" 557 | } 558 | }, 559 | "outputs": [], 560 | "source": [ 561 | "import operator\n", 562 | "import functools\n", 563 | "functools.reduce(lambda a,b: a+b, \n", 564 | " map(lambda f: f[1], \n", 565 | " chain(\n", 566 | " *map(lambda y: y[1], \n", 567 | " filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n", 568 | " )\n", 569 | " )\n", 570 | " )\n", 571 | ")" 572 | ] 573 | }, 574 | { 575 | "cell_type": "code", 576 | "execution_count": null, 577 | "metadata": { 578 | "slideshow": { 579 | "slide_type": "skip" 580 | } 581 | }, 582 | "outputs": [], 583 | "source": [ 584 | "list(chain(*[item[1] for item in fruits.items() if item[0] in {'Merry','Tom'}]))" 585 | ] 586 | }, 587 | { 588 | "cell_type": "code", 589 | "execution_count": null, 590 | "metadata": { 591 | "slideshow": { 592 | "slide_type": "skip" 593 | } 594 | }, 595 | "outputs": [], 596 | "source": [ 597 | "sum(it[1] for it in chain(*[item[1] for item in fruits.items() if item[0] in {'Merry','Tom'}]))" 598 | ] 599 | }, 600 | { 601 | "cell_type": "code", 602 | "execution_count": null, 603 | "metadata": { 604 | "slideshow": { 605 | "slide_type": "skip" 606 | } 607 | }, 608 | "outputs": [], 609 | "source": [ 610 | "fruits = {\n", 611 | " 'Merry': [\n", 612 | " ('apple', 5),\n", 613 | " ('orange', 3),\n", 614 | " ],\n", 615 | " 'John': [\n", 616 | " ('berries', 1),\n", 617 | " ('orange', 10),\n", 618 | " ],\n", 619 | " 'Tom' : [\n", 620 | " ('peaches', 2),\n", 621 | " ],\n", 622 | "}\n", 623 | "fruits" 624 | ] 625 | }, 626 | { 627 | "cell_type": "code", 628 | "execution_count": null, 629 | "metadata": { 630 | "slideshow": { 631 | "slide_type": "skip" 632 | } 633 | }, 634 | "outputs": [], 635 | "source": [ 636 | "sum([y[1] for x in [owoce for name, owoce in fruits.items() if name in [\"Merry\", \"Tom\"]] for y in x])" 637 | ] 638 | } 639 | ], 640 | "metadata": { 641 | "celltoolbar": "Slideshow", 642 | "kernelspec": { 643 | "display_name": "Python 3 (ipykernel)", 644 | "language": "python", 645 | "name": "python3" 646 | }, 647 | "language_info": { 648 | "codemirror_mode": { 649 | "name": "ipython", 650 | "version": 3 651 | }, 652 | "file_extension": ".py", 653 | "mimetype": "text/x-python", 654 | "name": "python", 655 | "nbconvert_exporter": "python", 656 | "pygments_lexer": "ipython3", 657 | "version": "3.12.3" 658 | } 659 | }, 660 | "nbformat": 4, 661 | "nbformat_minor": 4 662 | } 663 | -------------------------------------------------------------------------------- /Lectures/img/AdafruitTrinket.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/AdafruitTrinket.jpg -------------------------------------------------------------------------------- /Lectures/img/JSON.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/JSON.jpg -------------------------------------------------------------------------------- /Lectures/img/Observer.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/Observer.webp -------------------------------------------------------------------------------- /Lectures/img/OccamsRazor.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/OccamsRazor.jpeg -------------------------------------------------------------------------------- /Lectures/img/cl_atr.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/cl_atr.png -------------------------------------------------------------------------------- /Lectures/img/guido1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/guido1.jpg -------------------------------------------------------------------------------- /Lectures/img/img040.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/img040.gif -------------------------------------------------------------------------------- /Lectures/img/img041.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/img041.gif -------------------------------------------------------------------------------- /Lectures/img/long_words.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/long_words.jpg -------------------------------------------------------------------------------- /Lectures/img/obj_atr.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/obj_atr.png -------------------------------------------------------------------------------- /Lectures/img/okay-thats-it-everyone-out-of-the-gene-pool.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/agh-glk/python-lecture/2e67f1752c773ee59c97af3f64bf3dacd487aedb/Lectures/img/okay-thats-it-everyone-out-of-the-gene-pool.jpg -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | python-lecture 2 | ============== 3 | 4 | Wykłady z Pythona na AGH w formacie Jupyter Notebook. 5 | 6 | Ten wykład dotyczy Pythona w wersji 3.x. 7 | 8 | Gałąź python2x (https://github.com/agh-glk/python-lecture/tree/python2x) dotyczy... Pythona 2.x, ale nie jest aktualizowana jeszcze dłużej niż sam Python 2. 9 | 10 | ### Jak używać? 11 | 12 | #### Na Linuksie (Debian i podobne) 13 | 14 | https://jupyter.org/install 15 | 16 | W celu uruchomienia Jupyter Notebooka (dawniej IPython Notebook) należy: 17 | 18 | 0. Zainstaluj dodatkowe pakiety systemowe (jeśli jeszcze ich nie masz): 19 | 20 | ``` 21 | $ sudo apt-get install git python3-pip 22 | ``` 23 | 24 | 1. Zainstaluj pełny moduł Jupyter: 25 | 26 | ``` 27 | $ sudo pip3 install jupyter 28 | ``` 29 | 30 | 2. Pobierz źródła: 31 | 32 | ``` 33 | $ git clone https://github.com/agh-glk/python-lecture.git 34 | ``` 35 | 36 | 3. Wejdź do katalogu z wykładem: 37 | 38 | ``` 39 | $ cd python-lecture 40 | ``` 41 | 42 | 4. (Opcjonalnie) Jeśli chcesz uaktualnić źródła wykładu, wykonaj: 43 | 44 | ``` 45 | $ git pull 46 | ``` 47 | 48 | 5. Uruchom Notebook: 49 | 50 | ``` 51 | $ jupyter notebook 52 | ``` 53 | 54 | albo Jupyter Lab: 55 | 56 | ``` 57 | $ jupyter lab 58 | ``` 59 | 60 | 61 | Po wykonaniu powyższych czynności, w przeglądarce pod adresem `http://localhost:8888/` powinien odpowiadać Jupyter Notebook/Lab. 62 | 63 | 64 | #### Na Windowsie 65 | 66 | W celu uruchomienia Jupyter Notebooka: 67 | 68 | 1. Zainstaluj Anacondę: [strona pobierania](http://continuum.io/downloads). 69 | 70 | 2. Zaktualizuj Anacondę oraz Jupytera: 71 | 72 | ``` 73 | $ conda update conda 74 | $ conda update jupyter 75 | ``` 76 | 77 | 3. Pobierz źródła poprzez polecenie w Git Bash (jeśli nie masz Gita, [zainstaluj go](http://git-scm.com/download/win)): 78 | 79 | ``` 80 | $ git clone https://github.com/agh-glk/python-lecture.git 81 | ``` 82 | 4. Wejdź do katalogu z wykładem: 83 | 84 | ``` 85 | $ cd python-lecture 86 | ``` 87 | 88 | 5. (Opcjonalnie) Jeśli chcesz uaktualnić źródła wykładu, wykonaj: 89 | 90 | ``` 91 | $ git pull 92 | ``` 93 | 94 | 6. Uruchom Notebook: 95 | 96 | ``` 97 | $ jupyter notebook 98 | ``` 99 | 100 | Jeśli powyższa komenda nie działa, spróbuj 101 | 102 | ``` 103 | $ jupyter notebook nazwa_pliku.ipynb 104 | ``` 105 | 106 | Po wykonaniu powyższych czynności, w przeglądarce pod adresem `http://localhost:8888/` powinien odpowiadać Jupyter Notebook. 107 | 108 | 109 | 110 | ### Poprawki zauważonych błędów 111 | 112 | Wszelkie erraty i poprawki mile widziane, proszę zrobić fork + pull request. Albo po prostu wysłać maila. 113 | --------------------------------------------------------------------------------