>>> 123 + 222                                # Dodawanie liczb całkowitych
345
>>> 1.5 * 4                                  # Mnożenie liczb zmiennoprzecinkowych
6.0
>>> 2 ** 100                                 # 2 do potęgi 100
1267650600228229401496703205376L


>>> 3.1415 * 2                               # jako kod
6.2830000000000004
>>> print 3.1415 * 2                         # w postaci przyjaznej dla użytkownika
6.283


>>> import math
>>> math.pi
3.1415926535897931
>>> math.sqrt(85)
9.2195444572928871


>>> import random
>>> random.random( )
0.59268735266273953
>>> random.choice([1, 2, 3, 4])
1


>>> S = 'Mielonka'
>>> len(S)                                   # Długość
8
>>> S[0]                                     # Pierwszy element w S, indeksowanie rozpoczyna się od zera
'M'
>>> S[1]                                     # Drugi element od lewej
'i'


>>> S[-1]                                    # Pierwszy element od końca S
'a'
>>> S[-2]                                    # Drugi element od końca S
'k'


>>> S[-1]                                    # Ostatni element w S
'a'
>>> S[len(S)-1]                              # Indeks ujemny zapisany w trudniejszy sposób
'a'


>>> S                                        # Łańcuch z ośmioma znakami
'Mielonka'
>>> S[1:3]                                   # Wycinek z S z indeksami od 1 do 2 (bez 3)
'ie'

>>> S[1:]                                    # Wszystko poza pierwszym znakiem (1:len(S))
'ielonka'
>>> S                                        # Łańcuch S się nie zmienił
'Mielonka'
>>> S[0:7]                                   # Wszystkie elementy bez ostatniego
'Mielonk'
>>> S[:7]                                    # To samo co S[0:7]
'Mielonk'
>>> S[:-1]                                   # Wszystkie elementy bez ostatniego w łatwiejszej postaci
'Mielonk'
>>> S[:]                                     # Całość S jako kopia najwyższego poziomu (0:len(S))
'Mielonka'


>>> S
'Mielonka'
>>> S + 'xyz'                                # Konkatenacja
'Mielonkaxyz'
>>> S                                        # S pozostaje bez zmian
'Mielonka'
>>> S * 8                                    # Powtórzenie
'MielonkaMielonkaMielonkaMielonkaMielonkaMielonkaMielonkaMielonka'


>>> S
'Mielonka'
>>> S[0] = 'z'                               # Niezmienne obiekty nie mogą być modyfikowane
...pominięto tekst błędu...
TypeError: 'str' object does not support item assignment

>>> S = 'z' + S[1:]                          # Można jednak tworzyć wyrażenia budujące nowe obiekty
>>> S
'zielonka'


>>> S.find('ie')                             # Odnalezienie przesunięcia podłańcucha
1
>>> S
'Mielonka'

>>> S.replace('ie', 'XYZ')                   # Zastąpienie wystąpień podłańcucha innym
'MXYZlonka'
>>> S
'Mielonka'


>>> line = 'aaa,bbb,ccccc,dd'
>>> line.split(',')                          # Podzielenie na ograniczniku na listę podłańcuchów
['aaa', 'bbb', 'ccccc', 'dd']

>>> S = 'mielonka'
>>> S.upper( )                               # Konwersja na duże litery
'MIELONKA'

>>> S.isalpha( )                             # Sprawdzenie zawartości: isalpha, isdigit
True

>>> line = 'aaa,bbb,ccccc,dd\n'
>>> line = line.rstrip( )                    # Usunięcie białych znaków po prawej stronie
>>> line
'aaa,bbb,ccccc,dd'


>>> dir(S)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__str__', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']


>>> help(S.index)
Help on built-in function index:

index(...)
   S.index(sub [,start [,end]]) -> int
   Like S.find( ) but raise ValueError when the substring is not found.
   
   
>>> S = 'A\nB\tC'                            # \n to koniec wiersza, \t to tabulator
>>> len(S)                                   # Każde jest jednym znakiem
5

>>> ord('\n')                                # \n jest bajtem z wartością binarną 10 w ASCII
10

>>> S = 'A\0B\0C'                            # \0, binarny bajt zerowy, nie kończy łańcucha znaków
>>> len(S)
5   


>>> msg = """
aaaaaaaaaaaaa
bbb'''bbbbbbbbbb""bbbbbbb'bbbb
cccccccccccccc"""
>>> msg
'\naaaaaaaaaaaaa\nbbb\'\'\'bbbbbbbbbb""bbbbbbb\'bbbb\ncccccccccccccc'


>>> import re
>>> match = re.match('Witaj,[ \t]*(.*)Robinie', 'Witaj, sir   Robinie')
>>> match.group(1)
'sir '


>>> match = re.match('/(.*)/(.*)/(.*)', '/usr/home/drwal')
>>> match.groups( )
('usr', 'home', 'drwal')


>>> L = [123, 'mielonka', 1.23]              # Trzyelementowa lista z elementami różnego typu
>>> len(L)                                   # Liczba elementów listy
3


>>> L[0]                                     # Indeksowanie po pozycji
123

>>> L[:-1]                                   # Wycinkiem listy jest nowa lista
[123, 'mielonka']

>>> L + [4, 5, 6]                            # Konkatenacja także zwraca nową listę
[123, 'mielonka', 1.23, 4, 5, 6]

>>> L                                        # Oryginalna lista pozostaje bez zmian
[123, 'mielonka', 1.23]


>>> L.append('NI')                           # Rośnięcie: dodanie obiektu na końcu listy
>>> L
[123, 'mielonka', 1.23, 'NI']

>>> L.pop(2)                                 # Kurczenie się: usunięcie obiektu ze środka listy
1.23

>>> L                                        # "del L[2]" również usuwa element z listy
[123, 'mielonka', 'NI']


>>> M = ['bb', 'aa', 'cc']
>>> M.sort( )
>>> M
['aa', 'bb', 'cc']
>>> M.reverse( )
>>> M
['cc', 'bb', 'aa']


>>> L
[123, 'mielonka', 'NI']

>>> L[99]
...pominięto tekst błędu...
IndexError: list index out of range

>>> L[99] = 1
...pominięto tekst błędu...
IndexError: list assignment index out of range


>>> M = [[1, 2, 3],                          # Macierz 3 x 3 w postaci list zagnieżdżonych
         [4, 5, 6],
         [7, 8, 9]]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]


>>> M[1]                                     # Pobranie drugiego wiersza
[4, 5, 6]
>>> M[1][2]                                  # Pobranie drugiego wiersza, a z niego trzeciego elementu
6


>>> col2 = [row[1] for row in M]             # Zebranie elementów z drugiej kolumny
>>> col2
[2, 5, 8]

>>> M                                        # Macierz pozostaje bez zmian
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]


>>> [row[1] + 1 for row in M]                # Dodanie 1 do każdego elementu w drugiej kolumnie
[3, 6, 9]

>>> [row[1] for row in M if row[1] % 2 == 0] # Odfiltrowanie elementów nieparzystych
[2, 8]


>>> diag = [M[i][i] for i in [0, 1, 2]]      # Pobranie przekątnej z macierzy
>>> diag
[1, 5, 9]

>>> doubles = [c * 2 for c in 'mielonka']    # Powtórzenie znaków w łańcuchu
>>> doubles
['mm', 'ii', 'ee', 'll', 'oo', 'nn', 'kk', 'aa']


>>> D = {'jedzenie': 'Mielonka', 'ilość': 4, 'kolor': 'różowy'}

>>> D['jedzenie']                            # Pobranie wartości klucza "jedzenie"
'Mielonka'
>>> D['ilość'] += 1                          # Dodanie 1 do wartości klucza "ilość"
>>> D
{'jedzenie': 'Mielonka', 'kolor': 'różowy', 'ilość': 5}


>>> D = {}
>>> D['imię'] = 'Robert'                     # Tworzenie kluczy przez przypisanie
>>> D['zawód'] = 'programista'
>>> D['wiek'] = 40

>>> D
{'wiek': 40, 'zawód': 'programista', 'imię': 'Robert'}

>>> print D['imię']
Robert


>>> rec = {'dane osobowe': {'imię': 'Robert', 'nazwisko': 'Zielony'},
           'zawód': ['programista', 'inżynier'],
           'wiek': 40.5}

   
>>> rec['dane osobowe']                      # 'dane osobowe' to zagnieżdżony słownik
{'nazwisko': 'Zielony', 'imię': 'Robert'}

>>> rec['dane osobowe']['nazwisko']          # Indeksowanie zagnieżdżonego słownika
'Zielony'

>>> rec['zawód']                             # 'zawód' to zagnieżdżona lista
['programista', 'inżynier']

>>> rec['zawód'][-1]                         # Indeksowanie zagnieżdżonej listy
'inżynier'

>>> rec['zawód'].append('leśniczy')          # Rozszerzenie listy zawodów Roberta
>>> rec
{'wiek': 40.5, 'zawód': ['programista', 'inżynier', 'leśniczy'], 'dane osobowe': {'nazwisko': 'Zielony', 'imię': 'Robert'}}


>>> rec = 0                                  # Miejsce zajmowane przez obiekt zostaje odzyskane


>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D
{'a': 1, 'c': 3, 'b': 2}


>>> Ks = D.keys( )                           # Nieuporządkowana lista kluczy
>>> Ks
['a', 'c', 'b']

>>> Ks.sort( )                               # Posortowana lista kluczy
>>> Ks
['a', 'b', 'c']

>>> for key in Ks:                           # Iteracja przez posortowane klucze
       print key, '=>', D[key]
       
a => 1
b => 2
c => 3


>>> D
{'a': 1, 'c': 3, 'b': 2}

>>> for key in sorted(D):
       print key, '=>', D[key]
       
a => 1
b => 2
c => 3


>>> for c in 'mielonka':
       print c.upper( )

M
I
E
L
O
N
K
A


>>> squares = [x ** 2 for x in [1, 2, 3, 4, 5]]
>>> squares
[1, 4, 9, 16, 25]


>>> squares = []
>>> for x in [1, 2, 3, 4, 5]:                # To robi lista składana
       squares.append(x ** 2)

>>> squares
[1, 4, 9, 16, 25]


>>> D
{'a': 1, 'c': 3, 'b': 2}

>>> D['e'] = 99                              # Przypisanie nowego klucza rozszerza słownik
>>> D
{'a': 1, 'c': 3, 'b': 2, 'e': 99}

>>> D['f']                                   # Referencja do nieistniejącego klucza jest błędem
...pominięto tekst błędu...
KeyError: 'f'


>>> D.has_key('f')
False

>>> if not D.has_key('f'):
       print 'nie ma'

nie ma


>>> T = (1, 2, 3, 4)                         # Krotka z 4 elementami
>>> len(T)                                   # Długość krotki
4
>> T + (5, 6)                                # Konkatenacja
(1, 2, 3, 4, 5, 6)
>>> T[0]                                     # Indeksowanie i wycinki
1


>>> T[0] = 2                                 # Krotki są niezmienne
...pominięto tekst błędu...
TypeError: 'tuple' object does not support item assignment


>>> f = open('data.txt', 'w')                # Utworzenie nowego pliku w trybie do zapisu
>>> f.write('Witaj,\n')                      # Zapisanie do niego łańcuchów bajtów
>>> f.write('Brian\n')
>>> f.close( )                               # Zamknięcie pliku i wyczyszczenie bufora wyjściowego na dysku


>>> f = open('data.txt')                     # 'r' jest domyślnym trybem przetwarzania
>>> bytes = f.read( )                        # Wczytanie całego pliku do łańcucha znaków
>>> bytes
'Witaj,\nBrian\n'

>>> print bytes                              # Instrukcja print interpretuje znaki sterujące
Witaj,
Brian

>>> bytes.split( )                           # Zawartość pliku jest zawsze łańcuchem znaków
['Witaj,', 'Brian']


>>> dir(file)
['__class__', '__delattr__', '__doc__', '__enter__', '__exit__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'close', 'closed', 'encoding', 'fileno', 'flush', 'isatty', 'mode', 'name', 'newlines', 'next', 'read', 'readinto', 'readline', 'readlines', 'seek', 'softspace', 'tell', 'truncate', 'write', 'writelines', 'xreadlines']

>>> help(file.seek)
...przekonaj się sam!...


>>> X = set('mielonka')
>>> Y = set(['s', 'z', 'y', 'n', 'k', 'a'])  # Zbudowanie dwóch zbiorów z sekwencji
>>> X, Y
(set(['a', 'e', 'i', 'k', 'm', 'l', 'o', 'n']), set(['a', 'k', 'n', 's', 'y', 'z']))

>>> X & Y                                    # Część wspólna zbiorów
set(['a', 'k', 'n'])

>>> X | Y                                    # Suma zbiorów
set(['a', 'e', 'i', 'k', 'm', 'l', 'o', 'n', 's', 'y', 'z'])

>>> X – Y                                    # Różnica
set(['i', 'm', 'e', 'l', 'o'])


>>> import decimal                           # Liczby dziesiętne
>>> d = decimal.Decimal('3.141')
>>> d + 1
Decimal("4.141")

>>> 1 > 2, 1 < 2                             # Liczby typu Boolean
(False, True)

>>> bool('mielonka')
True

>>> X = None                                 # Pojemnik None
>>> print X
None

>>> L = [None] * 100                         # Inicjalizacja listy stu None
>>> L
[None, None, None, None, None, None, None, None, None, None, None, None, None,
...lista stu None...]

>>> type(L)                                  # Typy
<type 'list'>

>>> type(type(L))                            # Nawet typy są obiektami
<type 'type'>


>>> if type(L) == type([]):                  # Sprawdzanie typów
       print 'yes'

yes

>>> if type(L) == list:                      # Użycie nazwy typu
       print 'yes'

yes

>>> if isinstance(L, list):                  # Sprawdzanie zorientowane obiektowo
       print 'yes'

yes


>>> class Worker:
       def __init__(self, name, pay):        # Inicjalizacja przy utworzeniu
          self.name = name                   # self jest nowym obiektem; name to nazwisko, a pay - płaca
          self.pay = pay
       def lastName(self):
          return self.name.split( )[-1]      # Podział łańcucha znaków na znakach pustych
       def giveRaise(self, percent):
          self.pay *= (1.0 + percent)        # Uaktualnienie płacy w miejscu


>>> bob = Worker('Robert Zielony', 50000)    # Utworzenie dwóch obiektów
>>> anna = Worker('Anna Czerwona', 60000)    # Każdy ma imię i nazwisko oraz płacę
>>> bob.lastName( )                          # Wywołanie metody - self to bob
'Zielony'

>>> anna.lastName( )                         # Teraz self to anna
'Czerwona'

>>> anna.giveRaise(.10)                      # Uaktualnienie płacy Anny
>>> anna.pay
66000.0