{ "cells": [ { "metadata": {}, "cell_type": "markdown", "source": "### Powitanie\nPo uruchomieniu kontenera należy wyczyścić informacje wyjściowe za pomocą menu Kernel -> Restart & Clear Output.\n\nKorzystany z notatników Jupitera, które są podłączone do interpretera Python w wersji 3.\n\nMamy dwa główne rodzaj komórek\nCode: Tu piszemy kod w języku Python\nMarkDown : Tu piszemy dokumentację kodu\nOpis języka MarkDown https://blog.nayma.pl/podstawy-markdown/\n\nTa komórka jest oznaczona jako komórka MarkDown" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# tu mamy naszą pierwszą komórkę, typu Code, ustawiamy kursor myszy w komórce, klikamy, na górze jest przycisk \"Run\"\nprint(\"Witamy w świecie Pythona z poziomu notatnika Jupyter\")\n# komentarze jednolinijkowe zaczynamy od znaku #", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Jaka mamy wersje Pythona 2, czy 3 \nimport sys #importujemy modul sys\nprint (\"Używana wersja Pythona to: \", sys.version)\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Komentarze\n\n##### Linia zaczynająca się od #, komentarz ma zakres jednej linii\n##### Komentarz wielolinijkowy\n\n'''\nKomentarz wielolinijkowy\n'''" }, { "metadata": {}, "cell_type": "markdown", "source": "### Podstawowe typy danych\n#### całkowite\n#### rzeczywiste\n#### logiczne\n#### napisy\n\nNależy zwrócić uwagę na to, że mamy do czynienia z dynamicznym typowaniem, co w praktyce oznacza zmianę typu zmiennej w czasie i wymaga kontroli typu przez programistę. To na czym chcę się dodatkowo skoncentrować to jawna konwersja typów, system pomocy, wbudowane funkcje." }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Python jako kalkulator\n\n1+2", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Priorytety operatorów dodawania i mnożenia\n\n1+2*3", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# wymuszanie priorytetow operacji\n\n(1+2)*3", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# dzielenie, którego wynikiem jest wartość rzeczywista\n\n1/2", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# dzielenie, ktorego wynikiem jest nadal wartość rzeczywista\n\n4.0/2.0", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# dzielenie calkowite 5//2 -> 2 ile razy zmieście się 2 w 5\n\n5//2", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# nie mylić dzielenia całkowitego // z resztą z dzielenia całkowitego % 5%2 -> 1 , ile zostanie z podzialu 5 na 2 cześci\n5%2", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "##### typ całkowity" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# typ całkowity, wykorzystaju tu metodę type\n\ntype(2)\ntype(0)\ntype(1)\ntype(-100)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "##### typ rzeczywisty" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# typ rzeczywisty\n\ntype(2.5)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# typ rzeczywisty, nawet jeśli część ułamkowa jest zerem.\n\ntype(2.0)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "##### Typ logiczny" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# typ logiczny, rylko dwa stany False, True\ntype(False)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# a teraz prawda\ntype (True)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Włączenie możliwości wyswietlania wielu wyjść w notatniku\nfrom IPython.core.interactiveshell import InteractiveShell\nInteractiveShell.ast_node_interactivity = \"all\"", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# suma logiczna\nFalse or True # True\nFalse or False # False\nTrue or True # True\n\n# iloczyn logiczny\nTrue and True # True\nTrue and False # False\nFalse and False # False\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### typ napisowy" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "\"Napis1\" # Napis obraniczony \"\"\n'Napis2' # Napis obraniczony ''\nprint('Napis1',\"Napis2\")\n# Polaczone napisów # konkatenacja operatorem +\n\"Ala\"+ ' ma '+ 'kota'\n# jaka jest dlugosc napisu, wbudowana funkcja len\nprint(\"Napis ma długość \",len(\"Ala\"+ ' ma '+ 'kota'),\" znaków.\")", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# powielenie napisu kilka razy\n\"Ala ma kota \"*2\n# lub tak\n10*\"A kot nie ma mleka. \"", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "### Zmienne" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# zapiszmy wartość w zmiennej a\n\na=102\n\n# wyświetlamy jej wartość\n\nprint(a)\n\n# wyświetlamy jej typ\n\nprint(type(a))", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# python jest typowany dynamiczne, typ zmiennej a moze się zmieniać w czasie\n\na=2.1\n\n# wyswietlmy jej wartość\n\nprint(a)\n\n# wyswietlmy jej typ\n\nprint(type(a))", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "### Statyczne typowanie od wersji 3.6 ### " }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Od wersji Pythona 3.6 istnieje możliwość statycznej deklaracji typu\n\n# nazwa zmiennej: type\n\nzm_calk: int = 100 #SyntaxError: invalid syntax\nzm_rzecz: float = 100.0 \nzm_napis: str = '100'\nzm_log: bool = False \nprint(zm_calk,type(zm_calk)) \nprint(zm_rzecz,type(zm_rzecz)) \nprint(zm_napis,type(zm_napis)) \nprint(zm_log,type(zm_log)) ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "##### Usuwanie zmiennych" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "#usuwanie zmiennych\n\na=2.5\nprint(a)\n\n#usuwamy zmienną a\n\ndel a\n\n#uzycie usuniętej zmiennej konczy się błędem\n\nprint(a)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "#Python rozróżnia duże i małe litery\n\nb=1.0\nprint(B) #name 'B' is not defined", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "#Python rozróżnia duże i małe litery\n\nb=1.0 \nB=100\nprint(b,type(b)) #1.0 \nprint(B,type(B)) # 100 ", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Python jest silnie typowany (!)\n\na=1 # zmienny typu całkowitego (int)\nf=1.0 # zmienna typu rzeczywistego (float)\ns=\"Napis\" # zmianna napisowa\n\nprint(a+f) # 2.0\nprint(f+s) #TypeError: unsupported operand type(s) for +: 'float' and 'str'\nprint(s+a) #TypeError: must be str, not int", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "### Python jest silnie typowany\nWażne jest uzmysłowienie sobie informacji o tym, że Python jest nie tylko dynamicznie typowany, ale również silnie typowany, dlatego musimy uważać na wszelkie konwersje typów. Poniżej prosty kod, na trzy instrukcje print, tylko jedna wykona się poprawnie." }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Python jest silnie typowany (!)\n\n# Wymuszamy konwersję \n\n\na=1 # zmienny typu całkowitego (int)\nf=1.0 # zmienna typu rzeczywistego (float)\ns=\"Napis\" # zmianna napisowa\n\nprint(a+f) # 2.0\nprint(str(f)+s) #1.0Napis\nprint(s+str(a)) #Napis1\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Zmienne logiczne" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "#typy logiczne przyjmują tylko dwie wartości prawda/fałsz\n\nl1=True\nl2=False\n\n#wyswietlamy wartośc obu zmiennych\n\nprint(l1,l2)\nprint(type(l1))\n\n#operator iloczynu logicznego AND\n\nprint(l1 and l2)\n\n#operator sumy logicznej OR\n\nprint(l1 or l2)\n\n# operator negacji NOT\n\nprint (not l2)\n\n# alternatywa rozłączna XOR\n\nprint (l1 != l2)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Indeksowanie zmiennych napisowych\nDla indeksów nieujemnych\n0 - pierwszy element napisu\nlen()-1 - ostatni element napisu\n\nDla indeksów ujemnych \n-len() - pierwszy element napisu\n" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# indeksowanie elementow napisu, zaczynamy od numeru 0. To trzeba zapamiętać w innych językach jest różnie\nNapis='Kot płacze na kolanach Ali.'\nprint(Napis)\n# jaka jest dlugość napisu ?\nprint('Dlugosc napisu=',len(Napis))\n\n# pierwszy element napisu\n\nprint(\"Pierwszy element napisu=\",Napis[0])\nprint(\"Ostatni element napisu=\",Napis[len(Napis)-1])\nprint(\"Pierwszy element napisu=\",Napis[-len(Napis)])\nprint(\"Ostatni element napisu=\",Napis[-1])\nprint(\"Przedostatni element napisu=\",Napis[-2])", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "### Konwersje\n\nKonwersją bardzo ważne, ze względu na silne typowanie.\n#### Python jest silnie typowany, co oznacza, musimy kontrolować typy zmiennych przy operacjach miedzy nimi " }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# konwersja typu całkowitego na rzeczywisty, metoda float()\n\nfloat(1)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# konwersja typu rzeczywistego na całkowity, metoda int()\n\nint(1.0)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# konwersja typu całkowitego na rzeczywisty, metoda bool()\nbool(1.0)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "#konwersja typu logicznego na całkowity \n\na1=int(True)\na2=int(False)\nprint('poczatek: ',a1,a2)\n\n#konwersja typu całkowitego na logiczny 0 -> False, pozostałe liczby -> True\n\nb1=bool(-1)\nb2=bool(0)\nb3=bool(1)\nb4=bool(2)\nprint('konwersja z int: ',b1,b2,b3,b4)\n\n\n#konwersja typu rzeczywistego na logiczny 0.0 -> False, pozostałe liczby -> True\n\nb11=bool(-1.0)\nb21=bool(0.0)\nb31=bool(1.5)\nb41=bool(5.6)\nprint('konwersja z float:', b11,b21,b31,b41)\n\n\n# konwersja napisu na typ logiczny, pusty napis -> False, pozostałe -> True\n\nb12=bool('')\nb22=bool('Ala')\nb32=bool('ma')\nb42=bool('kota')\nprint('KOnwersja ze string: ',b12,b22,b32,b42)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "#konwesja typu łańcuchowego i liczowego\n\ns1='13'\ns2='12'\na1=int(s1+s2)\nprint(a1)\nprint(type(a1))\n\n# konwersja połączona z operarorem potęgowania **\n\na2=int(s1)**2\nprint(a2)\nprint(type(a2))\n\n# konwersja typu łańcuchowego przez typ całowity do typu rzeczywistego\n\nf1 = float(int(a1)-int(a2))\nprint(f1, type(f1))\n\n# konwersja typu rzeczywistego na łańcuchowy\n\ns3=str(f1)\nprint(s3,type(s3))\n\n1312\n\n169\n\n1143.0 \n1143.0 \n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "### System pomocy" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# polecenie help pozwala na dostęp do systemowej pomocy Pythona\nhelp(print)\nhelp(len)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# istnieje też możliwość otrzymania pomocy wykorzystując składnię Jupitera. To nie jest część języka Python (!)\n\n# dodajemy znak ? przed nazwą funkcji\n\n?print\n\n# to samo jeśli dodamy znak ? po nazwie funkcji\n\nprint?", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Po zapoznaniu się z podstawowymi typami zmiennych skalarnych warto zdobyć wiedzę o typach sekwencyjnych\n\nNależą do nich głównie\n\nListy (lists)\nKrotki (tuples)\nSłowniki (dictionaries)\nZbiory (sets)\nDzielimy je na zmienialne (mutable) i niezmienialne (immutable)\n\nListy i zbiory, słowniki są przedstawicielami tej pierwszej grupy, a krotki i , napisy i zbiory niezmienne (frozenset) są przedstawicielami tej drugiej..\nTypów niezmienialnych nie można bezpośrednio modyfikować\nPostanowiłem poświęcić na początek nieco uwagi na rozszerzenie wiedzy o napisach, sposobie indeksowania i generowania podciągów.\nWarto zapamiętać: Indeksy zaczynamy od zera, więc pierwszy element zmiennej napisowej s to s[0], ostatni to s[len[s]-1]. Mamy też do dyspozycji indeksy ujemne s[-1] to ostatni element napisu, a s[-len(s)] pierwszy." }, { "metadata": {}, "cell_type": "markdown", "source": "##### Listy []" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# listy tworzymy za pomoca nawiasów kwadratowych []\n# elementy listy nie musze byc tego samego typu\nlista1=[1,2,'Ala',4]\nprint('Lista lista1 : ',lista1,type(lista1))\n\n# utworzmy pusta liste, warto pamietac ze konwersja takiej listy na typ logiczny zwraca falsz (False)\n\nlista2=[]\n\nprint('Lista lista2 : ',lista2,type(lista2),bool(lista2))", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# indeksowanie elementow analogiczne jak dla napisow\n\nprint(lista1, lista1[1]) # \"[1, 2, 'Ala', 4]\"\nprint(lista1[-1]) # Wyswietla ostatni element listy\nlista1[3] = 'ma' # Zmiana elementu o indeksie [3] \nprint('Lista lista1 : ',lista1) # wyswietla \"[1, 2, 'Ala', 'ma']\"", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Krotki ()" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# krotki tworzymy za pomoca nawiasów zwyklych ()\n\nk1= 1,3,5,'Pies'\nprint(k1,type(k1))\n\n# W szczegolnosci mozemy tworzyc krotki bez wykorzystania ()\n\nk2 = 1,2,3,4,'Ala','ma','kota'\nprint(k2,type(k2))\n\n# pusta krotka, konwertowalna na typ logiczny jako falsz\n\nk3=()\n\nprint(k3,type(k3),bool(k3))\n\n# budowa krotki z jednym elementem\n\nk4a=(1)\nprint(k4a,type(k4a)) # 1 \n\n# w takim przypadku, nalezy postawic znak , po wartosci pierwszego/ostatniego elementu\n\nk4b=(1,)\nprint(k4b,type(k4b)) # (1,) \n(1, 3, 5, 'Pies') \n(1, 2, 3, 4, 'Ala', 'ma', 'kota') \n() False\n1 \n(1,) \nIn [5]:\n# dostep do elementow krotki analogicznie jak do elementow listy\n\nk5=('Ala','ma','kota',3.14,12,2.0)\nprint('Zawartosc krotki k5 : ',k5)\nprint('Pierwszy element krotki k5: ',k5[0])\n\nprint('Ostatni element: ',k5[-1])\n\n# dostep do elementow krotki \n\nkrotka1 = ('Poznan', 'Warszawa', 1995, 2018)\nkrotka2 = (1, 2, 3, 4, 5, 6, 7 ,8)\n\nprint (\"krotka1[0]: \", krotka1[0])\nprint (\"krotka2[1:5]: \", krotka2[1:5])\nZawartosc krotki k5 : ('Ala', 'ma', 'kota', 3.14, 12, 2.0)\nPierwszy element krotki k5: Ala\nOstatni element: 2.0\nkrotka1[0]: Poznan\nkrotka2[1:5]: (2, 3, 4, 5)\nIn [6]:\n# modyfikacja elementu krotki\n\nkrotka1 = ('Poznan', 'Warszawa', 1995, 2018)\n\nkrotka1[2] =1999 # TypeError: 'tuple' object does not support item assignment\n\n# krotka jest niezmienialna, co oznacza ze raz stworzony obiekt jest tylko do odczytu\n---------------------------------------------------------------------------\nTypeError Traceback (most recent call last)\n in ()\n 3 krotka1 = ('Poznan', 'Warszawa', 1995, 2018)\n 4 \n----> 5 krotka1[2] =1999 # TypeError: 'tuple' object does not support item assignment\n 6 \n 7 # krotka jest niezmienialna, co oznacza ze raz stworzony obiekt jest tylko do odczytu\n\nTypeError: 'tuple' object does not support item assignment\nIn [7]:\nkrotka1 = ('Poznan', 'Warszawa', 1995, 2018)\nkrotka2 = (1, 2, 3, 4, 5, 6, 7 ,8)\n\nkrotka3=krotka1+krotka2\nprint('Zawartosc krotka1 : ',krotka1,' o dlugosci :',len(krotka1))\nprint('Zawartosc krotka2 : ',krotka2,' o dlugosci :',len(krotka2))\nprint('Zawartosc krotka3 : ',krotka3,' o dlugosci :',len(krotka3))", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "##### Słowniki {}" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# słowniki przechowuja zestawy par klucz-wartość\n\n#tworzymy pusty słownik, rzutowany na typ logiczny daje wartość fałszu\n\nslownik1={}\n\nprint(slownik1,type(slownik1),bool(slownik1)) # {} False\n\n# dodajemy pierwsza parę do pustego słownika\n\nslownik1['wzrost']=187\n\nprint(slownik1,len(slownik1)) # {'wzrost': 187} 1\n\n# dodajemy druga pare\n\nslownik1['kolor']='blond'\n\nprint(slownik1,len(slownik1)) # {'wzrost': 187, 'kolor': 'blond'} 2\n\n# klucz jest unikalny w ramach slownika\n\n# zmiana wartosci dla klucza, takie podstawienie niszczy poprzednia wartość\nslownik1['wzrost']=190\n\nprint(slownik1,len(slownik1)) # {'wzrost': 190, 'kolor': 'blond'} 2\n\n# usuniecie pary klucz-wartosc\n\ndel slownik1['wzrost']\n\nprint(slownik1,len(slownik1)) # {'kolor': 'blond'} 1\n\n\n# dodanie po raz kolejny pary {'wzrost':1}\nslownik1['wzrost']=190\n\n# zauważmy zmianę kolejności kluczy\nprint(slownik1,len(slownik1)) # {'kolor': 'blond', 'wzrost': 190} 2\n\n# wyczyszczenie zawartości słownika\n\nslownik1.clear()\n\nprint(slownik1,len(slownik1)) # {} 0", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Zbiory set[]" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "#Deklaracja pustego zbioru, konwertowalnego na typ logiczny jako fałsz\n\nzbior1 = set()\n\nprint('Zawartość zbior1 : ',zbior1,'',type(zbior1),bool(zbior1))\n\n# definicja zbioru trzech elementów, konwertowalnego na typ logiczny jako prawda\nzbior2=set(['Agnieszka','Magda','Izabella'])\n \n \nprint('Zawartość zbior2 : ',zbior2,'',type(zbior2),bool(zbior2))\n\n# elementy zbioru są unikalnie, nie mogą się powtarzać\nzbior3=set(['Agnieszka','Magda','Izabella','Magda'])\n\n \nprint('Zawartość zbior3 : ',zbior3,'',type(zbior3))\n\n# jesli taki element istnieje to nie zostanie dodany do zbioru\nzbior3.add('Agnieszka')\n\nprint('Zawartość zbior3 po dodaniu istniejacego elementu: ',zbior3,'',type(zbior3))\n\n\n\nzbiora=set([2,4,8,16])\nzbiorb=set([2,4,6,8])\nprint ('\\nMamy dwa zbiory: zbiora i zbiorb .')\nprint('zbiora : ',zbiora, ' zbiorb : ',zbiorb)\n\n\n# podstawowe operacje na zbiorach\n\n# suma zbiorów: elementy ktore sa w pierwszym lub drugim zbiorze\nprint('\\nSuma zbiorów: \\n')\n\nprint('zbiora | zbiorb : ',zbiora | zbiorb) \n\n# alternatywnie\nprint('zbiora.union(zbiorb) : ',zbiora.union(zbiorb)) \nprint('\\nRóżnica zbiorów: \\n')\n\n# roznica zbiorow: tylko te elementy ktore sa w pierwszym zbiorze z nie ma ich w drugim\nprint('zbiora - zbiorb : ',zbiora - zbiorb) \n\n#alternatywnie\n\nprint('zbiora.difference(zbiorb) : ',zbiora.difference(zbiorb)) ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Sterowanie" }, { "metadata": {}, "cell_type": "markdown", "source": "Po krótkim przeglądzie typów skalarnych i sekwencyjnych przyszedł czas, by pochylić się nad:\n\n Instrukcjami warunkowymi\n Pętlami\n Wykorzystywaniem gotowych pakietów/modułów\n\nDobre opanowanie instrukcji warunkowych jest podstawą do budowy bardziej skomplikowanych struktur sterujących przebiegiem programu.\n\nNależy zapamiętać jak Python traktuje typ logiczny rzutowany na typ całkowity, gdzie 1 to prawa, a 0 to fałsz.\n\nJak jest wartość logiczna pustej listy, krotki lub słownika ? (sprawdź!)\n\nZnajomość typu logicznego, operatorów logicznych i instrukcji warunkowej jest również niezbędna przy budowie funkcji i nieco później przy budowie obiektów\n\n \n\nPython dostarcza jedynie dwa rodzaje pętli , for oraz while., ale moim zdaniem jest to wystarczający wybór. Możliwa jest iteracja po elementach listy, elementach słownika , elementach napisu czy zakresach. Dodatkowe sterowanie przebiegiem petli w postaci instrukcji break, continue, pass , else:\n\n break – przerwij pętlę\n continue – przerwij obecną iterację\n pass – nie rób nic\n else – wykonuj jeśli pętla zakończyła się inaczej niż break\n\nPozwala na budowę bardziej rozbudowanej logiki niż zwykła iteracja po elementach różnego typu.\n\n \n\nJedną z silnych cech Pythona jest liczba dostępnych i darmowych pakietów, które umożliwiają nam wykorzystanie skomplikowanych algorytmów w prosty sposób.\n\nNie ma sensu wynajdywanie koła od nowa, ale warto poznać podstawowe funkcjonalności i sposób ich wykorzystania\n\nPrzykładowe pakiety, gdzie praktyką jest stosowanie aliasów" }, { "metadata": {}, "cell_type": "markdown", "source": "#### Instrukcje warunkowe\n\nif warunek :" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# instrukcja warunkowa if\n\n# wykona się jeśli wartość logiczna warunku jest prawdziwa\nif True:\n print('Prawda jest najważniejsza\\n')\n\n# nie wykona się jeśli wartość logiczna warunku jest fałszywa\n\n \nif False:\n print('Ta instrukcja się nie wykona.')\n \n \n# wykonanie polecenia1 jeśli warunek jest prawdziwy a polecenie2 jeśli falszywy\n\n'''\nif ( warunek ):\n polecenie1\nelse:\n polecenie2\n'''\n\na=100\n\nif a<50:\n print('a jest mniejsze niż 50')\nelse:\n print('a jest większe lub równe 50')\n ", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# instrukcja warunkowa z elif i else\nif a > 50:\n # to się wykona jeśli warunek jest prawdziwy\n print(\"a jest większe niż 50\")\nelif a == 50:\n # w przeciwnym przypadku, jeśli warunek jest prawdziwy\n print(\"a jest równe 50\")\nelse:\n # w pozostałych przypadkach\n print(\"a jest mniejsze niż 50\")\n \n \na=50\n# instrukcja warunkowa z elif i else\nif a > 50:\n # to się wykona jeśli warunek jest prawdziwy\n print(\"a jest większe niż 50\")\nelif a == 50:\n # w przeciwnym przypadku, jeśli warunek jest prawdziwy\n print(\"a jest równe 50\")\nelse:\n # w pozostałych przypadkach\n print(\"a jest mniejsze niż 50\")\n \na=47\n# instrukcja warunkowa z elif i else\nif a > 50:\n # to się wykona jeśli warunek jest prawdziwy\n print(\"a jest większe niż 50\")\nelif a == 50:\n # w przeciwnym przypadku, jeśli warunek jest prawdziwy\n print(\"a jest równe 50\")\nelse:\n # w pozostałych przypadkach\n print(\"a jest mniejsze niż 50\") ", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# wykorzystanie funkcji input\n\nprint(\"Podaj liczbę:\", end=' ')\n\nraw_x = input() # pobieramy napis z wejścia standardowego (klawiatury)\nx = eval(raw_x) # próba interpretacji napisu tak jak wyrażenia języka Python\n\nprint('Wprowadzona liczba w stanie surowym: ',raw_x,type(raw_x),' Po ewaluacji :',x, type(x))\n\nif x<10:\n print('Wprowadzona liczba jest mniejsza niż 10')\nelif x == 10:\n # w przeciwnym przypadku, jeśli warunek jest prawdziwy\n print(\"Wprowadzona liczba jest równa 10\")\nelse:\n # w pozostałych przypadkach\n print(\"Wprowadzona liczba jest większa niż 10\") ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Range" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "range(5) # generujemy ciąg liczb od 0 do 4, czyli 0,1,2,3,4\nprint('range(5)->',list(range(5)))\n\n# opcjonalnie pierwszym paramettrem jest początek, domyślnie równy zero.\n# to samo co poprzednio\nprint('range(0,5)->',list(range(0,5)))\n\n\nrange(-1,5) # generujemy ciąg liczb od -1 do 4 , czyli -1,0,1,2,3,4\nprint('range(-1,5) ->',list(range(-1,5)))\n\n# trzecim parametrem wywołana jest krok zmiany, domyślnie równy jedności\nprint('range(-1,5,1) ->',list(range(-1,5,1)))\n\nrange(-1,5,2) # generujemy ciąg liczb całkowitych od -1 do 4 z krokiem 2, czyli -1,1,3\nprint('range(-1,5,2) ->',list(range(-1,5,2)))\n\n# sekwencja możę być też w drugą stronę\nprint('range(5,-10,-1) ->',list(range(10,0,-1)))\n", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# do samodzielego poćwiczenia dla różnych wartość trzech parametró wejściowych\nstart = 2\nstop = 14\nstep = 2\n\nprint(list(range(start, stop, step)))", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Petle" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# iteracja po liczbach całkowitych\nfor licznik in (1,2,3,4):\n print('liczni k= ',licznik)\n\n \n# iteracja po elementach napisu\n\nnapis1='Ala ma kota' \nfor litera in (range(len(napis1))):\n print ('Litera = ', napis1[litera])\n \n# iteracja po liście\n\nowoce = ['gruszka', 'jabłko', 'śliwka']\n\nfor owoc in range(len(owoce)):\n print ('Owoc =',owoce[owoc] )\n \n# petla for z dodatkowa klauzula else: na koncu\n\nfor licznik in range(1,11):\n print('licznik =',licznik)\nelse:\n print('Koniec i bomba!') \n \n \n \nfor licznik in range(10) :\n print('licznik = ',licznik,' ',end='\\n')\nelse:\n print('Koniec i bomba!') ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Przykład wykorzystania dotychczasowej wiedzy.\nPętle, instrukcja warunkowa, zmienna napisowa\n\nhttps://www.w3resource.com/python-exercises/python-conditional-exercise-17.php" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# małe ćwiczenie na dwie petle for wraz z instrukcjami warunkowymi\n\n# Rysowanie litery A\n\nresult_str=\"\"; \nfor row in range(0,7): \n for column in range(0,7): \n if (((column == 1 or column == 5) and row != 0) or ((row == 0 or row == 3) and (column > 1 and column < 5))): \n result_str=result_str+\"*\" \n else: \n result_str=result_str+\" \" \n result_str=result_str+\"\\n\" \nprint(result_str);", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Dodatkowe sterowanie w petli\nbreak - przerwij pętlę\n\ncontinue - przerwij obecną iterację\n\npass - nie rób nic\n\nelse - wykonuj jeśli pętla zakończyła się inaczej niż break" }, { "metadata": {}, "cell_type": "markdown", "source": "#### break" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "for i in range(1,6): # od 1 do 5\n if i>3: # nie wykona się Iteracja dla i : 4,5\n break\n \n print('Iteracja dla i :',i)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### continue" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "for i in range(1,6): # od 1 do 5\n if i%2==0:\n continue # pomijamy parzyste i\n print('Iteracja dla i :',i) ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### pass" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "for i in range(1,6): # od 1 do 5\n if i%2==0:\n pass # nic nie rób\n print('Iteracja dla i :',i) ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### else" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# wykonanie instrukcji na końcu pętli\n\nfor i in range(1,6): # od 1 do 5\n if i%2==0:\n pass # nic nie rób\n print('Iteracja dla i :',i) \nelse:\n print('Koniec pętli.')", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Przyklad petli for z else, który nie zostanie wykonany . \n\nfor i in range(1,11): # od 1 do 10\n if i%2==0:\n pass # nic nie rób\n print('Iteracja dla i :',i) \n if i%5==0: # konczymy na i=5\n break\nelse: # ta czesc nie wykona się \n print('Koniec pętli.')", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Funkcje\n\ndef nazwa (parametry):\n #### kod funkcji\n return wartosc\n \nPodobnie jak przy petlach i instrukcjach warunkowych, wykorzystujemy wcięcia \n\nFunkcja Fibonacci\n![image.png](attachment:image.png)\n", "attachments": { "image.png": { "image/png": "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" } } }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "#def nazwa( parametry ):\n# '''dokumentacja''' #opcjonalne\n# logika\n# return [wyrażenie] # opcjonalne\n\n# funkcja - ciąg FIbonacci, w wersji rekurencyjnej\ndef fib(n):\n if n < 2:\n return n\n return fib(n-2) + fib(n-1)\n\n\nprint (\"Fib(10) =\",fib(10))\n", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "def drukuj(napis):\n print(napis)\n\ndrukuj('Litwo, Ojczyzno moja')\n", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# dokumentowanie funkcji z poprzedniej komorki\nhelp(drukuj)\n", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# dodajemy dokumentację do funkcji\n\ndef drukuj(napis):\n '''Funkcja print drukuje podany w parametrze napis'''\n print(napis)\n \ndrukuj('Litwo, Ojczyzno moja') \nhelp(drukuj)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# pusta funkcja\n\ndef nicnierobie():\n pass # pusta instrukcja, to nie jest komentarz\n\n# wywołanie \nnicnierobie()\n\n\n# w wersji z dokumentacją\n\ndef nicnierobie():\n '''Funkcja leniwa. Nic nie robię i dobrze mi z tym.''' \n pass\n\n#wywołanie \nnicnierobie()\n# pomoc \nhelp(nicnierobie)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Operator Lambda ####" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "suma = lambda x,y : x+y\nroznica = lambda x,y:x-y\niloczyn = lambda x,y:x*y\niloraz = lambda x,y:x/y\nprint('suma=',suma(1,6))\nprint('roznica=',roznica(1,6))\nprint('iloraz=',iloczyn(1,6))\nprint('iloczyn=',iloraz(1,6))", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "#### Mapy z pakietu folium" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# instalujemy pakiet folium, na razie nie sprawdzamy, czy jest zainstalowany\n!pip install folium ", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# importujemy pakiet folium, który zainstalowaliśmy poprzednio, inaczje nie bedzie on widoczny w programie\nimport folium # jezeli pakiet nie jest zainstalowany to mamy ImportError: No module named 'folium'\n\n# konfiguracja obiektu mapy\n\nlowiczloc=[52.06,19.56] \npolskaloc=[52.325, 18.94]\nmapa = folium.Map(location=polskaloc, zoom_start=7)\n\n# wyswietlamy mape\nmapa", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "'''pojdzmy krok dalej i zbudujmy prosty mechanizam wykrywający \nze dany pakiet nie jest zainstalowany '''\n\nimport sys\n# sprawdzenie czy dany pakiet został zainstalowany\nif not 'folium' in sys.modules:\n # instalujemy pakiet\n !pip install folium\nelse:\n print(\"Pakiet folium jest już zainstalowany!\")\n# importujemy pakietu\nimport folium\n# sprawdzamy jego wersje \nprint ('Folium version :',folium.__version__)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "### Kilka sztuczek" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# zamiana wartości dwoch zmiennych\n\nz1 =5\nz2 =7\n\nprint('Stan wejściowy: ',z1,z2, type(z1),type(z2))\n\n# klasycznie za pomocą dodatkowej zmiennej\n\ntemp= z1\nz1 = z2\nz2 = temp\n\nprint('Stan wyjściowy z dodatkową zmienną: ',z1,z2, type(z1),type(z2))\n\n# sprytnie, bez pomocy dodatkowej zmiennej\n# tu zastosowano krotkę (tuple) \n# będzie o tym w dalszej cześć kursu\n\nprint('Stan wejściowy: ',z1,z2, type(z1),type(z2))\n\n# krotka w tle\nz1, z2 = z2, z1\n\nprint('Stan wyjściowy z krotką: ',z1,z2, type(z1),type(z2))", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# potegowanie ma wyższy priorytet niż mnożenie, dodawanie, ale również zmianę znaku (operator unarny) (!)\n\nprint(-2**8) # wynik -256\n\n# w takiej sytuacji zawsze można wymusić priorytet wykorzystująca nawiasy ()\n\nprint((-2)**8) # wynik 256", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "import sys\n\n# maksymalnia wartość liczby całkowitej 64 bitowej\n\nprint(sys.maxsize)\n\namax=amax=2**63 -1\n\nprint(amax,type(amax))\n\n# przekraczamy wartość maksymalną, czy pojawi się błąd ?\namax=2**128 # dwa do potegi 128, całkiem duża liczba\n\nprint(amax,type(amax)) # nadal typu int", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# przykład z poprzedniej komorki, który obrazuje dodawania kolejnych bajtów dla zmiennej całkowitej\n# rozszerzanie on demand\n\n# mały przedsmak wykorzystania pętli for\n\nx=256\nfor i in range(1,6):\n x=x*x\n print (\"size:\", x.__sizeof__(), \"value:\", x)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# liczby całkowite mogą stosować inne systemy niż dziesiętny\n\n# system dwójkowy -> liczbe rozpoczybamy od 0b (b= binary)\n\nabin=0b1111 # 1*2**3 + 1*2**2 + 1*2**1 +1*2**0 = 8 + 4 + 2 + 1 =15\n\n# system usemkowy -> liczbe rozpoczybamy od 0o ( o = octan)\n\naoct = 0o123 # 1*8**2 + 2*8**1 + 3 * 8**0 = 64 + 16 +3 = 83\n\n# system szestnastkowy -> liczbe rozpoczybamy od 0x (x = heXal )\n\nahex =0xff # 15*16**1 + 15*16**0 = 240 + 15 = 255\n\nprint(abin,aoct,ahex)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "markdown", "source": "# Gra LIFE" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# https://jakevdp.github.io/blog/2013/08/07/conways-game-of-life/\n\nimport numpy as np\n\ndef life_step_1(X):\n \"\"\"Game of life step using generator expressions\"\"\"\n nbrs_count = sum(np.roll(np.roll(X, i, 0), j, 1)\n for i in (-1, 0, 1) for j in (-1, 0, 1)\n if (i != 0 or j != 0))\n return (nbrs_count == 3) | (X & (nbrs_count == 2))\n\ndef life_step_2(X):\n \"\"\"Game of life step using scipy tools\"\"\"\n from scipy.signal import convolve2d\n nbrs_count = convolve2d(X, np.ones((3, 3)), mode='same', boundary='wrap') - X\n return (nbrs_count == 3) | (X & (nbrs_count == 2))\n \nlife_step = life_step_1", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "%pylab inline", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "!pip install JSAnimation\n\n# JSAnimation import available at https://github.com/jakevdp/JSAnimation\nfrom JSAnimation.IPython_display import display_animation, anim_to_html\nfrom matplotlib import animation\n\ndef life_animation(X, dpi=10, frames=10, interval=300, mode='loop'):\n \"\"\"Produce a Game of Life Animation\n \n Parameters\n ----------\n X : array_like\n a two-dimensional numpy array showing the game board\n dpi : integer\n the number of dots per inch in the resulting animation.\n This controls the size of the game board on the screen\n frames : integer\n The number of frames to compute for the animation\n interval : float\n The time interval (in milliseconds) between frames\n mode : string\n The default mode of the animation. Options are ['loop'|'once'|'reflect']\n \"\"\"\n X = np.asarray(X)\n assert X.ndim == 2\n X = X.astype(bool)\n \n X_blank = np.zeros_like(X)\n figsize = (X.shape[1] * 1. / dpi, X.shape[0] * 1. / dpi)\n\n fig = plt.figure(figsize=figsize, dpi=dpi)\n ax = fig.add_axes([0, 0, 1, 1], xticks=[], yticks=[], frameon=False)\n im = ax.imshow(X, cmap=plt.cm.binary, interpolation='nearest')\n im.set_clim(-0.05, 1) # Make background gray\n\n # initialization function: plot the background of each frame\n def init():\n im.set_data(X_blank)\n return (im,)\n\n # animation function. This is called sequentially\n def animate(i):\n im.set_data(animate.X)\n animate.X = life_step(animate.X)\n return (im,)\n animate.X = X\n\n anim = animation.FuncAnimation(fig, animate, init_func=init,\n frames=frames, interval=interval)\n \n #print anim_to_html(anim)\n return display_animation(anim, default_mode=mode)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "np.random.seed(0)\nX = np.zeros((30, 40), dtype=bool)\nr = np.random.random((10, 20))\nX[10:20, 10:30] = (r > 0.75)\nlife_animation(X, dpi=200, frames=40, mode='once')", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "X = np.zeros((6, 21))\nX[2:4, 1:3] = 1\nX[1:4, 5:9] = [[0, 1, 1, 0],\n [1, 0, 0, 1],\n [0, 1, 1, 0]]\nX[1:5, 11:15] = [[0, 1, 1, 0],\n [1, 0, 0, 1],\n [0, 1, 0, 1],\n [0, 0, 1, 0]]\nX[1:4, 17:20] = [[1, 1, 0],\n [1, 0, 1],\n [0, 1, 0]]\n\nlife_animation(X, dpi=5, frames=3)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "blinker = [1, 1, 1]\ntoad = [[1, 1, 1, 0],\n [0, 1, 1, 1]]\n\nX = np.zeros((6, 11))\nX[2, 1:4] = blinker\nX[2:4, 6:10] = toad\nlife_animation(X, dpi=5, frames=4)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "X = np.zeros((17, 17))\nX[2, 4:7] = 1\nX[4:7, 7] = 1\nX += X.T\nX += X[:, ::-1]\nX += X[::-1, :]\nlife_animation(X, frames=6)", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "from JSAnimation import examples", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "examples.lorenz_animation()", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "examples.basic_animation(interval=200)", "execution_count": null, "outputs": [] } ], "metadata": { "kernelspec": { "name": "python36", "display_name": "Python 3.6", "language": "python" }, "language_info": { "mimetype": "text/x-python", "nbconvert_exporter": "python", "name": "python", "pygments_lexer": "ipython3", "version": "3.6.6", "file_extension": ".py", "codemirror_mode": { "version": 3, "name": "ipython" } } }, "nbformat": 4, "nbformat_minor": 2 }