Przewodnik po jezyku

Python
Wydanie 2.3

Guido van Rossum

Fred L. Drake, Jr., editor

27 pazdziernika 2004

PythonLabs
Email: [email protected]
Copyright
c 2001 Python Software Foundation. Wszystkie prawa zastrzezone.
Copyright
c 2000 BeOpen.com. Wszystkie prawa zastrzezone.
Copyright
c 1995-2000 Corporation for National Research Initiatives. Wszystkie prawa zastrzezone.
Copyright
c 1991-1995 Stichting Mathematisch Centrum. Wszystkie prawa zastrzezone.
Peny tekst licencji oraz opis dopuszczalnego zakresu wykorzystania dokumentu umieszczono na jego koncu.
 Streszczenie

Python jest atwym do nauczenia, penym mocy i siy jezykiem programowania. Posiada struktury danych wysok-
iego poziomu i w prosty, acz efektywny sposb umozliwia programowanie obiektowe. Skadnia Pythona jest ele-
gancka, a dynamiczny system typw oraz fakt, iz Python jest interpreterem, powoduje, z e jest idealnym jezykiem
do pisania skryptw oraz tzw. byskawicznego rozwijania aplikacji w wielu dziedzinach, oraz na wielu platfor-
mach sprzetowo-programowych.
Interpreter Pythona oraz bogata biblioteka standardowa sa dostepne w sposb wolny i za darmo, zarwno w
postaci z rdowej jak i binarnej (dowolnie dystrybuowanych) na wiekszosc platform systemowych. Zaintere-
sowany uzytkownik znajdzie wiecej informacji na stronie internetowej Pythona, http://www.python.org. Ta sama
witryna zawiera rwniez pakiety instalacyjne i odnosniki do wielu pythonowych moduw (wolnych od opat),
programw oraz narzedzi jak i dodatkowej dokumentacji.
Python daje sie atwo rozszerzac o nowe funkcje i typy danych, ktre moga zostac zaimplementowane w C lub
C++ (lub innych jezykach, ktre moga byc skonsolidowane z moduami C). Python nadaje sie rwniez do wyko-
rzystania jako dodatkowy jezyk w aplikacjach, jako dodatkowy jezyk uatwiajacy dopasowanie ich do potrzeb
uzytkownika.
Przewodnik ten wprowadza czytelnika w podstawowe zaozenia i cechy Pythona jako jezyka i systemu. Pomocne
bedzie posiadanie interpretera Pythona pod reka do c wiczen na goraco,
aczkolwiek przykady sa na tyle
czytelne, z e materia ten moze byc czytany rwniez przy kawie.
Opis standardowych obiektw i moduw znajduje sie w Opisie biblioteki Pythona. Formalna definicja jezyka
przedstawiona jest w Podreczniku jezyka Python. Aby pisac rozszerzenia w jezyku C lub C++ przeczytaj Rozsz-
erzanie i wbudowywanie interpretera jezyka Python oraz Opis Python/C API. Ponadto istnieje kilka ksia zek
wgebiajacych
sie w sam jezyk Python.
Przewodnik ten nie usiuje opisac Pythona w sposb wszechstronny, poruszajac kazda ceche jezyka, nawet na-
jbardziej uzywana. Zamiast tego informuje czytelnika o wielu wartych zauwazenia cechach i daje dobre wyobraze-
nie o stylu pisania programw Pythona jak i o jego smaku i zapachu. Po przeczytaniu tego przewodnika,
czytelnik bedzie w stanie dowiedziec sie i zrozumiec wiele innych moduw Pythona, ktre zostay omwione w
Opisie biblioteki Pythona.

SPIS TRESCI

1 Wzniecajac
apetyt. . . 1
1.1 Dokad dalej? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 Uzywanie interpretera Pythona 3

2.1 Wywoanie interpretera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Interpreter i jego srodowisko . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Nieformalne wprowadzenie do Pythona 7

3.1 Uzywanie Pythona jako kalkulatora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 Pierwsze kroki w programowaniu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 Jeszcze wiecej sposobw na kontrolowanie programu 19

4.1 Instrukcje if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2 Instrukcje for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.3 Funkcja range() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.4 Instrukcja break i continue oraz klauzule else w petlach . . . . . . . . . . . . . . . . . . 21
4.5 Instrukcje pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.6 Definiowanie funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.7 Jeszcze wiecej o definiowaniu funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

5 Struktury danych 29
5.1 Wiecej o listach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2 Instrukcja del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.3 Listy niemutowalne i sekwencje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.4 Sowniki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.5 Jeszcze troche o warunkach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.6 Porwnanie sekwencji i innych typw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

6 Moduy 37
6.1 Ciag
dalszy o moduach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
6.2 Moduy standardowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6.3 Funkcja dir() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6.4 Pakiety . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

7 Wejscie i wyjscie 45
7.1 adniejsze formatowanie wyjscia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7.2 Czytanie z i pisanie do plikw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

8 Bedy i wyjatki
51
8.1 Bedy skadni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.2 Wyjatki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.3 Obsuga wyjatkw
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.4 Zgaszanie wyjatkw
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.5 Wyjatki definiowane przez uzytkownika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

i
 8.6 Jak posprzata
c po baaganiarzu? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

9 Klasy 57
9.1 Sowo na temat terminologii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
9.2 Przestrzenie i zasiegi nazw w Pythonie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
9.3 Pierwszy wglad w klasy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
9.4 Luzne uwagi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.5 Dziedziczenie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.6 Zmienne prywatne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.7 Sztuczki i chwyty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

10 Co teraz? 67

A Interaktywna edycja i operacje na historii polecen 69

A.1 Edycja linii polecen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
A.2 Zastepowanie polecen historycznych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
A.3 Funkcje klawiszowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
A.4 Komentarz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

Indeks 71

ii
 ROZDZIA

PIERWSZY

Wzniecajac
apetyt. . .

Jezeli kiedykolwiek pisaes pokazny skrypt, znasz prawdopodobnie to uczucie: z wielka checia chciabys dodac
jeszcze jedna ceche do programu, ale i tak jest juz zbyt wolny i zbyt duzy oraz wystarczajaco
skomplikowany; albo
ta nowa wasciwosc wymaga zaangazowania funkcji systemowej, ktra jest dostepna tylko z poziomu C . . . Zwykle
problem ten nie jest na tyle wazny, aby wymagao to przepisania wszystkiego w C, byc moze wymagana bedzie
obecnosc ancuchw znakowych zmiennej dugosci lub innych typw danych (jak uporzadkowane listy lub nazwy
plikw), ktre atwo wprowadzic w skrypcie, ale wymagaja mnstwa pracy w C, lub tez po prostu nie znasz tak
dobrze C.
Inna sytuacja: byc moze zaistniaa potrzeba pracy z paroma bibliotekami C i zwyczajowy cykl pisanie/kompilacja-
/testowanie/rekompilacja jest zbyt wolny. Potrzebujesz czegos szybszego do rozwijania programw. Byc moze
napisaes program, ktry mgby uzywac jakiegos jezyka rozszerzajacego jego mozliwosci, ale nie chciabys
projektowac jeszcze jednego jezyka, pisac i sprawdzac jego interpreter i dopiero wplesc go w swoja aplikacje.
W powyzszych przypadkach Python moze byc wasnie tym, czego szukasz. Python jest prosty w uzyciu lecz jest
prawdziwym jezykiem programowania, ktry oferuje o wiele wiecej struktur i pomocnych wasciwosci dla duzych
programw w porwnaniu z jezykiem powoki. Z drugiej strony, posiada o wiele wiecej sposobw wyapania
bedw niz C i bedac
jezykiem bardzo wysokiego poziomu, posiada wbudowane typy danych wysokiego poziomu
jak rozszerzalne tablice i sowniki, ktrych efektywne zaimplementowanie w C kosztowayby cie wiele dni pracy.
Z powodu tego, iz typy danych Pythona sa bardzo oglne, nadaja sie do zastosowania w o wiele wiekszych
obszarach problemowych, niz robi to Perl, aczkolwiek duzo rzeczy jest przynajmniej tak atwych w Pythonie jak
w powyzszych jezykach.
Python pozwala na podzia twego programu na moduy, ktre moga byc obiektem ponownego uzycia w innych
pythonowych programach. Jezyk dostarczany jest z obszernym zbiorem standardowych moduw, ktre moga byc
podstawowymi skadnikami twoich programw, lub suzyc jako przykady przy rozpoczeciu nauki programowa-
nia w Pythonie. Istnieja rwniez moduy wbudowane w interpreter, majace
na celu obsuge I/O, wywoan syste-
mowych, gniazdek lub nawet moduy interfejsu uzytkownika (GUI), jak np. Tk.
Python jest jezykiem interpretowanym, co oznacza, z e zaoszczedza ci zauwazalnie czas w procesie rozwijania
oprogramowania, poniewaz nie ma potrzeby kompilacji i aczenia
moduw. Interpreter moze byc uzyty w sposb
interaktywny, co pomaga w eksperymentowaniu z wasciwosciami jezyka, pisaniu podrecznych programw lub
testowaniu funkcji podczas rozwijania programu (ang. bottom-up developement). Jest tez podrecznym biurkowym
kalkulatorem.
Python umozliwia pisanie bardzo zwartych i czytelnych programw. Programy napisane w nim, sa zwykle o wiele
krtsze, niz odpowiedniki napisane w C lub C++, a to dlatego z e:

typy danych wysokiego poziomu pozwalaja wyrazic zozone operacje w pojedynczej instrukcji;
grupowanie polecen uzyskuje sie poprzez indentacje (wcinanie wierszy) zamiast uzywania sw kluczowych
begin/end lub nawiasw klamrowych;
nie potrzeba deklarowac zmiennych lub argumentw wywoan;

Python jest rozszerzalny: jesli znasz jezyk C, to atwo bedzie ci dodac nowa funkcje wbudowana lub modu do
interpretera, zarwno aby zrobic jakas krytyczna pod wzgledem czasu wykonania operacje jak i waczy c do
Pythona biblioteke, ktra byc moze jest dostepna tylko w formie binarnej (np. jakas specjalistyczna biblioteka

1
graficzna). Jak tylko poczujesz pewny grunt pod nogami, bedziesz mg waczy
c interpreter Pythona w aplikacje
napisana w C i uzywac go jako rozszerzenia lub jezyka komend w tej aplikacji.
Apropos, jezyk zosta tak nazwany w slad za programem telewizyjnym BBC Latajacy cyrk Monty Pythona
(Monty Pythons Flying Circus) i nie ma nic wsplnego z tymi okropnymi wez ami. Nie tylko pozwalamy na
wprowadzanie odniesien do Monty Pythona w dokumentacji, lecz rwniez zachecamy do tego!

1.1 Dokad
dalej?
Mam nadzieje, z e jestes w tym momencie mocno podekscytowany Pythonem i chcesz szczegowo go
poprbowac. Poniewaz najlepszym sposobem, aby nauczyc sie jezyka, jest jego uzywanie. . . wiec zapraszamy
cie i zachecamy abys to zaraz zrobi.
W nastepnym rozdziale wyjasnione sa sposoby uzywania interpretera. Rewelacje te sa dosc nuzace,
lecz konieczne
do poznania w celu przejscia do przykadw pokazanych w nastepnych czesciach przewodnika.
Reszta przewodnika wprowadzi cie w rznorakie wasciwosci Pythona jako jezyka i systemu poprzez przykady,
zaczynajac
od najprostszych wyrazen, polecen i typw danych, poprzez funkcje i moduy i konczac na nauce
zaawansowanych pojec , takich jak wyjatki
i definiowane przez uzytkownika klasy.

2 Rozdzia 1. Wzniecajac
apetyt. . .
 ROZDZIA

DRUGI

Uzywanie interpretera Pythona

2.1 Wywoanie interpretera

Interpreter Pythona jest zwykle zainstalowany jako plik /usr/local/bin/python;1 wstawienie /usr/local/bin do
sciezki wyszukiwan powoki na twojej odmianie U NIXA, umozliwia rozpoczecie pracy interpretera poprzez
polecenie

python

Poniewaz wybr katalogu, w ktrym umieszczono interpreter Pythona jest opcja instalacji jezyka, rwniez inne
miejsca sa mozliwe skonsultuj sie ze swoim lokalnym pythonowym guru lub administratorem systemu (innymi
sowy, /usr/local/bin jest jednym z bardziej popularnych katalogw).
Wpisanie znaku konca pliku EOF (Control-D w U NIKSIE, Control-Z w DOS-ie lub Windows) za poczatkowym
znakiem zachety (ang. prompt) spowoduje zakonczenie pracy interpretera z kodem zakonczenia rwnym zero.
Jezeli ten sposb nie zadziaa mozna w dalszym ciagu
bezbolesnie zakonczyc prace poprzez wpisanie nastepuja-

cych polecen: import sys; sys.exit().
Wasciwosci edycyjne linii polecen interpretera nie sa bardzo wysublimowane. Na U NIKSIE byc moze ktos,
kto zainstalowa interpreter waczy
rwniez wspomaganie edycji linii polecen za pomoca biblioteki GNU
readline, co dodaje bardziej wyszukanych wasciwosci interaktywnej edycji i historii polecen. Prawdopodob-
nie najszybszym sposobem sprawdzenia czy posiadasz rozszerzone wasciwosci linii polecen, jest nacisniecie
Control-P za pierwszym znakiem zachety Pythona, ktry zobaczysz po jego uruchomieniu. Jezeli cos zabrzeczy
jest wzbogacona edycja linii polecen; dodatek A zwiera wprowadzenie do klawiszologii. Jesli nic sie nie
zdarzy lub pojawi sie echo ^P, to edycja linii polecen nie jest mozliwabedzie mozna tylko uzywac klawisza
backspace, aby usuwac znaki z biezacego
wiersza.
Interpreter przypomina nieco unixowa powoke: kiedy jest wywoany ze standardowym wejsciem poaczonym
z
jakims urzadzeniem
tty, czyta i wykonuje komendy interaktywnie. Gdy zostanie wywoany z argumentem w
postaci nazwy pliku lub ze standardowym wejsciem jako plik, wtedy czyta go i wykonuje jak skrypt.
Trzecim sposobem na wywoanie interpretera jest python -c polecenia [arg] ..., co powoduje wyko-
nanie polecen zawartych w polecenia, analogicznie do opcji -c w powoce. Z powodu tego, iz polecenia Pythona
czesto zawieraja spacje lub inne znaki, ktre sa najpierw interpretowane przez powoke, najlepiej jest umiescic
polecenia w podwjnych cudzysowach.
Koniecznym jest zauwazenie rznicy pomiedzy python plik i python <plik. W ostatnim przypadku
polecenie pobrania wejscia jak np. wywoanie input() i raw_input() dotyczy zawartosci plik. Poniewaz
plik ten zostanie przeczytany w caosci na poczatku
dziaania interpretera, zanim polecenia w nim zawarte zostana
wykonane, program natychmiast napotka znak EOF. W przypadku pierwszym (ktry jest tym co chce sie zwykle
uzyskac) polecenia pobrania wejscia dotycza zarwno pliku, jak i urzadzenia
doaczonego
do standardowego
wejscia interpretera.
Kiedy uzywa sie skryptu, czasami jest potrzebne uruchomic tryb interaktywny zaraz po zakonczeniu jego dziaa-
nia. Mozna to uzyskac poprzez opcje -i, ktra przekazuje sie przy wywoaniu interpretera (ten sposb nie zadziaa,
1 C:\Program Files\Python\python.exe lub C:\Python\python.exe w systemie Windows

3
jesli skrypt czytany jest ze standardowego wejsciapowd: ten sam, ktry zosta opisany w poprzednim para-
grafie).

2.1.1 Przekazywanie argumentw

Nazwa skryptu i dodatkowe parametry wywoania sa przechowywane w zmiennej sys.argv, ktra jest lista
ancuchw znakw. Jej dugosc jest zawsze przynajmniej rwna jedennawet wtedy, gdy nie podano z adnej
nazwy skryptu i z adnych argumentw wywoania, sys.argv[0], jest pustym ciagiem. Gdy nazwa skryptu
przekazana jest w postaci - (co oznacza standardowe wejscie), sys.argv[0] przyjmuje wartosc -. Gdy
zostanie uzyta opcja -c i przekazane zostana polecenia w polecenia, sys.argv[0], przyjmuje wartosc -c.
Opcje za -c polecenia nie sa poykane przez interpreter Pythona, lecz pozostawiane w sys.argv dla pozostaych
polecen.

2.1.2 Tryb interaktywny

Jezeli instrukcje pochodza z urzadzenia

tty, mwi sie wtedy, z e interpreter jest w trybie interaktywnym. Inter-
preter zacheca wtedy do podania kolejnej instrukcji za pomoca wyswietlenia tzw. znaku zachety, zwykle w postaci
trzech znakw wiekszosci (>>>). Gdy wymaga kontynuacji instrukcji, w nastepnej linii wyswietla drugi znak
zachety, domyslnie w postaci trzech kropek (... ). Interpreter zaraz po uruchomieniu drukuje swoja wersje i
notke o prawach autorskich przed pierwszym znakiem zachety, tzn.:

python
Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06) [GCC 2.8.1] on sunos5
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>>

Linie kontynuacji instrukcji sa wymagane podczas wejscia w skadanie wielowierszowej instrukcji. Jako przykad
wezmy instrukcje if:

>>> swiat_jest_plaski = 1
>>> if swiat_jest_plaski:
... print "Bad
z ostroznym: nie spadnij!"
...
Bad
z ostro
znym: nie spadnij!

2.2 Interpreter i jego s rodowisko

2.2.1 Obsuga (wyapywanie) wyjatkw

interpreter drukuje komunikat o bedzie i slad stosu wywoan. W trybie interaktywnym

Jezeli pojawi sie bad,
powraca natychmiast do pierwszej zachety, a jesli wejscie pochodzio z pliku, konczy swoja prace z niezerowym
kodem wyjscia zaraz po wydrukowaniu slady stosu wywoan. (Wyjatki obsugiwane przez klauzule except w
instrukcji try nie sa bedami w tym kontekscie). Niektre bedy sa bezwzglednie fatalne i powoduja zakonczenie
pracy z niezerowym kodem wyjsciaodnosi sie to do wewnetrznych bedw i przypadkw wyczerpania pamieci.
Wszystkie komunikaty o bedach sa zapisywane na standardowym wyjsciu diagnostycznym, a zwyke komunikaty
pochodzace od wykonywanych polecen zapisywane sa na standardowym wyjsciu.
Nacisniecie klawisza przerwania (zwykle Control-C lub DEL) w czasie pierwszej lub drugiej zachety usuwa
znaki z wejscia i powoduje powrt do pierwszej zachety.2 Nacisniecie wyzej wspomnianego klawisza w czasie
wykonywania instrukcji powoduje zgoszenie wyjatku KeyboardInterrupt, ktry moze byc wyapany za
pomoca instrukcji try.
2 Pewien bad
w bibliotece GNU readline moze to uniemozliwic.

4 Rozdzia 2. Uzywanie interpretera Pythona

2.2.2 Wykonywalne skrypty Pythona
3

W systemach U NIX pochodzacych

z gaezi BSD, skrypty Pythona moga byc wykonywane bezposrednio przez
powoke, za pomoca wstawienia wiersza
#! /usr/bin/env python

na poczatku
pliku skryptu (zakadajac, z e interpreter jest widziany z zbiorze katalogw zawartych w zmiennej
$PATH) oraz ustawienia dla tego pliki atrybutu wykonywalnosci. Znaki #! musza byc pierwszymi znakami
pliku. Zauwazcie, iz znak #, jest znakiem rozpoczecia komentarza w Pythonie.

2.2.3 Plik rozpoczecia pracy interaktywnej

Kiedy uzywa sie Pythona interaktywnie, czesto pomocne jest wywoywanie pewnych standardowych polecen za
kazdym razem, gdy interpreter jest uruchamiany. Mozna to uzyskac poprzez umieszczenie w zmiennej syste-
mowej $PYTHONSTARTUP nazwy pliku zawierajacego twoje specyficzne instrukcje. Jest to podobne do mech-
anizmu pliku .profile w powoce U NIXA.
Plik ten jest czytany tylko podczas rozpoczecia sesji interaktywnej, nigdy w przypadku czytania polecen ze
skryptu i w przypadku, gdy plik /dev/tty jest podany explicite jako z rdo polecen (co skadin
ad zachowuje sie jak
sesja interaktywna). Plik ten wykonywany jest w tej samej przestrzeni nazw, w ktrej wykonywane sa instrukcje,
tak wiec obiekty, ktre definiuje lub importuje moga byc uzyte bez kwalifikowania podczas sesji interaktywnej.4
Mozna w nim zmienic rwniez znaki zachety, ktre umieszczone sa w zmiennych sys.ps1 i sys.ps2.
Jesli chce sie doaczy
c dodatkowy plik rozpoczecia z biezacego
katalogu, mozna dokonac tego z poziomu global-
nego pliku rozpoczecia execfile(.pythonrc.py). Jesli chce sie uzyc pliku rozpoczecia w skrypcie,
trzeba zrobic to explicite w skrypcie:

import os
if os.environ.get(PYTHONSTARTUP) \
and os.path.isfile(os.environ[PYTHONSTARTUP]):
execfile(os.environ[PYTHONSTARTUP])

3 XXX Jak to sie robi w Windows?

4 Cae to zawracanie gowy o kwalifikowaniu zostanie zrozumiane po zapoznaniu sie z praca z moduami (przyp. tum.)

2.2. Interpreter i jego s rodowisko 5

6
 ROZDZIA

TRZECI

Nieformalne wprowadzenie do Pythona

W ponizszych przykadach wejscie i wyjscie rozrznione zostao poprzez obecnosc znakw zachety (>>> i
... ): aby powtrzyc przykad, trzeba przepisac wszystko za znakiem zachety; linie, ktre nie zaczynaja sie
nim, sa wyjsciem (odpowiedziami) interpretera.
Uwaga! Pojawienie sie po raz drugi znaku zachety oznacza, z e trzeba wprowadzic pusty wiersz. Wtedy nastepuje
koniec instrukcji wielowierszowej.
Wiele przykadw w tym podreczniku, nawet te wprowadzone w linii polecen, zawieraja komentarze. W Pythonie
komentarz rozpoczyna sie od znaku # i ciagnie
sie az do konca fizycznego wiersza. Komentarz moze pojawic
sie na poczatku
linii lub konczyc instrukcje lecz nie moze byc zawarty w literale ciagu
znakw. Znak hash
(#) w ciagu
znakw jest po prostu zwykym znakiem, jednym z wielu tego ciagu.
Troche przykadw:

# to jest pierwszy komentarz

POMYJE = 1 # a to jest drugi komentarz
# ... uch, a to trzeci!
LANCUCH = "# To nie jest komentarz. To jest a
ncuch znakw."

3.1 Uzywanie Pythona jako kalkulatora

Wyprbujmy pare prostych polecen Pythona. Uruchom interpreter i poczekaj na pojawienie sie pierwszego znaku
zachety >>>. (Nie powinno to zaja
c duzo czasu).

3.1.1 Liczby

Interpreter dziaa jak prosty kalkulator: mozna wpisac wyrazenie do niego, a on wypisze jego wartosc . Skadnia
wyrazenia jest prosta: operator +, -, * i / dziaaja jak w wielu innych jezykach programowania (np. Pascal lub
C); nawiasy mozna uzyc do grupowania. Na przykad:

7
 >>> 2+2
4
>>> # To jest komentarz
... 2+2
4
>>> 2+2 # a to jest komentarz w tej samej linii co kod instrukcji
4
>>> (50-5*6)/4
5
>>> # Dzielenie cakowite zwraca liczb
e zaokraglon
a w d
... 7/3
2
>>> 7/-3
-3

Podobnie jak w C, znak rwnosci (=) jest uzywany do przypisania wartosci do zmiennej. Przypisanie do zmi-
ennej nie jest wypisywane przez interpreter:

>>> szerokosc = 20
>>> wysokosc = 5*9
>>> szerokosc * wysokosc
900

Wartosc moze byc przypisana jednoczesnie paru zmiennym:

>>> x = y = z = 0 # Zero x, y i z
>>> x
0
>>> y
0
>>> z
0

Python implementuje oczywiscie arytmetyke zmiennoprzecinkowa, a operatory z operandami typw mieszanych

przeksztacaja operandy cakowite w zmiennoprzecinkowe:

>>> 4 * 2.5 / 3.3

3.0303030303
>>> 7.0 / 2
3.5

Liczby zespolone sa rwniez wbudowaneczesci urojone zapisywane sa z przyrostkiem j lub J. Liczby

zespolone z niezerowa czescia rzeczywista zapisywane sa jako (real+imagj) lub moga byc stworzone za
pomoca funkcji complex(real, imag).

>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)

8 Rozdzia 3. Nieformalne wprowadzenie do Pythona

Liczby zespolone sa zawsze reprezentowane jako dwie zmiennoprzecinkowe liczby, odpowiednio czesc rzeczy-
wista i urojona. Aby wydobyc je z liczby urojonej z, nalezy uzyc z.real i z.imag.
>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5

Funkcje konwersji z liczby zmiennoprzecinkowej do cakowitej (float(), int() i long()) nie dziaaja
dla liczb urojonych nie ma poprawnego sposobu na przeksztacenie liczby zespolonej w rzeczywista. Uzyj
lub z.real, aby uzyskac czesc rzeczywista.
abs(z), aby uzyskac jej modu (jako liczbe zmienno przecinkowa)
>>> a=1.5+0.5j
>>> float(a)
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: cant convert complex to float; use e.g. abs(z)
>>> a.real
1.5
>>> abs(a)
1.58113883008

(TypeError: nie mozna przeksztacic zespolonej do zmiennoprzecinkowej; uzyj np. abs(z))

W trybie interaktywnym, ostatnio wydrukowane wyrazenie przypisywane jest do zmiennej _. Oznacza to, z e
jesli uzywa sie Pythona jako biurkowego kalkulatora, niejako atwym staje sie kontynuowanie obliczen jak w
ponizszym przykadzie:
>>> podatek = 17.5 / 100
>>> cena = 3.50
>>> cena * podatek
0.6125
>>> cena + _
4.1125
>>> round(_, 2) # zaokragla
do dwch miejsc po przecinku
4.11

Zmienna ta powinna byc traktowana przez uzytkownika jak tylko do odczytu. Nie warto wprost zapisywac (przyp-
isywac) cos do niejstworzy sie inna, niezalezna lokalna zmienna z ta sama nazwa przykrywajac
a wbudowana
zmienna o tych magicznych wasciwosciach.

3.1.2 Ciagi
znakw czyli napisy

Oprcz liczb Python moze rwniez manipulowac ciagami

znakw, ktre mozna wyrazic na pare sposobw. Moga
one byc objete pojedynczym lub podwjnym cudzysowem:
>>> zepsute jaja
zepsute jaja
>>> A\propos
"Apropos"
>>> "Apropos"
"Apropos"
>>> "Tak," powiedzia.
"Tak," powiedzia.
>>> "\"Tak,\" powiedzia."
"Tak," powiedzia.
>>> "A\propos," powiedziaa.
"A\propos," powiedziaa.

3.1. Uzywanie Pythona jako kalkulatora 9

Napisy moga rozciaga
c sie na wiele wierszy. Znaki nowej linii moga zostac zacytowane za pomoca znakw
ukosnika:
hello = "Jest to raczej dugi ciag
znakw zawierajacy\n\

kilka linii tekstu, tak jak robisz to w C.\n\
Zauwa
z,
ze znaki spacji i znaki biae na poczatku
linii\
sa znaczace.\n"

print hello

spowoduje pojawienie sie zaraz za tym:

Jest to raczej dugi ciag
znakw zawierajacy

kilka linii tekstu, tak jak robisz to w C.
Zauwa
z,
ze znaki spacji i znaki biae na poczatku
linii sa znaczace.

Rwnie dobrze ciagi znakw moga byc ujete w pary potrjnych cudzysoww: """ lub . Konce linii nie
musza byc w takim przypadku cytowane lecz zostana dosownie waczone
do ciagu.

print """
U
zytkowanie: cienias [OPCJE]
-h Poka
z ten opis polece
n
-H nazwaserwera Nazwa serwera, z ktrym chcesz si
e poaczy
c
"""

powoduje nastepujac
a odpowiedz interpretera:
U
zytkowanie: cienias [OPCJE]
-h Poka
z ten opis polece
n
-H nazwaserwera Nazwa serwera, z ktrym chcesz si
e poaczy
c

Interpreter drukuje wynik dziaan na napisach w ten sam sposb, w jaki sa one wprowadzane: objete cud-
zysowami i wraz z cudzysowami i innymi zabawnymi znakami poprzedzonymi znakiem ukosnika (\), tak aby
w sposb dokadny pokazac zawartosc ciagu.
ancuch objety jest podwjnym cudzysowem, jesli zawiera tylko
pojedyncze cudzysowie, w przeciwnym wypadku objety jest pojedynczym. (Instrukcja print, ktre zostanie
opisane pzniej, moze zostac uzyta do wypisywania ciagw
znakw bez okalajacych
je cudzysoww lub znakw
cytowania1 ).
ancuchy moga byc sklejane za pomoca operatora + i powielane za pomoca *:

>>> slowo = Pomoc + A

>>> slowo
PomocA
>>> < + slowo*5 + >
<PomocAPomocAPomocAPomocAPomocA>

Dwa literay napisu wystepujace

jeden obok drugiego sa automatycznie sklejane; np. pierwszy wiersz w
przykadzie powyzej mgby byc rwnie dobrze zapisany jako slowo=Pomoc A dziaa to tylko z
dwoma literaami, a nie z dowolnym wyrazeniem typu znakowego:
1 Czyli znakw specjalnych poprzedzonych znakiem ukosnika

10 Rozdzia 3. Nieformalne wprowadzenie do Pythona

 >>> import string # znaczenie sowa import zostanie wyja
snione p
zniej ...
>>> str ing # <- Tak jest w porzadalu

string
>>> string.strip(str) + ing # <- to te z
string
>>> string.strip(str) ing # <- to nie zadziaa!
File "<stdin>", line 1
string.strip(str) ing
^
SyntaxError: invalid syntax

(SyntaxError: za skadnia)
ancuchy znakw moga byc indeksowane. Podobnie jak w C, pierwszy znak w ciagu
ma indeks (numer porzad-
kowy) 0. Nie istnieje osobny typ oznaczajacy
znak znak jest po prostu napisem o dugosci jeden. Podobnie
jak w jezyku Icon2 podciagi
znakw moga zostac wyspecyfikowane za pomoca notacji tzw. wykrawania: dwch
indeksw przedzielonych dwukropkiem.

>>> slowo[5]
A
>>> slowo[0:2]
Po
>>> word[2:5]
moc

Odmiennie niz w C, ancuchy znakw w Pythonie nie moga byc modyfikowane. Przypisanie do zaindeksowanej
pozycji w ciagu
powoduje powstanie bedu:

>>> slowo[0] = x
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: object doesnt support item assignment
>>> slowo[:-1] = Splat
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: object doesnt support slice assignment

(TypeError: na obiekcie nie mozna wykonac operacji przypisania do elementu)

(TypeError: na obiekcie nie mozna wykonac opercji przypisania do wycinka)
Stworzenie, jednakze nowego ciagu
znakw z poaczenia
innych jest atwe i wydajne:

>>> x + sowo[1:]
xomocA
>>> Splat + slowo[-1:]
SplatA

Indeksy wykrawania posiadaja uzyteczne parametry domyslne: pominiety pierwszy indeks posiada domyslna
wartosc zero, a pominiety drugi domyslnie rwny jest dugosci ancucha znakw, ktrego dotyczy wykrawanie.
2 . . . pierwszy raz sysze o takim jezyku (przyp. tum.)

3.1. Uzywanie Pythona jako kalkulatora 11

 >>> slowo[:2] # Dwa pierwsze znaki
Po
>>> slowo[2:] # Wszystkie oprcz dwch pierwszych znakw
mocA

Oto uzyteczny niezmiennik operacji wykrawania: s[:i] + s[i:] jest rwne s.

>>> slowo[:2] + slowo[2:]
PomocA
>>> slowo[:3] + slowo[3:]
PomocA

Zdegenerowane indeksy wykrawania obsugiwane sa dosc ostroznie: indeks, ktry jest zbyt duzy, zastepowany jest
dugoscia ancucha, a ograniczenie grne, ktre okaze sie mniejsze od ograniczenia dolnego, powoduje powstanie
pustego napisu.
>>> slowo[1:100]
omocA
>>> slowo[10:]

>>> slowo[2:1]

Aby wyznaczyc znaki, liczac

od strony prawej ancucha znakw, uzywa sie indeksw bedacych
liczbami ujem-
nymi . Oto przykad:
>>> slowo[-1] # Ostatni znak
A
>>> slowo[-2] # Przedostatni znak
c
>>> slowo[-2:] # Dwa ostatnie znaki
cA
>>> slowo[:-2] # Wszystkie, oprcz dwch ostatnich znakw
Pomo

Prosze zauwazyc, z e 0 oznacza to samo co 0, tak wiec nie oznacza liczenia od prawej!
>>> slowo[-0] # (poniewa
z -0 jest rwne 0)
P

Ujemne wykrojenia, ktre sa przekraczaja ograniczenia ancucha sa skracane, ale nie prbuj tego na indeksach
jednoelementowych (nie oznaczajacych
wykrawania):
>>> slowo[-100:]
PomocA
>>> word[-10] # bad

Traceback (innermost last):
File "<stdin>", line 1
IndexError: string index out of range

(IndexError: indeks napisu poza jego granicami)

Najlepsza forma zapamietania sposobu dziaania wykrawania jest wyobrazenie sobie indeksw jako wskazwek
odnoszacych
sie do miejsc pomiedzy znakami, gdzie lewa krawedz pierwszego znaku nosi numer 0. Tak wiec,
prawa krawedz ostatniego znaku w ancuchu n znakw posiada indeks n, np.:

12 Rozdzia 3. Nieformalne wprowadzenie do Pythona

 +---+---+---+---+---+---+
| P | o | m | o | c | A |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1

W pierwszym rzedzie liczb mozemy zobaczyc pozycje wyznaczone przez indeksy 0. . . 6. Drugi rzad zawiera
odpowiednie indeksy ujemne. Wycinek od i do j skada sie ze wszystkich znakw pomiedzy krawedziami oznac-
zonymi odpowiednio i i j.
Dugosc wycinka mozna obliczyc z rznicy nieujemnych indeksw, pod warunkiem, z e oba mieszcza sie w grani-
np. dugosc slowo[1:3] rwna jest 2.
cach ciagu,
Wbudowana w interpreter funkcja len() zwraca dugosc ancucha:

>>> s = supercalifragilisticexpialidocious
>>> len(s)
34

3.1.3 Napisy Unicode

Od wersji 1.6 wprowadzono nowy typ danych: ancuchy znakw Unicode. Moga one zostac uzyte do prze-
chowywania i manipulacji danymi typu Unicode (zobacz http://www.unicode.org). Zostay one w niezy sposb
zintegrowane z istniejacym
w Pythonie systemem napisw i dostarczaja niezbednych konwersji tam, gdzie trzeba.
Unicode posiada przewage w oznaczeniu kazdego znaku uzywanego w starozytnych i nowoczesnych systemach
pismienniczych. Wczesniejsze rozwiazania
umozliwiaja przechowywanie tylko 256 znakw, ktrych pozycje
w tym zestawie zdefiniowane byy przez strony kodowe. Prowadzi to do duzego zamieszania, zwaszcza w
odniesieniu do internalizacji oprogramowania (zwykle nazywa sie to i18n i + 18 znakw + n =
internalization). Unicode rozwiazuje te problemy poprzez zdefiniowanie jednej strony kodowej dla wszys-
tkich systemw pismienniczych.
Stworzenie ancucha znakw Unicode w Pythonie jest tak samo proste jak w przypadku zwykego:

>>> uHello World !

uHello World !

Maa litera u z przodu ancucha oznacza, z e zostanie stworzony ancuch Unicode. Jesli chce sie umiescic
jakies znaki specjalne w tym ancuchu, mozna zrobic to poprzez kodowanie Unicode-Escape. Ponizszy przykad
pokazuje jak to uczynic:

>>> uHello\\u0020World !
uHello World !

Sekwencja cytowania (ang. escape sequence) \\u0020 oznacza wstawienie znaku Unicode na podanej pozycji
z kodem okreslonym szesnastkowo 0x0020 (znak spacji).
Inne znaki interpretowane sa poprzez uzycie ich odpowiedniego numeru porzadkowego
wprost jako porzadku

wyrazonego w Unicode. Fakt, iz pierwsze 256 znakw Unicode sa takie same jak standardowego zestawu Latin-1
uzywanego w wielu krajach zachodnich, proces kodowania ich w Unicode bardzo sie upraszcza.
Kasek
dla ekspertw: istnieje takze tryb surowy wprowadzania znakw, podobnie jak dla zwykych ancuchw.
Trzeba doaczy
c z przodu ancucha znak r, aby Python traktowa wszystko w tym ancuchu jako znaki kodowane
w trybie Raw-Unicode-Escape. Bedzie sie to stosowao tylko do konwersji \\uXXXX, tak jak w przykadzie
powyzej, gdy pojawia sie nieparzysta liczba ukosnikw z przodu litery u.

3.1. Uzywanie Pythona jako kalkulatora 13

 >>> urHello\u0020World !
uHello World !
>>> urHello\\u0020World !
uHello\\\\u0020World !

Tryb surowy jest najbardziej uzyteczny w przypadku, gdy trzeba wprowadzic mnstwo ukosnikw, np. jakies
wyrazenie regularne.3
Oprcz wspomnianych przed chwila standardowych sposobw kodowania znakw, Python dostarcza wiele innych
sposobw tworzenia ancuchw Unicode opartych na znanych juz kodowaniach.
Funkcja wbudowana unicode() dostarcza srodkw dostepu do wszystkich zarejestrowanych kodekw Uni-
code (tzw. COders i DECoders). Niektre z bardziej znanych kodowan, dla ktrych istniejace kodeki moga
przeprowadzic konwersje to Latin-1, ASCII, UTF-8 i UTF-16. Dwa ostatnie sa systemami kodowania zmiennej
dugosci, ktre pozwalaja przechowywac znaki Unicode w 8 lub 16 bitach. Python uzywa UTF-8 jako domyslnego
kodowania. Staje sie to wazne, gdy decydujemy sie umieszczac takie znaki w plikach lub drukowac.

>>> u""
u\344\366\374
>>> str(u"")
\303\244\303\266\303\274

Jesli przechowujesz dane kodowane w specyficzny sposb i chce sie wyprodukowac odpowiadajacy
im ancuch
Unicode, mozna uzyc unicode() z podana nazwa kodowania jako drugi parametr wywoania.

>>> unicode(\303\244\303\266\303\274,UTF-8)
u\344\366\374

Metoda ancucha znakowego encode() pozwala dokonac odwrotnej konwersji.

>>> u"".encode(UTF-8)
\303\244\303\266\303\274

3.1.4 Listy

Istnieje w Pythonie pewna liczba zozonych typw danych, uzywanych do grupowania innych wartosci. Na-
jbardziej uzytecznym typem jest lista, ktra mozna zapisac jako liste elementw poprzedzielanych przecinkiem,
umieszczona w kwadratowych nawiasach. Elementy listy nie musza byc tego samego typu.4

>>> a = [w
edzonka, jaja, 100, 1234]
>>> a
[w
edzonka, jaja, 100, 1234]

Podobnie jak indeksy ancuchw znakw, indeksy listy rozpoczynaja sie od wartosci 0. Listy moga byc przed-
miotem operacji wykrawania, sklejania itd.:
3 Modu re do obsugi wyrazen regularnych opisany zosta w Opisie biblioteki (przyp. tum.)
4I to jest to, co najbardziej rajcuje tygryski. . . (przyp. tum.)

14 Rozdzia 3. Nieformalne wprowadzenie do Pythona

 >>> a[0]
w
edzonka
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
[jaja, 100]
>>> a[:2] + [bekon, 2*2]
[wedzonka, jaja, bekon, 4]
>>> 3*a[:3] + [Srutututu!]
[wedzonka, jaja, 100, w
edzonka, jaja, 100, w
edzonka, jaja, 100,
Srutututu!]

Odmiennie niz napisy, ktre sa niemutowalne, mozna zmieniac poszczeglne elementy listy:

>>> a
[w
edzonka, jaja, 100, 1234]
>>> a[2] = a[2] + 23
>>> a
[w
edzonka, jaja, 123, 1234]

Mozliwe jest takze przypisanie do wycinka, co moze takze zmienic dugosc listy:

>>> # Zastap
pewne elementy:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Inne usu
n:
... a[0:2] = []
>>> a
[123, 1234]
>>> # W
z par
e:
... a[1:1] = [bletch, xyzzy]
>>> a
[123, bletch, xyzzy, 1234]
>>> a[:0] = a # Wstaw kopi
e siebie na poczatek

>>> a
[123, bletch, xyzzy, 1234, 123, bletch, xyzzy, 1234]

Wbudowana funkcja len() rwniez dotyczy list:

>>> len(a)
8

Mozliwe jest zagniezdzanie list (tworzenie list, ktrej elementami sa inne listy), np:

3.1. Uzywanie Pythona jako kalkulatora 15

 >>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append(xtra) # Zobacz podpunkt 5.1
>>> p
[1, [2, 3, xtra], 4]
>>> q
[2, 3, xtra]

Zauwazcie, z e w ostatnim przykadzie p[1] i q tak naprawde odnosza sie do tego samego egzemplarza obiektu!
Powrcimy do obiektowej semantyki pzniej.

3.2 Pierwsze kroki w programowaniu

Dodawanie 2 do 2 jest oczywiscie nie wszystkim, co mozna zrobic w Pythonie. Mozemy na przykad napisac
poczatkowe
Fibonacciego: 5
elementy ciagu

>>> # Ciag
Fibonacciego:
... # suma dwch elementw definiuje nast
epny element
... a, b = 0, 1
>>> while b < 10:
... print b
... a, b = b, a+b
...
1
1
2
3
5
8

Powyzszy przykad ukazuje nam pare nowych cech Pythona.

Pierwsza linia zawiera tzw. wielokrotne przypisanie: zmiennym a i b przypisuje sie jednoczesnie wartosci
0 i 1. W ostatniej linii uzyto jeszcze raz tego mechanizmu, gdzie mozemy sie przekonac, z e wyrazenia po
prawej stronie przypisania sa obliczane w pierwszej kolejnosci, zanim jakiekolwiek przypisanie ma miejsce.
Wyrazenia te obliczane sa od lewej do prawej.
Petla while wykonuje sie do chwili, gdy warunek (w tym przypadku: b < 10) jest prawdziwy. W
Pythonie, podobnie jak w C, kazda niezerowa wartosc cakowita oznacza prawde; zero oznacza fasz.
Warunek moze byc okreslony przez ancuch znakw lub liste wartosci tak naprawde, kazda sekwencja
o dugosci niezerowej oznacza prawde, a puste ciagi
oznaczaja fasz. Test uzyty w powyzszym przykadzie
jest prostym porwnaniem. Standardowe operatory porwnania sa takie same jak w C: < (mniejszy niz), >
(wiekszy niz), == (rwny), <= (mniejszy rwny),
Ciao petli jest wciete: indentacja (wcinanie) jest sposobem na grupowanie instrukcji. Obecnie Python
nie dostarcza z adnych udogodnien zwiazanych
z inteligentna edycja wierszy wejsciowych, tak wiec trzeba
wprowadzic znak spacji lub tabulacji, aby wcia c wiersz. W praktyce programy w Pythonie bedzie sie pisac
w jakims edytorze tekstw, a wiekszosc z nich posiada cos na ksztat mechanizmu auto-indentacji. W
chwili, gdy wprowadza sie jaka s instrukcje zozona w czasie sesji interpretera Pythona, trzeba zakonczyc
5 Kiedy sie wreszcie skonczy katowanie Fibbonaciego?! (przyp. tum.)

16 Rozdzia 3. Nieformalne wprowadzenie do Pythona

 ja pustym wierszem (bowiem interpreter nie wie, czy ostatni wprowadzony wiersz jest ostatnim z tej in-
strukcji). Wazne jest, aby kazdy wiersz nalezacy
do tej samej grupy instrukcji, by wciety o taka sama
liczbe spacji lub znakw tabulacji.
Instrukcja print zapisuje na standardowym wyjsciu wyrazenie, ktre stoi za nim. Rznica pomiedzy ta
instrukcja, a zwykym zapisem wyrazenia, ktre chce sie wypisac (tak jak robilismy to w przykadzie z
kalkulatorem) wystepuje w sposobie obsugi wielu wyrazen i napisw. ancuchy znakw wypisywane sa
bez cudzysoww, a pomiedzy nimi zapisywane sa spacje, tak aby mozna byo adnie sformatowac pojaw-
iajacy
sie napis, np:

>>> i = 256*256
>>> print Wartoscia i jest, i
Warto
scia i jest 65536

Przecinek postawiony na koncu instrukcji print powoduje pozostanie w tym samym wierszu po zakoncze-
niu wypisywania:

>>> a, b = 0, 1
>>> while b < 1000:
... print b,
... a, b = b, a+b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

Zauwazcie, z e interpreter wstawia znak nowej linii, zanim wydrukuje znak zachety, jezeli poprzedni wiersz
nie by zakonczony.

3.2. Pierwsze kroki w programowaniu 17

18
 ROZDZIA

CZWARTY

Jeszcze wiecej
sposobw na
kontrolowanie programu

Python wyposazony jest w zestaw wielu instrukcji, nie tylko w while, ktra juz poznalismy. Sa one dobrze
znane z innych jezykw programowania, choc posiadaja swj lokalny koloryt.

4.1 Instrukcje if
Zdaje mi sie, z e najbardziej znana instrukcja jest instrukcja if. Np.:
>>> x = int(raw_input("Prosze poda
c liczb
e: "))
>>> if x < 0:
... x = 0
... print Ujemna zmienia si
e na zero
... elif x == 0:
... print Zero
... elif x == 1:
... print Jeden
... else:
... print Wi
ecej
...

Mozna wstawic zero lub wiecej czesci elif, a czesc else jest opcjonalna. Sowo kluczowe elif jest skrtem
instrukcji else if i przydaje sie, gdy chce sie unikna
c kolejnej indentacji. Sekwencja if . . . elif . . . elif . . .
zastepuje instrukcje switch lub case spotykane w innych jezykach.1

4.2 Instrukcje for

Instrukcja for rzni sie troszeczke w Pythonie od tego, co uzywasz w C lub Pascalu. Nie prowadzi sie iteracji
od liczby do liczby (jak w Pascalu) lub daje sie uzytkownikowi mozliwosc definiowania kroku iteracji i warunki
zakonczenia iteracji (jak w C). Instrukcja for w Pythonie powoduje iteracje po elementach jakiejkolwiek sek-
wencji (np. listy lub ancucha znakw), w takim porzadku,
w jakim sa one umieszczone w danej sekwencji. Na
przykad:
1 Czyli instrukcje wyboru. (przyp. tum.)

19
 >>> # Mierzy pewne napisy:
... a = [kot, okno, wypr
zni
c]
>>> for x in a:
... print x, len(x)
...
kot 3
okno 4
wyprzni
c 9

Nie jest bezpiecznym modyfikacja sekwencji, ktra wasnie jest przedmiotem iteracji (mozna to zrobic tylko dla
mutowalnego typu sekwencji, tzn. listy). Jesli chce sie ja modyfikowac, np. duplikowac wybrane jej elementy, to
przeprowadz iteracje na jej kopii. Notacja wykrawania jest tu szczeglnie uzyteczna:

>>> for x in a[:]: # wykrj caa list

e (zrb jej kopi
e)
... if len(x) > 6: a.insert(0, x)
...
>>> a
[wypr
zni
c, kot, okno, wyprznic]

4.3 Funkcja range()

Jesli zasza potrzeba iteracji okreslonej zakresem liczbowym (czyli iteracji na sekwencji liczb w Pythonie), mozna
uzyc wbudowanej w interpreter funkcji range(). Wynikiem jej dziaania jest lista zawierajaca ciag arytmety-
czny, tzn.:
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Podany na jej wejsciu punkt koncowy nigdy nie zostanie zawarty w wynikowej liscie. range(10) tworzy liste
10 wartosci, a tak naprawde dokadnie zbir dopuszczalnych wartosci indeksw dla listy o dugosci 10. Jesli jest
taka potrzeba, mozna okreslic liczbe poczatkow
a tego ciagu
albo krok (nawet liczbe ujemna):

>>> range(5, 10)

[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]

Aby przegladn
ac wszystkie elementy listy aczy
sie funkcje range() i len(), tak jak ponizej:
>>> a = [Marysia, miaa, maego, baranka]
>>> for i in range(len(a)):
... print i, a[i]
...
0 Marysia
1 miaa
2 maego
3 baranka

20 Rozdzia 4. Jeszcze wiecej

sposobw na kontrolowanie programu
4.4 Instrukcja break i continue oraz klauzule else w petlach

Instrukcja break, podobnie jak w C, powoduje wyjscie z najblizej zagniezdzonej petli for lub while.
Instrukcja continue zostaa rwniez zapozyczona z C, powoduje przejscie do nastepnego kroku iteracji w petli.
Instrukcje petli posiadaja klauzule else: jest ona wykonywana w momencie zakonczenia dziaania petli przy
wyczerpaniu sie (dojscia za ostatni element) listy (petla for) lub gdy warunek petli zwraca wartosc faszu (petla
while), ale nie w momencie opuszczenia petli w wyniku zadziaania instrukcji break. Pokazane to zostao na
przykadzie algorytmu poszukiwania liczby pierwszej:
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
... print n, rwne, x, *, n/x
... break
... else:
... print n, jest liczba pierwsza

...
2 jest liczba pierwsza
3 jest liczba pierwsza
4 rwne 2 * 2
5 jest liczba pierwsza
6 rwne 2 * 3
7 jest liczba pierwsza
8 rwne 2 * 4
9 rwne 3 * 3

4.5 Instrukcje pass

Instrukcja pass nic nie robi. Moze byc uzyta wszedzie tam, gdzie wymagana jest jakas instrukcja z powodw
skadniowych, ale program nie przewiduje w tym miejscu z adnego dziaania. Na przykad:

>>> while 1:
... pass # Zaj
ety-poczekaj na naci
sni
ecie klawisza
...

4.6 Definiowanie funkcji

Mozemy stworzyc funkcje, ktra wypisuje ciag
Fibonaciego o wybranych granicach:

>>> def fib(n): # wypisz ciag

Fibonacciego a
z do n
... "Wypisuje ciag
Fibonacciego a
z do n"
... a, b = 0, 1
... while b < n:
... print b,
... a, b = b, a+b
...
>>> # Teraz, wywoajmy funkcj
e, ktra przed chwila zdefiniowali
smy:
... fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Sowo kluczowe def wprowadza definicje funkcji. Musi po nim nastepowac nazwa funkcji i lista jej parametrw
formalnych umieszczonych w nawiasach okragych.
Instrukcje, ktre tworza ciao funkcji, sa oczywiscie wsuniete

4.4. Instrukcja break i continue oraz klauzule else w petlach

21
w stosunku do wiersza zawierajacego
nazwe funkcji i musza zaczynac sie w nowym wierszu. Opcjonalnie, pier-
wszy wiersz ciaa funkcji moze byc goym napisem (literaem): jest to tzw. napis dokumentujacy
lub (inna nazwa
tego zjawiska) docstring.
Istnieja pewne narzedzia, ktre uzywaja napisw dokumentacyjnych (docstringw) do automatycznego tworzenia
drukowanej dokumentacji albo pozwalaja uzytkownikowi na interaktywne przegladanie
kodu. Dobrym zwycza-
jem jest pisane napisw dokumentacyjnych w czasie pisania programu: sprbuj sie do tego przyzwyczaic.
Wykonanie funkcji powoduje stworzenie nowej tablicy symboli lokalnych uzywanych w tej funkcji. Mwiac
precyzyjniej: wszystkie przypisania do zmiennych lokalnych funkcji powoduja umieszczenie tych wartosci w
lokalnej tablicy symboli, z czego wynika, z e odniesienia do zmiennych najpierw szukaja swych wartosci w
lokalnej tablicy symboli, a potem w globalnej, a dopiero na koncu w tablicy nazw wbudowanych w interpreter. Tak
wiec, zmiennym globalnym nie mozna wprost przypisac wartosci w ciele funkcji (chyba, z e zostana wymienione
w niej za pomoca instrukcji global), aczkolwiek moga w niej byc uzywane (czytane).
Parametry wywoania funkcyjnego (argumenty) wprowadzane sa do lokalnej tablicy symboli w momencie
wywoania funkcji. Tak wiec, argumenty przekazywane sa jej przez wartosc (gdzie wartosc jest zawsze odniesie-
niem do obiektu, a nie samym obiektem).2 Nowa tablica symboli tworzona jest rwniez w przypadku, gdy funkcja
wywouje inna funkcje.
Definicja funkcji wprowadza do aktualnej tablicy symboli nazwe tej funkcji. Nazwa ta identyfikuje wartosc , ktrej
typ rozpoznawany jest przez interpreter jako funkcja zdefiniowana przez uzytkownika. Wartosc ta (a wasciwie
obiekt (przyp. tum.)) moze byc przypisana innej nazwie, ktra potem moze zostac uzyta jak funkcja. Ta wasci-
wosc moze posuzyc jako oglny mechanizm zmiany nazw:

>>> fib
<function object at 10042ed0>
>>> f = fib
>>> f(100)
1 1 2 3 5 8 13 21 34 55 89

Moznaby tutaj naprostowac moje opowiesci, z e fib nie jest funkcja, ale procedura. W Pythonie, podobnie
jak w C, procedury sa specyficznymi funkcjami, ktre nie zwracaja wartosci3 Tak naprawde, mwiac jezykiem
technicznym, procedury naprawde zwracaja wartosc , aczkolwiek raczej nudna. 4 Wartosc ta nazywana jest None
(jest to nazwa wbudowana). Napisanie wartosci None jest w normalnych warunkach pomijane przez interpreter,
jezeli jest to jedyna wartosc , ktra miaa byc wypisana. Mozna ja zobaczyc, jezeli naprawde tego sie chce:

>>> print fib(0)

None

Bardzo proste jest napisanie funkcji, ktra zwraca liste liczb ciagu
Fibonacciego, zamiast wypisywac je:
2 Wasciwie wywoanie przez odniesienie, byoby lepszym okresleniem, poniewa z jezeli przekazywane jest odniesienie do obiektu mu-
towalnego, to wywoujacy funkcje zobaczy wszystkie zmiany dokonane na takim obiekcie (np. elementy wstawione do listy).
3 Wi
ec nie sa to funkcje. W C lub C++procedury-funkcje zwracaja wartosc void (przynajmniej skadniowo)! I tam na pewno sa to funkcje,
specyficzne, ale zawsze funkcje! (przyp. tum.)
4 Czyli jednak sa to funkcje! (przyp. tum.)

22 Rozdzia 4. Jeszcze wiecej

sposobw na kontrolowanie programu
 >>> def fib2(n): # zwraca warto
sci ciagu
Fibonacciego a
z do n
... "Zwraca warto
sci ciagu
Fibonacciego, a
z do n"
... wynik = []
... a, b = 0, 1
... while b < n:
... wynik.append(b) # zobacz poni
zej
... a, b = b, a+b
... return wynik
...
>>> f100 = fib2(100) # wywoaj ja
>>> f100 # wypisz wynik
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Ten przykad jak zwykle, demonstruje pare nowych pythonowatych wasciwosci:

Instrukcja return powoduje powrt z funkcji z pewna wartoscia. return bez wyrazenia za nim uzywane
jest do powrotu ze srodka procedury (dojscie do konca procedury, rwniez to powoduje), przy czym w takim
wypadku do wywoujacego powraca wartosc None.

Instrukcja wynik.append(b) wywouje metode obiektu listy wynik. Metoda jest funkcja nalezac a
do
obiektu i nazywa sie obiekt.nazwametody, gdzie obiekt jest jakims tam obiektem (rwnie dobrze
moze to byc wyrazenie), a nazwametody jest nazwa metody zdefiniowanej przez typ obiektu obiekt.
Rzne typy definiuja rzne metody. Metody rznych typw moga miec te same nazwy bez powodowania
niejednoznacznosci. (Mozliwe jest zdefiniowane swoich wasnych typw i metod przy uzyciu klas, tak jak
pokazane to bedzie pzniej). Metoda append() uzyta w przykadzie, zdefiniowana jest dla listy obiektw:
dodaje nowe elementy do konca listy. W tym przykadzie jest to odpowiednik wynik = wynik +
[b], ale jest bardziej wydajne.

4.7 Jeszcze wiecej

o definiowaniu funkcji
Mozliwe jest definiowanie funkcji ze zmienna liczba argumentw. Istnieja trzy formy takiej definicji, ktre moga
byc ze soba splatane.

4.7.1 Domyslne wartosci argumentw

Najbardziej uzyteczna forma jest okreslenie domyslnej wartosci dla jednego lub wiekszej liczby argumentw. W
ten sposb funkcja moze zostac wywoana z mniejsza liczba argumentw, niz bya zdefiniowana, tzn.:

def zapytaj_ok(zacheta, liczba_prob=4, zazalenie=Tak lub nie, bardzo

prosz
e!): while 1:
ok = raw_input(zacheta)
if ok in (t, ta, tak): return 1
if ok in (n, nie, ee, gdzie tam): return 0
liczba_prob = liczba_prob - 1
if liczba_prob < 0: raise IOError, uzytkownik niekumaty
print zazalenie

Funkcja ta moze zostac wywoana w taki sposb: zapytaj_ok(Naprawd

e chcesz zako c?) lub
nczy
w taki: zapytaj_ok(Zgadzasz si e nadpisa c ten plik?, 2).
Wartosci domyslne okreslane sa w punkcie definicji funkcji, w przestrzeni definiowania nazw, tak wiec np.:

4.7. Jeszcze wiecej

o definiowaniu funkcji 23
 i = 5
def f(arg = i): print arg
i = 6
f()

wypisze 5.
Wazne ostrzezenie: wartosc domyslna okreslana jest tylko raz. Ma to znaczenie w przypadku, gdy wartoscia ta
jest obiekt mutowalny, jak np. lista czy sownik. W przykadzie ponizej, funkcja akumuluje argumenty przekazane
jej w kolejnych wywoaniach:
def f(a, l = []):
l.append(a)
return l
print f(1)
print f(2)
print f(3)

Instrukcje print spowoduja:

[1]
[1, 2]
[1, 2, 3]

jesli nie chce sie, aby wartosci domyslne byy wspdzielone pomiedzy kolejnymi wywoaniami funkcji, mozna
ja napisac w taki sposb:

def f(a, l = None):

if l is None:
l = []
l.append(a)
return l

4.7.2 Argumenty kluczowe

Funkcja moze byc wywoana z uzyciem argumentw kluczowych, tzn. w formie klucz = wartosc . Na
przykad, ponizsza funkcja:

def papuga(napiecie, stan=racja, akcja=voom, typ=Norwegian Blue):

print "-- Ta papuga nie zrobiaby", akcja
print "je
sli przyozysz", napiecie, "woltw do niej."
print "-- Sliczne upierzenie, ten", typ
print "-- Tak,", stan, "!"

mogaby byc wywoana na pare rznych sposobw:

papuga(1000)
papuga(akcja = VOOOOOM, napiecie = 1000000)
papuga(tysiac,
stan = ju
z wacha
kwiatki od spodu)
parrot(milion, bereft of life, skoku)

lecz ponizsze wywoania byyby nieprawidowe:

24 Rozdzia 4. Jeszcze wiecej

sposobw na kontrolowanie programu
 papuga() # brakuje wymaganego argumentu
papuga(napiecie=5.0, trup) # niekluczowy argument za kluczowym
papuga(110, napiecie=220) s
# zduplikowana warto c argumentu
papuga(aktor=John Cleese) # nieznana nazwa argumentu

W oglnosci mwiac, 5 lista argumentw wywoania, musi miec jakis argument pozycyjny, po ktrym nastepuje
jakikolwiek argument kluczowy, gdzie klucze wybrane sa z listy parametrw formalnych. Nie jest wazne, czy

parametr formalny ma wartosc domyslna, czy tez nie. Zaden z argumentw nie moze otrzymac wartosci wiecej
niz jeden raz nazwy parametrw formalnych odpowiadajace argumentom pozycyjnym w wywoaniu nie moga
byc w nim uzyte jako kluczowe. Oto przykad wywoania, ktre sie nie powiedzie z uwagi na wymienione przed
chwila ograniczenia:

>>> def function(a):

... pass
...
>>> function(0, a=0)
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: keyword parameter redefined

Gdy na liscie parametrw formalnych funkcji widnieje **nazwa, to przy wywoaniu funkcji przypisywany jest mu
sownik zawierajacy wszystkie klucze, ktre nie odpowiadaja nazwom parametrw formalnych. Mechanizm ten
moze byc poaczony
z wystapieniem
parametru formalnego o nazwie *nazwa (co zostanie opisane w nastepnym
podrozdziale), ktry w momencie wywoania staje sie krotka (ang. tuple), ktra zawiera wszystkie argumenty
pozycyjne (niekluczowe) wymienione w wywoaniu funkcji za parametrami formalnymi. (*nazwa musi pojawic
sie przed **nazwa na liscie parametrw formalnych). Jezeli, na przykad, zdefiniujemy funkcje w ten sposb:

def sklep_z_serami(rodzaj, *argumenty, **klucze):

print "-- Czy macie", rodzaj, ?
print "-- Przykro mi,", rodzaj, "wa
snie si
e sko
nczy."
for arg in argumenty: print arg
print -*40
for kl in klucze.keys(): print kl, :, klucze[kl]

ktra mogaby byc wywoana o tak6 :

sklep_z_serami(Limburger, "Jest bardzo dojrzay, prosz

e pana.",
"Jest naprawd
e bardzo, BARDZO dojrzay, prosz
e pana.",
klient=John Cleese,
wlasciciel=Michael Palin,
skecz=Skecz ze sklepem z serami)

co oczywiscie spowoduje wypisanie:

5 jakmawia Nikus Dyzma (przyp. tum.)
6 To
jest bardzo nieudolne tumaczenie tego przesmiesznego skeczu. S.p. Beksinski zrobi to wiele smieszniej: niestety, nie miaem tego
nagrania przy sobie (przyp. tum.)

4.7. Jeszcze wiecej

o definiowaniu funkcji 25
 -- Czy macie Limburger ?
-- Przykro mi, Limburger wa
snie si
e skonczy.
Jest bardzo dojrzay, prosz
e pana.
Jest naprawd
e bardzo, BARDZO dojrzay, prosze pana.
----------------------------------------
klient : John Cleese
wlasciciel : Michael Palin
skecz : Skecz ze sklepem z serami

4.7.3 Lista arbitralnych argumentw

Ostatnim sposobem na to, aby funkcja zostaa wywoana w dowolna liczba argumentw jest wprost okreslenie
tego w definicji. Wszystkie argumenty zostana zapakowane w krotke.7 Przedtem na liscie argumentw moze
pojawic sie zero lub wiecej normalnych argumentw.

def fprintf(plik, format, *args):

plik.write(format % args)

4.7.4 Formy lambda

Ze wzgledu na wzrastajac
a liczbe gosw uzytkownikw, dodano do Pythona pare nowych wasciwosci spo-
tykanych zwykle w jezykach funkcjonalnych. Za pomoca sowa kluczowego lambda mozesz tworzyc mae,
anonimowe (czyli nienazwane) funkcje. Oto funkcja, ktra zwraca sume jej dwch argumentw: lambda a,
b: a+b. Formy lambda moga zostac uzyte we wszystkich miejscach, gdzie wymagane sa obiekty funkcji.
Skadniowo ograniczone sa do pojedynczego wyrazenia. Semantycznie, sa wasciwie szczypta cukru na skadnie
zwykych definicji funkcji. Podobnie jak zagniezdzone definicje funkcji, formy lambda nie moga uzywac nazw
zmiennych z zakresu zewnetrznego lecz moze to byc ominiete poprzez sprytne uzycie argumentw domyslnych:

def stworz_powiekszacza(n):
return lambda x, incr=n: x+incr

4.7.5 Napisy dokumentujace

Istnieje pewna konwencja dotyczaca

zawartosci i formatowania napisw dokumentujacych.

Pierwszy wiersz powinien byc krtki, zwiez le podsumowujacy dziaanie obiektu. Dla zwiezosci nie powinien
wprost okreslac nazwy obiektu lub jego typu albowiem atrybuty te sa dostepne dla czytelnika za pomoca innych
srodkw (z wyjatkiem
czasownika opisujacego
dziaanie funkcji). wiersz ten powien zaczynac sie od duzej litery
i konczyc kropka.
Jesli napis zawiera wiecej linii, drugi wiersz powinien byc pusty, wizualnie oddzielajac
reszte opisu. Nastepne
wiersze powinny obejmowac jeden lub wiecej akapitw, opisujac sposb wywoania obiektu, efekty uboczne itd.
Parser Pythona nie wycina znakw tabulacji i wciecia z wielowierszowych literaw napisw, dlatego tez
narzedzia do produkcji dokumentacji musza to robic same, jesli jest to wymagane. Robi sie to wg nastepujacej
konwencji. Pierwszy niepusty wiersz po pierwszym wierszu napisu okresla wielkosc wsuniecia caego napisu
dokumentujacego. (Nie mozna uzyc pierwszego wiersza, gdyz zazwyczaj poozony jest blizej otwierajacego
napis cydzysowia, tak, z e indentacja nie jest widoczna). Ekwiwalent tego wciecia zozony z biaych znakw
(czyli spacji, tabulacji) jest wycinany z poczatkw wierszy caego napisu. Wiersze, ktre sa wciete mniej niz ta
ilosc , nie powinny sie w napisie pojawic, ale jesli to sie stanie, to wszystkie znaki biae z przodu wiersza zostana
7 list
e niemutowalna (przyp. tum.)

26 Rozdzia 4. Jeszcze wiecej

sposobw na kontrolowanie programu
usuniete. Rwnowartosc wciecia liczona w spacjach powinna byc sprawdzona po rozwinieciu znakw tabulacji
(zazwyczaj do 8 spacji).
Oto przykad wielowierszowego docstringu:

>>> def moja_funkcja():

... """Nie rb nic, ale udokumentuj to.
...
... Naprawd
e, tutaj niczego si
e nie robi.
... """
... pass
...
>>> print moja_funkcja.__doc__
Nie rb nic, ale udokumentuj to.

Naprawd
e, tutaj niczego si
e nie robi.

4.7. Jeszcze wiecej

o definiowaniu funkcji 27
28
 ROZDZIA

PIATY

Struktury danych

Rozdzia ten opisuje pewne rzeczy, o ktrych powiedziano juz szczegowo oraz dodaje pare nowinek.

5.1 Wiecej
o listach
Typ listy posiada pewien zbir metod. Oto wszystkie jego metody:

append(x) Dodaje element do koncz listy, odpowiednik a[len(a):] = [x].

extend(L) Rozszerza liste poprzez doaczenie
wszystkich elementw podanej listy L, odpowiednik
a[len(a):] = L.
insert(i, x) Wstawia element na podana pozycje listy. Pierwszym argumentem wywoania jest indeks
elementu, przed ktrym nowy element ma zostac wstawiony: tak wiec a.insert(0,x) wstawia na
poczatek
listy, a a.insert(len(a),x) jest odpowiednikiem a.append(x)
remove(x) Usuwa pierwszy napotkany element z listy, ktrego wartoscia jest x. Jezeli nie ma na liscie takiego
elementu, zgaszany jest bad.

pop([i ]) Usuwa element z podanej pozycji na liscie i zwraca go jako wynik. Jezeli nie podano z adnego
indeksu a.pop(), zwraca ostatni element na liscie. Oczywiscie, jest on z niej usuwany.
index(x) Zwraca indeks pierwszego elementu listy, ktrego wartoscia jest x. Jezeli nie ma takiego elementu
zgaszany jest bad.

count(x) Zwraca liczbe wystapie
n elementu x na liscie.
sort() Sortuje elementy na liscie, w niej samej. (W wyniku nie jest tworzona nowa, posortowana lista (przyp.
tum.))
reverse() Odwraca porzadek
elementw listy, rwniez w niej samej.

Przykad, w ktrym uzyto wiekszosc z podanych powyzej metod:

29
 >>> a = [66.6, 333, 333, 1, 1234.5]
>>> print a.count(333), a.count(66.6), a.count(x)
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.6, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.6, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.6]
>>> a.sort()
>>> a
[-1, 1, 66.6, 333, 333, 1234.5]

5.1.1 Uzywanie listy jako stosu

Uzycie listy w roli stosu typu last-in, first-out (ostatni dodany element jest pierwszym pobranym) jest bardzo
atwe gdy sprbujemy wykorzystac jej metody. Aby dodac element na szczyt stosu, nalezy uzyc append().
pop(), bez podawania wprost indeksu, uzywane jest do pobrania elementu ze szczytu stosu. Na przykad:
>>> stos = [3, 4, 5]
>>> stos.append(6)
>>> stos.append(7)
>>> stos
[3, 4, 5, 6, 7]
>>> stos.pop()
7
>>> stos
[3, 4, 5, 6]
>>> stos.pop()
6
>>> stos.pop()
5
>>> stos
[3, 4]

5.1.2 Uzycie listy jako kolejki

Mozna uzywac listy rwnie wygodnie w roli kolejki first-in, first-out (pierwszy dodany element jest pierwszym
pobieranym). Aby dodac element na koniec kolejki, uzyj append(). Aby pobrac element z przodu kolejki, uzyj
pop(0). Na przykad:
>>> kolejka = ["Eric", "John", "Michael"]
>>> kolejka.append("Terry") # przybywa Terry
>>> kolejka.append("Graham") # przybywa Graham
>>> kolejka.pop(0)
Eric
>>> kolejka.pop(0)
John
>>> kolejka
[Michael, Terry, Graham]

30 Rozdzia 5. Struktury danych

5.1.3 Mechanizmy programowania funkcjonalnego

Istnieja trzy, bardzo uzyteczne przy pracy z listami, funkcje: filter(), map(), i reduce().
filter(funkcja, sekwencja) zwraca sekwencje (tego samego typu, gdy to mozliwe) zawierajac a te elementy
z listy wejsciowej, dla ktrych wywoanie funkcja(element) zwrci wartosc prawdziwa. Oto przykad obliczania
liczb pierwszych:

>>> def f(x): return x % 2 != 0 and x % 3 != 0

...
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]

map(funkcja, sekwencja) wywouje funkcja(element) dla kazdego elementu listy wejsciowej i zwraca liste
wartosci zwrconych przez funkcja. Na przykad, aby obliczyc szescian dla kazdego elementu z ciagu
liczb:

>>> def sze

scian(x): return x*x*x
...
>>> map(szescian, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

Przekazana moze zostac wiecej, niz jedna sekwencja funkcja funkcja musi miec wtedy tyle argumentw, ile
zostao podanych sekwencji i jest wywoywana z poszczeglnym elementem z kazdej sekwencji wejsciowej (lub
z None jesli ktras z nich jest krtsza od innej). Jezeli None zosta przekazany zamiast pierwszego argumentu
map, funkcja zwracajaca swoje argumenty jest zastepowana.1
Skadajac
te dwa przypadki zauwazmy, iz map(None, lista1, lista2) jest wygodnym sposobem przeksz-
tacenia pary list w liste par. Na przykad:

>>> sekw = range(8)

>>> def kwadrat(x): return x*x
...
>>> map(None, sekw, map(kwadrat, sekw))
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]

reduce(funkcja, sekwencja) zwraca pojedyncza wartosc , ktra powstaa w wyniku: wywoania dwu-
parametrowej funkcji funkcja dla dwch pierwszych elementw sekwencji, potem dla wyniku tego dziaania i
nastepnego elementu sekwencji itd. Na przykad, aby obliczyc sume liczb od 1 do 10:

>>> def dodaj(x,y): return x+y

...
>>> reduce(dodaj, range(1, 11))
55

Jesli istnieje tylko jeden element w sekwencji, zwracana jest jego wartosc . Jezeli sekwencja jest pusta, zgaszany
jest wyjatek.

Mozna przekazac poczatkow
a wartosc jako trzeci argument wywoania. W tym przypadku wartosc ta jest
zwracana, gdy sekwencja jest pusta. Funkcja jest stosowana dla wartosci poczatkowej
i pierwszego elementu
sekwencji, a nastepnie wynik tej operacji stanowi argument wejsciowy wraz z nastepnym elementem itd. Oto
przykad:
1 Nic z tego nie rozumiem. Taki ze mnie tumacz. . . (przyp. tum.)

5.1. Wiecej
o listach 31
 >>> def suma(sekw):
... def dodaj(x,y): return x+y
... return reduce(dodaj, sekw, 0)
...
>>> suma(range(1, 11))
55
>>> suma([])
0

5.1.4 Rozszerzenia skadni list

Sa one spjnym sposobem na tworzenie list bez odwoywania sie do map(), filter() i/lub lambda. Przed-
stawione ponizej definicje list czesto sa bardziej przejrzyste niz listy tworzone za pomoca w.w. konstrukcji.
Kazda z rozszerzonych konstrukcji skada sie z wyrazenia, po ktrym nastepuje klauzula for, potem zero lub
wiecej klauzuli for lub if. W rezultacie otrzymujemy liste powstaa w wyniku wyliczenia wyrazenia w kon-
tekscie klauzul for i if, ktre po nim wystepuja. Jesli wyrazenie ma typ krotki, musi zostac objete nawiasami
okragymi.

>>> owoce = [ banan, jerzyna , owoc pasji ]
>>> [uzbrojenie.strip() for bron in owoce]
[banan, jerzyna, owoc pasji]
>>> wek = [2, 4, 6]
>>> [3*x for x in wek]
[6, 12, 18]
>>> [3*x for x in wek if x > 3]
[12, 18]
>>> [3*x for x in wek if x < 2]
[]
>>> [{x: x**2} for x in wek]
[{2: 4}, {4: 16}, {6: 36}]
>>> [[x,x**2] for x in wek]
[[2, 4], [4, 16], [6, 36]]
>>> [x, x**2 for x in wek] # bad
- dla krotek wymaga si
e nawiasw okragych

File "<stdin>", line 1
[x, x**2 for x in wek]
^
SyntaxError: invalid syntax
>>> [(x, x**2) for x in wek]
[(2, 4), (4, 16), (6, 36)]
>>> wek1 = [2, 4, 6]
>>> wek2 = [4, 3, -9]
>>> [x*y for x in wek1 for y in wek2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in wek1 for y in wek2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]

(SyntaxError: za skadnia)

5.2 Instrukcja del

Jednym ze sposobw usuniecia elementu z listy za pomoca podania jego indeksu zamiast jego wartosci jest in-
strukcja del. Mozna ja rwniez uzyc do usuniecia wielu elementw poprzez usuniecie wycinka (robilismy to
wczesniej poprzez przypisanie pustej listy do wycinka). Na przykad:

32 Rozdzia 5. Struktury danych

 >>> a
[-1, 1, 66.6, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.6, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.6, 1234.5]

del moze zostac uzyte do usuwania zmiennych:

>>> del a

Prba uzycia zmiennej a po takiej operacji, powoduje zgoszenie bedu (chyba, z e bedzie to instrukcja przypisania
wartosci do tej zmiennej). Inne zastosowania del zostana przedstawione pzniej.

5.3 Listy niemutowalne i sekwencje

Przekonalismy sie juz, z e listy i napisy maja wiele wsplnych wasciwosci, np. indeksacja o operacje wycinania.
Sa to dwa przykady typw sekwencyjnych. Ze wzgledu na to, z e Python jest jezykiem rozszerzalnym2 , mozna
dodawac inne typy danych. Istnieje jeszcze jeden typ danych sekwencyjnych: krotka3 .
Taka lista skada sie z pewnej liczby elementw oddzielonych przecinkami, np.:

>>> t = 12345, 54321, hello!

>>> t[0]
12345
>>> t
(12345, 54321, hello!)
>>> # Krotki mo
zna zagnie
zd
za
c:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, hello!), (1, 2, 3, 4, 5))

Jak widac, krotka pokazywana jest zawsze na wyjsciu w okragych nawiasach, aby jesli zagniezdzone, byy inter-
pretowane poprawnie. Moga byc wprowadzane z lub bez nawiasw, aczkolwiek nawiasy sa niekiedy potrzebne
(np. jezeli krotka jest czescia jakiegos dugiego wyrazenia).
Krotki maja duzo zastosowan, np. jako para wsprzednych (x,y), rekord pracownikw z bazy danych itd. Nie jest
mozliwe przypisanie poszczeglnym elementom takiej listy wartosci, aczkolwiek mozna to zasymulowac poprzez
wycinanie i sklejanie.
Pewien problem z takimi listami pojawia sie jezeli maja zawierac zero lub jeden element: aby osiagn
ac taki efekt
trzeba uzyc lekko pokreconej skadni. Puste krotki tworzone sa przez pusta pare nawiasw okragych;
lista z
jednym elementem poprzez wartosc , po ktrej nastepuje przecinek (nie wystarcza otoczyc pojedyncza wartosc
nawiasami okragymi).
Brzydkie, ale efektywne. Na przykad:
2 ang. evolving
3 ang. tuple

5.3. Listy niemutowalne i sekwencje 33

 >>> pusta = ()
>>> jednoelementowa = hello, # <-- zauwa
zcie przecinek na ko
ncu!
>>> len(pusta)
0
>>> len(jednoelementowa)
1
>>> jednoelementowa
(hello,)

Instrukcja t = 12345, 54321, hello! jest przykadem pakowania krotki: wartosci 12345, 54321 i
hello! pakowane sa do krotki. Operacja odwrotna jest rwniez mozliwa, np.:

>>> x, y, z = t

Takie cos nazywane jest, odpowiednio, krotki. Takie rozpakowywanie wymaga, aby lista zmiennych po lewej
stronie miaa tyle samo elementw, ile dugosc listy niemutowalnej. Zauwazcie, z e takie przypisanie jest kombi-
nacja pakowania i rozpakowywania listy niemutowalnej!
Przez przypadek taka sama operacje mozna powtrzyc dla zwykej listy. Osiagamy
to przez otoczenie listy zmi-
ennych nawiasami kwadratowymi:

>>> a = [w
edzonka, jaja, 100, 1234]
>>> [a1, a2, a3, a4] = a

OBIEKTY MUTOWALNE!
LISTY NIEMUTOWALNEKROTKI MOGA ZAWIERAC

5.4 Sowniki
Innym uzytecznym typem danych w Pythonie jest sownik. Sowniki spotykane sa czasami w innych jezykach
programowania jako pamiec asocjacyjna lub tablice asocjacyjne. W odrznieniu od sekwencji, ktre sa in-
deksowane liczbami, sowniki indeksowane sa kluczami, ktre moga byc obiektami dowolnego, niemutowalnego
typu, np. napisy i liczby zawsze moga byc kluczami. Listy niemutowalne rwniez moga zostac uzyte jako klucze,
jezeli zawieraja napisy, liczby lub listy niemutowalne. Nie mozna uzyc zwykych list jako kluczy, poniewaz
mozna je modyfikowac za pomoca metody append().
Najlepiej wyobrazic sobie sownik jako nieuporzadkowany
zbir par klucz:wartosc , z zaozeniem, z e klucze sa
unikalne (w jednym sowniku). Para nawiasw klamrowych tworzy pusty sownik: {}. Umieszczenie listy par
klucz:wartosc , oddzielonych przecinkami w tych nawiasach dodaje poczatkowe
pary klucz:wartosc do sownika.
w ten sposb sowniki sa wyswietlane na standardowym wyjsciu.
Gwnymi operacjami na sownikach sa wkadanie wartosci z jakims kluczem i wyciaganie wartosci opatrzonej
podanym kluczem. Mozliwe jest usuwanie pary klucz:wartosc za pomoca del. Jezeli prbuje sie przechowac
klucz, ktry istnieje juz w sowniku, poprzednia wartosc zwiazana
z tym kluczem jest zapominana. Bad
powstaje
w wyniku prby pozyskania wartosci spod klucza, ktry nie istnieje w sowniku.
Metoda obiektu sownika keys() zwraca liste wszystkich kluczy uzywanych w sowniku, w porzadku
losowym
(jezeli chce sie uzyskac posortowana liste kluczy, zastosuj po prostu metode sort() na tej liscie). Do
sprawdzenia obecnosci klucza w sowniku suzy metoda has_key().4
Oto may przykad uzycia sownika:
4 posiada klucz? (przyp. tum.)

34 Rozdzia 5. Struktury danych

 >>> tel = {jack: 4098, sape: 4139}
>>> tel[guido] = 4127
>>> tel
{sape: 4139, guido: 4127, jack: 4098}
>>> tel[jack]
4098
>>> del tel[sape]
>>> tel[irv] = 4127
>>> tel
{guido: 4127, irv: 4127, jack: 4098}
>>> tel.keys()
[guido, irv, jack]
>>> tel.has_key(guido)
1

5.5 Jeszcze troche o warunkach

Warunki uzywane w instrukcjach while i if moga zawierac inne operatory, niz poznane dotychczas operatory
porwnania.
Operatory porwnania in oraz not in sprawdzaja czy jakas wartosc pojawia sie lub nie w sekwencji. Operatory
is i is not porwnuja, czy dwa obiekty sa w rzeczywistosci tymi samymi obiektami: ma to znaczenie tylko dla
przypadkw obiektw mutowalnych, takich jak listy. Wszystkie operatory porwnania maja taki sam priorytet,
ktry jest nizszy niz priorytet wszystkich operatorw numerycznych.
Porwnania moga byc sklejane w jeden ancuch, np. a < b == c sprawdza czy a jest mniejsze niz b i ponadto
czy b jest rwne c.
Porwnania moga byc aczone
operatorami logicznymi: and i or, a wynik porwnania (lub kazdego innego
wyrazenia logicznego) moze byc zanegowany poprzez not. Wszystkie, wyzej wymienione operatory maja nizszy
priorytet od priorytetu operatorw porwnania, aczkolwiek not ma wyzszy priorytet od or. Tak wiec A and
not B or C sa odpowiednikiem (A and (not B) )or C. Oczywiscie, zawsze mozna uzyc nawiasw,
a kolejnosc .
aby wyrazic pozadan
Operatory logiczne and i or sa tzw. operatorami skrtu5 . Ich argumenty ewaluowane sa od lewej do prawej, a
ewaluacja jest przerywane w momencie okreslenia ostatecznego wyniku. Np.: jezeli A i C sa prawdziwe ale B jest
faszywe, A and B and C nie ewaluuje wyrazenia C. W oglnosci, wartosc jaka zwraca operator skrtu jest
ostatnim ewaluowanym argumentem, gdy uzywana jest jako wartosc oglna a nie logiczna6
Mozliwe jest przypisanie wyniku porwnania lub innego wyrazenia logicznego do zmiennej. Na przykad:

>>> napis1, napis2, napis3 = , Trondheim, Hammer Dance

>>> nie_pusty = napis1 or napis2 or napis3
>>> nie_pusty
Trondheim

Zauwazcie, z e w Pythonie, odmiennie niz w C, przypisanie nie moze pojawic sie w srodku wyrazenia. Programisci
C moga sie na to zzymac, ale w ten sposb mozna uniknac powszechnego problemu spotykanego w C: piszac =
w wyrazeniu, kiedy zamierzao sie napisac ==.

5.6 Porwnanie sekwencji i innych typw

Sekwencje moga byc porwnane z innymi obiektami tego samego typu sekwencyjnego. Porwnanie stosuje
porzadek
leksykograficzny: na poczatku
porwnywane sa pierwsze dwa elementy, a jezeli sie rznia to wynik
5 ang. shortcut operators
6 Czy ktos moze to wyjasnic lepiej? (przyp. tum.)

5.5. Jeszcze troche o warunkach 35

porwnania jest juz okreslony. Jezeli sa rwne, do porwnania brane sa nastepne dwa elementy itd., az do wycz-
erpania sekwencji. Jezeli porwnywane elementy sa tego samego typu sekwencyjnego, porwnanie leksyko-
graficzne przeprowadzane jest na nich rekursywnie. Jezeli wszystkie elementy okaza sie rwne, sekwencje
uwazane sa za rwne. Jezeli jedna sekwencja jest poczatkowym podzbiorem drugiej, to krtsza sekwencja
jest mniejsza od duzszej. Leksykograficzny porzadek napisw ustanowiony jest za pomoca porzadku
ASCII dla
poszczeglnych znakw. Oto pare przykadw relacji porwnania pomiedzy sekwencjami tego samego typu:
(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
ABC < C < Pascal < Python
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, (aa, ab)) < (1, 2, (abc, a), 4)

Zauwazcie, z e mozna porwnywac obiekty rznych typw. Wynik takiego porwnania jest powtarzalny
lecz arbitralny: typy sa porzadkowane
wg swoich nazw. Tak wiec lista jest zawsze mniejsza niz napis
(list<string), a napis jest zawsze mniejszy niz lista niemutowalna (string<tuple), itd. Typy
liczbowe mieszane porwnywane sa wg ich wartosci numerycznej, tak wiec 0 rwne jest 0.0, etc.7

7 Nie powinno sie polegac na powyzszej zasadzie porwnywania rznych typw: moze sie ona zmienic w przyszych wersjach jezyka.

36 Rozdzia 5. Struktury danych

 ROZDZIA

SZSTY

Moduy

W chwili gdy zakonczy sie prace w interpreterze Pythona i ponownie rozpocznie, wszystkie definicje, ktre
wprowadzono (funkcje i zmienne) zostaja stracone. Dlatego tez, jesli chce sie napisac z dziebko duzszy pro-
gram, lepiej bedzie gdy uzyje sie edytora tekstw do przygotowania polecen dla interpretera i uruchomi go z
przygotowanym plikiem na wejsciu. Nazywa sie to tworzeniem skryptu1 W miare jak twj program staje sie
duzszy, zajdzie koniecznosc podzielenia go na kilka plikw w celu atwiejszej pielegnacji 2 caosci. Bedziesz
chcia rwniez uzyc funkcji, ktre wasnie napisaes w paru innych programach bez potrzeby wklejania ich w
kazdy program z osobna.
Python wspomoze te dziaania poprzez pewien sprytny mechanizm umieszczania definicji w pliku i uzywania ich
w skrypcie lub w interaktywnej postaci interpretera. Taki plik nazywany jest moduem: definicje z moduu moga
byc importowane do innych moduw lub do gwnego moduu (zestaw zmiennych, ktrych uzywaes w skrypcie
wykonywanym na najwyzszym poziomie i w trybie kalkulatora).
Modu jest plikiem zawierajacym
definicje Pythona i jego instrukcje. Nazwa pliku jest nazwa moduu pozbaw-
ionego rozszerzenia .py. W module, nazwa moduu dostepna jest jako wartosc zmiennej globalnej __name__.
Na przykad, uzyj swojego ulubionego edytora tekstw3 i stwrz plik o nazwie fibo.py. Umiesc go w biezacym

katalogu z nastepujac
a zawartoscia:

# Modu liczb Fibonacciego

def fib(n): # wypisz ciag

Fibonacciego a
z do n
a, b = 0, 1
while b < n:
print b,
a, b = b, a+b

def fib2(n): # zwr

c ciag
Fibonacciego a
z do n
wybik = []
a, b = 0, 1
while b < n:
wynik.append(b)
a, b = b, a+b
return wynik

Teraz, po uruchomieniu interpretera Pythona mozna zaimportowac ten modu za pomoca nastepujacego
polecenia:
>>> import fibo

W ten sposb nie zaimportuje sie nazw funkcji zdefiniowanych w module fibo wprost do biezacej
tablicy sym-
boli: to polecenie wprowadza tylko nazwe fibo do tej tablicy. Aby dostac sie do owych funkcji, trzeba uzyc
nazwy moduu:
1 To czy nazwa skrypt brzmi mniej powaznie od nazwy program jest sprawa gustu. . . (przyp. tum.)
2 ang. maintenance (przyp. tum.)
3 Niesmiertelne favorite text editor. . . (przyp. tum.)

37
 >>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
fibo

Jezeli chce sie uzywac funkcji czesto, mozna przypisac jej lokalna nazwe:

>>> fib = fibo.fib

>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

6.1 Ciag
dalszy o moduach
Modu moze zawierac instrukcje wykonywalne obok definicji funkcji. Instrukcje te maja na celu inicjalizacje
moduu. Wykonywane sa tylko w chwili importowania moduu po raz pierwszy, gdzies w programie.4
Kazdy z moduw posiada swoja prywatna tablice symboli, ktra uzywana jest przez wszystkie funkcje zdefin-
iowane w module jako globalna tablica symboli. W ten sposb, autor moduu moze uzywac w nim zmiennych
globalnych bez koniecznosci martwienia sie o przypadkowy konflikt nazwy wystepujacej
w module z nazwa glob-
alna zdefiniowana w programie uzytkownika. Z drugiej jednak strony, jezeli wiesz co robisz, mozna wpyna
c na
globalna zmienna moduu za pomoca takiej samej notacji, jakiej uzylismy poprzednio, aby uzyc wprost nazwy
funkcji z moduu: nazwa_modulu.nazwa_elementu.
Moduy moga importowac inne moduy. Zazwyczaj, acz nie jest to wymagane, wszystkie instrukcje import
umieszczane sa na poczatku
moduu (lub skryptu). Nazwy zaimportowanych moduw umieszczane sa w global-
nej tablicy symboli importujacych
moduw.
Istnieje wariant instrukcji import, ktra importuje nazwy z moduu wprost do tablicy symboli moduw impor-
tujacych.
Na przykad:
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Ta konstrukcja nie wprowadza nazwy moduu, z ktrego importujemy, do lokalnej tablicy symboli (tak wiec, w
tym przykadzie fibo nie jest zdefiniowane).
Jest tez pewien wariant, ktry importuje wszystkie nazwy z moduu:

>>> from fibo import *

>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Ten mechanizm pozwala zaimportowac wszystkie nazwy z wyjatkiem

tych, ktre zaczynaja sie od znaku pod-
kreslenia (_).

6.1.1 zka poszukiwan moduw

Scie

Gdy modu o nazwie pomyje jest importowany, interpreter poszukuje pliku o nazwie pomyje.py w bieza-
cym katalogu, nastepnie w katalogach okreslonych przez zmienna systemowa $PYTHONPATH. Zmienna ta ma
4 Tak naprawd e, definicja funkcji jest takze instrukcja,
ktra jest wykonywana. Wykonanie to powoduje wprowadzenie nazwy funkcji
do globalnej tablicy symboli moduu.

38 Rozdzia 6. Moduy
taka sama skadnie co zmienna $PATH, tzn. jest lista katalogw. W przypadku, gdy $PYTHONPATH nie jest
okreslona, lub gdy plik nie jest znaleziony w katalogach tam wymienionych, poszukiwanie kontynuowane jest na
sciezkach ustawionych w momencie instalacji: na U NIKSIE jest to zazwyczaj .:/usr/local/lib/python.
Na samym koncu, moduy poszukiwane sa na liscie katalogw umieszczonych w zmiennej pythonowej
sys.path, ktra inicjalizowana jest nazwami katalogu zawierajacego
skrypt wejsciowy (lub z biezacego
kat-
alogu), zawartoscia zmiennej $PYTHONPATH i domyslnymi katalogami instalacyjnymi. W ten sposb zmyslne
programy w Pythonie moga modyfikowac a nawet zastepowac sciezke poszukiwan moduw. Zobacz pzniej
podrozdzia na temat standardowych moduw.

6.1.2 Skompilowane pliki Pythona

Waznym czynnikiem przyspieszenia rozruchu dla maych programw, ktre uzywaja mnstwo standardowych
moduw jest obecnosc pliku pomyje.pyc. W pliku tym zawarta jest skompilowana juz bajt-kodowa5 wersja
moduu spam. Czas modyfikacji wersji pliku pomyje.py, z ktrego powsta pomyje.pyc, jest zarejestrowany
w tymze ostatnim. Plik .pyc jest ignorowany, jezeli oba te czasy nie pasuja do siebie6
W normalnych warunkach, nie trzeba zrobic nic szczeglnego, aby utworzyc plik pomyje.pyc. Kiedykolwiek
pomyje.py zostao pomyslnie skompilowane, interpreter usiuje zapisac skompilowana wersje do pomyje.pyc.
Nie ma bedu, jesli zapis sie nie powiedzie. Jezeli z jakiegokolwiek powodu plik ten nie zosta zapisany, to
pomyje.pyc zostanie rozpoznane jako niepoprawny i zignorowany. Zawartosc pomyje.pyc jest niezalezna od
platformy, tak wiec katalog moduw moze byc dzielony pomiedzy maszynami o rznej architekturze.7
Pare wskazwek dla ekspertw:

Gdy interpreter Pythona wywoany zosta z flaga -O, wygenerowany zostanie zoptymalizowany kod i
umieszczony w plikach .pyo. Obecnie, optymalizator nie robi z adnych rewelacyjnych rzeczy: usuwa
tylko instrukcje assert i instrukcje SET_LINENO. Gdy uzywasz -O, cay kod posredni jest optymali-
zowany, pliki .pyc sa ignorowane, a pliki .py kompilowane do zoptymalizowanego kodu posredniego.
Wywoanie interpretera z dwoma flagami -O (-OO) spowoduje optymalizacje kodu, ktra w pewnych przy-
padkach objawi sie w wadliwym dziaaniu programu. Obecnie tylko napisy __doc__ usuwane sa z kodu
posredniego, co objawia sie mniejszymi plikami .pyo. Poniewaz dziaanie niektrych programw moze
zalezec od obecnosci tych zmiennych, powinno sie uzywac tej opcji tylko wtedy gdy jest sie pewnym, co
sie robi.
Program nie dziaa szybciej, gdy czytany jest z pliku .pyc lub .pyo, w porwnaniu gdy czytany jest z
pliku .py: jedyne co jest szybsze, to predkosc adowania plikw.
W przypadku gdy nazwa skryptu podana jest w linii polecen, kod posredni dla niego nigdy nie zostanie
zapisany w pliku .pyo. Tak wiec, czas rozruchu skryptu moze byc zredukowany poprzez przesuniecie
wiekszosci kodu do moduw, pozostawiajac
may skrypt rozruchowy importujacy
te moduy.
Mozliwe jest posiadanie pliku pomyje.pyc (lub pomyje.pyo gdy uzywasz -O) bez moduu pomyje.py.
Ma to zastosowanie w przypadku dystrybucji bibliotek Pythona w formie, ktra ma sprawic trudnosci w
procesie reverse engineering.
Modu compileall moze zostac uzyty do stworzenia plikw .pyc (lub .pyo gdy uzyto -O) dla wszys-
tkich moduw z podanego katalogu.

6.2 Moduy standardowe

Python dostarczany jest z biblioteka standardowych moduw, ktre opisane sa w osobnym dokumencie: Opis
biblioteki Pythona (inaczej Opis biblioteki). Niektre moduy wbudowane sa w interpreter: sa one z rdem tych
8 jezyka, lecz pomimo tego zostay wbudowane albo z powodu wydajnosci, lub
operacji, ktre nie sa czescia jadra
5 ang. byte-coded
6 Innymi sowy: uzywany jest .pyc jesli data modyfikacji .py jest wczesniejsza od daty modyfikacji .pyc(przyp. tum.)
7 Zazwyczaj wersje interpretera musza by c tes same (przyp. tum.)
8 ang. core (przyp. tum.)

6.2. Moduy standardowe 39

aby wprowadzic dostep do podstawowych operacji systemu operacyjnego, np. funkcje systemowe. To co zostao
wbudowane w interpreter, jest kwestia opcji instalacji, tzn. modu ameba dostarczany jest tylko na te systemy,
ktre w pewien sposb wspomagaja podstawowe operacje Ameby. Jeden z moduw wbudowanych zasuguje
na szczeglna uwage: sys, ktry jest wbudowany w niemal kazdy interpreter Pythona. Zmienne sys.ps1 i
sys.ps2 definiuja napisy uzywane jako pierwszy i drugi znak zachety:

>>> import sys

>>> sys.ps1
>>>
>>> sys.ps2
...
>>> sys.ps1 = C>
C> print Yuck!
Yuck!
C>

Zmienne te dostepne sa tylko w trybie interakcyjnym interpretera.

Zmienna sys.path jest lista napisw, ktre decyduja o sciezce poszukiwan moduw przez interpreter. Domysl-
nie inicjowane sa zawartoscia zmiennej systemowej $PYTHONPATH lub wbudowanymi domyslnymi katalogami
poszukiwan, jesli $PYTHONPATH nie istnieje. Mozna modyfikowac sys.path poprzez standardowe operacje
na listach:

>>> import sys

>>> sys.path.append(/ufs/guido/lib/python)

6.3 Funkcja dir()

Funkcja wbudowana dir() suzy do znajdywania wszystkich nazw, ktre sa zdefiniowane w module. Zwraca
ona posortowana liste napisw:

>>> import fibo, sys

>>> dir(fibo)
[__name__, fib, fib2]
>>> dir(sys)
[__name__, argv, builtin_module_names, copyright, exit,
maxint, modules, path, ps1, ps2, setprofile, settrace,
stderr, stdin, stdout, version]

Wywoana bez argumentw dir() zwrci liste nazw, ktre wasnie zdefiniowaes:

>>> a = [1, 2, 3, 4, 5]
>>> import fibo, sys
>>> fib = fibo.fib
>>> dir()
[__name__, a, fib, fibo, sys]

Zauwaz, z e zwrcona zostaa lista wszystkich typw nazw: zmiennych, moduw, funkcji, itd.
dir() nie poda listy nazw funkcji i zmiennych wbudowanych. Jesli chce sie uzyskac taka liste, to posuz sie
standardowym moduem __builtin__:

40 Rozdzia 6. Moduy
 >>> import __builtin__
>>> dir(__builtin__)
[AccessError, AttributeError, ConflictError, EOFError, IOError,
ImportError, IndexError, KeyError, KeyboardInterrupt,
MemoryError, NameError, None, OverflowError, RuntimeError,
SyntaxError, SystemError, SystemExit, TypeError, ValueError,
ZeroDivisionError, __name__, abs, apply, chr, cmp, coerce,
compile, dir, divmod, eval, execfile, filter, float,
getattr, hasattr, hash, hex, id, input, int, len, long,
map, max, min, oct, open, ord, pow, range, raw_input,
reduce, reload, repr, round, setattr, str, type, xrange]

6.4 Pakiety
Pakiety sa sposobem na ustrukturalnienie przestrzeni nazw moduw Pythona poprzez uzywanie krop-
kowanych nazw moduw. Na przykad, nazwa moduu A.B oznacza modu skadowy B pakietu A. Tak
samo jak uzywanie moduw zaoszczedza autorom rznych moduw martwienia sie o konflikt nazw globalnych,
tak samo uzywanie kropkowanych nazw moduw zaoszczedza autorom wielomoduowych pakietw jak NumPy
lub Python Imaging Library martwienia sie nazwy swoich moduw.
Zazmy, z e chce sie zaprojektowac zbir moduw (pakiet) suzacy do jednolitej obsugi plikw i danych
dzwiekowych. Istnieje mnstwo formatw zapisu dzwieku (zwykle rozpoznawane po rozszerzeniu plikw, np.
.wav, .aiff, .au), co spowoduje, z e moze bedziesz musia stworzyc i utrzymywac zwiekszajac a sie kolekcje
moduw konwersji pomiedzy rznymi formatami plikw. Jest rwniez duzo rznych operacji, ktre mozna
przeprowadzic na danych dzwiekowych (np. miksowanie, dodawanie pogosu, zastosowanie funkcji equalizera,
tworzenie sztucznego efektu stereo), tak wiec, konczac juz, bedziesz pisa niekonczacy
sie strumien moduw do
wykonywania tych operacji. Ponizej przedstawiono jedna z mozliwych struktur takiego pakietu (wyrazona ona
jest w postaci hierarchicznego drzewa, na podobienstwo systemu plikw):

Sound/ Pakiet szczytowy

__init__.py Inicjalizacja pakietu do obsugi d
zwi
eku
Formats/ Moduy skadowe do konwersji plikw
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
Effects/ Pakiet skadowy z efektami d
zwi
ekowymi
__init__.py
echo.py
surround.py
reverse.py
...
Filters/ Pakiet skadowy z operacjami filtrowania
__init__.py
equalizer.py
vocoder.py
karaoke.py
...

Plik __init__.py sa wymagane, aby zmusic Pythona do traktowania katalogw jako zawierajace pakiety. Jest to
konieczne, aby uchronic katalogi z powszechnie spotykanymi nazwami, takie jak string, od niezamierzonego
ukrycia poprawnych moduw, ktre pojawia sie pzniej na sciezce poszukiwan moduw. W najprostszym przy-
padku, plik __init__.py moze byc pustym plikiem, ale moze tez zawierac pewien kod do wykonania, lub ustawiac

6.4. Pakiety 41
wartosc zmiennej __all__, opisana pzniej.
Uzytkownicy tego pakietu moga importowac poszczeglne moduy, np.:
import Sound.Effects.echo

To spowoduje zaadowanie moduu skadowego Sound.Effects.echo. Pzniej, trzeba uzywac go za pomoca

penej nazwy, tzn.
Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4)

Alternatywnym sposobem importowania moduu skadowego jest:

from Sound.Effects import echo

W ten sposb rwniez zaadujemy modu skadowy echo ale sprawimy, z e dostepny jest z nazwa niezawierajac
a
nazwy pakietu rodzicielskiego:

echo.echofilter(input, output, delay=0.7, atten=4)

Inna wariacja na ten temat jest zaimportowanie wprost z adanej

funkcji:

from Sound.Effects.echo import echofilter

W ten sposb ponownie adujemy modu skadowy echo, lecz jego funkcja echofilter() jest dostepna
wprost:

echofilter(input, output, delay=0.7, atten=4)

Zauwaz, z e kiedy uzywa sie from pakiet import element, element moze byc moduem skadowym (lub
pakietem skadowym) lub inna nazwa zdefiniowana dla tego pakietu jak funkcja, klasa czy zmienna. In-
strukcja import najpierw sprawdza, czy element jest zdefiniowany w pakiecie; jesli nie, zakada sie, z e jest
to modu i poczynione sa starania o jego zaadowanie. Jesli nie zostanie on znaleziony, zgaszany jest wyjatek

ImportError.
W przeciwienstwie do tego, jesli uzywa sie skadni import element.element_skladowy.kolejny_element_skladowy,
kazdy element z wyjatkiem
ostatniego musi byc pakietem: ostatni element moze byc moduem lub pakietem ale
nie klasa, funkcja lub zmienna zdefiniowana w poprzednim elemencie.

6.4.1 Importowanie * z pakietu

A teraz, co sie stanie, kiedy uzytkownicy napisza from Sound.Effects import *? Ktos mgby
pomyslec naiwnie, z e ta instrukcja w jakis sposb wychodzi do systemu plikw, znajduje wszystkie pliki z mod-
uami skadowymi, ktre sa obecne w pakiecie-katalogu i wszystkie je importuje. Niestety, taka operacja nie
dziaa zbyt dobrze na macintoshach i w Windows, gdzie system plikw nie zawsze wyposazony jest w dokadna
informacje na temat wielkosci liter w nazwach!9 Na tych platformach nie ma sposobu dowiedzenia sie, czy plik
ECHO.PY powien byc zaimportowany jako modu echo, Echo czy ECHO (np. Windows 95 ma denerwujacy
zwyczaj pokazywania nazw plikw z pierwsza duza litera). Ograniczenie DOS-a (8+3 znaki na nazwe pliku)
dodaje jeszcze jeden interesujacy problem do tej listy jezeli chodzi o dugie nazwy moduw.
Jedynym wyjsciem dla autora takiego pakietu jest dostarczenie wprost indeksu jego czesci skadowych. Instrukcja
importu posuguje sie nastepujac a konwencja:
jezeli kod pakietu __init__.py zdefiniuje liste o nazwie __all__,
to przyjmuje sie, z e zawiera ona nazwy wszystkich moduw importowanych za pomoca instrukcji from pakiet
import *. Zadaniem autora pakietu jest utrzymywanie stanu tej listy na biezaco, w chwili gdy wypuszczane sa
9 Ten wykrzyknik powinien sie tu pojawic! (przyp. tum.)

42 Rozdzia 6. Moduy
nowe wersje pakietu. Autorzy pakietw moga rwniez nie dostarczac tej listy, jesli nie widza sensu z importowania
* z ich pakietu. Na przykad plik Sound/Effects/__init__.py mgby zawierac nastepujacy kod:
__all__ = ["echo", "surround", "reverse"]

Znaczyoby to, z e from Sound.Effects import * zaimportuje trzy moduy skadowe z pakietu Sound.
Jesli __all__ nie jest zdefinowana, instrukcja from Sound.Effects import * nie zaimportuje wszys-
tkich moduw skadowych z pakietu Sound.Effects do biezacej przestrzeni nazw: upewni sie tylko, czy
pakiet Sound.Effects zosta zaimportowany (z mozliwym wykonaniem kodu z pliku __init__.py) a potem
zaimportuje wszystkie nazwy zdefiniowane w tym pakiecie. Wchodza w nie nazwy zdefiniowane (i moduy skad-
owe zaadowane wprost) w pliku __init__.py oraz moduy skadowe pakietu zaadowane wprost przez poprzed-
nie instrukcje importu, tzn.

import Sound.Effects.echo
import Sound.Effects.surround
from Sound.Effects import *

W tym przykadzie moduy echo i sorround importowane sa do biezacej

przestrzeni nazw poniewaz sa zdefin-
iowane w pakiecie Sound.Effects, gdy wykonywany jest from...import (dziaa to rwniez, gdy zdefin-
iowano __all__).
Trzeba tu zauwazyc, z e stosowanie importowania * z moduu lub pakietu idzie powoli w odstawke, poniewaz
czesto powoduje nieczytelny kod. Jest oczywiscie w porzadku,
gdy stosuje sie te formue, aby zaoszczedzic
troche na klepaniu klawiszami w trybie interaktywnym i gdy pewne moduy sa zaprojektowane tak, z e eksportuja
tylko nazwy odpowiadajace pewnym schematom.
Trzeba pamietac, z e nie ma nic zego w uzywaniu formuy from Pakiet import pewien_modul! Was-
ciwie, ta notacja jest zalecana, chyba z e modu importujacy
uzywa moduw skadowych o takiej samej nazwie z
paru rznych pakietw.

6.4.2 Odniesienia pomiedzy

pakietami

Czesto zachodzi wymg odniesienia sie jednego moduu do drugiego. Na przykad, modu sorround moze
uzywac moduu echo. W rzeczywistosci, jest to tak czesto spotykane, z e instrukcja import poszukuje najpierw
w zawierajacym
ja pakiecie, zanim przejdzie na standardowa sciezke poszukiwan. Tak wiec, modu sorround
moze uzyc zwykego import echo lub from echo import echofilter. Jesli importowany modu
nie zostanie znaleziony w biezacym
pakiecie (w ktrym biezacy
modu jest moduem skadowym), instrukcja
import szuka w szczytowym module o podanej nazwie.
Kiedy pakiety posiadaja skadowe pakiety (tak jak Sound w naszym przykadzie), nie istnieje skrt, aby odniesc
sie do moduu skadowego pakietw skadowych trzeba uzyc penej nazwy pakietu skadowego. Na przykad,
jesli modu Sound.Filters.vocoder musi uzyc moduu echo z pakietu Sound.Effects, moze zas-
tosowac from Sound.Effects import echo.

6.4. Pakiety 43
44
 ROZDZIA

SIDMY

Wejscie i wyjscie

Istnieje pare sposobw na prezentacje wynikw dziaania programu: dane moga zostac wydrukowane w czytelny
sposb, lub zapisane do pliku w celu ponownego uzycia. Ten rozdzia omawia pare z tych mozliwosci.

7.1 adniejsze formatowanie wyjscia

Jak dotad
spotkalismy sie z dwoma sposobami wypisywania wartosci: instrukcje wyrazenia i instrukcja print
(trzecim sposobem jest metoda write() nalezaca do obiektu pliku. Standardowym obiektem standardowego
pliku wyjsciowego jest sys.stdout. Poszukaj w Opisie biblioteki wiecej informacji na ten temat).
Czesto chce sie miec wiekszy wpyw na format drukowania wyniku, niz proste wiersze wartosci oddzielonych
spacjami. Istnieja dwa sposoby formatowania wyniku. Pierwszym jest przejecie na wasna odpowiedzialnosc
wszelkich czynnosci zwiazanych
z napisami: uzywa sie wycinania napisw i sklejania w ten sposb, z e tworzy sie
taki format wydruku, jaki przyjdzie do gowy. Standardowy modu string zawiera pare uzytecznych operacji na
napisach, jak rozszerzanie napisw do z adanej
szerokosci kolumny itd. Opiszemy to po krtce. Drugim sposobem
jest uzycie operatora % z napisem jako lewy argument. Operator % interpretuje lewy argument w podobny sposb
jak funkcja C sprintf():, jak format stylu, ktry zostanie zastosowany do argumentw po prawej stronie tego
operatora, a wynik zwracany jest w postaci napisu.
Oczywiscie, pozostaje jedno pytanie:, jak przeksztaca sie wartosci w napisy? Na szczescie, Python zna sposb,
aby przeksztacic dowolna wartosc w napis: funkcja repr() lub umieszczenie wartosc i pomiedzy odwrotnymi
apostrofami (). Oto pare przykadw:

>>> x = 10 * 3.14
>>> y = 200*200
>>> s = Wartoscia x jest + x + , a y jest + y + ...
>>> print s
Warto
scia x jest 31.4, a y jest 40000...
>>> # Odwrotne apostrofy dziaaja tak ze na inne warto
sci ni
z liczby:
... p = [x, y]
>>> ps = repr(p)
>>> ps
[31.4, 40000]
>>> # Przeksztacenie napisu powoduje dodanie apostrofw i uko snikw:
... hello = hello, world\n
>>> hellos = hello
>>> print hellos
hello, world\012
>>> # Argumentem odwrotnych apostrofw mo ze by
c lista niemutowalna:
... x, y, (wedzonka, jaja)
"(31.4, 40000, (w edzonka, jaja))"

Oto dwa sposoby na wypisanie kwadratw i szescianw liczb:

45
 >>> import string
>>> for x in range(1, 11):
... print string.rjust(x, 2), string.rjust(x*x, 3),
... # Zauwa
z przyklejony na ko
ncu przecinek w poprzednim wierszu
... print string.rjust(x*x*x, 4)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> for x in range(1,11):
... print %2d %3d %4d % (x, x*x, x*x*x)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

(Spacje pomiedzy kolumnami zostay dodane przez instrukcje print: zawsze dodaje spacje pomiedzy argumen-
tami.)
Ten przykad demonstruje funkcje string.rjust(), ktra justuje do prawej napis w polu o podanej szerokosci
poprzez dodanie spacji z lewej strony. Podobna do niej sa funkcje string.ljust() i string.center().
Funkcje te niczego nie wypisuja, po prostu zwracaja nowy napis. Jezeli napis wejsciowy jest zbyt duzy, nie skra-
caja go, lecz zwracaja nietkniety. Pomiesza to troche w wygladzie
kolumn ale zwykle jest to lepsza alternatywa od
pokazywania faszywej wartosci (jesli naprawde chce sie skrcic napis mozna zawsze dodac operacje wycinania,
np. string.ljust(x, n)[0:n]).
Istnieje tez inna funkcja, mianowicie string.zfill(), ktra uzupenia z lewej strony napis numeryczny
zerami. Rozumie ona znaki plus i minus:
>>> import string
>>> string.zfill(12, 5)
00012
>>> string.zfill(-3.14, 7)
-003.14
>>> string.zfill(3.14159265359, 5)
3.14159265359

Uzycie operatora % wyglada

nastepujaco:

>>> import math

>>> print Wartoscia PI jest w przybli
zeniu %5.3f. % math.pi
Warto
scia PI jest w przyblizeniu 3.142.

Jezeli podano wiecej niz jeden format w napisie, jako prawy operand podaje sie krotke wartosci, np.:

46 Rozdzia 7. Wejscie i wyjscie

 >>> tabela = {Sjoerd: 4127, Jack: 4098, Dcab: 7678}
>>> for nazwa, telefon in tabela.items():
... print %-10s ==> %10d % (nazwa, telefon)
...
Jack ==> 4098
Dcab ==> 7678
Sjoerd ==> 4127

Wiekszosc formatw dziaa dokadnie tak samo jak w C i wymaga podania wasciwego typu, aczkolwiek jezeli
nie zastosuje sie do tego, to w wyniku dostaje sie wyjatek,
a nie zrzut obrazu pamieci1 i przerwanie dziaania
programu. Format %s jest bardziej tolerancyjny: jezeli odpowiadajacy
mu argument nie jest napisem, przekszta-
cany jest w napis za pomoca wbudowanej funkcji str(). Mozna uzyc * do podania szerokosci lub precyzji w
oddzielnym (liczba cakowita) argumencie. Formaty C %n i %p nie sa obsugiwane.
Jesli posiadasz juz naprawde dugi napis formatujacy,
ktrego nie chce sie dzielic, mio by byo odnosic sie wprost
do zmiennych bedacych formatowanymi, zamiast do ich pozycji na liscie argumentw. Mozna to osiagn
a c poprzez
uzycie rozszerzenia w stosunku do formatw C w formie %(nazwa)format, tzn.:
>>> tabela = {Sjoerd: 4127, Jack: 4098, Dcab: 8637678}
>>> print Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d % tabela
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Jest to szczeglnie uzyteczne w poaczeniu

z nowa funkcja wbudowana vars(), ktra zwraca sownik zawiera-
jacy
wszystkie zmienne lokalne.

7.2 Czytanie z i pisanie do plikw

open() zwraca obiekt pliku i powszechnie uzywana jest z dwoma argumentami: open(nazw_pliku, tryb).

>>> f=open(/tmp/workfile, w)
>>> print f
<open file /tmp/workfile, mode w at 80a0960>

Pierwszym argumentem jest napis zawierajacy nazwe pliku. Drugim jest nastepny napis zawierajacy pare znakw
opisujacych
sposb uzycia pliku. tryb zawiera r, kiedy plik bedzie tylko czytany2 , w, gdy bedzie odbywao
sie wyacznie
pisanie do pliku (istniejacy
plik o tej nazwie zostanie zmazany), a a otwiera plik, do ktrego
mozna dodawac dane: dowolna dana zapisana do pliku bedzie dodana na jego koniec. r+ otwiera plik zarwno
do czytania jak i do pisania. Argument tryb jest opcjonalny: w przypadku jego braku plik zostanie otwarty w
trybie r.
W systemach Windows i na macintoshach dodanie b do tryb powoduje otwarcie pliku w trybie binarnym, tak
wiec mozemy podac tryby rb, wb i r+b. Windows rozrznia pliki tekstowe i binarne: znaki konca
linii w plikach tekstowych sa automatycznie zmieniane, gdy dane sa czytane lub pisane. Taka modyfikacja w
biaych rekawiczkach pliku wydaje sie byc wygodna dla plikw tekstowych zapisanych w kodzie ASCII, ale
zepsuje zawartosc plikw z danymi binarnymi jak np. pliki .EXE. Trzeba byc ostroznym stosujac
tryb binarny
przy czytaniu lub zapisie (trzeba jeszcze dodac, z e dokadne znaczenie trybu tekstowego na macintoshu, zalezy
od zastosowanej biblioteki C).

7.2.1 Metody obiektw pliku

W reszcie przykadw tego podrozdziau zakada sie, z e stworzono juz obiekt pliku o nazwie f.
1 ang. core dump (przyp. tum.)
2 ang. read-only (przyp. tum.)

7.2. Czytanie z i pisanie do plikw 47

Uzyj f.read(ile), aby przeczytac jaka s liczbe danych i dostac je w postaci napisu. ile jest opcjonalnym argu-
mentem liczbowym. Kiedy ile jest pominiete lub ujemne, caa zawartosc pliku zostanie przeczytana i zwrcona:
to twj problem, jesli wielkosc czytanego pliku dwukrotnie przewyzsza wielkosc pamieci twojego komputera.
W przypadku przeciwnym, co najwyzej ile bajtw zostanie przeczytanych i zwrconych. Jesli osiagni eto koniec
pliku, f.read() zwrci pusty napis ().

>>> f.read()
To jest cay plik.\012
>>> f.read()

f.readline() czyta z pliku pojedynczy wiersz. Znak nowej linii (\n) umiejscowiony jest na lewym koncu
napisu i zostaje pominiety tylko w wypadku ostatniego wiersza pod warunkiem, z e plik nie konczy sie znakiem
nowego wiersza. Powoduje to powstanie niejednoznacznosci w zwracanym napisie: jezeli f.readline()
zwrci pusty napis osiagn
elismy koniec pliku, podczas gdy pusta linia reprezentowana przez \n, tzn. napis
zawierajacy
tylko znak nowej linii.
>>> f.readline()
To jest pierwsza linia pliku.\012
>>> f.readline()
Druga linia pliku.\012
>>> f.readline()

f.readlines() stosuje f.readline() w sposb ciagy

i zwraca liste napisw reprezentujacych
wszystkie
wiersze z pliku.

>>> f.readlines()
[To jest pierwsza linia pliku.\012, Druga linia pliku.\012]

f.write(napis) zapisuje zawartosc napisu do pliku zawracajac

None.
>>> f.write(To jest test\n)

f.tell() zwraca liczbe cakowita oznaczajac a biezac

a pozycje w pliku mierzona w bajtach, liczac
od poczatku

pliku. Aby zmienic te pozycje uzyj f.seek(przesuniecie, od_czego). Nowa pozycja obliczana jest poprzez
dodanie przesuniecie do punktu odniesienia, a ten z kolei wyznaczony jest przez wartosc argumentu od_czego.
Wartosc od_czego rwna 0 oznacza poczatek pliku, 1 oznacza biezac a pozycje, a 2 to koniec pliku. od_czego
moze zostac pominiete i domyslnie przyjmowane jest jako 0, uzywajac jako punktu odniesienia poczatek pliku.

>>> f=open(/tmp/workfile, r+)

>>> f.write(0123456789abcdef)
>>> f.seek(5) # Id
z do 5 bajtu w pliku
>>> f.read(1)
5
>>> f.seek(-3, 2) # Id
z do 3 bajtu od ko
nca pliku
>>> f.read(1)
d

Jezeli konczy sie prace z plikiem, trzeba wywoac f.close()3 , aby go zamkna
c i zwolnic wszystkie zasoby
systemowe zwiazane
z otwarciem i obsuga tego pliku. Po wywoaniu f.close() wszelkie prby uzycia obiektu
pliku f automatycznie spala na panewce.
3 Metoda ta zostanie wywoana przez interpreter przy ostatecznym niszczeniu obiektu (przyp. tum.)

48 Rozdzia 7. Wejscie i wyjscie

 >>> f.close()
>>> f.read()
Traceback (innermost last):
File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

Obiekty pliku posiadaja dodatkowe metody, takie jak isatty() i truncate(), ktre sa z adziej uzywane.
Aby uzyskac kompletny opis obiektw pliku, siegnij po Opis biblioteki.

7.2.2 Modu pickle

Napisy moga byc w atwy sposb zapisywane i czytane z pliku. Liczby wymagaja troche wiecej zachodu, bowiem
metoda read() zwraca tylko napis, ktry musi byc poddany dziaaniu takiej funkcji jak string.atoi(),
ktra pobiera napis w rodzaju 123 i zwraca wartosc liczbowa 123. W przypadku jednak, gdy chce sie prze-
chowywac w pliku bardziej zozone typy danych jak listy, sowniki lub instancje klas, sprawy sie nieco komplikuja.
Python dostarcza standardowy modu pickle, ktry zaoszczedza uzytkownikom pisania i sledzenia kodu
suzacego
do zachowywania skomplikowanych typw danych. Ten zadziwiajacy 4 modu potrafi wziac na we-
jsciu prawie kazdy obiekt Pythona (nawet pewne formy kodu!) i przeksztacic go w napis. Proces ten zwie
sie marynowaniem5 . Rekonstruowanie obiektu z formy napisowej zwie sie odmarynowaniem6 . Pomiedzy
marynowaniem a odmarynowaniem, napis reprezentujacy obiekt moze zostac zapisany w pliku lub w innej danej,
lub przesany poaczeniem
sieciowym do jakiegos oddalonego komputera.7
Jezeli istnieje obiekt x i obiekt pliku f, ktry zosta otwarty do pisania, to najprostszy sposb zamarynowania
obiektu zajmuje jeden wiersz kodu:
pickle.dump(x, f)

Zakadajac,
z e f jest obiektem pliku, ktry zosta otwarty do czytania, odmarynowanie przebiega nastepujaco:

x = pickle.load(f)

(Istnieja warianty tego mechanizmu uzyteczne w przypadku marynowania wielu obiektw, lub gdy nie chce sie
zapisac danych marynaty w pliku skonsultuj sie z pena dokumentacja dla moduu pickle, ktra znajdziesz
w Opisie biblioteki).
pickle jest standardowym sposobem na uczynienie obiektw Pythona trwaymi i ponownie uzytymi przez
inne programy lub przysze wywoania tego samego programu: technicznym okresleniem tego mechanizmu
jest trwaosc obiektu. Z powodu powszechnego uzycia moduu pickle, wielu autorw piszacych rozsz-
erzenia do Pythona, dba o to, aby nowe typy danych, takie jak macierze, mogy byc poprawnie zamarynowane i
odmarynowane.

4 Skromnosc
ze wszech miar godna podziwu. . . (przyp. tum.)
5 ang. pickling (przyp. tum.)
6 ang. unpickling (przyp. tum.)
7 Wybraem te dwa okreslenia ze wzgl
edu na niesamowity efekt komiczny (przyp. tum.)

7.2. Czytanie z i pisanie do plikw 49

50
 ROZDZIA

SMY

Bedy
i wyjatki

Az do teraz, komunikaty o bedach nie byy czesto wspominane, ale jesli prbowaes uruchamiac wszystkie
przykady prawdopodobnie zobaczyes pare. Istnieja (przy najmniej) dwa rozrznialne rodzaje bedw: bedy
skadni i wyjatki.

8.1 Bedy
skadni
Bedy skadniowe, znane rwniez jako bedy parsingu, sa byc moze najbardziej powszechnym rodzajem zazalen,
ktre otrzymuje sie podczas nauki Pythona:
s
>>> while 1 print Cze c
swiecie
File "<stdin>", line 1
s
while 1 print Cze c
swiecie
^
SyntaxError: invalid syntax

Parser powtarza na wyjsciu obrazliwy dla niego wiersz i wyswietla maa strzake, wskazujac a na na-
jwczesniejszy punkt w wierszu gdzie znaleziono bad. Bad spowodowany zosta (lub przynajmniej wykryty
w) przez skadnik poprzedzajacy strzake: w tym przykadzie, bad
wykryty zosta na sowie kluczowym print,
z powodu braku znaku dwukropka (:) przed ta instrukcja. Nazwa pliku i numer linii sa rwniez wyswietlane,
aby wiedziec, gdzie szukac bedu, w przypadku gdy na wejsciu znajdowa sie skrypt.

8.2 Wyjatki

Nawet gdy wyrazenie jest skadniowo poprawne, moze spowodowac bad podczas prby wykonania go. Bedy
wykryte podczas wykonania nazywane sa wyjatkami i niekoniecznie musza zakonczyc program: za chwile
nauczysz sie jak radzic sobie z nimi w programach Pythona. Wiekszosc wyjatkw
nie jest obsugiwana przez
programy i objawiaja sie w komunikatach o bedzie, jak ponizej:

51
 >>> 10 * (1/0)
Traceback (innermost last):
File "<stdin>", line 1
ZeroDivisionError: integer division or modulo
>>> 4 + szynka*3
Traceback (innermost last):
File "<stdin>", line 1
NameError: szynka
>>> 2 + 2
Traceback (innermost last):
File "<stdin>", line 1
TypeError: illegal argument type for built-in operation

(ZeroDivisionError: dzielenie cakowite lub operacja modulo)

(TypeError: nieprawidowy typ argumentu operacji wbudowanej)
Ostatnia linia komunikatu o bedzie pokazuje co sie stao. Wyjatki
sa rznego typu, i ten typ wyswietlany jest
jako czesc komunikatu. W powyzszym przykadzie tymi typami sa ZeroDivisionError, NameError i
TypeError. Napis wyswietlany jako typ wyjatku jest nazwa wbudowanego w interpreter wyjatku,
ktry sie
wasnie pojawi. Zachodzi to dla wszystkich wyjatkw wbudowanych lecz niekoniecznie jest to prawda dla
wyjatkw
zdefiniowanych przez uzytkownika (jakkolwiek, jest to uzyteczna konwencja). Nazwy standardowych
wyjatkw
sa wbudowanymi identyfikatorami, a nie zastrzezonymi sowami kluczowymi.
Reszta wiersza komunikatu w szczegach opisuje to, co sie stao. Interpretacja i znaczenie tego opisu zalezy od
typu wyjatku.

Pierwsza czesc komunikatu pokazuje kontekst, w jakim wyjatek
sie zdarzy, w postaci sladu ze stosu wywoan.
Oglnie mwiac, kontekst zawiera slady wywoan w postaci wierszy kodu, aczkolwiek nie pokaze wierszy pod-
chodzacych
ze standardowego wejscia.
Opis biblioteki Pythona wyszczeglnia wszystkie wbudowane wyjatki
i przedstawia ich znaczenie.

8.3 Obsuga wyjatkw

Mozliwe jest napisanie programu, ktry obsuguje wybrane wyjatki.
Spjrzmy na przykad ponizej, w ktrym
uzytkownik podaje dane na wejsciu az do momentu, kiedy zostanie wprowadzona poprawna liczba cakowita.
Uzytkownik moze przerwac prace (poprzez nacisniecie Control-C lub dowolny sposobem, jaki jest mozliwy
poprzez klawiature w danym systemie operacyjnym). Przerwanie uzytkownika sygnalizowane jest poprzez
zgoszenie wyjatku
KeyboardInterrupt.
>>> while 1:
... try:
... x = int(raw_input("Prosz
e wprowadzi
c liczb
e: "))
... break
... except ValueError:
... print "Uch! to nie jest poprawna liczba! Sprbuj jeszcze raz..."
...

Oto jak dziaa instrukcja try:

Na poczatku
wykonywana jest klauzula try (czyli instrukcje pomiedzy try a except).
Jezeli nie pojawi sie z aden wyjatek
klauzula except jest pomijana. Wykonanie instrukcji try uwaza sie za
zakonczone.
Jezeli podczas wykonywania klauzuli try pojawi sie wyjatek,
reszta niewykonanych instrukcji jest pomi-
jana. Nastepnie, w zaleznosci od tego, czy jego typ pasuje do typw wyjatkw
wymienionych w czesci
except, wykonywany jest kod nastepujacy w tym bloku, a potem interpreter przechodzi do wykonywania
instrukcji umieszczonych po caym bloku try. . . except.

52 Rozdzia 8. Bedy
i wyjatki

 W przypadku pojawienia sie wyjatku,
ktry nie zostanie dopasowany do z adnego z wyjatkw
wymienionych
w klauzuli except, zostaje on przekazany do do nastepnych, zewnetrznych instrukcji try. Jezeli rwniez
tam nie zostanie znaleziony odpowiadajacy
mu blok except, wyjatek ten nie zostanie wyapany, stanie
nieobsuzonym wyjatkiem,
a wykonywanie programu zostanie wstrzymane wraz z pojawieniem sie komu-
nikatu podobnego do pokazanego powyzej.

Aby umozliwic obsuge wielu wyjatkw,

instrukcja try moze posiadac wiecej niz jedna klauzule except. W
takim przypadku, kod dla co najwyzej jednego wyjatku
zostanie wykonany. Kody obsugi wyjatkw wykonywane
sa tylko dla wyjatkw,
im czesci try, a nie w innych, sasiednich
ktre zostay zgoszone w odpowiadajacej
czesciach except. Klauzula except moze zawierac nazwy wielu wyjatkw,
podanych w formie listy otoczonej
1
nawiasami okragymi
:

... except (RuntimeError, TypeError, NameError):

... pass

W ostatniej podanej klauzuli except mozna pomina c nazwe lub nazwy wyjatkw
w celu obsuzenia dowolnego
wyjatku.
Nalezy posugiwac sie ta konstrukcja bardzo ostroznie, poniewaz jest to sposb do atwego zamaskowa-
nia prawdziwego wystapienia
bedu w programie! Mozna jej rwniez uzyc do wydrukowania komunikatu o
bedzie i ponownie zgosic wyapany wyjatek (umozliwiajac w ten sposb funkcji wywoujacej wyapanie zgos-
zonego wyjatku):

import string, sys

try:
f = open(mjplik.txt)
s = f.readline()
i = int(string.strip(s))
except IOError, (errno, strerror):
print "Bad
I/O (%s): %s" % (errno, strerror)
except ValueError:
print "Nie moge przeksztaci
c danej w liczb
e cakowita."

except:
print "Nieobsugiwany bad:",
sys.exc_info()[0]
raise

Instrukcja try . . . except wyposazona jest w opcjonalna klauzule else, ktra musi pojawic sie za wszystkimi
podanymi blokami except. Mozna po niej umiescic kod, ktry zostanie wykonany, jezeli nie zostanie zgoszony
wyjatek:

for arg in sys.argv[1:]:
try:
f = open(arg, r)
except IOError:
print nie mog
e otworzy
c pliku, arg
else:
print arg, ma, len(f.readlines()), lini
e/linii
f.close()

Wyjatek moze pojawic sie z przypisana sobie wartoscia, ktra nazywana jest argumentem wyjatku. Obecnosc tej
wartosci i jej typ zalezy od rodzaju wyjatku.
Jezeli chce sie poznac te wartosc , nalezy podac nazwe zmiennej (lub
liste zamiennych) za nazwa typu wyjatku
w klauzuli except:
1 Czyli w formie krotki (przyp. tum.).

8.3. Obsuga wyjatkw

53
 >>> try:
... szynka()
... except NameError, x:
... print nazwa, x, nie zostaa zdefiniowana
...
nazwa szynka nie zostaa zdefiniowana

Argument ten (jesli istnieje) pokazywany jest w ostatniej czesci (detail) komunikatu o niewyapanym wyjatku.

Kody obsugujace
wyjatek uruchamiane sa nie tylko po zgoszeniu wyjatku
w ich klauzuli try, ale takze w przy-
padku, gdy pojawia sie one w instrukcjach try umieszczonych w wywoywanych funkcjach (nawet posrednio):

>>> def to_sie_nie_uda():

... x = 1/0
...
>>> try:
... this_fails()
... except ZeroDivisionError, detale:
... print Obsuga b
edu wykonania programu:, detale
...
Obsuga bedu wykonania programu: integer division or modulo

8.4 Zgaszanie wyjatkw

Instrukcja raise suzy do wymuszania pojawienia sie podanego wyjatku.
Na przykad:

>>> raise NameError, HejTam

Traceback (innermost last):
File "<stdin>", line 1
NameError: HejTam

Pierwszy argument instrukcji raise suzy do podania nazwy wyjatku.

Opcjonalny drugi argument jest jego
wartoscia (argumentem wyjatku).

8.5 Wyjatki
definiowane przez uzytkownika
W programach Pythona mozna tworzyc swoje wyjatki
poprzez przypisanie napisu do zmiennej lub stworzenie
2
nowej klasy wyjatku.
Na przykad:
2O klasach, juz w nastepnym rozdziale. . . (przyp. tum.)

54 Rozdzia 8. Bedy
i wyjatki

 >>> class NowyWyjatek:
... def __init__(self, wartosc):
... self.wartosc = wartosc
... def __str__(self):
... return self.wartosc
...
>>> try:
... raise NowyWyjatek(2*2)
... except NowyWyjatek, w:
... print Zgoszono nowy wyjatek
o warto
sci:, w.wartosc
...
Zgoszono nowy wyjatek
o warto
sci: 4
>>> raise NowyWyjatek, 1
Traceback (innermost last):
File "<stdin>", line 1
__main__.NowyWyjatek: 1

W wielu standardowych moduach uzywa sie tego sposobu opisania bedw, ktre moga pojawic sie w zdefin-
iowanych w nich funkcjach.
Wiecej informacji o klasach mozna znalezc w rozdziale 9 Klasy.

8.6 Jak posprzata

c po baaganiarzu?
Instrukcja try posiada jeszcze jedna, opcjonalna klauzule, ktra suzy do definiowania dziaan, majacych
na celu
dokonanie koniecznych pod wszelkimi wzgledami porzadkw. Na przykad:

>>> try:
... raise KeyboardInterrupt
... finally:
... print
Zegnaj,
swiecie!
...

Zegnaj, swiecie!
Traceback (innermost last):
File "<stdin>", line 2
KeyboardInterrupt

Klauzula finally jest wykonywana niezaleznie od tego, czy pojawi sie wyjatek,
czy tez nie. Kod zawarty w tym
bloku jest rwniez wykonywany, gdy blok try zostanie opuszczony za pomoca instrukcji break lub return.
Instrukcja try musi posiadac co najmniej jeden blok except lub jeden blok finally, ale nigdy oba
rwnoczesnie.

8.6. Jak posprzata

c po baaganiarzu? 55
56
 ROZDZIA

DZIEWIATY

Klasy

System klas w Pythonie wyrazony jest minimalnym zestawem nowych srodkw skadniowych i semantycznych.
Jest to mieszanka mechanizmw znanych w C++ i Moduli-3. Tak jak w przypadku moduw, klasy w Pythonie
nie stawiaja z adnych barier pomiedzy swoja definicja a programista. Polega sie tutaj raczej na grzecznosci
programisty, ktrego dobre wychowanie nie pozwala na wamywanie sie do definicji klasy. Najwazniejsze cechy
systemu klas zachowane sa tu w caej swej mocy: mechanizm dziedziczenia klas pozwala na posiadanie wielu klas
bazowych, klasa pochodna jest w stanie przesonic definicje metod klas bazowych, jej metoda moze wywoywac
metode klasy bazowej o tej samej nazwie. Obiekty moga posiadac dowolna liczbe danych prywatnych.
W terminologii przejetej w C++, wszystkie skadowe klasy pythonowej (wacznie z atrybutami) sa publiczne, a
wszystkie funkcje skadowe sa wirtualne. Nie istnieja specjalne funkcje destruktora i konstruktora. Podobnie jak
w Moduli-3 nie istnieja skrtowe sposoby zapisu odniesienia do skadowej obiektu we wnetrzu metody: metoda
deklarowana jest z wymienionym wprost pierwszym argumentem reprezentujacym obiekt, na rzecz ktrego
zostanie wywoana. Podobnie jak w Smalltalku, klasy same sa obiektami, aczkolwiek w szerszym tego sowa
znaczeniu: w Pythonie wszystkie typy danych to obiekty. Ta cecha okresla semantyke mechanizmu importowania
i zmiany nazw. Jednak, podobnie jak w C++ i Moduli-3, typy wbudowane nie moga byc uzyte jako klasy bazowe
klas zdefiniowanych przez uzytkownika. Tak jak w C++, ale w odrznieniu od Moduli-3, wiekszosc wbudowanych
operatorw moga zostac za pomoca specjalnej skadni przedefiniowane dla rznych typw klasowych.

9.1 Sowo na temat terminologii

Z powodu braku oglnie przyjetej terminologii, w odniesieniu do klas uzywac bede terminw z jezyka Smalltalk i
C++. (Chetnie uzywabym terminologii zaczerpnietej z Moduli-3, poniewaz obiektowa semantyka tego jezyka jest
blizsza temu, co reprezentuje w tym wzgledzie Python, ale sadz
e, z e o Moduli-3 syszao niewielu czytelnikw).
Musze takze ostrzec, z e istnieje pewna terminologiczna puapka dla czytelnikw obeznanych z technologia obiek-
sowo obiekt w Pythonie nie oznacza koniecznie konkretu (instancji) klasy. Podobnie jak w C++ i
towa:
Moduli-3, w odrznieniu od Smalltalka, nie wszystkie typy w Pythonie sa klasowe. Podstawowe, wbudowane
typy danych jak liczby cakowite i listy nie sa klasowe (tzn. nie posiadaja klasy), nawet tak egzotyczne typy
jak pliki tez nie sa. Jednakze, wszystkie typy Pythona przejawiaja w swym zachowaniu to, co najlepiej mozna by
wyrazic sowem obiekt.
Obiekty posiadaja swoja indywidualnosc , mogac
posiadac jednoczesnie wiele nazw (w wielu zasiegach nazw). W
innych jezykach programowania nazywa sie to aliasami. Zazwyczaj nie jest to docenianie przy pierwszym spotka-
niu z Pythonem i w bezpieczny sposb jest ignorowane przy pracy z niemutowalnymi typami danych (liczbami,
napisami, niemutowalnymi listami). Jednakze, aliasy wpywaja (celowo) na semantyke kodu Pythona, gdy w gre
wchodza mutowalne typy danych, takie jak listy, sowniki i wiekszosc typw reprezentujacych
byty jednostkowe
na zewnatrz
programu (pliki, okna itp.) Zwykle aliasy przynosza korzysci, poniewaz zachowuja sie pod pewnymi
wzgledami jak wskazniki. Na przykad: przekazanie obiektu jako argumentu wywoania nie kosztuje duzo tylko
w przypadku przekazania przez implementacje wskaznika do niego. Jezeli funkcja modyfikuje przekazany w ten
sposb obiekt, wywoujacy funkcje widzi te zmiane jest to powodem wystepowania dwch rznych mecha-
nizmw przekazywania parametrw np. w Pascalu.

57
9.2 Przestrzenie i zasiegi
nazw w Pythonie
Zanim przejdziemy do omawiania klas, musze wspomniec co nieco o reguach zasiegu nazw w Pythonie. Definicja
klasy wprowadza do koncepcji przestrzeni nazw troche zamieszania i powinno sie wiedziec jak dziaaja zasiegi
przestrzeni nazw, aby w peni zrozumiec, co sie w klasach dzieje. Przez przypadek, wiedza o tym mechanizmie
jest bardzo uzyteczna dla kazdego zaawansowanego programisty Pythona.
Zacznijmy od definicji.
Przestrzen nazw jest wskazaniem obiektu poprzez nazwe. Wiekszosc przestrzeni nazw w Pythonie zaimplemen-
towanych jest obecnie w postaci pythonowych sownikw, ale zwykle nie jest to zauwazalne (z wyjatkiem
wyda-
jnosci) i moze sie w przyszosci zmienic. Przykadami przestrzeni nazw sa:
zbir nazw wbudowanych (funkcje
takie jak abs() i nazwy wyjatkw wbudowanych), nazwy globalne moduu i nazwy lokalne podczas wywoania
funkcji. W pewnym sensie, zbir atrybutw obiektw takze jest przestrzenia nazw. Wazne jest, aby pamietac, z e
nie istnieje absolutnie z aden zwiazek
pomiedzy nazwami z rznych przestrzeni nazw. Dwa rzne moduy moga
definiowac funkcje maksymalizuj uzytkownik tych moduw musi poprzedzic jej nazwe nazwa moduu.
Przy okazji: uzywam sowa atrybut dla kazdej nazwy poprzedzonej kropka np. w wyrazeniu z.real, real
jest atrybutem obiektu z. Mwiac scisle, odniesienia do nazw w moduach sa odniesieniami do atrybutw: w
wyrazeniu nazwa_modulu.nazwa_funkcji, nazwa_modulu jest obiektem moduu, a nazwa_funkcji
jest jego atrybutem. W tym przypadku istnieje bezposrednia relacja pomiedzy atrybutami moduu i nazwami
globalnymi w nim zdefiniowanymi: oba rodzaje nazw zdefiniowane sa w tej samej przestrzeni nazw! 1
Atrybuty moga byc tylko do odczytu lub zapisywalne. W tym ostatnim przypadku mozna dokonac operacji
przypisania wartosci do atrybutu. Atrybuty moduu sa zapisywalne: mozna np. napisac modul.wynik =
42. Tego rodzaju atrybuty moga byc usuwane za pomoca operatora del, np. del modul.wynik.
Przestrzenie nazw tworzone sa w rznych chwilach i sa aktywne przez rzny czas. Przestrzen nazw zawiera-
jaca
nazwy wbudowane tworzona jest podczas rozpoczecia pracy Pythona i nigdy nie jest usuwana. Przestrzen
nazw globalnych moduu tworzona jest podczas wczytywania jego definicji i jest aktywna rwniez do chwili
zakonczenia pracy interpretera. Instrukcje wykonywane przez szczytowe wywoania interpretera, zarwno czy-
tane z pliku jak i wprowadzane interaktywnie, sa czescia moduu o nazwie __main__ tak wiec posiadaja
swoja wasna przestrzen nazw globalnych. (Nazwy wbudowane rwniez przechowywane sa w module o nazwie
__builtin__.)
Przestrzen nazw lokalnych funkcji tworzona jest w momencie jej wywoania i niszczona, gdy nastepuje powrt
z funkcji lub zgoszono zosta w niej wyjatek,
ktry nie zosta tam obsuzony (zapomniany byoby wasci-
wym sowem, ktre dokadnie oddaoby to, co naprawde sie wtedy dzieje). Oczywiscie, wywoanie rekurencyjne
powoduje tworzenie za kazdym razem nowej przestrzeni nazw lokalnych.
Zasieg jest tekstowym obszarem programu Pythona, w ktrym przestrzen nazw jest wprost osiagalna.
Wprost os-
iagalna
oznacza tutaj, z e niekwalifikowane2 odniesienia do nazwy znajduja te nazwe w obowiazuj
acej
przestrzeni
nazw.
Pomimo iz zasiegi okreslane sa w sposb statyczny, uzywane sa w sposb dynamiczny. W kazdym momencie
wykonania programu, uzywa sie dokadnie trzech zagniezdzonych zasiegw nazw (tzn. wprost osiagalne
sa trzy
przestrzenie nazw): (i) najbardziej zagniezdzony, w ktrym najpierw poszukuje sie nazwy, zawiera on nazwy
lokalne; (ii) srodkowy, przeszukiwany w nastepnej kolejnosci, ktry zawiera aktualne nazwy globalne moduu
oraz (iii) zewnetrzny (przeszukiwany na koncu) jest zasiegiem nazw wbudowanych.
Lokalny zasieg nazw umozliwia zwykle odniesienia do nazw wystepujacych
(tekstowo) w biezacej
funkcji. Poza
obrebem funkcji, lokalna nazwa jest nazwa z przestrzeni nazw globalnych moduu. Definicja klasy stanowi jeszcze
jedna przestrzen nazw w rodzinie przestrzeni nazw lokalnych.
Wazne jest zdawac sobie sprawe z tego, z e zasiegi nazw okreslane sa statycznie: zasieg globalny funkcji zdefin-
iowanej w module jest jego przestrzenia nazw globalnych, bez wzgledu na to skad i za pomoca jakiego aliasu
funkcja zostaa wywoana. Z drugiej strony, wasciwe poszukiwanie nazw zachodzi w sposb dynamiczny, w
czasie wykonywania programu jakkolwiek, definicja jezyka ewoluuje w strone statycznego sposobu rozstrzy-
1 Z wyjatkiem
jednej rzeczy. Obiekty moduw posiadaja tajemniczy tylko atrybut do odczytu: __dict__, ktremu przypisany jest
sownik uzyty do zaimplementowania przestrzeni nazw. Nazwa __dict__ jest atrybutem, ale nie nazwa globalna. To oczywiste, z e uzywanie
tej nazwy jest pogwaceniem zasad implementacji przestrzeni nazw i powinno byc ograniczone tylko do przypadkw sledzenia programu typu
post-mortem.
2 tzn. nie trzeba podawa c nazwy moduu, klasy, obiektu wraz z kropka (przyp. tum.).

58 Rozdzia 9. Klasy
gania nazw, w czasie kompilacji. Nie mozna wiec polegac w programach na dynamicznym rozstrzyganiu nazw
(w rzeczywistosci, zmienne lokalne sa juz w obecnej wersji okreslane statycznie).
Jedna z cech szczeglnych Pythona jest to, z e przypisanie zawsze zachodzi w najbardziej zagniezdzonym zasiegu.
Przypisania nie powoduja kopiowania danych przywiazuj a jedynie nazwy do obiektw. To samo zachodzi w
przypadku usuwania: instrukcja del x usuwa zwiazek obiektu identyfikowanego przez nazwe x z ta nazwa w
przestrzeni nazw lokalnych. W rzeczywistosci, wszystkie operacje, ktre wprowadzaja nowe nazwy do przestrzeni
nazw lokalnych, to robia. Dotyczy to zawaszcza instrukcji importu i definicji funkcji (instrukcja global moze
zostac uzyta do oznaczenia, z e wyszczeglniona z nazwa nalezy do przestrzeni nazw globalnych).

9.3 Pierwszy wglad

w klasy
Klasy wymagaja uzycia pewnej nowej skadni, trzech nowych typw obiektowych i troche nowej semantyki.

9.3.1 Skadnia definicji klasy

Najprostsza forma definicji klasy jest:

class NazwaKlasy:
<instrukcja-1>
.
.
.
<instrukcja-N>

Definicje klas, podobnie jak definicje funkcji (instrukcja def) musza zostac wykonane, zanim zostana uzyte
(mozna umiescic definicje klasy w rozgaezieniu instrukcji if lub wewnatrz
funkcji).
W praktyce, instrukcje wewnatrz definicji klasy beda definicjami funkcji, ale rwniez dozwolone sa inne, czasem
bardzo uzyteczne powrcimy do tego pzniej. Definicja funkcji w ciele klasy posiada zwykle szczeglna
forme listy argumentw formalnych, dedykowanych szczeglnej konwencji wywoywania metod 3 to rwniez
zostanie wyjasnione pzniej.
Kiedy wprowadza sie definicje klasy do programu, tworzona jest nowa przestrzen nazw uzywana jako zasieg
lokalny nazw w ten sposb, wszystkie przypisania do zmiennych lokalnych dotycza nazw z tej wasnie
przestrzeni. W szczeglnosci, definicja funkcji powoduje powiazanie
jej nazwy z obiektem tej funkcji w lokalnej
przestrzeni nazw klasy.
Kiedy definicja klasy sie konczy, tworzony jest obiekt klasy. Mwiac wprost, jest rodzaj opakowania dla
przestrzeni nazw stworzonej przez definicje klasy o obiektach klasy dowiemy sie nieco wiecej w dalszej czesci
rozdziau. Zasieg pierwotny (ten, ktry obowiazywa
przed rozpoczeciem definicji klasy) jest przywracany, a
nowo utworzony obiekt klasy powiazany
zostaje z jej nazwa, ktra zostaa podana w nagwku definicji klasy (w
tym przypadku NazwaKlasy).

9.3.2 Obiekty klas

Na obiektach klasy mozna przeprowadzic dwa rodzaje operacji: odniesienia do atrybutw i konkretyzacje.
Odniesienie do atrybutu da sie wyrazic za pomoca standardowej skadni uzywanej w przypadku odniesien dla
wszystkich atrybutw w Pythonie: obiekt.nazwa. Prawidowymi nazwami atrybutw sa nazwy, ktre istniay
w przestrzeni nazw klasy w czasie tworzenia jej obiektu. Tak wiec, jesli definicja klasy wyglada
nastepujaco:

3 czyli funkcji zdefiniowanych dla obiektw klas (przyp. tum.).

9.3. Pierwszy wglad

w klasy 59
 class MojaKlasa:
"Prosta, przykadowa klasa"
i = 12345
def f(x):
return witaj
swiecie

to MojaKlasa.i i MojaKlasa.f sa prawidowymi odniesieniami do jej atrybutw, ktrych wartoscia jest

odpowiednio liczba cakowita i obiekt metody. Atrybutom klasy mozna przypisywac wartosci, w ten sposb
mozna zmienic wartosc MojaKlasa.i poprzez przypisanie. __doc__ jest takze prawidowa nazwa atrybutu
klasy, ktrego wartoscia jest napis dokumentacyjny nalezacy
do klasy: "Prosta, przykadowa klasa".
Konkretyzacje klasy przeprowadza sie uzywajac
notacji wywoania funkcji. Nalezy tylko udac, z e obiekt klasy jest
bezparametrowa funkcja, ktra zwraca instancje (konkret) klasy. Oto przykad (uzywa definicji klasy z poprzed-
niego c wiczenia):
x = MojaKlasa()

w ktrym tworzy sie nowy konkret klasy i wia

ze sie ten obiekt z nazwa zmiennej lokalnej x poprzez przypisanie
do niej.
Operacja konkretyzacji (wywoanie obiektu klasy) tworzy pusty obiekt. Dla wielu klas wystepuje koniecznosc
stworzenia swojego konkretu w pewnym znanym, poczatkowym
stanie. Dlatego tez, mozna zdefiniowac dla klas
specjalna metode o nazwie __init__(), tak jak ponizej:
def __init__(self):
self.dane = []

W momencie konkretyzacji klasy, automatycznie wywoana zostanie metoda __init__() dla nowopowstaego
konkretu klasy.
Tak wiec, w tym przykadzie, nowy, zainicjalizowany konkret klasy mozna uzyskac poprzez:

x = MojaKlasa()

Oczywiscie, dla zwiekszenia wygody w uzyciu, metoda __init__() moze posiadac argumenty. W tym
przypadku, argumenty dane na wejsciu operatora konkretyzacji klasy, przekazywane sa do __init__(). Na
przykad:
>>> class Zespolona:
... def __init__(self, rzeczywista, urojona):
... self.r = rzeczywista
... self.i = urojona
...
>>> x = Zespolona(3.0,-4.5)
>>> x.r, x.i
(3.0, -4.5)

9.3.3 Obiekty konkretu klasy

No dobrze, wiec co mozna zrobic z obiektem konkretu klasy? Jedyna operacja zrozumiaa dla obiektu konkretu
klasy jest odniesienie do jego atrybutw. Istnieja dwa rodzaje prawidowych nazw atrybutw takiego obiektu.
Pierwszy z nich nazywany jest przeze mnie atrybutami danych. Sa to odpowiedniki zmiennych konkretu klasy
w Smalltalku i danymi skadowymi w C++. Atrybuty danych nie musza byc deklarowane. Podobnie jak zmi-
enne lokalne, sa one tworzone w momencie pierwszego przypisania wartosci do nich. Jezeli x jest na przykad
konkretem klasy MojaKlasa, to ponizszy fragment kodu spowoduje wydrukowanie wartosci 16 bez powstania
komunikatu o bedzie:

60 Rozdzia 9. Klasy
 x.licznik = 1
while x.licznik < 10:
x.licznik = x.licznik * 2
print x.licznik
del x.licznik

Drugim rodzajem odniesienia do atrybutu sa metody. Metoda jest funkcja, ktra nalezy do obiektu konkretu
klasy. (W Pythonie, okreslenie metoda nie przynalezy tylko i wyacznie
do konkretw klasy: inne typy obiek-
towe tez moga miec metody, np. listy maja metody o nazwie append, insert, remove, sort, itd. Jednakze,
okreslenie metoda uzyte ponizej, odnosi sie do funkcji nalezacej
do instancji klasy, chyba, z e zaznaczono in-
aczej.)
Poprawna nazwa metody obiektu konkretu zalezy od jego klasy. Z definicji, wszystkie atrybuty klasy, ktre sa
funkcjami (zdefiniowanymi przez uzytkownika), sa poprawnymi nazwami metod konkretu tej klasy. Tak wiec, w
naszym przykadzie x.f jest funkcja, ale x.i juz nie, poniewaz MojaKlasa.i nie jest funkcja. x.f nie jest
tym samym co MyClass.f jest to obiekt metody, a nie obiekt funkcji.

9.3.4 Obiekty metod

Metode wywouje sie w nastepujacy

sposb:

x.f()

w naszym przykadzie zwrci ona napis "witaj swiecie". Nie jest jednakze konieczne wywoywac metode
w ten bezposredni sposb: x.f jest obiektem i mozna go zachowac i wywoac pzniej, np.:

xf = x.f
while 1:
print xf()

bedzie po wsze czasy drukowac witaj

swiecie.
Co wasciwie dzieje sie, gdy wywoywana jest metoda? Mozna byo zauwazyc, z e x.f() zostaa wywoana bez
argumentu, pomimo z e definicja funkcji f zawiera jeden argument formalny self. Co sie z nim stao? Pewne
jest, z e Python zgosi wyjatek,
gdy funkcja, ktra wymaga podania argumentw, wywoywana jest bez nich
nawet, jezeli z aden z nich nie jest wewnatrz
jej uzywany. . .
Odpowiedz jest dosc oczywista: jedna ze szczeglnych cech metody jest to, z e obiekt, na rzecz ktrego jest
wywoywana, przekazywany jest jako pierwszy argument funkcji. W naszym przykadzie, wywoanie x.f()
odpowiada dokadnie wywoaniu MyClass.f(x). Oglnie rzecz biorac, wywoanie metody z lista n argumen-
tw rwnoznaczne jest wywoaniem odpowiedniej funkcji klasy z lista argumentw stworzona poprzez wozenie
obiektu konkretu klasy przed pierwszy element (argument wywoania) listy argumentw.
Jesli w dalszym ciagu
nie jest zrozumiae jak dziaaja metody, sprbujmy spojrzec na ich implementacje, co
powinno rozjasnic nieco to zagadnienie. Gdy uzywa sie odniesienia do atrybutu konkretu klasy, ktry nie jest
atrybutem danych, nastepuje przeszukanie klasy konkretu. Jezeli znaleziono nazwe w klasie, ktra odnosi sie
do funkcji w niej zdefiniowanej, tworzony jest obiekt metody jako paczka zawierajaca odniesienia do obiektu
konkretu klasy i obiektu funkcji klasy. Kiedy obiekt metody jest wywoywany z lista argumentw, nastepuje jego
rozpakowanie, tworzona jest nowa lista argumentw z obiektu konkretu klasy i oryginalnej listy argumentw, a
nastepnie obiekt funkcji wywoywany jest z nowo utworzona lista.

9.4 Luzne uwagi

[Ten podrozdzia byc moze powinien byc umieszczony gdzies indziej. . . ]

9.4. Luzne uwagi 61

Nazwy atrybuty danych przesaniaja te same nazwy metod. Przyjeo sie uzywac pewnej konwencji w
nazewnictwie, aby unikna
c przypadkowego konfliktu nazw, co moze powodowac trudne do znalezienia bedy
w duzych programach. Na przykad, rozpoczynanie nazw metod od duzej litery, dodawanie przedrostka do nazwy
atrybutu danych (zazwyczaj jest to znak podkreslenia, _) lub uzywanie czasownikw dla metod i rzeczownikw
dla danych.
Atrybuty danych moga byc uzyte w metodach w ten sam sposb, w jaki uzywane sa przez zwykych uzytkownikw
(klientw) obiektu. Innymi sowy, klasy w Pythonie nie sa uzyteczne jako srodek do implementacji czystych
abstrakcyjnych typw danych. W rzeczywistosci, nic w Pythonie nie umozliwia ukrywania danych wszystko
to oparte jest na konwencji. (Z drugiej strony, implementacja Pythona, ktra jest cakowicie napisana w C, moze
cakowicie ukryc szczegy implementacyjne i kontrolowac zakres dostepu do obiektu, jesli jest to konieczne. Jest
do pewna droga postepowania dla wszelkich rozszerzen Pythona pisanych w C).
Klienci powinni uzywac atrybutw danych z pewna doza ostroznosci moga narobic duzo baaganu w niezmi-
ennikach metod poprzez naruszanie ich atrybutw danych. Prosze zauwazyc, z e mozna dodawac nowe atrybuty
danych do obiektu konkretu bez naruszania poprawnosci dziaania metod pod warunkiem, z e uniknieto konfliktu
nazw trzeba to znw zaznaczyc: trzymanie sie konwencji w nazewnictwie moze zaoszczedzic blu gowy w
tym wzgledzie.
Nie istnieje skrcony sposb dostepu z wnetrza metody do atrybutw danych (lub innych metod)! Moim zdaniem,
zwieksza to czytelnosc ich kodu: nie ma szansy pomieszania nazw zmiennych lokalnych i zmiennych konkretu
podczas przegladania
programu z rdowego.
Przyjeta oglnie konwencja jest nazywanie pierwszego argumentu metody self.4 To nic wiecej niz kon-
wencja: nazwa self nie ma zupenie z adnego specjalnego znaczenia w Pythonie (prosze jednak zauwazyc, z e nie
przestrzeganie tej konwencji moze spowodowac powstanie mniej czytelnego kodu oraz to, z e niektre narzedzia
suzace
do przegladania
definicji klas moga polegac wasnie na tej konwencji)5
Kazdy obiekt funkcji, ktry jest atrybutem klasy definiuje metode dla konkretu tej klasy. Nie jest konieczne aby
definicja takiej funkcji bya tekstowo umieszczona w definicji jej klasy: przypisanie obiektu funkcji do lokalnej
zmiennej w klasie powoduje to samo jakby bya ona tam umieszczona. Na przykad:

# Funkcja zdefiniowana poza obr

ebem klasy
def f1(self, x, y):
return min(x, x+y)

class C:
f = f1
def g(self):
return witaj
swiecie
h = g

W tym wypadku f, g i h sa wszystkie atrybutami klasy C, ktrych wartoscia sa obiekty funkcji i w konsekwencji
staja sie metodami konkretw klasy C h jest dokadnie odpowiednikiem g. Prosze zauwazyc, z e w praktyce
taka kombinacja suzy jedynie do wprowadzenia czytelnika takiego programu w stan gebokiego zmieszania i
frustracji.
Metody moga wywoywac inne metody poprzez uzycie atrybutw metod obiektu self, np.:
class Worek:
def __init__(self):
self.dane = []
def dodaj(self, x):
self.dane.append(x)
def dodaj_dwa_razy(self, x):
self.dodaj(x)
self.dodaj(x)

4 self mo zna przetumaczyc w tym kontekscie jako ja sam lub moja,mj. Dwa ostatnie okreslenia byc moze sa bardziej adekwatne
jezeli wezmiemy pod uwage, z e zaraz pod self nastepuje odniesienie do atrybutu konkretu, np. self.atrybut (przyp. tum.).
5 Dlatego te
z zrezygnowaem z tumaczenia tej nazw w przykadach na sowo takie jak ja, albo sie (przyp. tum.).

62 Rozdzia 9. Klasy
Metody moga uzywac odniesien do nazw globalnych w ten sam sposb jak zwyke funkcje. Zasieg globalny
zwiazany
z metoda jest po prostu tym moduem, ktry zawiera definicje klasy (sam klasa nigdy nie jest uzywana
jako zasieg globalny). Zazwyczaj rzadko mozna spotkac odniesienia do zmiennych globalnych w metodach.
Istnieje pare dobrych powodw do uzywania zmiennych globalnych: funkcje i moduy importowane do przestrzeni
nazw globalnych moga zostac uzyte przez metody, tak samo jak funkcje i klasy nalezace do tej samej przestrzeni.
Zwykle klasa zawierajaca te metode sama jest zdefiniowana w globalnym zasiegu. W nastepnym podrozdziale
bedzie sie mozna dowiedziec, dlaczego w metodzie trzeba czasami uzyc odniesienia do jej wasnej klasy!

9.5 Dziedziczenie
Bez istnienia mechanizmu dziedziczenia, ta cecha jezyka, ktra okreslana jest mianem klasy nie byaby jego
warta. Ponizej podano skadnie definicji klasy dziedziczacej:

class NazwaKlasyPotomnej(NazwaKlasyBazowej):
<instrukcja-1>
.
.
.
<instrukcja-N>

Nazwa NazwaKlasyBazowej musi byc zdefiniowana w zasiegu zawierajacym definicje klasy pochodnej. Za-
miast nazwy klasy bazowej dopuszcza sie rwniez wyrazenie. Jest to szczeglnie przydatne, jesli nazwa klasy
bazowej zdefiniowana jest w innym module, np.:

class NazwaKlasyPochodnej(modul.NazwaKlasyBazowej):

Wykonanie definicji klasy pochodnej nastepuje w taki sam sposb jak dla klasy bazowej. Klasa jest zapamiety-
wana w momencie stworzenia obiektu klasy. Ten mechanizm uzywany jest w procesie rozstrzygania odniesien
do atrybutw konkretu takiej klasy: jesli poszukiwany atrybut nie jest znajdowany w klasie, poszukiwany jest w
klasie bazowej. Ta zasada stosowana jest rekurencyjnie w przypadku, gdy klasa bazowa jest pochodna innej.
W konkretyzacji takiej klasy nie ma nic szczeglnego: NazwaKlasyPochodnej() tworzy nowy konkret klasy.
Odniesienia do metod rozstrzygane sa w nastepujacy
sposb: poszukuje sie odpowiedniego atrybutu klasy, jesli
jest to konieczne, schodzi sie z poszukiwaniem w gab
drzewa dziedziczenia. Gdy odniesienie wskazuje na obiekt
funkcji, metoda uznawana jest za poprawna.
Klasy pochodne moga przesaniac metody ich klas bazowych. Metody nie sa obsugiwane w z aden uprzywile-
jowany sposb, gdy wywouja inne metody tego samego konkretu klasy, a wiec metoda klasy bazowej, ktra
wywouje metode zdefiniowana w tej samej klasie moze uruchomic metode swojej klasy pochodnej, ktra tamta
przesania (uwaga dla programistw C++: wszystkie metody w Pythonie zachowuja sie jak wirtualne).
Przesoniecie metody w klasie pochodnej jest raczej rozszerzeniem zbioru obsugiwanych funkcji niz zastapieniem

elementu noszacego
taka sama nazwe jak ta metoda. Istnieje prosty sposb wywoania metody klasy bazowej:
po prostu NazwaKlasyPodstawowej.nazwa_metody(self, argumenty). Ten mechanizm mozna
stosowac, jezeli klasa podstawowa zdefiniowana jest w globalnym zasiegu nazw.

9.5.1 Dziedziczenie wielorakie

W Pythonie wystepuje ograniczona forma dziedziczenia wielorakiego. Ponizej podano przykad definicji klasy
dziedziczacej
z wielu klas podstawowych:

9.5. Dziedziczenie 63
 class NazwaKlasyPochodnej(Bazowa1, Bazowa2, Bazowa3):
<instrukcja-1>
.
.
.
<instrukcja-N>

Aby wyjasnic semantyke dziedziczenia wielorakiego w Pythonie, konieczne jest poznanie zasady znajdowa-
nia odniesien atrybutw klasy. Jest to zasada najpierw w gab,
potem na prawo. Jesli atrybut nie zostanie
znaleziony w klasie NazwaKlasyPochodnej, zostanie poszukany w Bazowa1, a potem (rekurencyjnie) w
klasach bazowych klasy Bazowa1 i jesli tam nie zostanie znaleziony, poszukiwanie zostanie przeniesione do
klasy Bazowa2.
(Niektrym bardziej naturalne wydaje sie byc poszukiwanie nazw w szerz przeszukiwanie Bazowa2 i
Bazowa3 przed przeszukaniem klas bazowych klasy Bazowa1. Wymaga to jednak znajomosci miejsca zdefin-
iowania konkretnego atrybutu (czy jest on zdefiniowany w Bazowa1 lub w jednej z jej klas bazowych), zanim
mozna by wywnioskowac konsekwencje konfilktu nazw atrybutu z klasy Bazowa2. Poszukiwanie najpierw w
gab
nie rozrznia atrybutw zdefiniowanych bezposrednio od dziedziczonych).
Nieograniczone uzycie dziedziczenia wielorakiego moze w oczywisty sposb stac sie koszmarem w procesie
pielegnacji oprogramowania, zwaszcza z e w Pythonie unikanie konfliktw nazw opiera sie na umowie. Jednym
ze bardziej znanych przykadw problemu z dziedziczeniem wielorakim jest sytuacja gdy dwie klasy bazowe
dziedzicza z tej samej klasy-przodka.6 . Nie wiadomo jak bardzo taka semantyka jest uzyteczna w poaczeniu
z
faktem, z e mamy pojedyncza kopie zmiennych konkretu lub atrybutw danych wsplnej klasy bazowej.

9.6 Zmienne prywatne

Python posiada ograniczony mechanizm implementacji zmiennych prywatnych klasy. Kazdy identyfikator o
nazwie __pomyje (przynajmniej dwa poprzedzajace znaki podkreslenia i co najwyzej jeden znak podkresle-
nia zakonczajacy
nazwe) jest zastepowany przez _nazwaklasy__pomyje, gdzie nazwaklasy jest nazwa
klasy z usunietymi znakami podkreslenia7 . Kodowanie to wystepuje zawsze, bez wzgledu na pozycje
biezacej
skadniowa identyfikatora. Moze to zostac uzyte do zdefiniowania prywatnych konkretw klasy i zmiennych kla-
sowych, metod, jak rwniez obiektw globalnych, a nawet do przechowywania zmiennych konkretw tej klasy w
konkretach innych klas. Uciecie nazwy moze wystapi c po przekroczeniu przez identyfikator dugosci 255 znakw.
Poza granicami klasy, lub gdy nazwa klasy skada sie tylko ze znakw podkreslenia, proces takiego kodowania
nigdy nie zachodzi.
Kodowanie nazw ma na celu uzyskanie atwego sposobu definiowania prywatnych zmiennych konkretu oraz
metod bez martwienia sie o zmienne konkretu zdefiniowane przez inne klasy pochodne, lub mucking with instance
variables by code outside the class. Trzeba zauwazyc, z e zasady kodowania nazw przeznaczone sa gwnie w
celu unikniecia nieprzyjemnych wypadkw dla zdeterminowanego programisty wcia z mozliwe jest uzyskanie
bezposredniego dostepu do do zmiennej uwazana za prywatna. Jest to nawet szczeglnie uzyteczne np. w przy-
padku debuggerw. Jest to wasciwie jedyny powd, dla ktrego ta dziura w bezpieczenstwie nie zostaa zaatana
(Pluskwa: dziedziczenie klasy o nazwie takiej samej jak jedna z klas bazowych powoduje bezposredni dostep do
zmiennych prywatnych klasy bazowej).
Kod przekazany instrukcji exec i funkcji eval() lub evalfile() nie zawiera nazwy biezacej klasy; this
is similar to the effect of the global statement, the effect of which is likewise restricted to code that is byte-
compiled together. To samo ograniczenie dotyczy getattr(), setattr() i delattr() oraz odwoan do
kluczy sownika __dict__.
Ponizej przedstawiono przykad klasy, ktra implementuje swoje wersje metod __getattr__ i
__setattr__. Za ich pomoca wszystkie atrybuty konkretu przechowywane sa w zmiennej prywatnej (przy-
pomina to sposb dziaania Pythona 1.4 i poprzednich wersji):
6 Zwaszcza w C++. . . (przyp. tum.)
7 Jesli takie wystepuja (przyp. tum.)

64 Rozdzia 9. Klasy
 class VirtualAttributes:
__vdict = None
__vdict_name = locals().keys()[0]

def __init__(self):
self.__dict__[self.__vdict_name] = {}

def __getattr__(self, name):

return self.__vdict[name]

def __setattr__(self, name, value):

self.__vdict[name] = value

9.7 Sztuczki i chwyty

Czasami potrzebe jest uzycie typu danych spotykanego w Pascalu pod nazwai
rekordu lub struktury w C. Trzeba
po prostu zgrupowac pewna liczbe nazwanych elemtw w jednym zasobniku. W prosty sposb da to sie wyrazic
za pomoca pustej definicji klasy, tzn.:
class Pracownik:
pass

janek = Pracownik() # Tworzy pusty rekord pracownika

# Wypenienie pl w rekordzie
janek.nazwa = Janek Kos
janek.miejsce = laboratorium komputerowe
janek.pensja = 1000

We fragmencie pythonowatego kodu, ktry wymaga uzycia szczeglnego abstrakcyjnego typu danych, mozna
skorzystac z jakiejs klasy, ktra emuluje metody wymaganego typu. Na przykad, jesli istnieje funkcja, ktra
formatuje dane na wyjsciu jakiegos pliku, to mozna zdefiniowac klase z metodami read() i readline), ktre
pobieraja dane z ancucha znakw zamiast z pliku i przekazac ja do danej funkcji.
Metody konkretu klasy rwniez posiadaja swoje atrybuty: m.im_self jest obiektem (wskazanie na), dla ktrego
dana metoda ma zostac wywoana, a m.im_func jest obiektem funkcji, ktra implementuje dana metode.

9.7.1 Wyjatki
moga byc klasami

Wyjatki
definiowane przez uzytkownika nie sa juz ograniczone tylko do obiektw napisw mozna rwniez
uzyc klas. Poprzez uzycie tego mechanizmu mozna stworzyc rozszerzalna hierarchie wyjatkw.

Istnieja dwie poprawne formy instrukcji zgoszenia wyjatku:

raise Klasa, konkret

raise konkret

W pierwszej formie, konkret musi byc konkretem klasy Klasa lub klasy pochodnej od niej. Druga forma jest
skrconym zapisem dla:

raise konkret.__class__, konkret

Klauzula except instrukcji try moze zawierac rwniez liste klas. Klasa w tej klauzuli odpowiada zgoszonemu

9.7. Sztuczki i chwyty 65

wyjatkowi,
jesli jest tej samej klasy co wyjatek
lub jego klasa bazowa (i nie inaczej lista klas pochodnych w
klauzuli except nie odpowiada wyjatkom, ktre sa ich klasami bazowymi). Na przykad, wynikiem dziaania
ponizszego kodu bedzie wyswietlenie B,C,D w takim wasnie porzadku:

class B:
pass
class C(B):
pass
class D(C):
pass

for c in [B, C, D]:

try:
raise c()
except D:
print "D"
except C:
print "C"
except B:
print "B"

Trzeba zauwazyc, z e jezeli klauzula except byaby odwrcona (tzn. except B na pierwszym miejscu),
program wyswietliby B, B, B uruchamiany jest kod pierwzej pasujacej
klauzuli.
Gdy wyswietlany jest komunikat o bedzie w przypadku niewyapanego wyjatku
klasowego, wyswietlana jest
nazwa klasy, potem dwukropek i spacja, a nastepnie konkret klasy wyjatku
przeksztacony do napisu za pomoca
funkcji wbudowanej str().

66 Rozdzia 9. Klasy
 ROZDZIA

DZIESIATY

Co teraz?

Mam nadzieje, z e lektura tego przewodnika wzbudzia zainteresowanie uzytkowaniem Pythona. Co teraz powinno
sie zrobic?
Nalezy przeczytac lub przynajmniej przekartkowac, Opis biblioteki. Stanowi on kompletny (aczkolwiek dosc
suchy) opis typw, funkcji i moduw, co moze zaoszczedzic mnstwo czasu podczas pisania programw w
Pythonie. Standardowa dystrybucja Pythona zawiera mnstwo kodu napisanego zarwno w C jak i w samym
Pythonie. Mozna spotkac moduy do czytania skrzynek pocztowych na U NIKSIE, odbierania tresci dokumentw
poprzez HTTP, generowania liczb losowych, przetwarzania opcji podanych w linii polecen, pisania skryptw CGI,
kompresji danych i duzo, duzo wiecej. Pobiezne przegladni
ecie Opisu biblioteki na pewno da wyobrazenie na
temat tego, co jest dostepne.
Gwna witryna Pythona jest http://www.python.org. Zawiera ona kod, dokumentacje i odnosniki do innych stron
na caym swiecie dotyczacych
Pythona. Witryna ta jest mirrorowana w wielu miejscach swiata: Europie, Japonii
i Australii. Mirror moze byc szybszy niz witryna gwna, co zalezy gwnie od lokalizacji Czytelnika. Bardziej
nieformalna witryna jest http://starship.python.net, ktra zawiera wiele stron domowych ludzi zajmujacych
sie
Pythonem oraz stworzone przez nich oprogramowanie, ktre mozna stamtad zaadowac (ang. download).
W celu zgoszenia bedw implementacji Pythona oraz zadawania pytan na jego temat, mozna zapisac sie na liste
dyskusyjna comp.lang.python lub wysac listy do [email protected]. Do listy dyskusyjnej i skrzynki pocztowej
prowadzi bramka, tak wiec wiadomosci tam wysyane sa automatycznie przesyane dalej do innych. Obecnie przez
bramke przechodzi okoo 3545 wiadomosci dziennie zawierajacych pytania (i odpowiedzi), sugestie na temat
nowych cech jezyka i zgoszenia nowych moduw. Przed wysaniem wiadomosci nalezy sprawdzic Liste Czesto
Zadawanych Pytan (FAQ) pod adresem http://www.python.org/doc/FAQ.html lub spojrzec na zawartosc katalogu
Misc znajdujacego
sie w standardowej dystrybucji z rdowej Pythona. Lista FAQ zawiera wiele odpowiedzi na
wcia
z napywajace
pytania i byc moze zawiera juz rozwiazanie
danego problemu.
Spoecznosc pythonowska mozna wspomc poprzez przyjaczenie
sie do organizacji Python Software Activity
(PSA), ktra obsuguje witryne python.org, ftp i serwery pocztowe oraz organizuje warsztaty Pythona. O tym jak
sie doaczy
c do PSA, mozna dowiedziec sie pod http://www.python.org/psa/.

67
68
 DODATEK

Interaktywna edycja i operacje na historii

polecen

Niektre wersje interpretera zawieraja mechanizmy edycji aktualnej linii polecen i operacji na historii polecen,
podobne do mechanizmw zawartych w powoce Korna i GNU Bash. Jest on zaimplementowany za pomoca
biblioteki GNU Readline. ktra umozliwia edycje w stylu Emacsa i edytora vi. Biblioteka ta posiada wasna
dokumentacje, ktrej nie bede tutaj duplikowa, jakkolwiek wyjasnie pewne podstawy jej uzywania. Interaktywna
edycja i i historia polecen, ktre sa tutaj opisane, dostepne sa jako opcja na platformach U NIX i CygWin.
Rozdzia ten nie opisuje wasnosci edycyjnych pakietu PythonWin Marak Hammonda oraz opartego na bibliotece
Tk srodowiska IDLE, ktry jest dydtrybuowany wraz z Pythonem. I zupenie inna para kaloszy sa wasnosci linii
polecen emulatora DOS-owego na NT i innych okien DOS-owych w Windows.

A.1 Edycja linii polecen

Edycja linii polecen jest aktywna, jesli jest zawarta w dystrybucji, w kazdym momencie wystapienia
pierwszego
lub drugiego znaku zachety. Biezacy wiersz moze byc edytowany za pomoca zwykych znakw sterujacych
Emacsa. Najwazniejszymi z nich sa: C-A (Control-A), ktre przesuwa kursor na poczatek linii, C-E na koniec,
C-B jedna pozycje w lewo, C-F na prawo. Znaki backspace usuwaja znaki na lewo od kursora, C-D na prawo.
C-K usuwa reszte linii na prawo od kursora, C-Y wstawia ostatnio usuniety napis. C-podkreslenie powraca do
stanu przed ostatnia zmianamo
ze to byc powtarzane, aby wrcic do wczesniejszych stanw edycji.

A.2 Zastepowanie
polecen historycznych
Dziaa to jak nastepuje: wszystkie wprowadzone, niepuste wiersze wejsciowe zachowywane sa w buforze historii.
W chwili, gdy wprowadzony jest nowy wiersz, znajdujemy sie w nowym wierszu, na koncu bufora historii. C-P
przesuwa nas jeden wiersz wstecz w buforze, C-N jeden wiersz naprzd. Kazdy wiersz w buforze moze byc
przedmiotem edycji. W chwili modyfikacji wiersza na jego przodzie pojawia sie znak asteriks. Nacisniecie
klawisza Return (Enter) powoduje wprowadzenie biezacego
wiersza do interpretacji. C-R rozpoczyna proces
inkrementacyjnego poszukiwania wstecz a C-S w przd.

A.3 Funkcje klawiszowe

Funkcje przypisywane kombinacjom klawiszy wraz z innymi parametrami moga byc dostosowane do potrzeb
uzytkownika, poprzez wstawienie odpowiednich polecen do pliku $HOME/.inputrc. Funkcje klawiszowe posi-
adaja nastepujac
a forme:
nazwa-kombinacji-klawiszowej: nazwa-funkcji

lub

69
 "napis": nazwa-funkcji

a opcje moga zostac ustawione za pomoca

set nazwa-opcji warto
sc

Na przykad:
# Wol
e styl vi:
set editing-mode vi
# Edycja za pomoca jednego wiersza:
set horizontal-scroll-mode On
# zmiana niektrych funkcji klawiszowych:
Meta-h: backward-kill-word
"\C-u": universal-argument
"\C-x\C-r": re-read-init-file

Trzeba zauwazyc, z e funkcja przypisana do klawisza TAB w Pythonie jest funkcja wstawiajaca
znak tabulacji
zamiast funkcji dopeniania nazw plikw, ktra w bibliotece Readline jest domyslna. Jezeli to jest naprawde
konieczne, mozna to pythonowe przypisanie zmienic poprzez wstawienie
TAB: complete

do pliku $HOME/.inputrc. Oczywiscie spowoduje to utrudnione wprowadzanie wierszy kontynuacji, ktre maja
byc wciete. . .
Automatyczne dopenianie nazw zmiennych i moduw jest dostepne. Aby to uzyskac w trybie interaktywnym
interpretera, nalezy dodac nastepujace
polecenie w pliku $HOME/.pythonrc.py:
import rlcompleter, readline
readline.parse_and_bind(tab: complete)

Klawiszowi TAB zostanie przypisana funkcja dopeniania nazw, tak wiec nacisniecie dwa razy tego klawisza
spowoduje wyswietlenie propozycji nazw, ktre pasuja do wprowadzonego juz napisu: instrukcji, biezacych
zmi-
ennych lokalnych i dostepnych w tym kontekscie nazw moduw. Dla wyrazen kropkowanych, jak string.a,
wyrazenie az do kropki zostanie okreslone, a nastepnie pojawia sie propozycje atrybutw wynikowego obiektu.
Prosze zauwazyc, z e moze to spowodowac wykonanie kodu aplikacji, jesli obiekt z metoda __getattr__()
jest czescia wyrazenia.

A.4 Komentarz
Wyzej wspomniana wasciwosc jest ogromnym krokiem naprzd w porwnaniu z poprzednimi wersjami in-
terpretera, aczkolwiek pozostay pewne niespenione z yczenia. Byoby mio, aby automatycznie sugerowano
poprawna indentacje w wierszach kontynuacji (parser wie czy nastepny symbol ma byc wciety). Mechanizm uzu-
peniania nazw mgby korzystac z tablicy symboli interpretera. Polecenie sprawdzenia (a nawet proponowania)
dopasowania nawiasw, cudzysowiw itd. rwniez byoby bardzo pomocne.

70 Dodatek A. Interaktywna edycja i operacje na historii polecen

 INDEKS

Symbole .pythonrc.py, 5
.pythonrc.py poszukiwanie
file, 70 sciezka, modu, 38
plik, 5 $PYTHONPATH, 3840
sciezka $PYTHONSTARTUP, 5
modu poszukiwanie, 38
__builtin__ (modu wbudowany), 40
R
readline (modu wbudowany), 70
C rlcompleter (modu standardowy), 70
compileall (modu standardowy), 39
S
D string (modu standardowy), 45
docstring, 22, 26 sys (modu standardowy), 40

F U
file unicode() (funkcja wbudowana), 14
.pythonrc.py, 70
for
Z
instrukcja, 19 zmienne srodowiskowe
$PATH, 5, 39
I $PYTHONPATH, 3840
instrukcja $PYTHONSTARTUP, 5
for, 19

M
metoda
obiekt, 61
modu
poszukiwanie sciezka, 38

N
napis dokumentujacy,
22
napisy dokumentujace,
26
napisy, dokumentacja, 22, 26

O
obiekt
metoda, 61
open() (funkcja wbudowana), 47

P
$PATH, 5, 39
pickle (modu standardowy), 49
plik

71