*** Strona 41 *******************************************************************

Liczby     3.1415, 1234, 999L, 3+4j
acuchy   'mielonka', "guida"
Listy      [1, [2, 'trzy'], 4]
Sowniki   {'jedzenie':'mielonka', 'smak':'pycha'}
Krotki     (1, 'mielonka', 4, 'U')
Pliki      text = open('jajka', 'r').read()

1234, -24, 0                     Zwyke liczby cakowite (jak long w C)
999999999999L                    Dugie liczby cakowite (nieograniczony rozmiar)
1.23, 3.14e-10, 4E210, 4.0e+210  Liczby zmiennoprzecinkowe (jak double w C)
0177, 0x9ff                      Stae w zapisie semkowym i szesnastkowym
3+4j, 3.0+4.0j, 3J               Stae zespolone


*** Strona 45-47 ****************************************************************

% python
>>> a = 3          # utworzona nazwa
>>> b = 4
>>> b / 2 + a      # to samo, co ((4 / 2) + 3)
5
>>> b / (2.0 + a)  # to samo, co (4 / (2.0 + 3))
0.8

>>> x = 1     # 0001
>>> x << 2    # przesuwa w lewo o 2 bity: 0100
4
>>> x | 2     # bitowe OR: 0011
3
>>> x & 1     # bitowe AND: 0001
1

>>> 9999999999999999999999999999 + 1
OverflowError: integer literal too large
>>> 9999999999999999999999999999L + 1
100000000000000000000000000000L

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

>>> import math
>>> math.pi
3.14159265359
>>>
>>> abs(-42), 2**4, pow(2, 4)
(42, 16, 16)


*** Strona 49-50 ****************************************************************

% python
>>> len('abc')         # dugo: liczba pozycji 
3
>>> 'abc' + 'def'      # czenie: nowy acuch
'abcdef'
>>> 'Ni!' * 4          # to samo, co "Ni!" + "Ni!" + ...
'Ni!Ni!Ni!Ni!'

>>> mojapraca = "hacker"
>>> for c in mojapraca: print c,    # przejcia przez pozycje
...
h a c k e r
>>> "k" in mojapraca                # 1 oznacza prawd
1

>>> S = 'mielonka'
>>> S[0], S[-2]             # indeksowanie od pocztku lub od koca
('m', 'k')
>>> S[1:3], S[1:], S[:-1]   # wycinanie: pobieranie segmentw
('ie', 'ielonka', 'mielonk')


*** Strona 51 *******************************************************************

>>> S = 'mielonka'
>>> S[0] = "x"
Powstaje bd!
>>> S = S + 'Mielonka!'           # aby zmieni acuch, naley utworzy nowy
>>> S
'mielonkaMielonka!'
>>> S = S[:8] + 'Burger' + S[-1]
>>> S
'mielonkaBurger!'
>>> 'To jest %d %s ptak!' % (1, 'martwy')   # podobnie jak dla sprintf w C
'To jest 1 martwy ptak!'


*** Strona 52 *******************************************************************

% cat echo.py
import sys
print sys.argv

% python echo.py -a -b -c
['echo.py', '-a', '-b', '-c']

>>> wykrzyknik = "Ni"
>>> "Rycerze, ktorzy mowia: %s!" % wykrzyknik
'Rycerze, ktorzy mowia: Ni!'
>>> "%d %s %d you" % (1, 'mielonka', 4)
'1 mielonka 4 you'
>>> "%s -- %s -- %s" % (42, 3.14159, [1, 2, 3])
'42 -- 3.14159 -- [1, 2, 3]'


*** Strona 53-55 ****************************************************************

>>> import string              # standardowy modu pomocniczy
>>> S = "spammify"
>>> string.upper(S)            # przeksztaca na wielkie litery
'SPAMMIFY'
>>> string.find(S, "mm")       # zwraca indeks acucha podrzdnego
3
>>> string.atoi("42"), `42`    # przeksztacanie z/na acuch
(42, '42')
>>> string.join(string.split(S, "mm"), "XX")
'spaXXify'

>>> "mielonka" + 42
Powoduje bd
>>> "mielonka" +`42`
'mielonka42'
>>> string.atoi("42") + 1
43

>>> mieszane = "Guido's"     # apostrof wewntrz cudzysowu
>>> mieszane
"Guido's"
>>> mieszane = 'Guido"s'     # cudzysw wewntrz apostrofw
>>> mieszane
'Guido's'
>>> mieszane = 'Guido\'s'    # uycie lewego ukonika jako modyfikatora
>>> mieszane
"Guido's"

>>> split = "To" "jest" "powiazane"
>>> split
'Tojestpowiazane'

>>> wielki = """To jest
... wielowierszowy blok
... tekstu; Python wstawia
... znak konca wiersza
... po kazdym wierszu."""
>>>
>>> wielki
'To jest\012wielowierszowy blok\012tekstu; Python wstawia\012znak konca wiersza\012po kazdym wierszu.'


*** Strona 59-61 ****************************************************************

% python
>>> len([1, 2, 3])                  # dugo (rozmiar)
3
>>> [1, 2, 3] + [4, 5, 6]           # czenie
[1, 2, 3, 4, 5, 6]
>>> ['Ni!'] * 4                     # powtarzanie
['Ni!', 'Ni!', 'Ni!', 'Ni!']
>>> for x in [1, 2, 3]: print x,    # iteracja
...
123

>>> `[1, 2]` + "34"                 # to samo, co "[1, 2]" + "34"
'[1, 2]34'
>>> [1, 2] + list("34")             # to samo, co [1, 2] + ["3", "4"]
[1, 2, '3', '4']

>>> L = ['mielonka', 'Mielonka', 'MIELONKA!']
>>> L[2]                            # offset zerowy
'MIELONKA!'
>>> L[-2]                           # offset ujemny: zliczanie od prawej
'Mielonka'
>>> L[1:]                           # operacja wycinania zwraca wycinek
['Mielonka', 'MIELONKA!']

>>> L = ['mielonka', 'Mielonka', 'MIELONKI!']
>>> L[1] = 'jajka'                  # przypisanie indeksowane
>>> L
['mielonka', 'jajka', 'MIELONKI!']
>>> L[0:2] = ['jedz', 'wiecej']     # przypisanie do wycinka: usu i wstaw
>>> L                               # zastpienie pozycji 0,1
['jedz', 'wiecej', 'MIELONKI!']

>>> L.append('prosze')              # wywoanie metody append 
>>> L
['jedz', 'wiecej', 'MIELONKI!', 'prosze']
>>> L.sort()                        # sortowanie pozycji listy ('M' < 'j')
>>> L
['MIELONKI!', 'jedz', 'prosze', 'wiecej']

>>> L
['MIELONKI!', 'jedz', 'prosze', 'wiecej']
>>> del L[0]                        # usuwa jedn pozycj
>>> L
['jedz', 'prosze', 'wiecej']
>>> del L[1:]                       # usuwa cay segment
>>> L                               # to samo, co L[1:] = []
['jedz']


*** Strona 63-64 ****************************************************************

% python
>>> d2 = {'mielonka': 2, 'szynka': 1, 'jajka': 3}
>>> d2['mielonka']         # pobieranie wartoci dla klucza
2
>>> len(d2)                # liczba pozycji w sowniku
3
>>> d2.has_key('szynka')  # test obecnoci klucza (1 oznacza prawd)
1
>>> d2.keys()              # lista kluczy
['jajka', 'mielonka', 'szynka']

>>> d2['szynka'] = ['grilowac', 'piec', 'smazyc']    # zmiana pozycji
>>> d2
{'jajka': 3, 'mielonka': 2, 'szynka': ['grilowac', 'piec', 'smazyc']}
>>> del d2['jajka']                          # usuwanie pozycji
>>> d2
{'mielonka': 2, 'szynka': ['grilowac', 'piec', 'smazyc']}
>>> d2['przekaska'] = 'Bekon'                # dodawanie nowej pozycji
>>> d2
{'przekaska': 'Bekon', 'mielonka':2, 'szynka': ['grilowac', 'piec', 'smazyc']}

>>> tabela = {'Python': 'Guido van Rossum',
...           'Perl':   'Larry Wall',
...           'Tcl':    'John Ousterhout' }
...
>>> jezyk = 'Python'
>>> tworca = tabela[jezyk]
>>> tworca
'Guido van Rossum'
>>> for jezyk in tabela.keys(): print jezyk, '\t', tabela[jezyk]
...
Tcl     John Ousterhout
Python  Guido van Rossum
Perl    Larry Wall


*** Strona 66 *******************************************************************

import anydbm
plik = anydbm.open("nazwapliku")      # dowizanie do pliku zewntrznego
plik['klucz'] = 'dane'                # zachowywanie danych wedug klucza
dane = plik['klucz']                  # pobieranie danych wedug klucza

import cgi
formularz = cgi.FieldStorage()  # rozbir danych formularza (stdin, environ)
if formularz.has_key('imie'):
    showReply('Witaj, ' + formularz['imie'].value)


*** Strona 69 *******************************************************************

>>> mojplik = open('mojplik', 'w')          # otwarcie do zapisu (utworzenie)
>>> mojplik.write('witaj pliku tekstowy\n') # zapis wiersza tekstu
>>> mojplik.close()

>>> mojplik = open('mojplik', 'r')          # otwarcie do odczytu
>>> mojplik.readline()                      # odczytanie wiersza
'witaj pliku tekstowy\012'
>>> mojplik.readline()                      # pusty acuch: koniec pliku
''


*** Strona 71-73 ****************************************************************

class MojaSekwencja:
    def __getitem__ (self, index):
        # wywoywanie dla self[index], for x in self, x in self
    def __getslice__(self, low, high):
        # wywoywanie dla self[low:high]
    def __add__(self, other):
        # wywoywanie dla self + other

>>> 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] = 'niespodzianka'           # zmienia wszystkie trzy odwoania!
>>> L
['a', [1, 'niespodzianka', 3], 'b']
>>> D
{'x': [1, 'niespodzianka', 3], 'y': 2}

>>> L1 = [1, ('a', 3)]         # taka sama warto, unikatowe obiekty
>>> L2 = [1, ('a', 3)]
>>> L1 == L2, L1 is L2         # czy odpowiednik? czy taki sam obiekt?
(1, 0)

>>> L1 = [1, ('a', 3)]
>>> L2 = [1, ('a', 2)]
>>> L1 < L2, L1 == L2, L1 > L2   # mniejsze, rwne, wiksze: krotka wynikw
(0, 0, 1)


*** Strona 76-78 ****************************************************************

>>> L = [1, 2, 3]
>>> M = ['X',  L, 'Y']     # wstawienie odwoania do L
>>> M
['X', [1, 2, 3], 'Y']
>>> L[1] = 0               # zmienia si take M
>>> M
['X', [1, 0, 3], 'Y']

>>> L = [1, 2, 3]
>>> M = ['X', L[:], 'Y']    # wstawiona kopia L
>>> L[1] = 0                # zmienia tylko L, a nie M
>>> L
[1, 0, 3]
>>> M
['X', [1, 2, 3], 'Y']


>>> L = [4, 5, 6]
>>> X = L * 4            # tak jak [4, 5, 6] + [4, 5, 6] + ...
>>> Y = [L] * 4          # [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               # ma wpyw na Y, ale nie na 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 = ['hi.']; L.append(L)    # dodaje odwoanie do tego samego obiektu
>>> L                           # przed 1.5.1: ptla! (Ctrl-C przerywa)


T = (1, 2, 3)
T[2] = 4             # bd!
T = T[:2] + (4,)     # poprawnie: (1, 2, 4)


***kod do wicze znajduje si w katalogu "rozwiazania"***