Listy (list) oraz krotki (tuple) stanowią uporządkowane zbiory danych w postaci obiektów, przy czym mogą być to obiekty różnych typów. Odpowiednikiem list w innych językach programowania często jest tablica, przy czym w językach o statycznym typowaniu może ona przechowywać jedynie obiekty jednego, zadeklarowanego typu, lista w Python’ie może przechowywać obiekty różnych typów.

Listy są mutowalnym typem danych , a więc możliwym do modyfikacji po utworzeniu (można dodawać nowe, modyfikować  oraz usuwać istniejące elementy listy). Listę można utworzyć korzystając z nawiasów kwadratowych lub konstruktora list(obiekt_iterowalny). Krotki są z kolei niemutowalne, do  ich tworzenia służą nawiasy okrągłe lub konstruktor tuple(obiekt_iterowalny).

Przykładowo:

>>> a=('jednoelementowa krotka',)
>>> b=’jeszcze jedna jednoelementowa krotka’,
>>> c=['jednoelementowa lista']

Powyższy przykład tworzy jednoelementowe krotki „a”,”b” oraz listę „c”. Należy zwrócić uwagę, na znak przecinka na końcu jednoelementowych krotek:  bez niego utworzone zostałyby łańcuchy znakowe, a nie krotki!Ponieważ krotki oraz listy są uporządkowanymi zbiorami elementów więc można posługiwać się indeksami w celu wybrania odpowiedniego elementu (należy pamiętać iż indeksy zaczynają się od zera) oraz notacją „plastrową”, np.:

>>> a=["Chapman","Cleese","Terry","Eric","Terry","Michael"]
>>> a[0]
'Chapman'
>>> a[-1]
'Michael'
>>> a[1:3]
['Cleese', 'Terry']
>>> a[0:-1]
['Chapman', 'Cleese', 'Terry', 'Eric', 'Terry']
>>> a[2:]
['Terry', 'Eric', 'Terry', 'Michael']
>>> a[:2]
['Chapman', 'Cleese']

Korzystając z ujemnych indeksów można odwoływać się do elementów od końca. Notacja a[:2] zwraca listę stworzoną z dwóch pierwszych elementów listy „a”, z kolei a[3:] utworzy i zwróci listę złożoną z elementów listy „a” od indeksu 3 do końca.

Charakterystyczna jest własność pakowania/rozpakowania krotek:

>>> x=”Graham”,”John”,”Terry”
>>> x
(”Graham”,”John”,”Terry”)
>>> a,b,c=x
>>> a
”Graham”
>>> b
”John”
>>> c
”Terry”

Poprzez pakowanie utworzona została krotka „x”, która następnie została rozpakowana w ten sposób, iż kolejne jej  wartości zostały przypisane zmiennym „a”, „b” oraz „c”. Rozpakować w ten sposób można także odpowiednią listę. Przy rozpakowywaniu ilość zmiennych (po lewej stronie) musi być równa ilości elementów danej sekwencji (po prawej).

Listę można utworzyć także na podstawie dowolnego, iterowalnego obiektu:

>>> a=[1,2,3,4]
>>> [i**2 for i in a]
[1, 4, 9, 16]

Jest to tak zwana lista składana.

Przy tak tworzonej liście możliwe jest umieszczenie dodatkowej instrukcji warunkowej:

>>> a=(3,4,2,5,7,12)
>>> [i for i in a if i%2==0]
[4, 2, 12]

Powyższe polecenie utworzy listę z parzystych elementów krotki „a”.

Krotki oraz listy posiadają jedynie dwie wspólne metody:

Lista posiada szereg charakterystycznych dla typu mutowalnego metod:

Dodatkowo, wbudowana funkcja sorted(s) umożliwia utworzenie posortowanej listy z elementów sekwencji „s”.

Jeszcze kilka przykładów użycia list:

a=[‘pierwsza’,’druga’,’trzecia’,123,456,7.0,True]
print a,type(a)
print a[1],type(a[1])
print a[2:4],type(a[2:4])
print a[1][3],type(a[1][3])
print a[1][2:5],type(a[1][2:5])
print a[-3]
print len(a)

w odpowiedzi dostajemy:

print a,type(a)
['pierwsza', 'druga', 'trzecia', 123, 456, 7.0, True]
print a[1],type(a[1])
druga
print a[2:4],type(a[2:4])
['trzecia', 123]
print a[1][3],type(a[1][3])
g
print a[1][2:5],type(a[1][2:5])
uga
print a[-3]
456
print len(a)
7

Python jest językiem bardzo intuicyjnym, z reguły robi to co chcemy:

1. print a : to oczywiście wypisanie zawartości całej tablicy, tablica „a jest typu list.
2. print a[1] : wypisujemy drugi element tablicy (numeracja od zera!), którym jest łańcuch „druga”.
3. print a[2:4] : tu już robi się ciekawiej, wyrażenie a[M,N] tworzy i zwraca nową listę zawierającą elementy z listy „a” od indeksu M do N-1 (a więc w tym przypadku od 2 do 3).
4. print a[1][3] : do poszczególnych elementów łańcucha (jego liter) mamy dostęp dokładnie w ten sam sposób jak do elementów listy. Wyrażenie a[1] zwraca referencje do drugiego elementu listy „a” (a więc łańcucha ‘druga’), natomiast a[1][3] do czwartegjego elementu – licząc oczywiście od 0 – a tym samym do czwartego znaku czyli litery ‘g’ (zwracany jest 1-elementowy łańcuch).
5. print a[1][2:5] : analogicznie do dwóch poprzednich przykładów wyrażenie to tworzy nowy łańcuch powstały poprzez wycięcie z łańcucha a[1] liter od 2 do 5-1.
6. 6. print a[-2] : poprzez użycie znaku minus mamy możliwość dostępu do elementów listy poczynając od jej końca. Ta sama zasada dotyczy również łańcuchów znakowych.
7. Możemy użyć funkcji len by dowiedzieć się ile elementów liczy lista.

Pisząc dalej w konsoli:

dir([])

Dowiemy się o wszystkich metodach listy:

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Bardziej szczegółowy opis listy oraz każdej z jej metod można wywołać korzystając funkcji pomocy:

help([])
help([].sort)

Duża ilość metod ze znakami “__” odnosi się do operatorów, przykładowo metoda “__add__” odpowiada za przeładowanie operatora “+”: listy można więc do siebie dodawać. Przykładowo pisząc:

x1=[1,2,3,4]
x2=[5,'znaki',False]
x3=x1+x2
print x3
[1, 2, 3, 4, 5, 'znaki', False]

Wyrażenie „x1+x2” tworzy nową listę, będącą złożeniem x1 i x2.

Zbiory

Zbiór – set – jest nieuporządkowaną kolekcją unikalnych obiektów (w przeciwieństwie do list czy krotek dany element może występować tylko raz w zbiorze). Istnieją zbiory mutowalne, tworzone za pomocą polecenia set oraz niemutowalne tworzone poleceniem frozenset. Zbiór można utworzyć na podstawie dowolnego iterowalnego obiektu, np.:

>>> a=['pierwszy',2,3.1415]
>>> s=set(a)
>>> s
{'pierwszy', 2, 3.1415000000000002}
>>> f=frozenset(a)
>>> f
frozenset({'pierwszy', 2, 3.1415000000000002})

Python 3.0 daje także możliwość użycia nawiasów klamrowych do utworzenia obiektu typu set:

>>> a={1,2,3}
>>> a
{1, 2, 3}
>>> type(a)
<class 'set'>

Możliwe jest także utworzenie zbioru składanego (analogicznie do składanych list):

>>> a=('x','y','z')
>>> q={i for i in a}
>>> q
{'y', 'x', 'z'}
>>> type(q)
<class 'set'>

Wprowadzać nowe elementy do zbioru typu set można za pomocą metodą add, a usuwać  metodą discard:

>>> s.add('nowy')
>>> s
{'pierwszy', 2, 3.1415000000000002, 'nowy'}
>>> s.discard(2)
>>> s
{'pierwszy', 3.1415000000000002, 'nowy'}

Do usuwania elementów ze zbioru służy także metoda remove, która wyrzuci wyjątek KeyError przy próbie usunięcia elementu, którego nie ma w zbiorze.

Ponieważ zbiór jest nieuporządkowaną kolekcją obiektów tak więc nie wspiera indeksowania ani notacji „plastrowej” .

Zarówno na zbiorach set oraz frozenset można wykonywać szereg operacji za pomocą zdefiniowanych operatorów lub odpowiednich metod:

Powyższe operatory wymagają aby ich argumenty były zbiorami, w przeciwieństwie do metod, którym można przekazać dowolny iterowalny obiekt:

>>> x=set('abcd')>>> y=set('12ac')
>>> x | y
{'a', 'c', 'b', 'd', '1', '2'}
>>> x - y
{'b', 'd'}
>>> x ^ y
{'b', 'd', '1', '2'}
>>> x.union('AB')
{'a', 'A', 'c', 'b', 'd', 'B'}
>>> x.intersection('bc')
{'c', 'b'}
>>> x.symmetric_difference('abc')
{'d'}Można porównywać i łączyć ze sobą, za pomocą operatorów, zbiory set oraz frozenset :>>> set('ABC')==frozenset('BCA')
True
>>> frozenset('WXY')|set('XYZ')
frozenset({'W', 'Y', 'X', 'Z'})Operacje, które łączą instancje typu set z frozenset zwracają typ pierwszego operandu.

Typ set jest mutowalny i dlatego też posiada dodatkowo specyficzne operatory i metody umożliwiające różnego rodzaju operacje na zbiorze:

Tu także metodom można przekazać iterowalny argument, operatory mogą działać jedynie na obiektach typu set.

Słowniki

Słowniki zwane również tablicami asocjacyjnymi lub mapami są typem danych w postaci nieuporządkowanych par klucz-wartość.Przy listach oraz krotkach kluczem jest liczba całkowita, natomiast kluczem słownika może być dowolny niezmienny (immutable), a więc haszowalny (hashable) obiekt.

Ponieważ klucze słownika służą do jednoznacznego wskazania określonego obiektu/wartości, więc muszą być (w obrębie danego słownika) unikalne, w przeciwieństwie do obiektów na jakie wskazują (różne klucze w słowniku mogą wskazywać na ten sam obiekt lub różne obiekty tego samego typu, o takich samych wartościach).

Poniższy przykład tworzy 2-elementowy słownik z kluczami różnych typów, wypisuje go wraz z ilością elementów:

>>> s = {1:'ONE','drugi':2.0}
>>> s
{1: 'ONE', 'drugi': 2.0}
>>> s['PI']=3.1415
>>> s
{1: 'ONE', 'drugi': 2.0, 'PI': 3.1415000000000002}
>>> del(s[1])
>>> s
{'drugi': 2.0, 'PI': 3.1415000000000002}

Tak jak i inne typy tak słowniki posiadają szereg charakterystycznych dla nich metod:

Powyższe metody są wspólne dla Python’a 3.0 oraz 2.6. Ten ostatni posiadał jeszcze (dla zgodności z gałęzią 2) metody iterkeys, itervalues oraz iteritems które zwracały obiekty iterowalne, dzięki którym można było poruszać się odpowiednio po kluczach, wartościach oraz parach klucz/wartość słownika. Te metody nie są już obecne w Python’ie 3.0. Istnieją natomiast metody keys, values oraz items o analogicznym przeznaczeniu (metody te także są obecne w Python’ie 2.6, lecz zwracają tam listy zamiast iterowalnych obiektów).

Poniższy przykład tworzy 2-elementowy słownik z kluczami różnych typów, wypisuje go wraz z ilością elementów. Polecenie dir zwraca listę metod słownika.

my_dict = {1:1,'dwa':2.0}
print my_dict ,  len(my_dict)
{1: 1, 'dwa’:2.0}

dir(my_dict)
['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

Raz utworzonemu słownikowi można zarówno dodawać, ujmować jak i zastępować elementy:

>>> my_dict['xxx']=123
>>> print my_dict
{1: 1, 'xxx': 123, 'dwa': 2.0}
>>> del(my_dict['xxx'])
>>> print my_dict
{1: 1, 'dwa': 2.0}
>>> print my_dict.keys()
[1, 'dwa']
print my_dict.values()
[1, 2.0]
>>> >>> print my_dict.items()
[(1, 1), ('dwa', 2.0)]

W powyższym przykładzie użyte zostały trzy użyteczne metody słownika:

• keys : zwraca listę kluczy słownika.
• values : zwraca listę wartości słownika.
• items : zwraca listę, której elementami są krotki (klucz,wartość) słownika.

Funkcja dict umożliwia utworzenie słownika z krotki lub listy:

>>> krotka=((1,'jeden'),('2',222))
>>> lista=[['111',1],[2,'dwa']]
>>> dict(krotka)
{1: 'jeden', '2': 222}
>>> dict(lista)
{2: 'dwa', '111': 1}

Typy sekwencyjne to skończone zbiory uporządkowanych danych indeksowanych poprzez nieujemne liczby.  Podstawowe sekwencyjne typy to łańcuchy znakowe (str), krotki oraz listy:

>>> znaki='abc'
>>> krotka=(1,2,3)
>>> lista=[4,5,6]

Wbudowana funkcja len(z) zwraca ilość elementów zbioru  z.  Dostęp do poszczególnych elementów obiektów dowolnego uporządkowanego typu sekwencyjnego możliwy jest za pomocą nawiasów klamrowych, należy przy tym pamiętać że elementy są indeksowane od zera:

>>> print(len(znaki))
3
>>> print(znaki[0])
a
>>> print(krotka[1])
2
>>> print(lista[2])
6

Typy sekwencyjne można podzielić  na mutowalne i niemutowalne. W powyższym przykładzie dwa pierwsze obiekty są niemutowalne, a więc nie można zmieniać ich zawartości po utworzeniu. Próba zmiany kończy się wyrzuceniem wyjątku:

>>> lista[0]=7
>>> print(lista)
[7, 5, 6]
>>> znaki[0]='x'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Dla sekwencyjnych typów danych dostępnych jest szereg użytecznych funkcji i operatorów:

Typy sekwencyjne wspierają także operatory porównań (==,>,<,>=,<=). W szczególności krotki oraz listy porównywane są poprzez porównywanie kolejnych, odpowiadających sobie elementów.  Aby dwa takie obiekty były sobie równe muszą zawierać tyle samo elementów odpowiednich typów w określonej kolejności.

Slicing

Typy sekwencyjne posiadają charakterystyczną własność zwaną slicing’iem, co można rozumieć jako „dzielenie na plastry”. Slicing tworzy nowy obiekt danego typu poprzez „okrojenie” podanego zbioru do wybranych elementów. Przykładowo wyrażenie z[n:m] pozwala wybrać wszystkie elementy zbioru „z”, których indeks x spełnia warunek n<=x<m (czyli dla wyrażenia z[0:10] mamy do czynienia z elementami zbioru „z” o indeksach od 0 do 9 włącznie).

Niektóre typy sekwencyjne posiadają także „rozszerzony” slicing z trzecim parametrem określającym krok, wyrażenie  z[n:m:o] wybierze wszystkie elementy zbioru „z” o określonym indeksie x, gdzie x=n+p*k dla p>=0 oraz n<=x i n<=x<m.

Typy znakowe

Typy znakowe (łańcuchy znakowe) reprezentują uporządkowaną sekwencję symboli (znaków alfabetu). Jedna z zasadniczych różnic pomiędzy wersjami 3.0 a 2.6 (i wcześniejszymi) jest właśnie  implementacja łańcuchów znakowych.

Python 2.6

Python 2.6 podobnie jak jego poprzednicy posiada dwa rodzaje typów znakowych: str oraz unicode.  Oba typy wywodzą się z tej samej klasy basestring, dzięki czemu posiadają szereg wspólnych metod.

Łańcuch znakowy typu str tworzony jest poprzez umieszczenie tekstu w  cudzysłowach lub apostrofach, łańcuch unikodowy (ang. unicode string) powinien być dodatkowo uzupełniony znakiem u przed cudzysłowem/apostrofem:

>>> text="znaki"
>>> inny='str'
>>> unikod=u”tekst unikodowy”

Można konwertować pomiędzy typem str a unicode korzystając z dostępnych metod encode oraz decode:

>>> unikod=u"żółta kość"
>>> unikod
u'\u017c\xf3\u0142ta ko\u015b\u0107'
>>>
>>> print(s)
żółta kość
>>> string=unikod.encode("cp852")
>>> string
'\xbe\xa2\x88ta ko\x98\x86'
>>> print(string)
żółta kość
>>> unikod2=string.decode("cp852")
>>> unikod2
u'\u017c\xf3\u0142ta ko\u015b\u0107'
>>> print(unikod2)
żółta kość

Na początku powyższego przykładu tworzony jest unikodowy obiekt unikod o zawartości „żółta kość”. Następnie za pomocą metody encode tworzony jest na jego podstawie obiekt string typu str o określonym kodowaniu (cp852 to domyślne kodowanie konsoli Windows).  Ostatecznie obiekt ten został użyty w metodzie decode do utworzenia obiektu unikodowego unikod2 (z odpowiednim kodowaniem, w przeciwnym razie użyte byłoby kodowanie domyślne).  Jak widać przekształcenia ostatecznie  doprowadziły do utworzenia obiektu o typie i zawartości identycznej z obiektem z początku przykładu.

Python 3.0

W Python’ie 3.0 typ str jest już unikodowy, nie ma więc potrzeby by istniał (dostępny jeszcze w wersji 2.6) typ unicode (notacja z prefix’em u” nie istnieje).

Nowością jest natomiast typ bajtowy (bytes). To nowy, niemutowalny typ umożliwiający  przechowywanie bajtowych wartości (wartości typu całkowitego z przedziału 0..255). Analogicznie jak przy typach str i unicode z Python’a 2.6 tak i tu można natomiast konwertować str na bytes za pomocą metody str.encode(), do odwrotnej konwersji służy metoda bytes.decode(). Można także użyć wyrażeń bytes(s, encoding) oraz str(b, encoding).

Obiekty tego typu można tworzyć umieszczając znak b przed apostrofem lub cudzysłowem:

>>> o=b"abc"
>>> print(o)
b'abc'

Typy str i bytes nie posiadają wspólnej nadklasy i nie mogą być mieszane (przykładowo nie można dodawać do siebie obiektów tych typów).

Nowy jest także typ bytearray : to mutowalny typ o interfejsie podobnym do bytes. Można konwertować pomiędzy obiektami typów bytes i bytearray.

Typy bytes oraz bytearray dostępne są zarówno w Python’ie 3.0 i 2.6.

Metody klasy str

Niezależnie czy mamy do czynienia z Python’em 3.0 czy 2.6 klasa str posiada szereg użytecznych metod  (występują one także w unikodzie Python’a 2.6)

Dekoduje łańcuch do unikodu używając kodowania encoding (lub domyślnego jeśli nie jest podane), errors określa reakcję na błędy: domyślnym jest ‘strict’ – w razie błędu wyrzucony zostanie wyjątek UnicodeError. Inne możliwości to ‘ignore’ , ‘replace’, a także inne nazwy zarejestrowane poprzez metodę register_error() modułu codecs.

Formatowanie łańcuchów znakowych

Formatowanie łańcuchów znakowych jest jednym z elementów, które ulegają zmianie w Python’ie. Standardowym operatorem formatowania w wersji oraz wcześniejszych był znak %. W wersji 3.0 można się nim także posługiwać, jednak najprawdopodobniej w wersji 3.1 będzie on oznaczony jako niepożądany (ang. deprecated), a w przyszłych wydaniach ostatecznie usunięty.

Zalecanym, obecnym także w Python’ie 2.6,  sposobem formatowania łańcuchów znakowych jest metoda format. Metoda ta  traktuje łańcuch znakowy jako szablon, a użyte w nim nawiasy klamrowe są znakami o specjalnym przeznaczeniu, np.:

>>> szablon1="Witaj {0}"
>>> szablon2="Data urodzenia:{rok}-{miesiac}-{dzien}"
>>> print(szablon1.format('Wiktor'))
Witaj Wiktor
>>> print(szablon2.format(rok=2000,miesiac=3,dzien=22))
Data urodzenia:2000-3-22

Nazwami pól mogą być zarówno liczby określające ich indeks jak i argumenty o podanej nazwie. Można także odwoływać się do atrybutów obiektów oraz poprzez klucze do odpowiednich wartości słownika.

Poniższy przykład pokazuje dostęp do atrybutów day, month oraz year obiektu reprezentującego aktualną datę, a także do wartości słownika poprzez odpowiednie klucze :

>>> import datetime
>>> data = datetime.datetime.now()
>>> slownik = {"d":"dzien","m":"miesiac","r":"rok"}
>>> szablon = "Jest {1[d]}:{0.day},{1[m]}:{0.month},{1[r]}:{0.year}"
>>> >>> print(szablon.format(data,slownik))
Jest dzien:4,miesiac:1,rok:2009

Po indeksie/nazwie pola może wystąpić specyfikator formatu poprzedzony znakiem dwukropka.

Ogólny format specyfikatora formatu jest następujący:

[[wypełnienie]justowanie][znak][#][0][rozmiar].[precyzja][typ]

gdzie:

• wypełnienie :  dowolny znak oprócz }
• justowanie :  znak określający rodzaj justowania
• znak (+ lub -) dla wartości numerycznej
• # : oznacza użycie prefix’u dla niedziesiętnej wartości numerycznej
• 0 : przed rozmiarem oznacza dopełnienie zerami
• rozmiar : wartość całkowita określająca rozmiar pola
• precyzja : precyzja dla wartości zmiennoprzecinkowej
• typ : znak oznaczający typ prezentacji

Znak określający wypełnienie może wystąpić przed znakiem określającym justowanie, który może przyjmować następujące wartości:

Przykładowo:

>>> s=’wypis’
>>> "{0:<10}".format(s)
'wypis     '
>>> "{0:>10}".format(s)
'     wypis'
>>> "{0:^10}".format(s)
'  wypis   '
>>> "{0:=10}".format(-123)
'-      123'

Zawartość zmiennej „s” (łańcuch ‘wypis’) jest wypisywana na 10 polach, kolejno wyjustowana do lewej (domyślne zachowanie), prawej i środka. Numeryczna wartość -123 jest wypisywana również na 10 polach,  z dopełnieniem po znaku liczby.

Typ prezentacji daje dodatkowe możliwości formatowania wartości numerycznej:

Użycie wybranych typów prezentacji pokazuje poniższy przykład:

>>> "123 w postaci binarnej dopełnione zerami : {0:08b}".format(123)
'123 w postaci binarnej dopełnione zerami : 01111011'
>>> "123 w postaci ósemkowej : {0:10o}".format(123)
'123 w postaci ósemkowej :        173'
>>> "123 w postaci szesnastkowej : {0:2x}".format(123)
'123 w postaci szesnastkowej : 7b'
>>> "1.23456 format ogólny : {0:10.4g}".format(1.23456)
'1.23456 format ogólny :      1.235'
>>> "0.59 procentowo : {0:2.0%}".format(0.59)
'0.59 procentowo : 59%'

W specyfikatorze formatu można odwoływać się do innych pól poprzez zagnieżdżanie. Przykładowo wpisując w konsoli polecenie:

>>> "{0:{1}{2}{3}}".format(123,'#','^',9)
'###123###'

uzyskamy wycentrowany łańcuch z wartością 123 dopełniony znakami # do długości 9 znaków.

W następnej, ostatniej już części opiszemy listy oraz krotki, a także wprowadzimy pojęcie zbioru.

Sam język posiada szereg wbudowanych typów:

1. None

None to specyficzne dla Python’a słowo kluczowe oznaczające brak przypisanej wartości (w innych językach często odpowiednikiem jest Null) .

2. Typ logiczny

Typem reprezentującym logiczną prawdę (wartość True) lub fałsz (False)  jest bool. Najczęściej wyrażenie zwracające taką wartość używane jest w instrukcjach warunkowych (if) lub pętlach (while).

Przykładowo:

>>> if not x:
print(„OK”)


Użyty w powyższym przykładzie operator not spowoduje, iż wyraz OK  zostanie wypisany tylko wtedy, gdy  wartość zmiennej „x” NIE jest prawdą.

Testowana wartość zmiennej „x” nie musi być typu logicznego bool – wyrażenie zostanie uznane za fałsz gdy  jest jedną z poniższych wartości:

• None
• Logiczną wartością False
• Liczbową wartością zero
• Pustą sekwencją (krotką (), listą [], łańcuchem znakowym ””) lub słownikiem {}
• Dowolnym obiektem, którego klasa definiuje metodę __len__ lub __bool__ , a metoda ta, dla tego obiektu zwraca wartość numeryczną 0 lub logiczny fałsz (False).

W Python’ie 2.6 i wcześniejszych  metoda __bool__ nosiła nazwę __nonzero__

Podstawowe operatory logiczne to or,and oraz not:

Odpowiednie wartości logiczne zwracane są przez używane w rozmaitych wyrażeniach (najczęściej instrukcjach warunkowych „if”) operatory porównań:

Począwszy od Python’a 3.0 operacja porównania wartości, która nie ma sensu (np. porównanie 1<”” albo None>None) wyrzuca wyjątek TypeError.

W poprzednich wersjach (włącznie z 2.6) można było wpisać:

>>> a=None>""
>>> a
False

W Python’ie 3.0 wyrzucony zostanie wyjątek:

>>> a=None>""
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: NoneType() > str()


Typy numeryczne

Python posiada wbudowanych kilka standardowych typów numerycznych, umożliwiające operacje na liczbach całkowitych, rzeczywistych oraz zespolonych.

Poniższa lista prezentuje operatory i  funkcje typów numerycznych:

1. int

Liczby całkowite, do wersji 2.6 Python’a były one przechowywane za pomocą wartości 32-bitowych (aby sprawdzić  największą wartość jaką może przyjmować  int można było w Python’ie 2.6 i wcześniejszych użyć metody maxint z modułu sys). Python 3.0 ujednolicił typy int oraz long: istnieje jeden typ int zachowujący się jak long z Python’a 2.6 (a więc jego zakres nie jest ograniczony).

Aby utworzyć zmienną x typu int i przypisać jej wartość  123 wystarczy napisać:

>>> x1 = 123

Wykorzystując odpowiednie prefix’y możliwe jest także użycie notacji dwójkowej, ósemkowym oraz szesnastkowej:

>>> x2=0b1111011
>>> x3=0o173
>>> x4=0x7b

Wszystkie powyższe zapisy tworzą zmienne o wartości dziesiętnej 123

Dla liczb całkowitych istnieje także możliwość wykonywania operacji bitowych. Poniższa tabela przedstawia operatory bitowe w kolejności rosnącego priorytetu.

Priorytet operacji bitowych jest niższy niż operacji arytmetycznych , a wyższy od porównań.

2. float

To liczby zmiennoprzecinkowe, implementowane za pomocą zmiennych typu double języka C, ich precyzja zależy od konkretnej platformy.

Tworzyć liczby tego typu można  następująco:

>>> x = 123.0

3. complex

To  liczby zespolone, podobnie jak float implementowane za pomocą wartości double języka C.  Mając liczbę zespoloną x można odwołać się do części rzeczywistej poprzez x.real, a do urojonej przez x.imag.

Liczby urojone można tworzyć następująco:

>>> x1=1+2j
>>> x2=complex(0,4)
>>> print(x1)
(1+2j)
>>> print(x2)
4j


W następnej części napiszemy o wbudowanych typach sekwencyjnych.

• pobranie listy ostatnio odtwarzanych utworów przez określonego użytkownika
• pobranie informacji o wykonawcy, albumie czy wydarzeniu w określonej lokalizacji
• dodanie utworu, albumu czy wykonawcy do własnej biblioteki lub listy odtwarzania
• wysyłanie informacji o odtwarzanych utworach do serwisu (scrobbling)

Możliwości jest dużo więcej, cała dokumentacja dostępna pod adresem http://www.lastfm.pl/api/intro

Pierwszym krokiem do korzystania z API (prócz oczywiście samej rejestracji i zalogowania się w serwisie) jest pozyskanie odpowiedniego klucza. Należy przejść na stronę http://www.lastfm.pl/api/account , gdzie trzeba określić formę naszej aplikacji (zwykle jest to pierwsza opcja “Non-commercial Use” – czyli aplikacja do użytku niekomercyjnego) a także jej nazwę oraz krótki opis.

Po wysłaniu formularza od razu dostaniemy dwa klucze opisane jako API Key oraz secret.

W kolejnym kroku pobieramy potrzebne biblioteki z zakładki downloads (http://www.last.fm/api/downloads), gdzie znajdują się interfejsy do większości popularnych języków programowania. W przypadku Pythona należu pobrać i zainstalować moduł pyLast (http://code.google.com/p/pylast/), który znajduje się w repozytorium svn. Jeżeli pracujemy pod Linuksem wystarczy (jeśli mamy zainstalowanego klienta svn) wydać komendę:

svn checkout http://pylast.googlecode.com/svn/trunk/ pylast-read-only

a następnie zainstalować ją odpowiednią dla dystrybucji komendą, np.

sudo python setup.py install

W przypadku Windows można do pobrania kodu użyć klienta Tortoise SVN lub po prostu pobrać pliki pylast.py i setup.py z repozytorium i zainstalować komendą
python setup.py install

Teraz przetestujemy instalację, początek każdego połączenia będzie identyczny:

import pylast
API_KEY = 'tu Twój API KEY'
API_SECRET = 'tu Twoje hasło'
username = 'tu nazwa Twojego użytkownika'
password_hash = pylast.md5('tu hasło Twojego użytkownika')
network = pylast.get_lastfm_network(api_key = API_KEY, api_secret = API_SECRET, username = username, password_hash = password_hash)</code>

Utworzony obiekt network posłuży nam do pobierania odpowiednich obiektów zawierających informacje o artystach, albumach czy utworach, a także do wysyłania poleceń do serwisu.

aby teraz pobrać informację o artyście piszemy:

artist = network.get_artist('Iron Maiden')

Teraz pobierzemy listę najpopularniejszych utworów:

tracks=artist.get_top_tracks()

I wyświetlamy pierwsze 10:

i=0
for track in tracks:
print track.item.title
i += 1
if i == 10: break;

Run To The Hills
The Number of the Beast
The Trooper
2 Minutes to Midnight
Aces High
Fear of the Dark
Hallowed Be Thy Name
Wasted Years
Can I Play With Madness
The Evil That Men Do

w podobny sposób możemy pobrać listę tagów:

tags=artist.get_top_tags()
i=0
for tag in tags:
print tag.item.name
i += 1
if i == 10: break;

heavy metal
metal
NWOBHM
hard rock
rock
Power metal
british
classic rock
Iron Maiden
New Wave of British Heavy Metal

Oczywiście można także bezpośrednio pobrać informację o określonym utworze:

track = network.get_track("Iron Maiden", "Rime of the ancient mariner")

i wysłać informacje o “polubieniu go”:

track.love()

Pobranie informacji o albumie i jego utworach jest analogiczne, z tym że utwory albumu pobrane za pomocą metody get_tracks są w postaci listy:

album = network.get_album('Amorphis','Eclipse')
print album.get_tracks()

[Amorphis - Two Moons, Amorphis - House Of Sleep, Amorphis - Leaves Scar, Amorphis - Born From Fire, Amorphis - Under A Soil And Black Stone, Amorphis - Perkele (The God of Fire), Amorphis - The Smoke, Amorphis - Same Flesh, Amorphis - Brothers moon, Amorphis - Empty Opening, Amorphis - Stonewomen (Bonus Track)]

podobnie proste jest otagowanie albumu i pobranie listy tagów:

album.add_tags('progressive metal')
album.get_tags()

[metal, Progressive metal]

Jak widać API jest bardzo proste i przyjemne w użyciu, jedynym problemem może być dokumentacja, w takim przypadku bardzo pomagają polecenia dir oraz help.

1. Obiekty

Dane każdego programu w Python’ie przechowywane są za pomocą obiektów oraz relacji między nimi.  Każdy obiekt posiada trzy własności: unikalny identyfikator (czasem  nazwany  tożsamością), który nigdy się nie zmienia (można go interpretować jako adres obiektu w pamięci), a także typ (również niezmienny w czasie życia obiektu) oraz określoną wartość.

Jeżeli wartości obiektu po jego utworzeniu także nie można zmienić  to mamy do czynienia z tak zwanym obiektem niemutowalnym (ang. immutable), w przeciwnym razie jest to obiekt mutowalny (ang. mutable).

Mutowalność określa sam typ obiektu: przykładowo, obiekty typów  numerycznych (jak int czy float), łańcuchów znakowych (str) oraz krotek (tuple) są niemutowalne, natomiast można modyfikować listy (list) oraz słowniki (dict). Obiekty tworzone przez użytkownika (instancje klas) są zwykle mutowalne. Szczegółowo o podstawowych typach danych napiszemy w kolejnych częściach.

Gdy trzeba zmodyfikować wartość zmiennej typu niemutowanego, to tworzony jest po prostu nowy obiekt danego  typu i przypisywany tej zmiennej (tak, by wskazywała na ten nowy obiekt). Mutowalność ma także znaczenie przy przekazywaniu zmiennych do funkcji: możemy przekazywać zmienne zarówno mutowalne jak i niemutowalne, lecz należy pamiętać iż w funkcji tej nie zmodyfikujemy przekazanych  obiektów typów niemutowanych.

Wszystkie typy niezmienne (immutable) są także haszowalne (hashable): oznacza to, że posiadają metodę __hash__, która zwraca określoną wartość, niezmienną przez cały okres „życia” obiektu. Tylko obiekty haszowalne mogą być  użyte jako klucze w słownikach (dict)  oraz elementy zbiorów (set). Z wbudowanych typów Python’a jedynie lista (list) oraz słownik (dict) są niehaszowalne, z kolei obiekty tworzone przez użytkownika domyślnie są haszowalne.

2. Referencje

W Python’ie referencje to byty „wskazujące” na obiekty określonego typu.  Nazwane referencje (o nadanej, określonej nazwie) będą zwane dalej zmiennymi. Referencja „wskazuje” na odpowiedni obszar pamięci w którym znajduje się obiekt określonego typu.  Wspomniane wyżej przekazywanie obiektów  do  funkcji realizowane jest właśnie przez  referencje.

Aby się o tym przekonać wystarczy wpisać w konsoli następujący przykład:

>>> def wypisz(a):
>>>     print("przekazana wartosc a =",a,", id a =",id(a))
>>> x=123
>>> print(id(x))
505306344
>>> wypisz(x)
przekazna wartosc a = 123 , id a = 505306344


Powyższy przykład deklaruje funkcje „wypisz” z jednym parametrem, której jedynym zadaniem jest wypisanie przekazanej poprzez parametr „a” wartości. Użyta tu wbudowana funkcja id zwraca unikalny identyfikator obiektu, zwykle jest to reprezentacja adresu, pod którym obiekt znajduje się w pamięci operacyjnej. Przed wywołaniem funkcji tworzona jest zmienna „x”, której przypisana jest wartość liczbowa 123. Następnie dwukrotnie wywoływana jest wbudowana funkcja id: najpierw bezpośrednio a następnie w samej funkcji  wypisz. Widać, że wypisywana przez id wartość jest identyczna, a więc  mamy do czynienia z jednym i tym samym obiektem.

W Python’ie nie trzeba martwić się o niszczenie nieużywanych obiektów: działająca na zasadzie zliczania referencji „śmieciarka” (ang. garbage collector) zwolni obszar pamięci jeżeli obiekt, który go zajmował nie jest już używany (w uruchomionym programie nie ma już więcej referencji wskazujących na ten obiekt).

3. Dynamiczne typowanie

Python jest językiem o tak zwanym dynamicznym typowaniu: w przeciwieństwie do języków o typowaniu statycznym (takich jak C/C++ czy Java) nie trzeba w nim jawnie deklarować typu tworzonej zmiennej.  Język sam określi typ korzystając z kontekstu, przykładowo pisząc:

>>> a = 3
>>> x = ‘znaki’


Zostaną utworzone dwie zmienne:  zmienna „a” typu int (liczba całkowita) oraz „x” typu str (łańcuch znakowy) i  zostaną im przypisane odpowiednie wartości.

Referencja nie jest przypisana utworzonemu raz obiektowi aż do jego „śmierci”, w każdej chwili możemy spowodować by wskazywała na obiekt  innego typu, np.

>>> a = ‘teraz to zmienna typu str’


W następnej części opiszemy wbudowane w język, podstawowe typy danych i odpowiednie operatory.

W systemie Windows instalacja Pythona sprowadza się do uruchomienia gotowego programu instalacyjnego, w systemach linuksowych Python zwykle jest już zainstalowany (często jest głęboko zintegrowany z dystrybucją:  przykładowo w  Gentoo polecenie emerge – będące częścią systemu zarządzania pakietami Portege – zostało napisane właśnie w tym języku).

Jeśli jednak Pythona nie ma w systemie, to należy zainstalować go korzystając z pakietów przygotowanych dla danej dystrybucji, np w dystrybucjach opartych na Debianie (jak Ubuntu) będzie to polecenie:

sudo apt-get install python


W Linuksie można też spróbować instalacji ze źródeł wykonując następujące polecenia w folderze, w którym znajduje się pobrany z www.python.org plik Python-2.5.1.tar.bz2:

tar xfj Python-2.5.1.tar.bz2
cd Python-2.5.1
./configure --prefix=/opt/python/2.5.1
make
make install


Ostatnie polecenie należy wykonać jako użytkownik root.  Jeżeli nie mamy dostępu do konta superużytkownika to alternatywą jest instalacja lokalna, w takim przypadku polecenie configure może wyglądać następująco:

./configure --prefix=~/python/2.5.1


Uruchomienie

W systemie Windows wybierając opcję „Python (command line)” z menu Programy dostajemy dostęp do konsoli  interpretera języka.  W Linuksie wpisujemy w konsoli  powłoki polecenie python lub python2.5 (jeśli jest on w ścieżce wyszukiwania zawartej w zmiennej środowiskowej PATH, w przeciwnym razie należy użyć pełnej ścieżki – np. /opt/python/2.5.1/bin/python bądź też ~/python/2.5.1/bin/python jeśli został zainstalowany lokalnie – w katalogu użytkownika).

Uruchomiony interpreter powinien wyświetlić informacje o wersji i znak zachęty „>>>”:

Python 2.5.1 (r251:54863, Apr 18 2007, 08:51:08) [MSC v.1310 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information
>>>

Python jest językiem interpretowanym, co jest zarówno jego zaletą jak i wadą:

• zaletą, ponieważ odpada czasochłonny proces kompilacji kodu, który może być natychmiast wykonany. W dodatku ten sam kod, bez żadnych modyfikacji, może być wykonany na różnych platformach.
• wadą, ponieważ skompilowany dla konkretnej platformy kod będzie zwykle dużo szybszy od interpretowanego.

Wymieniona wada nie tu jednak dużą przeszkodą: moc obliczeniowa komputerów praktycznie podwaja się co rok. Do pewnych zastosowań (nie tylko web-developmentu ale także pisania prostych gier) Python wydaje się optymalny przede wszystkim ze względu na wspomnianą szybkość tworzenia aplikacji i czytelność.

Dynamiczne typowanie

Python nie wymaga deklarowania typów, co nie oznacza że ich nie posiada: każda wartość jest określonego typu. Język oferuje kilka wbudowanych, podstawowych typów:

• int dla wartości całkowitych
• float dla zmiennoprzecinkowych
• bool dla logicznych (True,False)
• str lub unicode dla łańcuchów znakowych

Aby przykładowo przypisać zmiennej o nazwie a1 wartość 123 wystarczy napisać:

a1=123

Takie przypisanie wartości do literału powołuje zmienną do życia – nie jest potrzebne wcześniejsze zadeklarowanie jej typu. W każdej chwili, dokładnie w ten sam sposób można zmiennej a1 przypisać wartość innego typu:

a1=’To wskazuje zmienna a1’

Łańcuchy znakowe są niezmienne – raz utworzonego łańcucha nie można zmienić, np. skrócić, czy zamienić część znaków. Można natomiast utworzyć nowy łańcuch na jego podstawie. Python oferuje dużą ilość operacji na łańcuchach. Aby się o tym przekonać wystarczy po utworzeniu zmiennej a1 w pokazany sposób wpisać w konsoli polecenie:

dir(a1)

Interpreter wypisze listę operacji jaką można wykonać na zmiennej a1:

['__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']

Przykładowo, aby dowiedzieć się co robi metoda swapcase można użyć polecenia help:

help(a1.swapcase)

Powyższe polecenie wypisze odpowiedni tekst pomocy (w języku angielskim):

swapcase(...)
S.swapcase() -> string

Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.

Co oznacza że metoda swapcase zwraca kopię łańcucha S, w którym duże litery będą zamienione na małe, a małe na duże. Tworzymy zmienną a2, a następnie wypisujemy jej wartość pisząc w konsoli:

a2=a1.swapcase()
print a2

Wyrażenie a1.swapcase() oznacza wywołanie metody swapcase obiektu a1. Metoda ta tworzy i zwraca odpowiedni łańcuch znakowy, który ostatecznie zostaje przypisany zmiennej a2.
Polecenie print zapisuje swe argumenty (tu wartość zmiennej a2) na standardowe wyjście (zwykle ekran monitora). W rezultacie na konsoli pojawi się napis:

tO WSKAZUJE ZMIENNA A1

W każdej chwili możemy dowiedzieć się jakiego typu jest wartość przypisana do zmiennej a2 pisząc:

type(a2)

Odpowiedź będzie zgodna z oczekiwaniami:

<type 'str'>

Nie musimy się martwić niszczeniem raz utworzonych obiektów, tym zajmuje się wbudowany w język garbate collector (dosłownie: śmieciarka), który niszczy nieużywane obiekty zwalniając przydzielone im obszary pamięci.

Referencje

Zmienne a1 i a2 z ostatnich przykładów są tak zwanymi referencjami do obiektów. Referencje to dane zawierające informacje gdzie wskazywany przez nie obiekt znajduje się w pamięci. Do jednego obiektu może istnieć praktycznie dowolnie duża ilość referencji w aplikacji (na taki obiekt może wskazywać dowolnie wiele utworzonych zmiennych).

Wspomniany mechanizm śmieciarki działa właśnie na zasadzie zliczania referencji: obiekt jest usuwany z pamięci jeżeli w aplikacji nie wskazuje na niego już żadna referencja.