Po uruchomieniu kontenera należy wyczyścić informacje wyjściowe za pomocą menu Kernel -> Restart & Clear Output.
Korzystany z notatników Jupitera, które są podłączone do interpretera Python w wersji 3.
Mamy dwa główne rodzaj komórek Code: Tu piszemy kod w języku Python MarkDown : Tu piszemy dokumentację kodu Opis języka MarkDown https://blog.nayma.pl/podstawy-markdown/
Ta komórka jest oznaczona jako komórka MarkDown
# tu mamy naszą pierwszą komórkę, typu Code, ustawiamy kursor myszy w komórce, klikamy, na górze jest przycisk "Run"
print("Witamy w świecie Pythona z poziomu notatnika Jupyter")
# komentarze jednolinijkowe zaczynamy od znaku #
# Jaka mamy wersje Pythona 2, czy 3
import sys #importujemy modul sys
print ("Używana wersja Pythona to: ", sys.version)
Należ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.
# Python jako kalkulator
1+2
# Priorytety operatorów dodawania i mnożenia
1+2*3
# wymuszanie priorytetow operacji
(1+2)*3
# dzielenie, którego wynikiem jest wartość rzeczywista
1/2
# dzielenie, ktorego wynikiem jest nadal wartość rzeczywista
4.0/2.0
# dzielenie calkowite 5//2 -> 2 ile razy zmieście się 2 w 5
5//2
# nie mylić dzielenia całkowitego // z resztą z dzielenia całkowitego % 5%2 -> 1 , ile zostanie z podzialu 5 na 2 cześci
5%2
# typ całkowity, wykorzystaju tu metodę type
type(2)
type(0)
type(1)
type(-100)
# typ rzeczywisty
type(2.5)
# typ rzeczywisty, nawet jeśli część ułamkowa jest zerem.
type(2.0)
# typ logiczny, rylko dwa stany False, True
type(False)
# a teraz prawda
type (True)
# Włączenie możliwości wyswietlania wielu wyjść w notatniku
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"
# suma logiczna
False or True # True
False or False # False
True or True # True
# iloczyn logiczny
True and True # True
True and False # False
False and False # False
"Napis1" # Napis obraniczony ""
'Napis2' # Napis obraniczony ''
print('Napis1',"Napis2")
# Polaczone napisów # konkatenacja operatorem +
"Ala"+ ' ma '+ 'kota'
# jaka jest dlugosc napisu, wbudowana funkcja len
print("Napis ma długość ",len("Ala"+ ' ma '+ 'kota')," znaków.")
# powielenie napisu kilka razy
"Ala ma kota "*2
# lub tak
10*"A kot nie ma mleka. "
# zapiszmy wartość w zmiennej a
a=102
# wyświetlamy jej wartość
print(a)
# wyświetlamy jej typ
print(type(a))
# python jest typowany dynamiczne, typ zmiennej a moze się zmieniać w czasie
a=2.1
# wyswietlmy jej wartość
print(a)
# wyswietlmy jej typ
print(type(a))
# Od wersji Pythona 3.6 istnieje możliwość statycznej deklaracji typu
# nazwa zmiennej: type
zm_calk: int = 100 #SyntaxError: invalid syntax
zm_rzecz: float = 100.0
zm_napis: str = '100'
zm_log: bool = False
print(zm_calk,type(zm_calk))
print(zm_rzecz,type(zm_rzecz))
print(zm_napis,type(zm_napis))
print(zm_log,type(zm_log))
#usuwanie zmiennych
a=2.5
print(a)
#usuwamy zmienną a
del a
#uzycie usuniętej zmiennej konczy się błędem
print(a)
#Python rozróżnia duże i małe litery
b=1.0
print(B) #name 'B' is not defined
#Python rozróżnia duże i małe litery
b=1.0
B=100
print(b,type(b)) #1.0 <class 'float'>
print(B,type(B)) # 100 <class 'int'>
# Python jest silnie typowany (!)
a=1 # zmienny typu całkowitego (int)
f=1.0 # zmienna typu rzeczywistego (float)
s="Napis" # zmianna napisowa
print(a+f) # 2.0
print(f+s) #TypeError: unsupported operand type(s) for +: 'float' and 'str'
print(s+a) #TypeError: must be str, not int
Waż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.
# Python jest silnie typowany (!)
# Wymuszamy konwersję
a=1 # zmienny typu całkowitego (int)
f=1.0 # zmienna typu rzeczywistego (float)
s="Napis" # zmianna napisowa
print(a+f) # 2.0
print(str(f)+s) #1.0Napis
print(s+str(a)) #Napis1
#typy logiczne przyjmują tylko dwie wartości prawda/fałsz
l1=True
l2=False
#wyswietlamy wartośc obu zmiennych
print(l1,l2)
print(type(l1))
#operator iloczynu logicznego AND
print(l1 and l2)
#operator sumy logicznej OR
print(l1 or l2)
# operator negacji NOT
print (not l2)
# alternatywa rozłączna XOR
print (l1 != l2)
Dla indeksów nieujemnych 0 - pierwszy element napisu len()-1 - ostatni element napisu
Dla indeksów ujemnych -len() - pierwszy element napisu
# indeksowanie elementow napisu, zaczynamy od numeru 0. To trzeba zapamiętać w innych językach jest różnie
Napis='Kot płacze na kolanach Ali.'
print(Napis)
# jaka jest dlugość napisu ?
print('Dlugosc napisu=',len(Napis))
# pierwszy element napisu
print("Pierwszy element napisu=",Napis[0])
print("Ostatni element napisu=",Napis[len(Napis)-1])
print("Pierwszy element napisu=",Napis[-len(Napis)])
print("Ostatni element napisu=",Napis[-1])
print("Przedostatni element napisu=",Napis[-2])
# konwersja typu całkowitego na rzeczywisty, metoda float()
float(1)
# konwersja typu rzeczywistego na całkowity, metoda int()
int(1.0)
# konwersja typu całkowitego na rzeczywisty, metoda bool()
bool(1.0)
#konwersja typu logicznego na całkowity
a1=int(True)
a2=int(False)
print('poczatek: ',a1,a2)
#konwersja typu całkowitego na logiczny 0 -> False, pozostałe liczby -> True
b1=bool(-1)
b2=bool(0)
b3=bool(1)
b4=bool(2)
print('konwersja z int: ',b1,b2,b3,b4)
#konwersja typu rzeczywistego na logiczny 0.0 -> False, pozostałe liczby -> True
b11=bool(-1.0)
b21=bool(0.0)
b31=bool(1.5)
b41=bool(5.6)
print('konwersja z float:', b11,b21,b31,b41)
# konwersja napisu na typ logiczny, pusty napis -> False, pozostałe -> True
b12=bool('')
b22=bool('Ala')
b32=bool('ma')
b42=bool('kota')
print('KOnwersja ze string: ',b12,b22,b32,b42)
#konwesja typu łańcuchowego i liczowego
s1='13'
s2='12'
a1=int(s1+s2)
print(a1)
print(type(a1))
# konwersja połączona z operarorem potęgowania **
a2=int(s1)**2
print(a2)
print(type(a2))
# konwersja typu łańcuchowego przez typ całowity do typu rzeczywistego
f1 = float(int(a1)-int(a2))
print(f1, type(f1))
# konwersja typu rzeczywistego na łańcuchowy
s3=str(f1)
print(s3,type(s3))
1312
<class 'int'>
169
<class 'int'>
1143.0 <class 'float'>
1143.0 <class 'str'>
# polecenie help pozwala na dostęp do systemowej pomocy Pythona
help(print)
help(len)
# istnieje też możliwość otrzymania pomocy wykorzystując składnię Jupitera. To nie jest część języka Python (!)
# dodajemy znak ? przed nazwą funkcji
?print
# to samo jeśli dodamy znak ? po nazwie funkcji
print?
Po zapoznaniu się z podstawowymi typami zmiennych skalarnych warto zdobyć wiedzę o typach sekwencyjnych
Należą do nich głównie
Listy (lists) Krotki (tuples) Słowniki (dictionaries) Zbiory (sets) Dzielimy je na zmienialne (mutable) i niezmienialne (immutable)
Listy i zbiory, słowniki są przedstawicielami tej pierwszej grupy, a krotki i , napisy i zbiory niezmienne (frozenset) są przedstawicielami tej drugiej.. Typów niezmienialnych nie można bezpośrednio modyfikować Postanowiłem poświęcić na początek nieco uwagi na rozszerzenie wiedzy o napisach, sposobie indeksowania i generowania podciągów. Warto 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.
# listy tworzymy za pomoca nawiasów kwadratowych []
# elementy listy nie musze byc tego samego typu
lista1=[1,2,'Ala',4]
print('Lista lista1 : ',lista1,type(lista1))
# utworzmy pusta liste, warto pamietac ze konwersja takiej listy na typ logiczny zwraca falsz (False)
lista2=[]
print('Lista lista2 : ',lista2,type(lista2),bool(lista2))
# indeksowanie elementow analogiczne jak dla napisow
print(lista1, lista1[1]) # "[1, 2, 'Ala', 4]"
print(lista1[-1]) # Wyswietla ostatni element listy
lista1[3] = 'ma' # Zmiana elementu o indeksie [3]
print('Lista lista1 : ',lista1) # wyswietla "[1, 2, 'Ala', 'ma']"
# krotki tworzymy za pomoca nawiasów zwyklych ()
k1= 1,3,5,'Pies'
print(k1,type(k1))
# W szczegolnosci mozemy tworzyc krotki bez wykorzystania ()
k2 = 1,2,3,4,'Ala','ma','kota'
print(k2,type(k2))
# pusta krotka, konwertowalna na typ logiczny jako falsz
k3=()
print(k3,type(k3),bool(k3))
# budowa krotki z jednym elementem
k4a=(1)
print(k4a,type(k4a)) # 1 <class 'int'>
# w takim przypadku, nalezy postawic znak , po wartosci pierwszego/ostatniego elementu
k4b=(1,)
print(k4b,type(k4b)) # (1,) <class 'tuple'>
(1, 3, 5, 'Pies') <class 'tuple'>
(1, 2, 3, 4, 'Ala', 'ma', 'kota') <class 'tuple'>
() <class 'tuple'> False
1 <class 'int'>
(1,) <class 'tuple'>
In [5]:
# dostep do elementow krotki analogicznie jak do elementow listy
k5=('Ala','ma','kota',3.14,12,2.0)
print('Zawartosc krotki k5 : ',k5)
print('Pierwszy element krotki k5: ',k5[0])
print('Ostatni element: ',k5[-1])
# dostep do elementow krotki
krotka1 = ('Poznan', 'Warszawa', 1995, 2018)
krotka2 = (1, 2, 3, 4, 5, 6, 7 ,8)
print ("krotka1[0]: ", krotka1[0])
print ("krotka2[1:5]: ", krotka2[1:5])
Zawartosc krotki k5 : ('Ala', 'ma', 'kota', 3.14, 12, 2.0)
Pierwszy element krotki k5: Ala
Ostatni element: 2.0
krotka1[0]: Poznan
krotka2[1:5]: (2, 3, 4, 5)
In [6]:
# modyfikacja elementu krotki
krotka1 = ('Poznan', 'Warszawa', 1995, 2018)
krotka1[2] =1999 # TypeError: 'tuple' object does not support item assignment
# krotka jest niezmienialna, co oznacza ze raz stworzony obiekt jest tylko do odczytu
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-6-4dac655d56c5> in <module>()
3 krotka1 = ('Poznan', 'Warszawa', 1995, 2018)
4
----> 5 krotka1[2] =1999 # TypeError: 'tuple' object does not support item assignment
6
7 # krotka jest niezmienialna, co oznacza ze raz stworzony obiekt jest tylko do odczytu
TypeError: 'tuple' object does not support item assignment
In [7]:
krotka1 = ('Poznan', 'Warszawa', 1995, 2018)
krotka2 = (1, 2, 3, 4, 5, 6, 7 ,8)
krotka3=krotka1+krotka2
print('Zawartosc krotka1 : ',krotka1,' o dlugosci :',len(krotka1))
print('Zawartosc krotka2 : ',krotka2,' o dlugosci :',len(krotka2))
print('Zawartosc krotka3 : ',krotka3,' o dlugosci :',len(krotka3))
# słowniki przechowuja zestawy par klucz-wartość
#tworzymy pusty słownik, rzutowany na typ logiczny daje wartość fałszu
slownik1={}
print(slownik1,type(slownik1),bool(slownik1)) # {} <class 'dict'> False
# dodajemy pierwsza parę do pustego słownika
slownik1['wzrost']=187
print(slownik1,len(slownik1)) # {'wzrost': 187} 1
# dodajemy druga pare
slownik1['kolor']='blond'
print(slownik1,len(slownik1)) # {'wzrost': 187, 'kolor': 'blond'} 2
# klucz jest unikalny w ramach slownika
# zmiana wartosci dla klucza, takie podstawienie niszczy poprzednia wartość
slownik1['wzrost']=190
print(slownik1,len(slownik1)) # {'wzrost': 190, 'kolor': 'blond'} 2
# usuniecie pary klucz-wartosc
del slownik1['wzrost']
print(slownik1,len(slownik1)) # {'kolor': 'blond'} 1
# dodanie po raz kolejny pary {'wzrost':1}
slownik1['wzrost']=190
# zauważmy zmianę kolejności kluczy
print(slownik1,len(slownik1)) # {'kolor': 'blond', 'wzrost': 190} 2
# wyczyszczenie zawartości słownika
slownik1.clear()
print(slownik1,len(slownik1)) # {} 0
#Deklaracja pustego zbioru, konwertowalnego na typ logiczny jako fałsz
zbior1 = set()
print('Zawartość zbior1 : ',zbior1,'',type(zbior1),bool(zbior1))
# definicja zbioru trzech elementów, konwertowalnego na typ logiczny jako prawda
zbior2=set(['Agnieszka','Magda','Izabella'])
print('Zawartość zbior2 : ',zbior2,'',type(zbior2),bool(zbior2))
# elementy zbioru są unikalnie, nie mogą się powtarzać
zbior3=set(['Agnieszka','Magda','Izabella','Magda'])
print('Zawartość zbior3 : ',zbior3,'',type(zbior3))
# jesli taki element istnieje to nie zostanie dodany do zbioru
zbior3.add('Agnieszka')
print('Zawartość zbior3 po dodaniu istniejacego elementu: ',zbior3,'',type(zbior3))
zbiora=set([2,4,8,16])
zbiorb=set([2,4,6,8])
print ('\nMamy dwa zbiory: zbiora i zbiorb .')
print('zbiora : ',zbiora, ' zbiorb : ',zbiorb)
# podstawowe operacje na zbiorach
# suma zbiorów: elementy ktore sa w pierwszym lub drugim zbiorze
print('\nSuma zbiorów: \n')
print('zbiora | zbiorb : ',zbiora | zbiorb)
# alternatywnie
print('zbiora.union(zbiorb) : ',zbiora.union(zbiorb))
print('\nRóżnica zbiorów: \n')
# roznica zbiorow: tylko te elementy ktore sa w pierwszym zbiorze z nie ma ich w drugim
print('zbiora - zbiorb : ',zbiora - zbiorb)
#alternatywnie
print('zbiora.difference(zbiorb) : ',zbiora.difference(zbiorb))
Po krótkim przeglądzie typów skalarnych i sekwencyjnych przyszedł czas, by pochylić się nad:
Instrukcjami warunkowymi
Pętlami
Wykorzystywaniem gotowych pakietów/modułów
Dobre opanowanie instrukcji warunkowych jest podstawą do budowy bardziej skomplikowanych struktur sterujących przebiegiem programu.
Należy zapamiętać jak Python traktuje typ logiczny rzutowany na typ całkowity, gdzie 1 to prawa, a 0 to fałsz.
Jak jest wartość logiczna pustej listy, krotki lub słownika ? (sprawdź!)
Znajomość typu logicznego, operatorów logicznych i instrukcji warunkowej jest również niezbędna przy budowie funkcji i nieco później przy budowie obiektów
Python 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:
break – przerwij pętlę
continue – przerwij obecną iterację
pass – nie rób nic
else – wykonuj jeśli pętla zakończyła się inaczej niż break
Pozwala na budowę bardziej rozbudowanej logiki niż zwykła iteracja po elementach różnego typu.
Jedną 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.
Nie ma sensu wynajdywanie koła od nowa, ale warto poznać podstawowe funkcjonalności i sposób ich wykorzystania
Przykładowe pakiety, gdzie praktyką jest stosowanie aliasów
if warunek :
# instrukcja warunkowa if
# wykona się jeśli wartość logiczna warunku jest prawdziwa
if True:
print('Prawda jest najważniejsza\n')
# nie wykona się jeśli wartość logiczna warunku jest fałszywa
if False:
print('Ta instrukcja się nie wykona.')
# wykonanie polecenia1 jeśli warunek jest prawdziwy a polecenie2 jeśli falszywy
'''
if ( warunek ):
polecenie1
else:
polecenie2
'''
a=100
if a<50:
print('a jest mniejsze niż 50')
else:
print('a jest większe lub równe 50')
# instrukcja warunkowa z elif i else
if a > 50:
# to się wykona jeśli warunek jest prawdziwy
print("a jest większe niż 50")
elif a == 50:
# w przeciwnym przypadku, jeśli warunek jest prawdziwy
print("a jest równe 50")
else:
# w pozostałych przypadkach
print("a jest mniejsze niż 50")
a=50
# instrukcja warunkowa z elif i else
if a > 50:
# to się wykona jeśli warunek jest prawdziwy
print("a jest większe niż 50")
elif a == 50:
# w przeciwnym przypadku, jeśli warunek jest prawdziwy
print("a jest równe 50")
else:
# w pozostałych przypadkach
print("a jest mniejsze niż 50")
a=47
# instrukcja warunkowa z elif i else
if a > 50:
# to się wykona jeśli warunek jest prawdziwy
print("a jest większe niż 50")
elif a == 50:
# w przeciwnym przypadku, jeśli warunek jest prawdziwy
print("a jest równe 50")
else:
# w pozostałych przypadkach
print("a jest mniejsze niż 50")
# wykorzystanie funkcji input
print("Podaj liczbę:", end=' ')
raw_x = input() # pobieramy napis z wejścia standardowego (klawiatury)
x = eval(raw_x) # próba interpretacji napisu tak jak wyrażenia języka Python
print('Wprowadzona liczba w stanie surowym: ',raw_x,type(raw_x),' Po ewaluacji :',x, type(x))
if x<10:
print('Wprowadzona liczba jest mniejsza niż 10')
elif x == 10:
# w przeciwnym przypadku, jeśli warunek jest prawdziwy
print("Wprowadzona liczba jest równa 10")
else:
# w pozostałych przypadkach
print("Wprowadzona liczba jest większa niż 10")
range(5) # generujemy ciąg liczb od 0 do 4, czyli 0,1,2,3,4
print('range(5)->',list(range(5)))
# opcjonalnie pierwszym paramettrem jest początek, domyślnie równy zero.
# to samo co poprzednio
print('range(0,5)->',list(range(0,5)))
range(-1,5) # generujemy ciąg liczb od -1 do 4 , czyli -1,0,1,2,3,4
print('range(-1,5) ->',list(range(-1,5)))
# trzecim parametrem wywołana jest krok zmiany, domyślnie równy jedności
print('range(-1,5,1) ->',list(range(-1,5,1)))
range(-1,5,2) # generujemy ciąg liczb całkowitych od -1 do 4 z krokiem 2, czyli -1,1,3
print('range(-1,5,2) ->',list(range(-1,5,2)))
# sekwencja możę być też w drugą stronę
print('range(5,-10,-1) ->',list(range(10,0,-1)))
# do samodzielego poćwiczenia dla różnych wartość trzech parametró wejściowych
start = 2
stop = 14
step = 2
print(list(range(start, stop, step)))
# iteracja po liczbach całkowitych
for licznik in (1,2,3,4):
print('liczni k= ',licznik)
# iteracja po elementach napisu
napis1='Ala ma kota'
for litera in (range(len(napis1))):
print ('Litera = ', napis1[litera])
# iteracja po liście
owoce = ['gruszka', 'jabłko', 'śliwka']
for owoc in range(len(owoce)):
print ('Owoc =',owoce[owoc] )
# petla for z dodatkowa klauzula else: na koncu
for licznik in range(1,11):
print('licznik =',licznik)
else:
print('Koniec i bomba!')
for licznik in range(10) :
print('licznik = ',licznik,' ',end='\n')
else:
print('Koniec i bomba!')
Przykład wykorzystania dotychczasowej wiedzy. Pętle, instrukcja warunkowa, zmienna napisowa
https://www.w3resource.com/python-exercises/python-conditional-exercise-17.php
# małe ćwiczenie na dwie petle for wraz z instrukcjami warunkowymi
# Rysowanie litery A
result_str="";
for row in range(0,7):
for column in range(0,7):
if (((column == 1 or column == 5) and row != 0) or ((row == 0 or row == 3) and (column > 1 and column < 5))):
result_str=result_str+"*"
else:
result_str=result_str+" "
result_str=result_str+"\n"
print(result_str);
Dodatkowe sterowanie w petli break - przerwij pętlę
continue - przerwij obecną iterację
pass - nie rób nic
else - wykonuj jeśli pętla zakończyła się inaczej niż break
for i in range(1,6): # od 1 do 5
if i>3: # nie wykona się Iteracja dla i : 4,5
break
print('Iteracja dla i :',i)
for i in range(1,6): # od 1 do 5
if i%2==0:
continue # pomijamy parzyste i
print('Iteracja dla i :',i)
for i in range(1,6): # od 1 do 5
if i%2==0:
pass # nic nie rób
print('Iteracja dla i :',i)
# wykonanie instrukcji na końcu pętli
for i in range(1,6): # od 1 do 5
if i%2==0:
pass # nic nie rób
print('Iteracja dla i :',i)
else:
print('Koniec pętli.')
# Przyklad petli for z else, który nie zostanie wykonany .
for i in range(1,11): # od 1 do 10
if i%2==0:
pass # nic nie rób
print('Iteracja dla i :',i)
if i%5==0: # konczymy na i=5
break
else: # ta czesc nie wykona się
print('Koniec pętli.')
#def nazwa( parametry ):
# '''dokumentacja''' #opcjonalne
# logika
# return [wyrażenie] # opcjonalne
# funkcja - ciąg FIbonacci, w wersji rekurencyjnej
def fib(n):
if n < 2:
return n
return fib(n-2) + fib(n-1)
print ("Fib(10) =",fib(10))
def drukuj(napis):
print(napis)
drukuj('Litwo, Ojczyzno moja')
# dokumentowanie funkcji z poprzedniej komorki
help(drukuj)
# dodajemy dokumentację do funkcji
def drukuj(napis):
'''Funkcja print drukuje podany w parametrze napis'''
print(napis)
drukuj('Litwo, Ojczyzno moja')
help(drukuj)
# pusta funkcja
def nicnierobie():
pass # pusta instrukcja, to nie jest komentarz
# wywołanie
nicnierobie()
# w wersji z dokumentacją
def nicnierobie():
'''Funkcja leniwa. Nic nie robię i dobrze mi z tym.'''
pass
#wywołanie
nicnierobie()
# pomoc
help(nicnierobie)
suma = lambda x,y : x+y
roznica = lambda x,y:x-y
iloczyn = lambda x,y:x*y
iloraz = lambda x,y:x/y
print('suma=',suma(1,6))
print('roznica=',roznica(1,6))
print('iloraz=',iloczyn(1,6))
print('iloczyn=',iloraz(1,6))
# instalujemy pakiet folium, na razie nie sprawdzamy, czy jest zainstalowany
!pip install folium
# importujemy pakiet folium, który zainstalowaliśmy poprzednio, inaczje nie bedzie on widoczny w programie
import folium # jezeli pakiet nie jest zainstalowany to mamy ImportError: No module named 'folium'
# konfiguracja obiektu mapy
lowiczloc=[52.06,19.56]
polskaloc=[52.325, 18.94]
mapa = folium.Map(location=polskaloc, zoom_start=7)
# wyswietlamy mape
mapa
'''pojdzmy krok dalej i zbudujmy prosty mechanizam wykrywający
ze dany pakiet nie jest zainstalowany '''
import sys
# sprawdzenie czy dany pakiet został zainstalowany
if not 'folium' in sys.modules:
# instalujemy pakiet
!pip install folium
else:
print("Pakiet folium jest już zainstalowany!")
# importujemy pakietu
import folium
# sprawdzamy jego wersje
print ('Folium version :',folium.__version__)
# zamiana wartości dwoch zmiennych
z1 =5
z2 =7
print('Stan wejściowy: ',z1,z2, type(z1),type(z2))
# klasycznie za pomocą dodatkowej zmiennej
temp= z1
z1 = z2
z2 = temp
print('Stan wyjściowy z dodatkową zmienną: ',z1,z2, type(z1),type(z2))
# sprytnie, bez pomocy dodatkowej zmiennej
# tu zastosowano krotkę (tuple)
# będzie o tym w dalszej cześć kursu
print('Stan wejściowy: ',z1,z2, type(z1),type(z2))
# krotka w tle
z1, z2 = z2, z1
print('Stan wyjściowy z krotką: ',z1,z2, type(z1),type(z2))
# potegowanie ma wyższy priorytet niż mnożenie, dodawanie, ale również zmianę znaku (operator unarny) (!)
print(-2**8) # wynik -256
# w takiej sytuacji zawsze można wymusić priorytet wykorzystująca nawiasy ()
print((-2)**8) # wynik 256
import sys
# maksymalnia wartość liczby całkowitej 64 bitowej
print(sys.maxsize)
amax=amax=2**63 -1
print(amax,type(amax))
# przekraczamy wartość maksymalną, czy pojawi się błąd ?
amax=2**128 # dwa do potegi 128, całkiem duża liczba
print(amax,type(amax)) # nadal typu int
# przykład z poprzedniej komorki, który obrazuje dodawania kolejnych bajtów dla zmiennej całkowitej
# rozszerzanie on demand
# mały przedsmak wykorzystania pętli for
x=256
for i in range(1,6):
x=x*x
print ("size:", x.__sizeof__(), "value:", x)
# liczby całkowite mogą stosować inne systemy niż dziesiętny
# system dwójkowy -> liczbe rozpoczybamy od 0b (b= binary)
abin=0b1111 # 1*2**3 + 1*2**2 + 1*2**1 +1*2**0 = 8 + 4 + 2 + 1 =15
# system usemkowy -> liczbe rozpoczybamy od 0o ( o = octan)
aoct = 0o123 # 1*8**2 + 2*8**1 + 3 * 8**0 = 64 + 16 +3 = 83
# system szestnastkowy -> liczbe rozpoczybamy od 0x (x = heXal )
ahex =0xff # 15*16**1 + 15*16**0 = 240 + 15 = 255
print(abin,aoct,ahex)
# https://jakevdp.github.io/blog/2013/08/07/conways-game-of-life/
import numpy as np
def life_step_1(X):
"""Game of life step using generator expressions"""
nbrs_count = sum(np.roll(np.roll(X, i, 0), j, 1)
for i in (-1, 0, 1) for j in (-1, 0, 1)
if (i != 0 or j != 0))
return (nbrs_count == 3) | (X & (nbrs_count == 2))
def life_step_2(X):
"""Game of life step using scipy tools"""
from scipy.signal import convolve2d
nbrs_count = convolve2d(X, np.ones((3, 3)), mode='same', boundary='wrap') - X
return (nbrs_count == 3) | (X & (nbrs_count == 2))
life_step = life_step_1
%pylab inline
!pip install JSAnimation
# JSAnimation import available at https://github.com/jakevdp/JSAnimation
from JSAnimation.IPython_display import display_animation, anim_to_html
from matplotlib import animation
def life_animation(X, dpi=10, frames=10, interval=300, mode='loop'):
"""Produce a Game of Life Animation
Parameters
----------
X : array_like
a two-dimensional numpy array showing the game board
dpi : integer
the number of dots per inch in the resulting animation.
This controls the size of the game board on the screen
frames : integer
The number of frames to compute for the animation
interval : float
The time interval (in milliseconds) between frames
mode : string
The default mode of the animation. Options are ['loop'|'once'|'reflect']
"""
X = np.asarray(X)
assert X.ndim == 2
X = X.astype(bool)
X_blank = np.zeros_like(X)
figsize = (X.shape[1] * 1. / dpi, X.shape[0] * 1. / dpi)
fig = plt.figure(figsize=figsize, dpi=dpi)
ax = fig.add_axes([0, 0, 1, 1], xticks=[], yticks=[], frameon=False)
im = ax.imshow(X, cmap=plt.cm.binary, interpolation='nearest')
im.set_clim(-0.05, 1) # Make background gray
# initialization function: plot the background of each frame
def init():
im.set_data(X_blank)
return (im,)
# animation function. This is called sequentially
def animate(i):
im.set_data(animate.X)
animate.X = life_step(animate.X)
return (im,)
animate.X = X
anim = animation.FuncAnimation(fig, animate, init_func=init,
frames=frames, interval=interval)
#print anim_to_html(anim)
return display_animation(anim, default_mode=mode)
np.random.seed(0)
X = np.zeros((30, 40), dtype=bool)
r = np.random.random((10, 20))
X[10:20, 10:30] = (r > 0.75)
life_animation(X, dpi=200, frames=40, mode='once')
X = np.zeros((6, 21))
X[2:4, 1:3] = 1
X[1:4, 5:9] = [[0, 1, 1, 0],
[1, 0, 0, 1],
[0, 1, 1, 0]]
X[1:5, 11:15] = [[0, 1, 1, 0],
[1, 0, 0, 1],
[0, 1, 0, 1],
[0, 0, 1, 0]]
X[1:4, 17:20] = [[1, 1, 0],
[1, 0, 1],
[0, 1, 0]]
life_animation(X, dpi=5, frames=3)
blinker = [1, 1, 1]
toad = [[1, 1, 1, 0],
[0, 1, 1, 1]]
X = np.zeros((6, 11))
X[2, 1:4] = blinker
X[2:4, 6:10] = toad
life_animation(X, dpi=5, frames=4)
X = np.zeros((17, 17))
X[2, 4:7] = 1
X[4:7, 7] = 1
X += X.T
X += X[:, ::-1]
X += X[::-1, :]
life_animation(X, frames=6)
from JSAnimation import examples
examples.lorenz_animation()
examples.basic_animation(interval=200)