% python
>>> nudge = 1
>>> wink = 2
>>> A, B = nudge, wink                       # Przypisanie krotki
>>> A, B                                     # Jak A = nudge; B = wink
(1, 2)
>>> [C, D] = [nudge, wink]                   # Przypisanie listy
>>> C, D
(1, 2)


>>> nudge = 1
>>> wink = 2
>>> nudge, wink = wink, nudge                # Krotki: zamiana wartości
>>> nudge, wink                              # Jak T = nudge; nudge = wink; wink = T
(2, 1)


>>> [a, b, c] = (1, 2, 3)                    # Przypisanie krotki wartości do listy nazw
>>> a, c
(1, 3)
>>> (a, b, c) = "ABC"                        # Przypisanie łańcucha znaków do krotki
>>> a, c
('A', 'C')


>>> string = 'JAJO'
>>> a, b, c, d = string                      # Ta sama liczba elementów po obu stronach
>>> a, d
('J', 'O')
>>> a, b, c = string                         # Błąd: różna liczba elementów
...pominięto tekst błędu...
ValueError: too many values to unpack


>>> a, b, c = string[0], string[1], string[2:] # Indeksowanie i wycinek
>>> a, b, c
('J', 'A', 'JO')

>>> a, b, c = list(string[:2]) + [string[2:]] # Wycinek i konkatenacja
>>> a, b, c
('J', 'A', 'JO')

>>> a, b = string[:2]                        # To samo w prostszej formie
>>> c = string[2:]
>>> a, b, c
('J', 'A', 'JO')

>>> (a, b), c = string[:2], string[2:]       # Zagnieżdżone sekwencje
>>> a, b, c
('J', 'A', 'JO')


>>> ((a, b), c) = ('JA', 'JO')               # Połączone w pary zgodnie z kształtem i pozycją
>>> a, b, c
('J', 'A', 'JO')


>>> red, green, blue = range(3)
>>> red, blue
(0, 2)


>>> range(3)                                 # W Pythonie 3.0 można spróbować list(range(3))
[0, 1, 2]


>>> L = [1, 2, 3, 4]
>>> while L:
...    front, L = L[0], L[1:]
...    print front, L
...
1 [2, 3, 4]
2 [3, 4]
3 [4]
4 []


...    front = L[0]
...    L = L[1:]


>>> a = b = c = 'mielonka'
>>> a, b, c
('mielonka', 'mielonka', 'mielonka')


>>> c = 'mielonka'
>>> b = c
>>> a = b


>>> a = b = 0
>>> b = b + 1
>>> a, b
(0, 1)


>>> a = b = []
>>> b.append(42)
>>> a, b
([42], [42])


>>> a = []
>>> b = []
>>> b.append(42)
>>> a, b
([], [42])


X = X + Y                                    # Forma tradycyjna
X += Y                                       # Nowsza forma rozszerzona


>>> x = 1
>>> x = x + 1                                # Forma tradycyjna
>>> x
2

>>> x += 1                                   # Forma rozszerzona
>>> x
3


>>> S = "mielonka"
>>> S += "MIELONKA"                          # Niejawna konkatenacja
>>> S
'mielonkaMIELONKA'


>>> L = [1, 2]
>>> L = L + [3]                              # Konkatenacja: wolniej
>>> L
[1, 2, 3]
>>> L.append(4)                              # Szybciej, ale w miejscu
>>> L
[1, 2, 3, 4]


>>> L = L + [5, 6]                           # Konkatenacja: wolniej
>>> L
[1, 2, 3, 4, 5, 6]
>>> L.extend([7, 8])                         # Szybciej, ale w miejscu
>>> L
[1, 2, 3, 4, 5, 6, 7, 8]


>>> L += [9, 10]                             # Odwzorowane na L.extend([9, 10])
>>> L
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


>>> L = [1, 2]
>>> M = L                                    # L i M są referencjami do jednego obiektu
>>> L = L + [3, 4]                           # Konkatenacja tworzy nowy obiekt
>>> L, M                                     # Zmiana L, ale nie M
([1, 2, 3, 4], [1, 2])
>>> L = [1, 2]
>>> M = L
>>> L += [3, 4]                              # Ale += tak naprawdę oznacza extend
>>> L, M                                     # Również w M zmiana jest widoczna!
([1, 2, 3, 4], [1, 2, 3, 4])


>>> x = 0                                    # x powiązane z obiektem liczby całkowitej
>>> x = "Troll"                              # Teraz jest łańcuchem znaków
>>> x = [1, 2, 3]                            # A teraz listą


>>> L = [1, 2]
>>> L.append(3)                              # append jest metodą modyfikującą listę w miejscu
>>> L
[1, 2, 3]


>>> L = L.append(4)                          # append zwraca None, a nie L
>>> print L                                  # Tracimy więc naszą listę!
None


>>> x = 'a'
>>> y = 'b'
>>> print x, y
a b


>>> print x + y
ab
>>> print '%s...%s' % (x, y)
a...b


>>> print 'Witaj, świecie!'                  # Wyświetlenie obiektu łańcucha znaków
Witaj, świecie!


>>> 'Witaj, świecie!'                        # Wynik zwracany interaktywnie
'Witaj, świecie!'


>>> import sys                               # Wyświetlenie obiektu w trudniejszy sposób
>>> sys.stdout.write('Witaj, świecie!\n')
Witaj, świecie!


print X


import sys
sys.stdout.write(str(X) + '\n')


import sys
sys.stdout = open('log.txt', 'a')            # Przekierowuje print do pliku
...
print x, y, x                                # Pokazuje się w log.txt


>>> import sys
>>> temp = sys.stdout                        # Zapisane w celu późniejszego przywrócenia
>>> sys.stdout = open('log.txt', 'a')        # Przekierowanie print do pliku
>>> print 'mielonka'                         # Tekst trafia do pliku, a nie tutaj
>>> print 1, 2, 3
>>> sys.stdout.close( )                      # Wyczyszczenie wyjścia na dysk
>>> sys.stdout = temp                        # Przywrócenie oryginalnego strumienia
>>> print 'z powrotem tu'                    # Tekst znowu pokazuje się tutaj
z powrotem tu
>>> print open('log.txt').read( )            # Wynik poprzednich instrukcji print
mielonka
1 2 3


log = open('log.txt', 'a')
print >> log, x, y, z                        # Zapis do obiektu podobnego do pliku 
print a, b, c                                # Zapis do oryginalnego stdout


>>> log = open('log.txt', 'w')
>>> print >> log, 1, 2, 3
>>> print >> log, 4, 5, 6
>>> log.close( )
>>> print 7, 8, 9
7 8 9
>>> print open('log.txt').read( )
1 2 3
4 5 6


>>> import sys
>>> sys.stderr.write(('Niepoprawnie!' * 5) + '\n')
Niepoprawnie!Niepoprawnie!Niepoprawnie!Niepoprawnie!Niepoprawnie!

>>> print >> sys.stderr, 'Niepoprawnie!' * 5
Niepoprawnie!Niepoprawnie!Niepoprawnie!Niepoprawnie!Niepoprawnie!


class FileFaker:
   def write(self, string):
      # Coś robi z łańcuchem znaków
import sys
sys.stdout = FileFaker( )
print someObjects                            # Przesyła do metody write klasy


myobj = FileFaker( )                         # Przekierowanie do obiektu na tę jedną operację
print >> myobj, someObjects                  # Nie przestawia sys.stdout


python script.py < plik_wejściowy > plik_wyjściowy
python script.py | filterProgram


A = B = C = []