Python i Django 2

Typy zmiennych

W Pythonie typowanie jest dynamiczne, tzn. interpreter rozpoznaje typ zmiennej na podstawie jej wartości. Typy proste Typy złożone Listy Krotki Zbiory Słowniki

Typy proste

Lista typów prostych jest dosyć krótka i trochę niestandardowa:

int Typ całkowity skończony, jest zazwyczaj czterobajtowy, tzn. obejmuje liczby od -2³¹ do 2³¹-1, cztery bajty są gwarantowane, może być ich więcej, informacje o największej liczbie typu int można uzyskać tak:
```
import sys
sys.maxint
```
Dopuszczalne są cztery systemy liczbowe:
```
z = 15
z = 0xF
z = 0o17
z = 0b1111
```
Powyższe instrukcje nadają zmiennej z wartość 15₁₀. Stsosowane są kolejno: system dziesiętny, szesnastkowy, ósemkowy i dwójkowy.
long Typ całkowity nieskończony, Python automatycznie konwertuje z typu int na typ long po przekroczeniu zakresu, możemy wymusić powtanie zmiennej typu long:
```
z = 23L
z = long(23)
```
float Jedyny typ zmiennoprzecinkowy.
complex Typ zespolony.
```
z = complex(1,1)
z = 1+1j
```
każda z powyższych instrukcji tworzy zmienną zespoloną z o wartości 1+i
bool Typ logiczny, wartości zmiennej typu logicznego to True i False (wielkość liter ma znaczenie), dokonywane są niejawne konwersje na typ bool (z typu bool):
```
a = True
b = 2
if a and b:
   print "tak" => tak
if a or b:
   print "tak" => tak
```
str Napis, ogranicznikiem napisów mogą być: apostrofy, cudzysłowy, potrójne apostrofy i potrójne cudzysłowy.
```
s = "Jan powiedział: 'basta'"
t = 'Jan powiedział: "basta"'
t == s => True
```
Potrójnych ograniczników używamy gdy chcemy napis umieścić w kilku wierszach.
```
s="""W tym wierszu jest początek napisu
a w tym jego koniec"""
s => 'W tym wierszu jest pocz\xb9tek napisu\na w tym jego koniec'
```
Napisy możemy łączyć przy pomocy operatora konkatenacji +, nie ma niejawnych konwersji na typ str
```
x = 34
"x = "+str(x) => 'x = 34'
```
Dostęp do pojedynczych znaków napisu daje nam operator []. Argument operatora [] może być liczbą ujemną! Każdy znak w napisie s ma dwa indeksy:
- tradycyjny, pierwsza litera ma indeks 0,..., ostatnia ma indeks len(s)-1,
- specyficzny dla Pythona, pierwsza litera ma indeks -len(s), druga -len(s)+1,..., ostatnia -1.
Podobnie jak w kilku innych językach (np. C#, Java) napisy są niemodyfikowalne, w szczególności, nie można zmieniać pojedynczych znaków.
```
s = "Hokus-pokus"
s[-2] => 'u'
s[5] => '-'
s[5] = "+"
Traceback (most recent call last):
  File "", line 1, in 
    s[5] = "+"
TypeError: 'str' object does not support item assignment
```
Dostęp do większych fragmentów napisu daje nam operator zakresu [od:do]. Operator zakresu działa również (i działa identycznie!) na omówionych dalej typach złożonych: listach i krotkach.
Jeżeli znak o indeksie od znajduje się na lewo od znaku o indeksie do, to s[od:do] zwraca fragment napisu s od pozycji od do pozycji do-1 (jeżeli od, do > 0, to długość zwracanego napisu wynosi do - od), w przeciwnym razie zwraca napis pusty. Argumenty od i do są nieobowiązkowe, wartości domyślne to: od = 0, do = len(s)
```
s = "0123456789"
s[3:3] => ''
s[2:4] => '23'
s[:6] => '012345'
s[6:] => '6789'
s[-3:9] => '78'
s[-4:] => '6789'
```
Napis (zmienna s typu str) jest obiektem, istnieje wiele użytecznych metod w klasie str, poniżej niepełna lista w porządku alfabetycznym, w kilku przypadkach pominięte zostały nieobowiązkowe argumenty modyfikujące działanie metod:
- s.capitalize() - zwraca napis, pierwsza litera została zamieniona na dużą, pozostałe na małe,
- s.center(width,[fillchar]) - zwraca napis wycentrowany w polu odługości width, uzupełniony z lewej i prawej znakiem fillchar, fillchar musi być napisem o długości 1, domyślnie fillchar = " ", jeżeli width≤len(s), to metoda center nic nie robi,
- s.count(substr) - zwraca ilość rozłącznych wystąpień ciągu substr
```
s="aaaa"
s.count("a") => 4
s.count("aa") => 2
s.count("aaa") => 1
```
- s.endswith(substr) - zwraca True jeżeli napis s kończy się ciągiem substr, False w przeciwnym razie,
- s.find(substr) - zwraca indeks pierwszego wystąpienia podciągu substr w napisie s, -1 jeżeli substr nie jest fragmentem s
- s.index(substr) - zwraca indeks pierwszego wystąpienia podciągu substr w napisie s, jeżeli substr nie jest fragmentem s, to jest błąd wykonania
- s.join(iterator) - zwraca napis będący konkatenacją: pierwszy element iteratora, napis s, drugi element iteratora, napis s,..., ostatni element iteratora, iteratorem może być inny napis, elementami iteratora są wtedy litery tego napisu, może nim być lista lub krotka. Ponieważ nie ma niejawnej konwersji na typ str, to każdy element iteratora musi być typu str:
```
".".join("salceson") => 's.a.l.c.e.s.o.n'
"+".join([str(i) for i in range(1,21)]) => '1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20'
```
  w drugim przykładzie wykorzystałem funkcję range(a,b) (a i b są typu int), zwraca ona listę zawierającą liczby całkowite od a do b-1, wykorzystałem też jedną z postaci pętli for, zostanie ona omówiona później,
- s.lower() - zwraca napis, wszystkie litery zostały zamienione na małe,
- s.replace(old,new) - zwraca napis, w którym rozłączne podciągi old zostały zamienione na new
```
"ababa".replace("aba","cc") => 'ccba'
```
- s.split(separator) - zwraca listę napisów, pierwszy napis w zwracanej liście, to podciąg od poczatku s do pierwszego wystapienia separatora, drugi, to podciąg między pierwszym adrugim wystapieniem separatora,...
```
"ababa".split("a") => ['', 'b', 'b', '']
```
- s.startswith(substr) - zwraca True jeżeli napis s zaczyna się ciągiem substr, False w przeciwnym razie,
- s.swapcase() - zwraca napis, małe litery zostały zamienione na duże, duże na małe,
- s.title() - zwraca napis, pierwsza litera każdego słowa została zamieniona na dużą, pozostałe na małe,
- s.upper() - zwraca napis, wszystkie litery zostały zamienione na duże.

Spis treści

Typy złożone

W Pythonie nie ma tablic. Jest kilka rodzajów kolekcji, każdy element kolekcji może być innego typu, prostego lub złożonego.

Lista, typ list, listy są indeksowane od zera, jeżeli l jest (niepustą) listą, to l[0] oznacza jej pierwszy element.
- Tworzenie listy:
```
l1 = list()
l2 = []
l3 = [1,2,True,"wojna"]
```
  pierwsze dwie instrukcje tworzą pustą listę, trzecia tworzy listę czteroelementową, rozmiar listy możemy odczytać wywołując funkcję globalną len, len(l3) => 4.
- Metody modyfikujące listę:
  - l[index] = value - zmienia wartość elementu na pozycji index, jest błąd wykonania jeżeli index<0 lub index≥len(l),
  - l.append(value) - dopisuje nowy element na końcu listy l,
  - l.extends(m) - dopisuje na końcu listy l wszystkie elementy z listy m,
  - l.insert(index,value) - wstawia nowy element na pozycji index, pozostałe elementy sie przesuwają,
  - l.pop([index]) - usuwa (i zwraca) z listy l element z pozycji index, parametr index nie jest obowiązkowy, domyślnie usuwany jest ostatni element,
  - l.remove(value) - usuwa z listy pierwszy element równy value, jeśli takiego elementu nie ma, to jest błąd wykonania, jeżeli elementy listy l są obiektami (typami złożonymi), to działanie metody remove może być trochę zaskakujące:
```
m1 = [1,2]
m2 = [3,4]
m3 = [1,2]
l = [m1, m2, m3]
l => [[1, 2], [3, 4], [1, 2]]
l.remove(m3)
l => [[3, 4], [1, 2]]
```
    wynika to z faktu, że przy porównywaniu obiektów (kolekcji) porównywana jest ich zawartość, a nie referencje,
  - l.reverse() - odwraca (tzn. zmienia kolejność na przeciwną) listę, odwracanie odbywa się "w miejscu" - odwrócona lista zastępuje pierwotną,
  - l.sort() lub l.sort(reverse=True) - sortuje listę "w miejscu", pierwsza wersja sortuje rosnąco, druga malejąco, nie jest wymagane by elementy listy były tego samego typu:
```
l=[False, True, 0, 3, 0.1, 3.5, complex(1,1), "Moby", "Dick", [1,2,3]]
l.sort()               
Traceback (most recent call last):
  File "", line 1, in 
    l.sort()
TypeError: no ordering relation is defined for complex numbers
l.pop(6)
l.sort()
l => [False, 0, 0.1, True, 3, 3.5, [1, 2, 3], 'Dick', 'Moby']
```
- Szukanie:
  - metoda l.index(value) - zwraca indeks pierwszego elementu równego value, jeśli takiego elementu, to jest błąd wykonania,
  - metoda l.count(value) - zwraca ilość elementów równych value, może zwrócić zero,
  - instrukcja value in l - zwraca True jeżeli lista zawiera element równy value, False w przeciwnym razie.
- Operatory "arymetyczne":
  - l + m - tworzy nową listę zawierającą wpierw elementy listy l, a potem elementy listy m (pierwotne listy l i m nie ulegają zmianie),
  - l * k, k jest typu int - tworzy nową listę zawierającą k powtórzeń listy l
```
l = [1,2]
m = l*5
m => [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
m = l*(-5)
m => []
```
    jak widać, nie ma błędu wykonania gdy k jest ujemne.
- Rozpakowanie:
```
l = range(10)
l => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x,y = l[8:] #rozpakowanie
x => 8
y => 9
```
  ilość zmiennych po lewej stronie musi być równa długości listy po prawej stronie, do zmiennych są przypisywane kolejne elementy listy. Po lewej stronie może też wystapic tylko jedna zmienna, nie ma wtedy rozpakowania, tylko utworzenie nowej listy.
```
l = range(10)
x = l[4:]
x => [4, 5, 6, 7, 8, 9] 
x = l[9:]
x => [9]
x = l[9]
x => 9
```

Spis treści

Krotka, typ tuple, to niemodyfikowalna lista.
Tworzenie krotki:
```
k1 = tuple()
k2 = ()
k3 = 1,2,True,"Jan"
k4 = (1,2,True,"Jan")
```
pierwsze dwie instrukcje tworzą pustą krotkę (tworzenie takiej krotki jest bez sensu, bo już jej nie zmienimy), trzecia i czwarta tworzą krotkę czteroelementową, rozmiar krotki możemy odczytać wywołując funkcję globalną len, len(k3) => 4.
Metod modyfikujących nie ma, szukanie, operatory "arymetyczne" i rozpakowanie działają dla krotek identycznie jak dla list.
Czy można operator + zastosować do listy i krotki? Nie, trzeba stosować konwersję.
```
l = [1,2,3]
k = (4,5,6)
l + k
Traceback (most recent call last):
  File "", line 1, in 
    l + k
TypeError: can only concatenate list (not "tuple") to list
l + list(k) => [1, 2, 3, 4, 5, 6]
tuple(l) + k => (1, 2, 3, 4, 5, 6)
```

Spis treści

Zbiór, typ set, w zbiorze nie ma uporządkowania elementów, zbiór nie może zawierać list, zbiorów i słowników, może zawierać krotki. Python pilnuje by w zbiorze nie było dwóch identycznych elementów.
Tworzenie zbioru:
```
z1 = set() #powstał zbiór pusty
z2 = set("sakwa") #powstał zbiór czteroelementowy zawierający litery 's', 'a', 'k' i 'w'
z3 = set(range(1,11)) #powstał zbiór zawierający liczby od 1 do 10
```
Metody w klasie set:
- z.add(element) - dodaje (próbuje dodać) element do zbioru z, nie sygnalizuje czy dodawanie sie powiodło, jeżeli ta informacja jest ważna to możemy np. napisać własną funkcję:
```
def addToSet(zbior,element):
   bylo = len(zbior)
   zbior.add(element)
   return len(zbior)>bylo
```
- z.clear() - usuwa ze zbioru wszystkie elementy,
- z.intersection(otherSet) - zwraca zbiór będący częścią wspólną zbiorów z i otherSet, możliwy jest krótszy zapis: z & otherSet
- z.remove(element) - usuwa ze zbioru z podany element, jest błąd wykonania, jeżeli element nie należy do zbioru, komunikatu o błędzie można uniknąć tak:
```
if element in z:
   z.remove(element)
```
- z.union(otherSet) - zwraca zbiór będący sumą zbiorów z i otherSet, możliwy jest krótszy zapis: z | otherSet

Spis treści

Słownik, typ dict, zawiera pary (klucz, wartość), klucze są na ogół typu str, mogą być też krotkami, liczbami i wartościami logicznymi.
Tworzenie słownika:
```
d = dict() #powstał pusty słownik
d = {"one":"jeden","two":"dwa","three":"trzy"} #powstał skromny słownik angielsko-polski
```
Operacje na słowniku:
- d[klucz] - zwraca wartość powiązaną z podanym kluczem (d["one"] => 'jeden'), gdy klucza nie ma w słowniku jest błąd wykonania,
- d[klucz] = nowaWartość - modyfikuje (lub dopisuje, jeżeli klucza nie było w słowniku) wartość powiązaną z kluczem,
```
d["four"] = "ctery"
d["four"] = "cztery"
d["four"] => 'cztery'
```
- del(d[klucz]) - usuwa ze słownika podany klucz i powiązaną z nim wartość, gdy klucza nie ma w słowniku jest błąd wykonania,
Metody w klasie dict:
- d.clear() - usuwa ze słownika wszystkie klucze,
- d.get(klucz) - zwraca wartość powiązaną z podanym kluczem, gdy klucza nie ma w słowniku zwraca None,
- d.has_key(klucz) - zwraca True gdy klucz jest w słowniku, False w przeciwnym razie,
- d.items() - zwraca listę dwuelementowych krotek, każda krotka to para (klucz,wartość),
```
d = {"jeden":1,"dwa":2}
d.items() => [('jeden', 1), ('dwa', 2)]
```
- d.keys() - zwraca listę wszystkich kluczy,
- d.values() - zwraca listę wszystkich wartości,
Spis treści

Poprzedni wykład

Lista wykładów

Następny wykład