2
Typy a operátory

### Struktura programů v Pythonu

### Proč používat standardní datové typy?

### Čísla

% python
>>> a = 3           # vytvoří se proměnná
>>> b = 4

>>> b / 2 + a      # ekvivalentní s ((4 / 2) + 3)
5
>>> b / (2.0 + a)  # ekvivalentní s (4 / (2.0 + 3))
0.8

>>> x = 1          # před jedničkou si můžeme představit nuly
>>> x << 2         # bitový posun o dva vlevo: 100 (dvojkově)
4
>>> x | 2          # bitové 1 or 10 (dvojkově): 11 (dvojkově)
3
>>> x & 1          # bitové 1 and 1: 1
1

>>> 9999999999999999999999999999 + 1
10000000000000000000000000000L
>>> 9999999999999999999999999999L + 1
10000000000000000000000000000L

>>> 1j * 1J
(-1+0j)
>>> 2 + 1j * 3
(2+3j)
>>> (2+1j)*3
(6+3j)

>>> abs(-42), 2**4, pow(2, 4)
(42, 16, 16)

>>> import math
>>> math.pi
3.1415926535897931

### Řetězce

% python
>>> len('abc')     # délka seznamu (řetězce): počet položek
3
>>> 'abc' + 'def'  # skládání: výsledkem je nový řetězec
'abcdef'
>>> 'Ni!' * 4      # ekvivalent "Ni!" + "Ni!" + ...
'Ni!Ni!Ni!Ni!'

>>> myjob = "hacker"
>>> for c in myjob: print c,      # procházíme položkami (seznamu)
...
h a c k e r
>>> "k" in myjob                  # 1 jako pravda
1

>>> S = 'spam'
>>> S[0], S[-2]    # přístup k prvkům od začátku i konce
('s', 'a')
>>> S[1:3], S[1:], S[:-1]         # výběr části
('pa', 'pam', 'spa')

>>> S = 'spam'
>>> S[0] = "x"                    # vyvolá výjimku TypeError
>>> S = S + 'Spam!'               # změna vytvořením nového
>>> S
'spamSpam!'
>>> S = S[:4] + 'Burger' + S[-1]
>>> S
'spamBurger!'
>>> 'That is %d %s bird!' % (1, 'dead')  # jako sprintf v C
That is 1 dead bird!

>>> exclamation = "Ni"
>>> "The knights who say %s!" % exclamation
'The knights who say Ni!'
>>> "%d %s %d you" % (1, 'spam', 4)
'1 spam 4 you'
>>> "%s -- %s -- %s" % (42, 3.14159, [1, 2, 3])
'42 -- 3.14159 -- [1, 2, 3]'

>>> import string                 # modul pro práci s řetězci
>>> S = "spammify"
>>> string.upper(S)               # všechny velké - uppercase
'SPAMMIFY'
>>> string.find(S, "mm")          # vrací pozici prvního výskytu
3
>>> string.atoi("42"), `42`       # “přetypování” z / na řetězec
(42, '42')
>>> string.join(string.split(S, "mm"), "XX")
'spaXXify'

>>> "spam" + 42                   # vyhodí vyjímku TypeError
>>> "spam" + '42'
'spam42'
>>> string.atoi("42") + 1
43

>>> mixed = "Guido's"    # apostrof v uvozovkách
>>> mixed
"Guido's"

>>> mixed = 'Guido"s'    # uvozovky v apostrofech
>>> mixed
'Guido"s'

>>> mixed = 'Guido\'s'   # vkládání apostrofu přes lomítko
>>> mixed
"Guido's"

>>> split = "This" "is" "concatenated"
>>> split
'Thisisconcatenated'

>>> big = """Python puts
... an end-of-line marker
... after each line."""
>>> big
'Python puts\nan end-of-line marker\nafter each line.'

### Seznamy

% python
>>> len([1, 2, 3])                  # počet prvků
3
>>> [1, 2, 3] + [4, 5, 6]           # skládání
[1, 2, 3, 4, 5, 6]
>>> ['Ni!'] * 4                     # opakování
['Ni!', 'Ni!', 'Ni!', 'Ni!']
>>> for x in [1, 2, 3]: print x,    # procházení seznamem
...
1 2 3

>>> `[1, 2]` + "34"          # obdoba "[1, 2]" + "34"
'[1, 2]34'
>>> [1, 2] + list("34")      # jako [1, 2] + ["3", "4"]
[1, 2, '3', '4']

>>> L = ['spam', 'Spam', 'SPAM!']
>>> L[2]                            # číslujeme od nuly
'SPAM!'
>>> L[-2]                           # záporné: počítáme zprava
'Spam'
>>> L[1:]                           # výběr části
['Spam', 'SPAM!']

>>> L = ['spam', 'Spam', 'SPAM!']
>>> L[1] = 'eggs'                   # přiřazení prvku
>>> L
['spam', 'eggs', 'SPAM!']
>>> L[0:2] = ['eat', 'more']        # přiřazení části
>>> L                               # (nultému a prvnímu prvku)
['eat', 'more', 'SPAM!']

>>> L.append('please')              # volání metody append,
>>> L
['eat', 'more', 'SPAM!', 'please']

>>> L.sort()                        # setřídí ('S' < 'e')
>>> L
['SPAM!', 'eat', 'more', 'please']

>>> L
['SPAM!', 'eat', 'more', 'please']
>>> del L[0]                        # smaže jeden prvek
>>> L
['eat', 'more', 'please']

>>> del L[1:]                       # smaže část, jedná se o 
>>> L                               # ekvivalent L[1:] = []
['eat']

### Slovníky

% python
>>> d2 = {'spam': 2, 'ham': 1, 
... 'eggs': 3}
>>> d2['spam']                      # hodnota přes klíč
2
>>> len(d2)                         # počet prvků
3
>>> d2.has_key('ham')               # je definován? (1 – pravda)
1
>>> d2.keys()                       # seznam klíčů
['eggs', 'spam', 'ham']

>>> d2['ham'] = ['grill', 'bake', 'fry']   # změna
>>> d2
{'eggs': 3, 'spam': 2, 'ham': ['grill', 'bake', 'fry']}
>>> del d2['eggs']                         # výmaz
>>> d2
{'spam': 2, 'ham': ['grill', 'bake', 'fry']}
>>> d2['brunch'] = 'Bacon'                 # přidání prvku
>>> d2
{'brunch': 'Bacon', 'spam': 2, 'ham': ['grill', 'bake', 'fry']}

>>> table = {'Python': 'Guido van Rossum',
...          'Perl': 'Larry Wall',
...          'Tcl': 'John Ousterhout' }
...                                        # stisknout Enter
>>> language = 'Python'
>>> creator = table[language]
>>> creator
'Guido van Rossum'
>>> for lang in table.keys(): print lang, '\t', table[lang]
...
Tcl     John Ousterhout
Python  Guido van Rossum
Perl    Larry Wall

### ntice

### Soubory

>>> soubor = open('soubor', 'w')    # otevřeme soubor pro zápis
>>> soubor.write('Ahoj soubore\n')  # zapíšeme řádku textu
>>> soubor.close()
>>> soubor = open('soubor', 'r')    # otevřeme soubor pro čtení
>>> soubor.readline()               # znovu načteme řádku
'hello text file\n'
>>> soubor.readline()               # prázdný = konec souboru
''

### Obecně o vlastnostech objektů

>>> L = ['abc', [(1, 2), ([3], 4)], 5]
>>> L[1]
[(1, 2), ([3], 4)]
>>> L[1][1]
([3], 4)
>>> L[1][1][0]
[3]
>>> L[1][1][0][0]
3

>>> X = [1, 2, 3]
>>> L = ['a', X, 'b']
>>> D = {'x':X, 'y':2}

>>> X[1] = 'Ivan'                   # změna se projeví všude
>>> L 
['a', [1, 'Ivan', 3], 'b']
>>> D
{'x': [1, 'Ivan', 3], 'y': 2}

>>> L1 = [1, ('a', 3)] 
>>> L2 = [1, ('a', 3)]   # stejný obsah, jiné objekty
>>> L1 == L2, L1 is L2   # ntice ekvivalentní?, stejné objekty?
(1, 0)

>>> L1 = [1, ('a', 3)]
>>> L2 = [1, ('a', 2)]
>>> L1 < L2, L1 == L2, L1 > L2 # ntice menší?, ekviv.?, větší?
(0, 0, 1)

### Oblíbené problémy

>>> L = [1, 2, 3]
>>> M = ['X', L, 'Y']    # vkládáme referenci na náš objekt
>>> M
['X', [1, 2, 3], 'Y']
>>> L[1] = 0             # změní i hodnotu M
>>> M
['X', [1, 0, 3], 'Y'] 

>>> L = [1, 2, 3]
>>> M = ['X', L[:], 'Y'] # vkládáme kopii L
>>> L[1] = 0             # změní pouze L
>>> L
[1, 0, 3]
>>> M
['X', [1, 2, 3], 'Y']

>>> L = [4, 5, 6]
>>> X = L * 4            # jako [4, 5, 6] + [4, 5, 6] + ...
>>> Y = [L] * 4          # resp. [L] + [L] + ... = [L, L,...]
>>> X
[4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]
>>> Y
[[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]]

>>> L[1] = 0             # ovlivní jen Y (ne X)
>>> X 
[4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]
>>> Y 
[[4, 0, 6], [4, 0, 6], [4, 0, 6], [4, 0, 6]]

>>> L = ['ha']; L.append(L)   # přidáme referenci sama na sebe
>>> L                         # do 1.5.1: smyčka! (ctrl-C)

>>> T = (1, 2, 3)
>>> T[2] = 4          # vyhodí chybu
>>> T = T[:2] + (4,)  # v pořádku - nová ntice (1, 2, 4)

### Shrnutí

### Cvičení

2 ** 16
2 / 5, 2 / 5.0

"spam" + "eggs"
S = "ham"
"eggs " + S
S * 5
S[:0]
"green %s and %s" % ("eggs", S)

('x',)[0]
('x', 'y')[1]

L = [1,2,3] + [4,5,6]
L, L[:], L[:0], L[-2], L[-2:]
([1,2,3]+[4,5,6])[2:4]
[L[2], L[3]]
L.reverse(); L
L.sort(); L
L.index(4); L

{'a':1, 'b':2}['b']
D = {'x':1, 'y':2, 'z':3}
D['w'] = 0
D['x'] + D['w']
D[(1,2,3)] = 4
D.keys(), D.values(), D.has_key((1,2,3)) 

[[]], ["",[],(),{},None]

X = 'spam'
Y = 'eggs'
X, Y = Y, X
X
Y

D = {}
D[1] = 'a'
D[2] = 'b'

>>> D[(1, 2, 3)] = 'c'
>>> D
{1: 'a', 2: 'b', (1, 2, 3): 'c'}