Podr ˛ecznik programisty Pythona – opis
j ˛ezyka
Wersja 2.3
Guido van Rossum
Fred L. Drake, Jr., editor
tłumaczenie:
Zbigniew Chyla
26 stycznia 2005
PythonLabs
E-mail:
python-docs@python.org
Polska dokumentacja Pythona
E-mail:
pythondoc@python.org.pl
Copyright c
2001 Python Software Foundation. Wszystkie prawa zastrze˙zone.
Copyright c
2000 BeOpen.com. Wszystkie prawa zastrze˙zone.
Copyright c
1995-2000 Corporation for National Research Initiatives. Wszystkie prawa zastrze˙zone.
Copyright c
1991-1995 Stichting Mathematisch Centrum. Wszystkie prawa zastrze˙zone.
Copyright c
for the Polish edition 2001-3003 Zbigniew Chyla. Wszystkie prawa zastrze˙zone.
Pełny tekst licencji oraz opis dopuszczalnego zakresu wykorzystania dokumentu umieszczono na jego ko´ncu.
Streszczenie
Python jest interpretowanym, obiektowym, wysokopoziomowym j˛ezykiem programowania z dynamiczn ˛
a seman-
tyk ˛
a. Dzi˛eki wbudowanym wysokopoziomowym strukturom danych, dynamicznej typizacji oraz mo˙zliwo´sci dy-
namicznego nadawania nazw obiektom, stanowi on zarówno doskonałe narz˛edzie do szybkiego tworzenia ap-
likacji, jak i j˛ezyk skryptowy, pozwalaj ˛
acy na ł ˛
aczenie istniej ˛
acych komponentów zaimplementowanych w innych
j˛ezykach. Bardzo prosta składnia j˛ezyka zwi˛eksza czytelno´s´c programów, zmniejszaj ˛
ac tym samym koszty ich
piel˛egnacji. Python umo˙zliwia tworzenie modułów oraz grupowanie ich w pakiety, co zwi˛eksza modularno´s´c
programu i pozwala na wielokrotne wykorzystywanie istniej ˛
acego kodu. Interpreter j˛ezyka, wraz z rozbudowan ˛
a
bibliotek ˛
a standardow ˛
a, dost˛epny jest bez jakichkolwiek opłat w wersji przeznaczonej dla niemal ka˙zdej z ist-
niej ˛
acych platform sprz˛etowych i programowych. Dost˛ep obejmuje kod binarny oraz ´zródłowy programu, a tak˙ze
mo˙zliwo´s´c swobodnego jego rozpowszechniania.
Niniejszy podr˛ecznik opisuje składni˛e oraz semantyk˛e samego j˛ezyka. Temat uj˛ety został w sposób zwi˛ezły, lecz
precyzyjny i kompletny. Opis wbudowanych typów danych oraz wbudowanych funkcji umieszczony został w
odr˛ebnym podr˛eczniku –
Podr˛ecznik programisty Pythona – opis biblioteki standardowej
. Osoby stawiaj ˛
ace pier-
wsze kroki w programowaniu w Pythonie powinny zapozna´c si˛e z
Przewodnikiem programisty Pythona
. Dla osób
korzystaj ˛
acych z j˛ezyka C lub C++ przeznaczone s ˛
a dwa kolejne podr˛eczniki:
Rozszerzanie i osadzanie inter-
pretera Pythona
, który w sposób ogólny przedstawia techniki tworzenia modułów rozszerzaj ˛
acych mo˙zliwo´sci
interpretera, oraz
Opis API Python/C
, szczegółowo opisuj ˛
acy interfejs dost˛epny dla programistów C i C++.
SPIS TRE ´
SCI
1
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
3
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
Identyfikatory i słowa kluczowe
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
13
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
Hierarchia typów standardowych
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
33
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
37
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
39
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
Jednoargumentowe operacje arytmetyczne
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
Dwuargumentowe operacje arytmetyczne
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
44
Dwuargumentowe operacje bitowe
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
45
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
45
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
46
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
5.13 Kolejno´s´c warto´sciowania
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
48
49
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
50
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
52
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
52
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
53
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
53
i
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
54
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
54
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
58
59
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
60
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
60
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
60
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
61
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
62
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
63
65
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
Wej´scie w trybie interaktywnym
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
Wej´scie przy analizie wyra˙ze´n
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
66
67
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
Warunki dost˛epu do Pythona lub korzystania z niego w inny sposób
. . . . . . . . . . . . . . . .
68
71
ii
ROZDZIAŁ
PIERWSZY
Wst ˛ep
Niniejszy podr˛ecznik opisuje j˛ezyk programowania Python. Zamierzeniem autorów nie było stworzenie przewod-
nika dla osób nawi ˛
azuj ˛
acych pierwszy kontakt z tym j˛ezykiem, powinny wi˛ec one si˛egn ˛
a´c po inn ˛
a lektur˛e.
Cho´c u˙zywanie precyzyjnych sformułowa´n jest jednym z naszych podstawowych zało˙ze´n, do opisu wszystkich
elementów j˛ezyka, poza analiz ˛
a składniow ˛
a oraz leksykaln ˛
a, u˙zywamy j˛ezyka naturalnego. Mo˙ze to wprawdzie
prowadzi´c do pewnych niejednoznaczno´sci, jednak powinno uczyni´c dokument bardziej zrozumiałym dla prze-
ci˛etnego czytelnika.
Oznacza to mniej wi˛ecej tyle, ˙ze gdyby osoba przybyła z Marsa próbowała stworzy´c now ˛
a implementacj˛e Pythona
wył ˛
acznie na podstawie tre´sci tego dokumentu, musiałaby domy´sla´c si˛e pewnych rzeczy i ostateczny produkt
mógłby odpowiada´c zupełnie innemu j˛ezykowi. Z drugiej strony, je´sli czytelnik zna ju˙z Pythona, lecz chci-
ałby pozna´c precyzyjne reguły dotycz ˛
ace pewnych jego elementów, to z pewno´sci ˛
a je tutaj odnajdzie. Osobom
poszukuj ˛
acym bardziej sformalizowanej definicji j˛ezyka polecamy po´swi˛ecenie swego czasu na jej stworzenie,
ew. wynalezienie maszyny klonuj ˛
acej :-).
Opisywanie w tym dokumencie zbyt wielu szczegółów dotycz ˛
acych implementacji niosłoby ze sob ˛
a pewne
niebezpiecze´nstwa, gdy˙z mo˙ze ona w przyszło´sci ulec zmianie, ponadto mog ˛
a zosta´c stworzone inne implemen-
tacje j˛ezyka. Z drugiej strony, w powszechnym u˙zyciu jest obecnie tylko jedna implementacja Pythona (cho´c
istnieje równie˙z druga) i od czasu do czasu wspominamy o niektórych elementach jej dotycz ˛
acych, zwłaszcza,
gdy narzuca ona pewne dodatkowe ograniczenia. W zwi ˛
azku z tym w dokumencie odnale´z´c mo˙zna gdzieniegdzie
krótkie „uwagi na temat implementacji”.
Ka˙zda implementacja Pythona dostarczana jest ze spor ˛
a liczb ˛
a wbudowanych modułów. Zostały one opisane w
odr˛ebnym podr˛eczniku (
Podr˛ecznik programisty Pythona - opis biblioteki standardowej
), lecz równie˙z w niniejszej
publikacji wspominamy o kilku z nich, je´sli wymaga tego zrozumienie pewnych elementów j˛ezyka.
1.1
Notacja
Opis elementów leksykalnych oraz gramatyki został stworzony przy u˙zyciu zmodyfikowanej wersji notacji BNF.
Definicje wygl ˛
adaj ˛
a w tym zapisie nast˛epuj ˛
aco:
nazwa:
lk_litera (lk_litera | "_")*
lk_litera:
"a"..."z"
Pierwszy wiersz okre´sla, ˙ze
nazwa
składa si˛e z jednego elementu
lk_litera
, z nast˛epuj ˛
ac ˛
a po nim seri ˛
a zera
lub wi˛ecej elementów, z których ka˙zdy to
lk_litera
lub podkre´slenie. Z kolei drugi wiersz mówi nam, ˙ze
lk_litera
jest pojedynczym znakiem z zakresu od „
a
” do „
z
” (reguła ta dotyczy nazw wykorzystywanych w
regułach gramatyki, pojawiaj ˛
acych si˛e w tym dokumencie).
Ka˙zda reguła rozpoczyna si˛e nazw ˛
a, któr ˛
a reguła definiuje, po niej za´s pojawia si˛e dwukropek. Pionowa kreska (
|
)
wykorzystywana jest do rozdzielenia dwóch alternatyw i jest to operator o najmniejszym priorytecie. Gwiazdka
(
*
) oznacza zero lub wi˛ecej wyst ˛
apie´n poprzedzaj ˛
acego j ˛
a elementu, podobnie znak plus (
+
), jednak opisuje on co
najmniej jedno wyst ˛
apienie, za´s uj˛ecie fragmentu w nawiasy kwadratowe (
[ ]
) oznacza co najwy˙zej jedno jego
wyst ˛
apienie (innymi słowy, staje si˛e on opcjonalny). Operatory
*
i
+
maj ˛
a najwy˙zszy priorytet, do grupowania
1
u˙zywane s ˛
a nawiasy. Literały napisowe ujmowane s ˛
a w apostrofy. Jedyn ˛
a funkcj ˛
a odst˛epów jest rozdzielenie
s ˛
asiaduj ˛
acych tokenów. Ka˙zda z reguł gramatyki zapisywana jest zwykle w pojedynczym wierszu, lecz w przy-
padku reguły o wielu alternatywach mo˙ze by´c ona zapisana w wielu wierszach poprzez umieszczenie pionowej
kreski na pocz ˛
atku ka˙zdego wiersza poza pierwszym.
W definicjach leksykalnych (takich, jak przedstawiona powy˙zej) u˙zywane s ˛
a równie˙z dwie dodatkowe formy
zapisu. Dwa literały znakowe, rozdzielone trzema kropkami oznaczaj ˛
a wybór dowolnego znaku z zakresu od
pierwszego z nich do drugiego (wł ˛
acznie) w zbiorze
ASCII
. Zwrot umieszczony w nawiasach trójk ˛
atnych (
<...>
)
definiuje symbol w sposób opisowy, z wykorzystaniem j˛ezyka naturalnego, co pozwala np. na okre´slenie „znaku
kontrolnego”.
Pomimo wykorzystywania niemal tej samej formy zapisu, definicje leksykalne ró˙zni ˛
a si˛e w zasadniczy sposób
od definicji składniowych. Definicje leksykalne operuj ˛
a na pojedynczych znakach pobieranych z wej´scia, za´s
definicje składniowe operuj ˛
a na strumieniu tokenów uzyskanych w pierwszym etapie analizy. Wszystkie przy-
padki u˙zycia notacji BNF w kolejnym rozdziale („Analiza leksykalna”) dotycz ˛
a definicji leksykalnych, podczas
gdy w dalszych rozdziałach mowa o definicjach składniowych.
2
Rozdział 1. Wst ˛ep
ROZDZIAŁ
DRUGI
Analiza leksykalna
Program w Pythonie jest analizowany przez parser. Wej´scie dla parsera stanowi strumie´n tokenów, wygen-
erowanych przez analizator leksykalny. Poni˙zszy rozdział opisuje sposób, w jaki analizator leksykalny przetwarza
zawarto´s´c pliku na tokeny.
Zawarto´s´c programu w Pythonie składa si˛e ze znaków z 7-bitowego zbioru
ASCII
. Dodano w wersji 2.3: Mo˙zliwe
jest wskazanie, ˙ze literały napisowe i komentarze s ˛
a zapisane przy u˙zyciu kodowania innego, ni˙z ASCII. U˙zywa
si˛e do tego celu deklaracji kodowania..
Dla zgodno´sci ze starszymi wersjami, przy odnalezieniu znaków 8-
bitowych kompilator Pythona wypisuje jedynie ostrze˙zenie. Aby unikn ˛
a´c ostrze˙ze´n, nale˙zy jawnie zadeklarowa´c
u˙zywane kodowanie lub te˙z zamiast bezpo´sredniego zapisu znaków u˙zy´c sekwencji specjalnych (je´sli operujemy
na danych binarnych).
Zestaw znaków wykorzystywany podczas uruchamiania programu zale˙zny jest od urz ˛
adze´n, z którymi program
jest poł ˛
aczony, jednak zwykle stanowi on nadzbiór zbioru
ASCII
.
Uwaga na temat zgodno´sci z przyszłymi wersjami: Kusz ˛
acym pomysłem mo˙ze by´c zało˙zenie, ˙ze u˙zywanym
zestawem znaków 8-bitowych jest ISO Latin-1 (nadzbiór
ASCII
, obejmuj ˛
acy wi˛ekszo´s´c znaków u˙zywanych w
j˛ezykach zachodnich), jednak istnieje prawdopodobie´nstwo, ˙ze w przyszło´sci powszechnym stanie si˛e u˙zywanie
edytorów tekstu obsługuj ˛
acych Unicode. Edytory tego typu zwykle korzystaj ˛
a z kodowania UTF-8, równie˙z
b˛ed ˛
acego nadzbiorem
ASCII
, jednak traktuj ˛
acego znaki o kodach od 128 do 255 w szczególny sposób. Poniewa˙z
wi˛ec decyzja na temat jednolitego kodowania jeszcze nie zapadła, nie nale˙zy zakłada´c ani korzystania z Latin-1,
ani te˙z z UTF-8, cho´c aktualna implementacja wydaje si˛e faworyzowa´c Latin-1 (zarówno w odniesieniu do kodu
´zródłowego, jak i zestawu znaków u˙zywanego przy wykonaniu programu).
2.1
Struktura wiersza
Program w Pythonie podzielony jest na szereg wierszy logicznych.
2.1.1
Wiersze logiczne
Koniec wiersza logicznego jest reprezentowany przez token NEWLINE. Instrukcje nie mog ˛
a przecina´c granicy
wiersza, za wyj ˛
atkiem sytuacji, w których zezwala na to składnia, odnosz ˛
ac si˛e do NEWLINE, np. pomi˛edzy
instrukcjami wewn ˛
atrz instrukcji zło˙zonych. Wiersz logiczny jest tworzony w oparciu o jeden lub wi˛ecej wierszy
fizycznych, przy wykorzystaniu jawnych lub niejawnych reguł ł ˛
aczenia wierszy.
2.1.2
Wiersze fizyczne
Koniec wiersza fizycznego oznaczony jest w sposób, który jest zale˙zny od platformy programowej. W przy-
padku systemów wywodz ˛
acych si˛e (pod wzgl˛edem architektury) z systemu U
NIX
, koniec wiersza reprezentuje
pochodz ˛
acy ze zbioru
ASCII
znak LF (przesuni˛ecie wiersza, ang. linefeed). W systemie, którego u˙zywa Mac-
intosh, jest to, równie˙z zdefiniowany w
ASCII
, znak CR (powrót kursora, ang: carriage return). W systemach
DOS/Windows koniec wiersza reprezentuje sekwencja obu tych znaków: CR LF (powrót kursora z wyst˛epuj ˛
acym
po nim przesuni˛eciem wiersza).
3
2.1.3
Komentarze
Komentarz rozpoczyna si˛e znakiem krzy˙zyka (
#
), który nie jest cz˛e´sci ˛
a literału napisowego, i ko´nczy si˛e wraz
z ko´ncem wiersza fizycznego. Za wyj ˛
atkiem sytuacji, w których zastosowano jawne zł ˛
aczenie wierszy, komen-
tarz oznacza koniec wiersza logicznego. Jako, ˙ze analizator leksykalny nie generuje tokenów odpowiadaj ˛
acych
komentarzom, s ˛
a one zupełnie niewidoczne dla analizatora składniowego.
2.1.4
Deklaracje kodowania
Je´sli
komentarz
w
pierwszym
wierszu
pliku
´zródłowego
pasuje
do
wyra˙zenia
regularnego
d
coding[=:]\s*([\w-_.]+)
c
, wówczas jest on traktowany jako deklaracja kodowania.
Pierwsza
grupa w tym wyra˙zeniu okre´sla kodowanie pliku. Zalecane formy tych wyra˙ze´n to:
# -*- coding: <nazwa-kodowania> -*-
która jest rozpoznawane przez program GNU Emacs oraz
# vim:fileencoding=<nazwa-kodowania>
która jest rozpoznawana przez program VIM Brama Moolenara. Dodatkowo, je´sli pierwsze bajty w pliku tworz ˛
a
znacznik kolejno´sci bajtów UTF-8 (
’\xef\xbb\xbf’
), wówczas zadeklarowanym kodowaniem pliku jest
UTF-8 (znacznik ten obsługuje m.in. program notepad firmy Microsoft).
Je´sli zostanie zadeklarowane kodowanie, jego nazwa musi nale˙ze´c do zbioru rozpoznawanego przez Pythona.
Ustalone kodowanie jest u˙zywane na etapie analizy leksykalnej, w szczególno´sci przy odnajdywaniu ko´nców
napisów i przy interpretetacji zawarto´sci literałów Unicode. Na potrzeby analizy składniowej literały napisowe s ˛
a
konwertowane do Unicode, po czym, przed rozpocz˛eciem wykonywania, nast˛epuje przywrócenie ich pierwotnego
kodowania. Deklaracja kodowania musi wyst˛epowa´c we wierszu samodzielnie.
2.1.5
Jawne ł ˛
aczenie wierszy
Przy u˙zyciu znaku odwróconego uko´snika (
\
) mo˙zliwe jest poł ˛
aczenie wielu wierszy fizycznych w jeden wiersz
logiczny. Je´sli ostatnim znakiem wiersza fizycznego jest odwrócony uko´snik, nie b˛ed ˛
acy cz˛e´sci ˛
a komentarza ani
literału napisowego, wiersz ł ˛
aczony jest z kolejnym poprzez usuni˛ecie odwróconego uko´snika oraz nast˛epuj ˛
acego
po nim znaku (lub znaków) ko´nca wiersza. Na przykład:
if 1900 < year < 2100 and 1 <= month <= 12 \
and 1 <= day <= 31 and 0 <= hour < 24 \
and 0 <= minute < 60 and 0 <= second < 60:
# wygl ˛
ada na poprawn ˛
a dat˛
e
return 1
Wiersz zako´nczony odwróconym uko´snikiem nie mo˙ze zawiera´c komentarza. Odwrócony uko´snik nie powoduje
przedłu˙zenia komentarza, ani ˙zadnego tokenu, za wyj ˛
atkiem literału napisowego.
U˙zywanie odwróconego
uko´snika w innej cz˛e´sci wiersza poza literałem napisowym jest niedopuszczalne.
2.1.6
Niejawne ł ˛
aczenie wierszy
Wyra˙zenia uj˛ete w nawiasy okr ˛
agłe, nawiasy kwadratowe lub nawiasy klamrowe mog ˛
a by´c rozmieszczone w
wielu wierszach fizycznych bez konieczno´sci u˙zycia odwróconych uko´sników. Na przykład:
4
Rozdział 2. Analiza leksykalna
month_names = [’Januari’, ’Februari’, ’Maart’,
# To s ˛
a holenderskie
’April’,
’Mei’,
’Juni’,
# nazwy wszystkich
’Juli’,
’Augustus’, ’September’,
# miesi˛
ecy w
’Oktober’, ’November’, ’December’]
# roku
Niejawnie zł ˛
aczone wiersze mog ˛
a zawiera´c komentarze. Wci˛ecia w wierszach, b˛ed ˛
acych kontynuacj ˛
a pierwszego
z nich, nie s ˛
a istotne. W´sród zł ˛
aczonych w ten sposób wierszy dopuszczalne s ˛
a równie˙z wiersze puste. Niejawnie
ł ˛
aczone wiersze mo˙zna stosowa´c równie˙z wewn ˛
atrz literałów napisowych u˙zywaj ˛
acych potrójnych znaków cy-
towania (wi˛ecej na ten temat poni˙zej), jednak w tym wypadku nie mog ˛
a one zawiera´c komentarzy.
2.1.7
Wiersze puste
Wiersze logiczne, zawieraj ˛
ace tylko spacje, tabulacje, znaki przesuni˛ecia wiersza i ew. komentarze, s ˛
a ignorowane
(tj. nie s ˛
a dla nich generowane tokeny NEWLINE). Traktowanie pustych wierszy przy pracy interaktywnej mo˙ze
by´c inne i jest zale˙zne od implementacji. W przypadku standardowej implementacji, całkowicie puste wiersze (tj.
te, które nie zawieraj ˛
a ˙zadnych znaków, nawet spacji, czy komentarzy) oznaczaj ˛
a zako´nczenie bie˙z ˛
acej instrukcji
wielowierszowej.
2.1.8
Wci ˛ecia
Odst˛epy (spacje i tabulacje), wyst˛epuj ˛
ace na pocz ˛
atku wiersza logicznego, wykorzystywane s ˛
a do wyliczenia
poziomu wci˛ecia tego wiersza. Poziom wci˛ecia słu˙zy z kolei okre´sleniu sposobu grupowania instrukcji.
Przy analizie wiersza ka˙zdy ze znaków tabulacji zmieniany jest na najmniejsz ˛
a mo˙zliw ˛
a liczb˛e spacji, tak ˛
a jed-
nak, ˙ze wraz z liczb ˛
a znaków poprzedzaj ˛
acych tworzy ona wielokrotno´s´c o´smiu (zamierzeniem jest zastosowanie
reguły, która jest domy´slna w systemach U
NIX
). Ostateczny poziom wci˛ecia okre´sla całkowita liczba spacji przed
pierwszym niepustym znakiem w wierszu. Wci˛ecie nie mo˙ze zosta´c podzielone pomi˛edzy kilka wierszy fizy-
cznych za pomoc ˛
a odwróconego uko´snika. W przypadku wierszy logicznych, składaj ˛
acych si˛e z wielu wierszy
fizycznych, uwzgl˛edniane jest tylko wci˛ecie pierwszego z nich.
Uwaga na temat zgodno´sci pomi˛edzy platformami: ze wzgl˛edu na odmienne zachowanie si˛e edytorów tekstu
w ´srodowiskach ró˙znych od ´srodowiska systemu U
NIX
, nie nale˙zy w obr˛ebie jednego pliku u˙zywa´c do tworzenia
wci˛e´c jednocze´snie spacji i tabulacji. Warto przy tym odnotowa´c, ˙ze pewne platformy mog ˛
a jawnie ogranicza´c
maksymalny poziom wci˛ecia.
Znak formfeed mo˙ze wyst˛epowa´c na pocz ˛
atku wiersza i b˛edzie on wówczas zignorowany, jednak jego pojawienie
si˛e w dalszej cz˛e´sci wiersza przed pierwszym niepustym znakiem powoduje, ˙ze poziom wci˛ecia jest niezdefin-
iowany.
Poziomy wci˛ecia kolejnych wierszy s ˛
a wykorzystywane do wygenerowania tokenów INDENT i DEDENT. Proces
przebiega przy u˙zyciu stosu w sposób opisany poni˙zej.
Przed odczytaniem pierwszego wiersza na stosie odkładana jest liczba zero, która nigdy nie jest z niego zdej-
mowana. Liczby odło˙zone na stosie tworz ˛
a zawsze ci ˛
ag rosn ˛
acy od dna do wierzchołka stosu. Po obliczeniu
poziomu wci˛ecia kolejnego wiersza logicznego jest on porównywany z liczb ˛
a na wierzchołku stosu. Je´sli liczby
s ˛
a równe, nic si˛e nie dzieje. Je´sli poziom wci˛ecia wiersza jest wi˛ekszy, jest on odkładany na stosie i generowany
jest token INDENT. Je´sli poziom wci˛ecia jest mniejszy, wówczas musi on by´c równy jednej z liczb odło˙zonych
na stosie; wszystkie liczby wi˛eksze od niego s ˛
a zdejmowane ze stosu i dla ka˙zdej z nich generowany jest token
DEDENT. Po osi ˛
agni˛eciu ko´nca pliku dla ka˙zdej pozostałej na stosie liczby dodatniej równie˙z generowany jest
token DEDENT.
Poni˙zszy fragment kodu zawiera wci˛ecia ustawione w poprawny (cho´c myl ˛
acy) sposób.
2.1. Struktura wiersza
5
def perm(l):
# Obliczenie listy wszystkich permutacji l
if len(l) <= 1:
return [l]
r = []
for i in range(len(l)):
s = l[:i] + l[i+1:]
p = perm(s)
for x in p:
r.append(l[i:i+1] + x)
return r
Poni˙zszy przykład demonstruje ró˙zne bł˛edy dotycz ˛
ace wci˛e´c:
def perm(l):
# bł ˛
ad: wci˛
ecie pierwszego wiersza
for i in range(len(l)):
# bł ˛
ad: brak wci˛
ecia
s = l[:i] + l[i+1:]
p = perm(l[:i] + l[i+1:])
# bł ˛
ad: nieoczekiwane wci˛
ecie
for x in p:
r.append(l[i:i+1] + x)
return r
# bł ˛
ad: niekonsekwentne wci˛
ecie
(W rzeczywisto´sci pierwsze trzy bł˛edy s ˛
a wykrywane przez parser, tylko ostatni z nich wykrywa analizator
leksykalny, poniewa˙z poziom wci˛ecia wiersza zawieraj ˛
acego
return r
nie odpowiada poziomowi pobranemu
ze stosu.)
2.1.9
Odst ˛epy pomi ˛edzy tokenami
Za wyj ˛
atkiem pocz ˛
atku wiersza logicznego (tj. miejsca, gdzie ustalany jest poziom wci˛ecia) oraz literałów
napisowych, znaki puste takie jak spacja, tabulacja i znak formfeed mog ˛
a by´c zamiennie u˙zywane do rozdziela-
nia tokenów. Znaki puste s ˛
a wymagane pomi˛edzy dwoma tokenami tylko wówczas, gdy sklejenie tych tokenów
mogłoby zosta´c zinterpretowane jako inny token.
2.2
Inne tokeny
Poza tokenami NEWLINE, INDENT i DEDENT istnieje równie˙z pi˛e´c innych kategorii tokenów: identyfika-
tory, słowa kluczowe, literały, operatory i rozgraniczniki. Znaki puste (za wyj ˛
atkiem omówionych wcze´sniej
znaków ko´nca wiersza) nie s ˛
a tokenami, lecz słu˙z ˛
a do rozdzielenia s ˛
asiaduj ˛
acych tokenów. W przypadku niejed-
noznaczno´sci, za kolejny token w ci ˛
agu wej´sciowym uznawany jest najdłu˙zszy mo˙zliwy ci ˛
ag znaków, tworz ˛
acy
pojedynczy token.
2.3
Identyfikatory i słowa kluczowe
Identyfikatory, okre´slane równie˙z jako nazwy, s ˛
a opisywane przez nast˛epuj ˛
ace definicje leksykalne:
identifier
::=
(letter|"_") (letter | digit | "_")*
letter
::=
lowercase | uppercase
lowercase
::=
"a"..."z"
uppercase
::=
"A"..."Z"
digit
::=
"0"..."9"
Identyfikatory mog ˛
a mie´c dowoln ˛
a długo´s´c. Małe i wielkie litery s ˛
a rozró˙zniane.
6
Rozdział 2. Analiza leksykalna
2.3.1
Słowa kluczowe
Nast˛epuj ˛
ace identyfikatory s ˛
a u˙zywane jako słowa zarezerwowane w j˛ezyku, nazywane te˙z jego słowami kluc-
zowymi. Nie mog ˛
a by´c one u˙zywane jako zwykłe identyfikatory, a ich zapis musi by´c zgodny z podanym poni˙zej:
and
del
for
is
raise
assert
elif
from
lambda
return
break
else
global
not
try
class
except
if
or
while
continue
exec
import
pass
yield
def
finally
in
Zwracamy uwag˛e, ˙ze cho´c identyfikator
as
mo˙ze by´c u˙zywany jako element składniowy instrukcji
import
, nie
nale˙zy on obecnie do zbioru słów zarezerwowanych.
W przyszło´sci zarówno
as
, jak i
None
stan ˛
a si˛e si˛e słowami kluczowymi.
2.3.2
Zarezerwowane klasy identyfikatorów
Pewne klasy identyfikatorów (poza słowami kluczowymi) maj ˛
a specjalne znaczenie. Nale˙z ˛
a do nich:
Zapis
Znaczenie
Uwagi
_*
Nie jest importowany przez „
from
moduł
import *
”
(1)
__*__
Nazwa zdefiniowana przez system
__*
Nazwa przekształcana jako prywatna wewn ˛
atrz klasy
Zajrzyj te˙z do sekcji: 6.12, „Instrukcja
import
”; 3.3, „Specjalne nazwy metod”; 5.2.1, „Identyfikatory (nazwy)”.
Uwaga:
(1) Przy pracy interaktywnej specjalny identyfikator „
_
” jest u˙zywany do zapisu wyniku ostatniego obliczenia.
Jest on wówczas umieszczony w module
__builtin__
. Przy pracy nieinteraktywnej identyfikator „
_
”
nie ma ˙zadnego specjalnego znaczenia i nie jest domy´slnie zdefiniowany.
2.4
Literały
Literały s ˛
a zapisem warto´sci stałych pewnych wbudowanych typów.
2.4.1
Literały napisowe
Literały napisowe opisywane s ˛
a przez nast˛epuj ˛
ace definicje składniowe:
stringliteral
::=
[stringprefix](shortstring | longstring)
stringprefix
::=
"r" | "u" | "ur" | "R" | "U" | "UR" | "Ur" | "uR"
shortstring
::=
"’" shortstringitem* "’" | ’“ shortstringitem* ’“
longstring
::=
"”’" longstringitem* "”’"
| ’“ longstringitem* ’“
shortstringitem
::=
shortstringchar | escapeseq
longstringitem
::=
longstringchar | escapeseq
shortstringchar
::=
<dowolny znak ASCII poza "\", nowym wierszem lub znakiem cytowania>
longstringchar
::=
<dowolny znak ASCII poza "\">
escapeseq
::=
"\" <dowolny znak ASCII>
Powy˙zsze produkcje nie wskazuj ˛
a na pewne istniej ˛
ace ograniczenie składniowe. Polega ono na tym, ˙ze pomi˛edzy
symbolem
stringprefix
i pozostał ˛
a cz˛e´sci ˛
a literału napisowego nie s ˛
a dopuszczalne ˙zadne odst˛epy.
2.4. Literały
7
U˙zywaj ˛
ac j˛ezyka naturalnego: literały napisowe mo˙zemy utworzy´c poprzez uj˛ecie napisu w odpowiadaj ˛
ace sobie
apostrofy (
’
) lub cudzysłowy (
"
). Napis mo˙zna uj ˛
a´c równie˙z w odpowiadaj ˛
ace sobie grupy trzech apostrofów
lub cudzysłowów (w tym przypadku odwołujemy si˛e do niego jako do potrójnie zacytowanego napisu). Aby
umie´sci´c wewn ˛
atrz literału napisowego znak o specjalnym znaczeniu, np. znak nowego wiersza, apostrof, cud-
zysłów, czy te˙z sam odwrócony uko´snik (
\
), nale˙zy odpowiedni znak poprzedzi´c odwróconym uko´snikiem. Je´sli
literał znakowy poprzedzimy liter ˛
a „
r
” lub „
R
”, jest on nazywany napisem surowym i stosuj ˛
a si˛e do niego inne
reguły traktowania sekwencji poprzedzonych odwróconym uko´snikiem. Przedrostek „
u
” lub „
U
” oznacza, ˙ze
napis jest napisem Unicode. W napisach tych u˙zywa si˛e zestawu znaków zdefiniowanego przez Unicode Consor-
tium i ISO 10646. W napisach Unicode dost˛epne s ˛
a te˙z pewne dodatkowe, opisane poni˙zej, sekwencje specjalne.
Mo˙zliwe jest ł ˛
aczenie obu przedrostków znakowych. W takim przypadku znak „
u
” musi si˛e pojawi´c przed „
r
”.
Wewn ˛
atrz potrójnie zacytowanych napisów dopuszczalne jest umieszczanie znaków nowego wiersza oraz apos-
trofów i cudzysłowów bez poprzedzania ich odwróconym uko´snikiem. Wyj ˛
atkiem jest oczywi´scie grupa trzech
apostrofów lub cudzysłowów (w zale˙zno´sci od grupy rozpoczynaj ˛
acej literał), która oznacza koniec napisu.
O ile napis nie jest poprzedzony znakiem „
r
” lub „
R
”, sekwencje specjalne traktowane s ˛
a zgodnie z regułami
podobnymi do stosowanych w standardzie j˛ezyka C. Rozpoznawanymi sekwencjami specjalnymi s ˛
a:
Sekwencja specjalna
Znaczenie
Uwagi
\
nowy_wiersz
Ignorowana
\\
Odwrócony uko´snik (
\
)
\’
Apostrof (
’
)
\"
Cudzysłów (
"
)
\a
ASCII
Brz˛eczyk (BEL)
\b
ASCII
Backspace (BS)
\f
ASCII
Formfeed (FF)
\n
ASCII
Przesuni˛ecie wiersza (LF)
\N{
nazwa
}
Znak o nazwie nazwa w bazie danych Unicode (tylko napisy Unicode)
\r
ASCII
Powrót kursora (CR)
\t
ASCII
Tabulacja pozioma (TAB)
\u
xxxx
Znak o warto´sci 16-bitowej xxxx zapisanej szesnastkowo (tylko Unicode)
(1)
\U
xxxxxxxx
Znak o warto´sci 32-bitowej xxxxxxxx zapisanej szesnastkowo (tylko Unicode)
(2)
\v
Pionowa tabulacja (VT) w zestawie
ASCII
\
ooo
Znak
ASCII
o kodzie ooo zapisanym ósemkowo
(3)
\x
hh
Znak
ASCII
o kodzie hh zapisanym szesnastkowo
(4)
Uwagi:
(1) Przy u˙zyciu tej sekwencji specjalnej mo˙zliwe jest kodowanie indywidualnych jednostek kodu, które tworz ˛
a
cz˛e´sci pary zast˛epczej.
(2) W ten sposób mo˙zna zakodowa´c dowolny znak Unicode, jednak je´sli Python został skompilowany z ustaw-
ieniem u˙zycia 16-bitowych jednostek kodu (ustawienie domy´slne), to znaki spoza zakresu BMP (Basic
Multilingual Plane) b˛ed ˛
a kodowane z wykorzystaniem par zast˛epczych. Przy u˙zyciu tej sekwencji specjal-
nej mo˙zliwe jest te˙z kodowanie indywidualnych jednostek kodu, które tworz ˛
a cz˛e´sci pary zast˛epczej.
(3) Podobnie, jak w Standardzie C dopuszczalne jest u˙zycie do trzech cyfr ósemkowych.
(4) W odró˙znieniu w Standardu C dopuszczalne jest u˙zycie co najwy˙zej dwóch cyfr szesnastkowych.
W odró˙znieniu od Standardu C, wszystkie nierozpoznane sekwencje specjalne s ˛
a pozostawiane bez zmian, tj.
odwrócony uko´snik jest pozostawiany wewn ˛
atrz napisu. Zachowanie to jest bardzo przydatne przy wykrywaniu
bł˛edów – po niepoprawnym zapisaniu sekwencji łatwo wykryjemy bł ˛
ad w napisie wynikowym. Zauwa˙zmy, ˙ze
pozycje w powy˙zszej tabeli oznaczone jako „(tylko Unicode)” s ˛
a traktowane jako nierozpoznane, je´sli pojawi ˛
a si˛e
w literałach nie b˛ed ˛
acych literałami Unicode.
Je´sli napis poprzedzony jest znakiem „
r
” lub „
R
”, ka˙zdy znak pojawiaj ˛
acy si˛e po odwróconym uko´sniku jest
pozostawiany bez zmian, pozostawiane s ˛
a równie˙z wszystkie odwrócone uko´sniki. Na przykład, literał napisowy
r"\n"
składa si˛e z dwóch znaków: odwróconego uko´snika i małej litery „
n
”. Apostrofy i cudzysłowy mog ˛
a po-
jawi´c si˛e w napisie po poprzedzeniu ich odwrotnym uko´snikiem, jednak odwrotny uko´snik pozostanie wówczas
8
Rozdział 2. Analiza leksykalna
cz˛e´sci ˛
a napisu. Na przykład,
r"\
jest poprawnym literałem, składaj ˛
acym si˛e z dwóch znaków: odwróconego
uko´snika i cudzysłowu,
r"\"
nie jest natomiast poprawnym literałem, poniewa˙z nawet surowe napisy nie mog ˛
a
by´c zako´nczone nieparzyst ˛
a liczb ˛
a odwróconych uko´sników (w szczególno´sci surowe napisy nie mog ˛
a by´c za-
ko´nczone pojedynczym odwróconym uko´snikiem). Pojedynczy odwrócony uko´snik z nast˛epuj ˛
acym po nim ko´ncem
wiersza traktuje si˛e jako par˛e znaków wewn ˛
atrz surowego napisu, nie za´s jako kontynuacj˛e wiersza.
W przypadku, gdy zostanie u˙zyte poł ˛
aczenie przedrostków „
r
” lub „
R
” oraz „
u
” lub „
U
”, przetwarzane s ˛
a sek-
wencje specjalne
\uXXXX
, lecz wszystkie pozostałe uko´sniki pozostaj ˛
a jako cz˛e´s´c napisu. Na przykład, literał
napisowy
ur"\u0062\n"
składa si˛e z trzech znaków Unicode o nazwach: „LATIN SMALL LETTER B”,
„REVERSE SOLIDUS” oraz „LATIN SMALL LETTER N”. Odwrócony uko´snik mo˙ze by´c poprzedzony innym
odwróconym uko´snikiem, jednak w takim przypadku oba pozostan ˛
a cz˛e´sci ˛
a napisu. W wyniku tego, sekwencje
specjalne
\uXXXX
s ˛
a rozpoznawane tylko, je´sli literał zawiera nieparzyst ˛
a liczb˛e odwróconych uko´sników.
2.4.2
Sklejanie literałów napisowych
Dopuszczalne jest umieszczenie bezpo´srednio po sobie (po rozdzieleniu za pomoc ˛
a pustych znaków) wielu liter-
ałów napisowych, które s ˛
a wówczas traktowane jak sklejenie poszczególnych napisów. Napisy uj˛ete mog ˛
a by´c w
ró˙zne znaki. Na przykład,
"witaj" ’´
swiecie’
jest odpowiednikiem
"witaj ´
swiecie"
. Mo˙zliwo´s´c t˛e
mo˙zna wykorzysta´c do zmniejszenia liczby odwróconych uko´sników, zwykle potrzebnych przy dzieleniu długich
napisów pomi˛edzy wiele wierszy, lub nawet do umieszczenia komentarzy pomi˛edzy fragmentami napisu, np.:
re.compile("[A-Za-z_]"
# litera lub podkre´
slenie
"[A-Za-z0-9_]*"
# litera, cyfra lub podkre´
slenie
)
Zauwa˙zmy, ˙ze cho´c sklejanie jest zdefiniowane na poziomie składniowym, to jednak realizowane jest w trakcie
kompilacji. Aby sklei´c napisy w trakcie wykonania, konieczne jest u˙zycie operatora „+”. Sklejane fragmenty
mog ˛
a by´c tworzone przy u˙zyciu ró˙znych sposobów cytowania, np. mo˙zliwe jest sklejanie surowych napisów z
napisami wykorzystuj ˛
acymi potrójne apostrofy.
2.4.3
Literały liczbowe
Istniej ˛
a cztery typy literałów liczbowych: liczby całkowite, długie liczby całkowite, liczby zmiennoprzecinkowe
i liczby urojone. Nie istniej ˛
a literały zespolone, gdy˙z liczby zespolone mo˙zna zapisa´c jako sum˛e liczby urojonej i
liczby rzeczywistej.
Zwracamy uwag˛e na fakt, i˙z literały liczbowe nie zawieraj ˛
a znaku. Zapis typu
-1
jest w rzeczywisto´sci wyra˙ze-
niem zło˙zonym z operatora
-
oraz literału
1
.
2.4.4
Literały całkowitoliczbowe i długie literały całkowitoliczbowe
Literały całkowitoliczbowe i długie literały całkowitoliczbowe opisywane s ˛
a przez nast˛epuj ˛
ace definicje
leksykalne:
longinteger
::=
integer ("l" | "L")
integer
::=
decimalinteger | octinteger | hexinteger
decimalinteger
::=
nonzerodigit digit* | "0"
octinteger
::=
"0" octdigit+
hexinteger
::=
"0" ("x" | "X") hexdigit+
nonzerodigit
::=
"1"..."9"
octdigit
::=
"0"..."7"
hexdigit
::=
digit | "a"..."f" | "A"..."F"
Cho´c do oznaczenia długiej liczby całkowitej mo˙zna u˙zy´c przyrostka zarówno w postaci małej, jak i wielkiej litery
„
L
”, zalecane jest u˙zywanie wielkiej litery, poniewa˙z mała litera „
l
” mo˙ze by´c mylona z cyfr ˛
a „
1
”.
Literały całkoliczbowe opisuj ˛
ace warto´s´c przekraczaj ˛
ac ˛
a najwi˛eksz ˛
a dopuszczaln ˛
a dla zwykłych liczb całkow-
itych (tj. 2147483647, je´sli u˙zywana jest arytmetyka 32-bitowa) s ˛
a akceptowane tak, takby były literałami opisu-
2.4. Literały
9
j ˛
acymi długie liczby zmiennoprzecinkowe. Podobnie zachowuj ˛
a si˛e literały ósemkowe i szesnastkowe, jednak dla
warto´sci przekraczaj ˛
acych najwi˛eksz ˛
a liczb˛e całkowit ˛
a (ze znakiem), a mniejszych lub równych najwi˛ekszej licz-
bie całkowitej bez znaku (przy arytmetyce 32-bitowej s ˛
a to, odpowiednio, warto´sci 2147483647 i 4294967295)
ich warto´s´c ustalana jest poprzez odj˛ecie warto´sci zapisanej w literale od najwi˛ekszej liczby całkowitej bez znaku
zwi˛ekszonej o 1 (4294967296 przy arytmetyce 32-bitowej). Poza ograniczeniem wynikaj ˛
acym z rozmiaru dost˛ep-
nej pami˛eci nie nakłada si˛e ˙zadnych ogranicze´n na dopuszczalne warto´sci długich literałów całkowitoliczbowych.
Na przykład, je´sli u˙zywana jest maszyna 32-bitowa, to warto´sci ˛
a literału 0xdeadbeef jest -559038737, podczas
gdy literału 0xdeadbeeffeed — +244837814107885L.
Kilka przykładów literałów całkowitoliczbowych (pierwszy wiersz) i długich literałów całkowitoliczbowych
(wiersze drugi i trzeci):
7
2147483647
0177
0x80000000
3L
79228162514264337593543950336L
0377L
0x100000000L
79228162514264337593543950336
0xdeadbeeffeed
2.4.5
Literały zmiennoprzecinkowe
Literały zmiennoprzecinkowe s ˛
a opisane przez nast˛epuj ˛
ace definicje leksykalne:
floatnumber
::=
pointfloat | exponentfloat
pointfloat
::=
[intpart] fraction | intpart "."
exponentfloat
::=
(intpart | pointfloat) exponent
intpart
::=
digit+
fraction
::=
"." digit+
exponent
::=
("e" | "E") ["+" | "-"] digit+
Zwró´cmy uwag˛e, ˙ze cz˛e´s´c całkowita i wykładnik liczby zmiennoprzecinkowej mog ˛
a wygl ˛
ada´c jak liczby w za-
pisie ósemkowym, lecz zawsze traktowane s ˛
a jak liczby w zapisie dziesi˛etnym. Na przykład, „
077e010
” jest
popranym literałem i reprezentuje t˛e sam ˛
a liczb˛e, co literał „
77e10
”. Dopuszczalny zakres warto´sci liczb zmi-
ennoprzecinkowych jest zale˙zny od implementacji. Kilka przykładów literałów zmiennoprzecinkowych:
3.14
10.
.001
1e100
3.14e-10
0e0
Zwuwa˙zmy, i˙z literały liczbowe nie zawieraj ˛
a znaku. Zapis typu
-1
jest w rzeczywisto´sci wyra˙zeniem zło˙zonym
z operatora
-
oraz literału
1
.
2.4.6
Literały urojone
Literały urojone opisuje poni˙zsza definicja leksykalna:
imagnumber
::=
(floatnumber | intpart) ("j" | "J")
Literał urojony reprezentuje liczb˛e zespolon ˛
a z cz˛e´sci ˛
a rzeczywist ˛
a równ ˛
a 0,0. Liczby zespolone reprezentowane
s ˛
a przez pary liczb zmiennoprzecinkowych i nakładaj ˛
a jednakowe ograniczenia na ich zakresy. Liczb˛e zespolon ˛
a
z niezerow ˛
a cz˛e´sci ˛
a rzeczywist ˛
a mo˙zna zapisa´c jako sum˛e liczby rzeczywistej i urojonej, np.
(3+4j)
. Poni˙zej
przedstawiamy kilka przykładów literałów urojonych:
3.14j
10.j
10j
.001j
1e100j
3.14e-10j
2.5
Operatory
Nast˛epuj ˛
ace tokeny s ˛
a operatorami:
10
Rozdział 2. Analiza leksykalna
+
-
*
**
/
//
%
<<
>>
&
|
^
~
<
>
<=
>=
==
!=
<>
Zapisy
<>
oraz
!=
stanowi ˛
a alternatywne formy zapisu tego samego operatora. Zaleca si˛e u˙zywanie
!=
, forma
<>
jest przestarzała.
2.6
Rozgraniczniki
Nast˛epuj ˛
ace tokeny słu˙z ˛
a w gramatyce jako rozgraniczniki:
(
)
[
]
{
}
,
:
.
‘
=
;
+=
-=
*=
/=
//=
%=
&=
|=
^=
>>=
<<=
**=
Kropka mo˙ze pojawi´c si˛e równie˙z jako cz˛e´s´c literału zmiennoprzecinkowego lub urojonego. Sekwencja trzech
kropek ma specjalne znaczenie w wykrojeniach. Elementy drugiej połowy powy˙zszej listy, tj. modyfikuj ˛
ace
operatory przypisania, na poziomie leksykalnym słu˙z ˛
a rozdzielaniu tokenów, lecz powoduj ˛
a równie˙z wykonanie
pewnych operacji.
Nast˛epuj ˛
ace drukowalne znaki
ASCII
maj ˛
a specjalne znaczenie, jako cz˛e´sci innych tokenów, ew. s ˛
a w inny sposób
znacz ˛
ace dla analizatora leksykalnego:
’
"
#
\
Nast˛epuj ˛
ace drukowalne znaki
ASCII
nie s ˛
a wykorzystywane w Pythonie.
Ich wyst ˛
apienie poza literałami
napisowymi i komentarzami bezwarunkowo powoduje bł ˛
ad:
@
$
?
2.6. Rozgraniczniki
11
12
ROZDZIAŁ
TRZECI
Model danych
3.1
Obiekty, warto´sci i typy
Obiekty s ˛
a w Pythonie abstrakcj ˛
a danych. Ka˙zda dana jest reprezentowana przez obiekt lub przez relacj˛e pomi˛edzy
obiektami. (Zgodnie z modelem „komputera z programem w pami˛eci” Von Neumanna kod równie˙z reprezen-
towany jest przez obiekty.)
Ka˙zdy obiekt ma to˙zsamo´s´c, typ i warto´s´c. Od chwili utworzenia obiektu jego to˙zsamo´s´c nigdy si˛e nie zmienia,
mo˙zna o niej my´sle´c jak o adresie obiektu w pami˛eci. Do porównania to˙zsamo´sci dwóch obiektów słu˙zy op-
erator
is
. Funkcja
id()
zwraca warto´s´c całkowit ˛
a, reprezentuj ˛
ac ˛
a to˙zsamo´s´c (w standardowej implementacji
funkcja ta zwraca adres obiektu, przekształcony do postaci liczbowej). Typ obiektu, podobnie jak jego to˙zsamo´s´c,
równie˙z nie mo˙ze ulec zmianie.
1
Typ okre´sla zbiór atrybutów i operacji, które mo˙zna wykona´c na obiekcie (np.
„czy obiekt ma długo´s´c?”) oraz definiuje zbiór dopuszczalnych warto´sci obiektu. Typ obiektu (który równie˙z jest
obiektem) mo˙zna pobra´c za pomoc ˛
a funkcji
type()
. Warto´s´c obiektu w przypadku pewnych obiektów mo˙ze
zosta´c zmieniona. Obiekty o takiej wła´sciwo´sci nazywamy obiektami zmiennymi, natomiast te, których warto´s´c
nie mo˙ze ulec zmianie, nazywamy obiektami niezmiennymi. (Warto´s´c niezmiennego typu kontenerowego, która
zawiera odwołania do obiektów zmiennych, mo˙ze zosta´c po´srednio zmieniona poprzez zmian˛e obiektów skład-
owych; sam kontener jest jednak w tym przypadku nadal traktowany jako niezmienny, poniewa˙z zbiór, kolejno´s´c,
itp. obiektów składowych nie mo˙ze ulec zmianie. Jak wida´c, ró˙znica pomi˛edzy obiektami zmiennymi i niezmien-
nymi bywa do´s´c subtelna.) Zmienno´s´c obiektu jest cech ˛
a narzucon ˛
a przez jego typ. Na przykład, liczby, napisy i
krotki s ˛
a niezmienne, podczas gdy słowniki i listy s ˛
a zmienne.
Obiekty nie s ˛
a nigdy jawnie usuwane, mog ˛
a jednak zosta´c usuni˛ete niejawnie (w procesie od´smiecania), kiedy nie
b˛ed ˛
a ju˙z dost˛epne z ˙zadnego miejsca w programie. Implementacja mo˙ze opó´zni´c od´smiecenie lub zrezygnowa´c z
niego zupełnie, nie mo˙ze jedynie usuwa´c obiektów, które nadal s ˛
a dost˛epne z pewnych miejsc. (Aktualna imple-
mentacja wykorzystuje liczniki odwoła´n, wraz z opcjonalnym opó´znionym wykrywaniem odwoła´n cyklicznych;
wi˛ecej szczegółów na temat implementacji od´smiecania mo˙zna uzyska´c w podr˛eczniku
Podr˛ecznik programisty
Pythona - opis biblioteki standardowej
).
Zwró´cmy uwag˛e, ˙ze implementacje Pythona mog ˛
a, ze wzgl˛edu na ułatwienie procesu ´sledzenia programu i
wyszukiwania w nim bł˛edów, tworzy´c niejawnie dodatkowe odwołania do obiektów, co wydłu˙za ich czas ˙zycia.
Podobna sytuacja mo˙ze zaj´s´c przy przechwyceniu wyj ˛
atku za pomoc ˛
a instrukcji „
try
...
except
”.
Pewne obiekty zawieraj ˛
a odwołania do zasobów „zewn˛etrznych”, jakimi s ˛
a np. pliki lub okna w systemie ok-
ienkowym. Przyjmuje si˛e, ˙ze zasoby te s ˛
a zwalniane w chwili od´smiecania obiektu, jednak ka˙zdy z tych obiektów
umo˙zliwia równie˙z jawne zwolnienie zasobów, zwykle za pomoc ˛
a metody
close()
, poniewa˙z nigdy nie mamy
gwarancji od´smiecenia obiektu. Programy korzystaj ˛
ace z takich obiektów powinny zawsze jawnie zwalnia´c wyko-
rzystywane przez nie zasoby. W bardzo wygodny sposób pozwala to uczyni´c instrukcja „
try
...
finally
”.
Pewne obiekty zawieraj ˛
a odwołania do innych obiektów. S ˛
a one nazywane kontenerami. Kontenerami s ˛
a na
przykład krotki, listy i słowniki. Odwołania te stanowi ˛
a cz˛e´s´c warto´sci kontenera. W wi˛ekszo´sci przypadków,
odwołuj ˛
ac si˛e do warto´sci kontenera mamy na my´sli równie˙z warto´sci jego obiektów składowych, nie za´s tylko
ich to˙zsamo´sci. Przy okre´slaniu zmienno´sci kontenera uwzgl˛edniane s ˛
a jednak wył ˛
acznie to˙zsamo´sci obiektów
1
Od Pythona w wersji 2.2 rozpocz ˛
ał si˛e proces ł ˛
aczenia typów z klasami, co sprawia, ˙ze przedstawione zało˙zenie, podobnie jak kilka
innych zawartych w podr˛eczniku, nie jest zupełnie ´scisłe i kompletne. Na przykład obecnie jest mo˙zliwa zmiana typu obiektu, o ile ma to
miejsce przy zachowaniu pewnych ustalonych warunków. Do czasu przeprowadzenia obszernego przegl ˛
adu tego podr˛ecznika nale˙zy zawarte
w nim stwierdzenia odnosi´c tylko do „klasycznych klas”, które ze wzgl˛edu na zgodno´s´c wstecz s ˛
a w Pythonie 2.2 i 2.3 u˙zywane domy´slnie.
13
składowych. Warto´s´c niezmiennego kontenera (takiego, jak krotka) mo˙ze wi˛ec ulec zmianie, je´sli zawiera odwoła-
nia do obiektów zmiennych i warto´s´c którego´s z tych obiektów si˛e zmieni.
Typ obiektu wpływa na niemal wszystkie aspekty jego zachowania. W pewnym sensie ma wpływ nawet na
to˙zsamo´s´c obiektu, poniewa˙z wyra˙zenia zwracaj ˛
ace now ˛
a warto´s´c typu niezmiennego mog ˛
a w rzeczywisto´sci
zwróci´c odwołanie do istniej ˛
acego ju˙z obiektu tego typu o tej samej warto´sci, za´s w przypadku typów zmiennych
nie jest to dopuszczalne. Na przykład, po wykonaniu „
a = 1; b = 1
”
a
i
b
mog ˛
a (cho´c nie musz ˛
a, gdy˙z
zale˙zy to od implementacji) odwoływa´c si˛e do tego samego obiektu o warto´sci jeden, podczas gdy po wykonaniu
„
c = []; d = []
” mamy gwarancj˛e, ˙ze
c
i
d
odwołuj ˛
a si˛e do dwóch ró˙znych, nowo utworzonych pustych
list. (Zauwa˙zmy jednak, ˙ze „
c = d = []
” przypisuje ten sam obiekt do
c
oraz
d
.)
3.2
Hierarchia typów standardowych
Poni˙zej znajduje si˛e lista typów wbudowanych w Pythonie. Moduły rozszerzaj ˛
ace (napisane w C, Javie lub innym
j˛ezyku, zale˙znie od implementacji) mog ˛
a definiowa´c dodatkowe typy. Hierarchia mo˙ze równie˙z zosta´c poszerzona
o nowe typy w przyszłych wersjach Pythona. Mog ˛
a si˛e np. pojawi´c liczby wymierne, tablice liczb całkowitych
zapisane w efektywny sposób, itp.
Niektóre z poni˙zszych opisów typów zawieraj ˛
a akapit opisuj ˛
acy „atrybuty specjalne”. S ˛
a to atrybuty, daj ˛
ace
dost˛ep do szczegółów implementacyjnych i nie s ˛
a przeznaczone do ogólnego u˙zytku, gdy˙z ich definicje mog ˛
a w
przyszło´sci ulec zmianie.
None Typ ten ma tylko jedn ˛
a warto´s´c i istnieje jeden obiekt o tej warto´sci, dost˛epny poprzez wbudowan ˛
a nazw˛e
None
. W wielu sytuacjach u˙zywany jest on do oznaczenia braku warto´sci, np. zwracany jest przez funkcje,
które jawnie niczego nie zwracaj ˛
a. Warto´sci ˛
a logiczn ˛
a obiektu
None
jest fałsz.
NotImplemented Typ ten ma tylko jedn ˛
a warto´s´c i istnieje jeden obiekt o tej warto´sci, dost˛epny poprzez wbu-
dowan ˛
a nazw˛e
NotImplemented
. Mo˙ze on zosta´c zwrócony przez metody numeryczne i metody porów-
na´n szczegółowych w przypadkach, gdy wykonywana operacja nie mo˙ze zosta´c wykonana z podanymi ar-
gumentami. (Nast˛epnie, w zale˙zno´sci od operatora, interpreter spróbuje wykona´c operacj˛e odwrotn ˛
a lub w
inny sposób uratowa´c sytuacj˛e.) Warto´sci ˛
a logiczn ˛
a obiektu
NotImplemented
jest fałsz.
Wykrojenie Typ ten ma tylko jedn ˛
a warto´s´c i istnieje jeden obiekt o tej warto´sci, dost˛epny poprzez wbudowan ˛
a
nazw˛e
Ellipsis
. Jest on wykorzystywany do zaznaczenia obecno´sci formy „
...
” w wykrojeniu.
Warto´sci ˛
a logiczn ˛
a obiektu
Ellipsis
jest prawda.
Liczby Liczby s ˛
a tworzone za pomoc ˛
a literałów liczbowych oraz zwracane jako wyniki przez operatory arytmety-
czne i wbudowane funkcje arytmetyczne. Obiekty liczbowe s ˛
a niezmienne - po utworzeniu nie zmieniaj ˛
a
nigdy swojej warto´sci. Liczby w Pythonie s ˛
a oczywi´scie silnie powi ˛
azane z matematycznym poj˛eciem
liczby, lecz nało˙zone s ˛
a na nie pewne ograniczenia zwi ˛
azane z reprezentacj ˛
a liczb w komputerach.
Python rozró˙znia liczby całkowite (integer), zmiennoprzecinkowe (floating point) oraz zespolone (com-
plex):
Liczby całkowite Reprezentuj ˛
a one elementy matematycznego zbioru liczb całkowitych.
Istniej ˛
a trzy typy liczb całkowitych:
Zwykłe liczby całkowite Reprezentuj ˛
a one liczby w zakresie co najmniej od -2147483648 do
2147483647. (Zakres mo˙ze by´c wi˛ekszy na maszynach z dłu˙zszym słowem maszynowym, lecz
nigdy nie b˛edzie mniejszy) Je´sli wynik operacji nie mie´sci si˛e w zakresie, wynikiem operacji jest
warto´s´c długiego typu całkowitoliczbowego (w niektórych przypadkach jest zamiast tego gen-
erowany wyj ˛
atek
OverflowError
). Przy operacjach przesuni˛e´c i maskowa´n bitowych zakłada
si˛e, ˙ze liczby całkowite zapisane s ˛
a przy u˙zyciu kodu uzupełnieniowego do dwóch na przynajm-
niej 32 bitach.
Długie liczby całkowite Reprezentuj ˛
a one liczby w nieograniczonym zakresie, a raczej ogranic-
zonym wył ˛
acznie rozmiarem dost˛epnej pami˛eci.
Przy operacjach przesuni˛e´c i maskowa´n
bitowych zakłada si˛e, ˙ze liczby całkowite zapisane s ˛
a przy u˙zyciu kodu uzupełnieniowego do
dwóch w wersji daj ˛
acej iluzj˛e operowania na niesko´nczonej liczbie bitów.
14
Rozdział 3. Model danych
Warto´sci logiczne Reprezentuj ˛
a one logiczne warto´sci False (fałsz) oraz True (prawda). Te dwie
warto´sci s ˛
a jedynymi obiektami typu logicznego Boolean. Typ logiczny jest podtypem zwykłych
liczb całkowitych, za´s warto´sci tego typu w niemal wszystkich kontekstach zachowuj ˛
a si˛e jak
warto´sci 0 (w przypadku fałszu) oraz 1 (w przypadku prawdy). Wyj ˛
atkiem jest przekształcanie
warto´sci do postaci napisowej – w tym przypadku warto´sciom odpowiadaj ˛
a napisy
"False"
i
"True"
.
Reguły reprezentacji liczb całkowitych skonstruowane s ˛
a tak, aby operacje przesuni˛e´c i maskowa´n
na liczbach ujemnych były jak najbardziej u˙zyteczne i aby przej´scia pomi˛edzy zwykłymi i długimi
liczbami całkowitymi nie powodowały niespodzianek. W przypadku ka˙zdej operacji poza przesuni˛e-
ciem w lewo, je´sli jej rezultat mie´sci si˛e w zakresie zwykłych liczb całkowitych, da ona dokładnie
taki sam wynik niezale˙znie od u˙zytego typu całkowitego oraz przy u˙zyciu operatorów z argumentami
ró˙znych typów.
Liczby zmiennoprzecinkowe Reprezentuj ˛
a one liczby za pomoc ˛
a zapisu zmiennoprzecinkowego pod-
wójnej precyzji udost˛epnianego przez maszyn˛e. Dopuszczalny zakres liczb i obsługa przepełnie´n
uzale˙znione s ˛
a od architektury maszyny (oraz implementacji Pythona w Javie lub C). Python nie
obsługuje liczb zmiennoprzecinkowych pojedynczej precyzji, poniewa˙z ew. oszcz˛edno´s´c pami˛eci i
czasu procesora uzyskana dzi˛eki ich wykorzystaniu, byłaby i tak utracona z powodu u˙zycia ich za
po´srednictwem obiektów Pythona, a wprowadzanie dodatkowego typu zmiennoprzecinkowego kom-
plikowałoby sam j˛ezyk.
Liczby zespolone Reprezentuj ˛
a one liczby zespolone jako pary liczb w zapisie zmiennoprzecinkowym
podwójnej precyzji udost˛epnianym przez maszyn˛e.
Uwagi wspomniane przy liczbach zmienno-
przecinkowych nale˙zy odnie´s´c równie˙z do liczb zespolonych. Cz˛e´s´c rzeczywist ˛
a oraz urojon ˛
a liczby
zespolonej
z
mo˙zna pobra´c poprzez atrybuty
z.real
oraz
z.imag
(przeznaczone wył ˛
acznie do
odczytu).
Sekwencje Reprezentuj ˛
a one sko´nczone zbiory uporz ˛
adkowane, indeksowane przy u˙zyciu nieujemnych liczb
całkowitych. Liczb˛e elementów sekwencji mo˙zna uzyska´c przy u˙zyciu wbudowanej funkcji
len()
. Je´sli
długo´s´c sekwencji (liczba elementów) wynosi n, wówczas zbiór indeksów zawiera liczby 0, 1, . . . , n-1, a
i-ty element sekwencji uzyskujemy poprzez a
[
i
]
.
Sekwencje pozwalaj ˛
a równie˙z na wykrajanie: a
[
i
:
j
]
odnosi si˛e do wszystkich elementów o indeksie k,
takim, ˙ze i
<=
k
<
j. Wykrojenia u˙zywane w wyra˙zeniach s ˛
a sekwencjami tego samego typu, co pierwotna
sekwencja. Oznacza to, ˙ze indeksy w wykrojeniu s ˛
a liczone od 0.
Niektóre sekwencje obsługuj ˛
a te˙z „rozszerzone wykrojenie” z trzecim parametrem „krok”: a
[
i
:
j
:
k
]
wybiera wszystkie elementy sekwencji a o indeksach x spełniaj ˛
acych warunek x
=
i
+
n
*
k, n
>= 0
i
i
<=
x
<
j.
Ze wzgl˛edu na cech˛e zmienno´sci wyró˙znia si˛e dwa typy sekwencji:
Sekwencje niezmienne Obiekty niezmiennych typów sekwencyjnych nie mog ˛
a by´c po utworzeniu mody-
fikowane. Je´sli obiekt zawiera odwołania do innych obiektów, mog ˛
a one by´c zmienne i podlega´c
modyfikacjom, jednak kolekcja obiektów, do której odwołujemy si˛e bezpo´srednio poprzez obiekt
niezmienny, nie mo˙ze ulec zmianie.
Do niezmiennych sekwencji nale˙z ˛
a nast˛epuj ˛
ace typy:
Napisy Elementami napisów s ˛
a znaki, zapisywane przy u˙zyciu co najmniej o´smiu bitów.
Typ
znakowy nie istnieje, do reprezentacji znaku u˙zywa si˛e napisu zawieraj ˛
acego jeden element.
Do konwersji pomi˛edzy znakami i nieujemnymi liczbami całkowitymi, reprezentuj ˛
acymi ich
warto´sci, słu˙z ˛
a funkcje
chr()
oraz
ord()
. Bajty o warto´sciach 0-127 zwykle reprezentuj ˛
a
odpowiednie kody
ASCII
, lecz interpretacja warto´sci znaków zale˙zy od programu. Typ napisowy
jest równie˙z u˙zywany do reprezentacji tablicy bajtów, np. odczytanych z pliku.
(W systemach, których rodzimym zestawem znaków nie jest
ASCII
, do wewn˛etrznej reprezentacji
napisów mo˙ze by´c u˙zywany EBCDIC. Funkcje
chr()
oraz
ord()
implementuj ˛
a wówczas odw-
zorowanie pomi˛edzy
ASCII
a EBCDIC, a operatory porównania napisów zachowuj ˛
a kolejno´s´c w
zbiorze
ASCII
.)
Unicode Elementami obiektu Unicode s ˛
a jednostki kodu Unicode. Mog ˛
a one przechowywa´c warto´sci
16-bitowe lub 32-bitowe, reprezentuj ˛
ace kody porz ˛
adkowe Unicode (maksymaln ˛
a warto´s´c kodu
porz ˛
adkowego mo˙zna odczyta´c z
sys.maxunicode
, a jest ona zale˙zna od konfiguracji Pythona
3.2. Hierarchia typów standardowych
15
przed jego kompilacj ˛
a). Obiekt Unicode mo˙ze zawiera´c pary zast˛epcze i s ˛
a one w takim przy-
padku przedstawiane jako dwa oddzielne elementy. Do konwersji pomi˛edzy jednostkami kodu
i nieujemnymi liczbami całkowitymi reprezentuj ˛
acymi kody porz ˛
adkowe Unicode, zdefiniowane
w standardzie Unicode 3.0, słu˙z ˛
a wbudowane funkcje
unichr()
oraz
ord()
. Mo˙zliwe s ˛
a
równie˙z konwersje do i z innych sposobów kodowania, słu˙zy do tego metoda
encode
oraz wbu-
dowana funkcja
unicode()
.
Krotki Elementami krotek mog ˛
a by´c dowolne obiekty Pythona. Krotki składaj ˛
ace si˛e z co najmniej
dwóch elementów zapisuje si˛e jako ci ˛
agi wyra˙ze´n rozdzielonych przecinkami umieszczone w
nawiasach. Krotki jednoelementowe tworzymy poprzez zapisanie przecinka po wyra˙zeniu (samo
wyra˙zenie w nawiasach nie wystarczy, poniewa˙z nawiasy u˙zywane s ˛
a do grupowania wyra˙ze´n).
Pust ˛
a krotk˛e tworzymy przy u˙zyciu pustej pary nawiasów.
Sekwencje zmienne Zmienne sekwencje mog ˛
a by´c po utworzeniu modyfikowane. Zapis odwołania do in-
deksu oraz wykrojenia mo˙ze by´c wykorzystywany jako miejsce przeznaczenia przy operacjach przyp-
isania oraz w instrukcjach
del
.
Istnieje obecnie jeden wbudowany zmienny typ sekwencyjny:
Listy Elementami listy mog ˛
a by´c dowolne obiekty Pythona.
Listy s ˛
a zapisywane poprzez
umieszczenie w nawiasach kwadratowych wyra˙ze´n (reprezentuj ˛
acych elementy) rozdzielonych
przecinkami. W odró˙znieniu od krotek do zapisu listy o długo´sci 1 nie jest potrzebna specjalna
forma. Podobnie jest przy listach pustych.
Jako kolejny przykład zmiennego typu sekwencyjnego mo˙ze posłu˙zy´c typ z modułu rozszerzaj ˛
acego
array
.
Odwzorowania Reprezentuj ˛
a one sko´nczone zbiory obiektów, indeksowane przy u˙zyciu dowolnych zbiorów in-
deksów. Zapis
a[k]
wybiera z odwzorowania
a
element indeksowany przez
k
. Mo˙ze on by´c u˙zywany w
wyra˙zeniach oraz jako miejsce przeznaczenia w instrukcjach przypisania i instrukcjach
del
. Wbudowana
funkcja
len()
zwraca liczb˛e elementów odwzorowania.
Obecnie istnieje jeden wewn˛etrzny typ odwzorowawczy:
Słowniki Słowniki reprezentuj ˛
a sko´nczone zbiory obiektów, indeksowane niemal dowolnymi warto´sciami.
Jako klucze (indeksy) nie s ˛
a dopuszczalne jedynie warto´sci zawieraj ˛
ace listy, słowniki lub obiekty
innych typów zmiennych, porównywanych przy u˙zyciu ich warto´sci, zamiast to˙zsamo´sci. Powodem
tego ograniczenia jest fakt, ˙ze efektywna implementacja słownika wymaga, aby warto´s´c rozsiewaj ˛
aca
(ang. hash value) klucza była stała. Typy liczbowe, u˙zywane jako klucze, podlegaj ˛
a zwykłym regułom
porówna´n liczbowych. Je´sli dwie warto´sci s ˛
a równe w sensie operacji porównania (np.
1
i
1.0
), mog ˛
a
by´c one u˙zywane wymiennie jako klucze odnosz ˛
ace si˛e do tego samego elementu słownika.
Słowniki s ˛
a zmienne. Mog ˛
a one by´c tworzone przy u˙zyciu notacji
{...}
(patrz rozdział 5.2.5,
„Drukowalne formy słowników”).
Typy z modułów rozszerze´n
dbm
,
gdbm
,
bsddb
mog ˛
a słu˙zy´c jako dodatkowe przykłady typów odw-
zorowawczych.
Typy wywoływalne S ˛
a to typy, na których mo˙zna zastosowa´c operacj˛e wywołania funkcji (zobacz rozdział 5.3.4,
„Wywołania”)
Funkcje zdefiniowane przez u˙zytkownika Obiekt funkcji zdefiniowanej przez u˙zytkownika tworzony
jest przy u˙zyciu definicji funkcji (zobacz rozdział 7.5, „Definicje funkcji”). Przy wywołaniu nale˙zy
u˙zy´c listy argumentów, odpowiadaj ˛
acej li´scie parametrów formalnych funkcji.
Atrybuty specjalne:
func_doc
lub
__doc__
jest napisem dokumentuj ˛
acym funkcji, ew. zaw-
iera warto´s´c
None
, je´sli napis dokumentuj ˛
acy nie jest dost˛epny;
func_name
lub
__name__
jest
nazw ˛
a funkcji;
__module__
jest nazw ˛
a modułu, w którym zdefiniowano funkcj˛e, ew. ma warto´s´c
None
, je´sli nazwa modułu nie jest dost˛epna;
func_defaults
jest krotk ˛
a, zawieraj ˛
ac ˛
a domy´slne
warto´sci argumentów dla tych, które je posiadaj ˛
a, lub
None
je´sli ˙zaden z argumentów nie ma
warto´sci domy´slnej;
func_code
jest obiektem kodu, reprezentuj ˛
acym skompilowan ˛
a tre´s´c funkcji;
func_globals
jest słownikiem przechowuj ˛
acym globalne zmienne funkcji — definiuje on glob-
aln ˛
a przestrze´n nazw modułu, w którym została zdefiniowana funkcja;
func_dict
lub
__dict__
zawiera przestrze´n nazw obsługuj ˛
ac ˛
a dowolne atrybuty funkcji;
func_closure
ma warto´s´c
None
lub jest krotk ˛
a komórek zawieraj ˛
acych powi ˛
azania z wolnymi zmiennymi funkcji.
16
Rozdział 3. Model danych
Spo´sród powy˙zszych atrybutów
func_code
,
func_defaults
,
func_doc
/
__doc__
oraz
func_dict
/
__dict__
mog ˛
a by´c zapisywalne, za´s pozostałe nigdy nie mog ˛
a by´c zmieniane. Do-
datkowe informacje na temat definicji funkcji mo˙zna uzyska´c z jej obiektu kodu; zobacz poni˙zej opis
typów wewn˛etrznych.
Metody zdefiniowane przez u˙zytkownika Metody zdefiniowane przez u˙zytkownika ł ˛
acz ˛
a klas˛e, egzem-
plarz klasy (lub
None
) oraz dowolny obiekt wywoływalny (zwykle funkcj˛e zdefiniowan ˛
a przez
u˙zytkownika).
Atrybuty specjalne tylko do odczytu:
im_self
jest obiektem egzemplarza klasy,
im_func
jest
obiektem funkcji;
im_class
jest klas ˛
a obiektu
im_self
w przypadku metod dowi ˛
azanych, za´s w
przypadku metod niedowi ˛
azanych — klas ˛
a, która zwróciła si˛e o metod˛e;
__doc__
jest napisem doku-
mentuj ˛
acym metody (identycznym z
im_func.__doc__
);
__name__
jest nazw ˛
a metody (identy-
czn ˛
a z
im_func.__name__
);
__module__
jest nazw ˛
a modułu, w którym zdefiniowano metod˛e,
ew. ma warto´s´c
None
, je´sli nazwa modułu nie jest dost˛epna.
Zmieniono w wersji 2.2: Atrybut
im_self
odnosił si˛e wcze´sniej do klasy, która zdefiniowała metod˛e.
Metody pozwalaj ˛
a te˙z na dost˛ep (lecz nie ustawianie) do dowolnych atrybutów funkcji z zawartych w
nich obiektów funkcji.
Obiekty metod zdefiniowanych przez u˙zytkownika mog ˛
a by´c tworzone poprzez pobranie atrybutu
klasy (by´c mo˙ze za po´srednictwem jej egzemplarza), je´sli atrybut ten jest obiektem funkcji zdefin-
iowanej przez u˙zytkownika, niedowi ˛
azanym obiektem metody zdefiniowanej przez u˙zytkownika
lub te˙z obiektem metody poziomu klasy. Je´sli atrybut jest obiektem metody zdefiniowanej przez
u˙zytkownika, utworzenie nowego obiektu metody nast˛epuje tylko wówczas, gdy klasa, z której po-
bierany jest atrybut, jest t ˛
a sam ˛
a klas ˛
a, co klasa powi ˛
azana z oryginalnym obiektem metody lub te˙z
jest jej klas ˛
a pochodn ˛
a. W przeciwnym wypadku u˙zywany jest pozostawiony bez zmian oryginalny
obiekt metody.
Je´sli obiekt metody zdefiniowanej przez u˙zytkownika zostanie utworzony w wyniku pobrania z klasy
obiektu funkcji zdefiniowanej przez u˙zytkownika, wówczas jego atrybut
im_self
ustalany jest na
warto´s´c
None
, a on sam uznawany jest za niedowi ˛
azany. Je´sli obiekt tworzony jest w wyniku po-
brania z klasy obiektu funkcji zdefiniowanej przez u˙zytkownika za po´srednictwem egzemplarza klasy,
wówczas warto´sci ˛
a atrybutu
im_self
obiektu jest ten egzemplarz, za´s obiekt metody uznawany jest
za dowi ˛
azany. W obu przedstawionych przypadkach atrybut
im_class
nowego obiektu metody za-
wiera klas˛e, z której pobrano funkcj˛e, za´s
im_func
odnosi si˛e do oryginalnego obiektu funkcji.
Je´sli obiekt metody zdefiniowanej przez u˙zytkownika zostanie utworzony w wyniku pobrania innej
metody z klasy lub jej instancji, wynik działania jest taki sam, jak w przypadku obiektu funkcji, za
wyj ˛
atkiem tego, ˙ze warto´sci ˛
a atrybutu
im_func
nowej instancji nie jest sam obiekt metody, lecz jego
atrybut
im_func
.
Je´sli obiekt metody zdefiniowanej przez u˙zytkownika zostanie utworzony w wyniku pobrania metody
poziomu klasy z klasy lub jej instancji, wówczas warto´sci ˛
a jego atrybutu
im_self
jest sama klasa
(a zatem kopia warto´sci atrybutu
im_class
), za´s warto´sci ˛
a atrybutu
im_func
jest obiekt funkcji
realizuj ˛
acej metod˛e poziomu klasy.
Kiedy wywoływany jest niepowi ˛
azany obiekt metody zdefiniowanej przez u˙zytkownika, wywołanie
przekazywane jest do zawartej w nim funkcji, z tym jednak ograniczeniem, ˙ze pierwszy argument
musi by´c wła´sciw ˛
a klas ˛
a (
im_class
) lub jej klas ˛
a pochodn ˛
a.
Kiedy wywoływany jest powi ˛
azany obiekt metody zdefiniowanej przez u˙zytkownika, na pocz ˛
atku listy
argumentów dodawana jest instancja klasy (
im_self
), a nast˛epnie wywołanie przekazywane jest do
zawartej w obiekcie funkcji. Na przykład, je´sli
C
jest klas ˛
a, zawieraj ˛
ac ˛
a definicj˛e funkcji
f()
, a
x
jest
instancj ˛
a
C
, wywołanie
x.f(1)
jest równowa˙zne wywołaniu
C.f(x, 1)
.
Je´sli obiekt metody zdefiniowanej przez u˙zytkownika pochodzi od obiektu metody poziomu klasy,
wówczas „instancja klasy”, zapisana w atrybucie
im_self
jest w rzeczywisto´sci sam ˛
a klas ˛
a, zatem
wywołanie
x.f(1)
lub
C.f(1)
jest równowa˙zne wywołaniu
f(C,1)
, gdzie
f
jest funkcj ˛
a realizu-
j ˛
ac ˛
a metod˛e.
Zauwa˙zmy, ˙ze przekształcenie obiektu funkcji w (powi ˛
azany lub niepowi ˛
azany) obiekt metody
odbywa si˛e przy ka˙zdym pobraniu atrybutu z klasy lub instancji. W pewnych przypadkach mo˙ze si˛e
opłaca´c prosta optymalizacja, polegaj ˛
aca na przypisaniu atrybutu do zmiennej lokalnej, a nast˛epnie
wywoływanie ju˙z tylko jej. Przekształcenia wykonywane s ˛
a tylko w odniesieniu do funkcji zdefin-
iowanych przez u˙zytkownika; inne obiekty wywoływalne (i wszystkie niewywoływalne) s ˛
a pobierane
bez przekształce´n. Warto te˙z odnotowa´c, ˙ze funkcje zdefiniowane przez u˙zytkownika, b˛ed ˛
ace atrybu-
3.2. Hierarchia typów standardowych
17
tami instancji, nie s ˛
a przekształcane w powi ˛
azane obiekty metod; dzieje si˛e tak wył ˛
acznie, je´sli funkcja
jest atrybutem klasy.
Funkcje generuj ˛
ace Funkcja lub metoda, w której u˙zyto instrukcji
yield
(patrz sekcja 6.8, „Instrukcja
yield
”) jest nazywana funkcj ˛
a generuj ˛
ac ˛
a. Przy wywołaniu takiej funkcji zawsze zwracany jest
obiekt iteratora, który mo˙ze by´c u˙zywany do wykonania jej tre´sci: wywołanie metody
next()
it-
eratora powoduje wykonywanie funkcji do czasu, gdy da ona w wyniku warto´s´c, przy u˙zyciu in-
strukcji
yield
. Je´sli funkcja wykona instrukcj˛e
return
lub sterowanie osi ˛
agnie koniec funkcji,
wygenerowany zostanie wyj ˛
atek
StopIteration
, sygnalizuj ˛
ac osi ˛
agni˛ecie ko´nca zbioru warto´sci
zwracanych przez iterator.
Wbudowane funkcje Wbudowane obiekty funkcyjne okrywaj ˛
a funkcje napisane w j˛ezyku C. Przykładami
wbudowanych funkcji s ˛
a
len()
, czy
math.sin()
(
math
jest standardowym wbudowanym mod-
ułem). Liczba oraz typy argumentów s ˛
a okre´slone przez funkcj˛e w C. Atrybuty specjalne tylko do
odczytu:
__doc__
jest napisem dokumentuj ˛
acym funkcji, ew. zawiera warto´s´c
None
, je´sli napis
dokumentuj ˛
acy nie jest dost˛epny;
__name__
jest nazw ˛
a funkcji;
__self__
jest ustawione na
None
(zobacz jednak kolejny punkt);
__module__
jest nazw ˛
a modułu, w którym zdefiniowano funkcj˛e,
ew. ma warto´s´c
None
, je´sli nazwa modułu nie jest dost˛epna.
Wbudowane metody S ˛
a to w rzeczywisto´sci inne formy wbudowanych funkcji, zawieraj ˛
ace jednak obiekt,
przekazany do funkcji w j˛ezyku C jako niejawny dodatkowy argument. Przykładem wbudowanej
metody jest lista
.append()
, przy zało˙zeniu, ˙ze lista jest obiektem listowym. W tym przypadku
__self__
, atrybut specjalny tylko do odczytu, ustawiany jest na obiekt reprezentowany przez list.
Klasy typizuj ˛
ace Klasy typizuj ˛
ace, zwane te˙z „klasami w nowym stylu” s ˛
a wywoływalne. Obiekty te
pełni ˛
a zazwyczaj rol˛e obiektów fabrykuj ˛
acych dla ich nowych instancji, jednak mo˙zliwe jest tworze-
nie odmiennie zachowuj ˛
acych si˛e klas poprzez przedefiniowanie metody
__new__()
. Argumenty
wywołania obiektu s ˛
a przekazywane metodzie
__new__()
oraz, w typowych przypadkach, metodzie
__init__()
, inicjuj ˛
acej nowoutworzon ˛
a instancj˛e.
Klasyczne klasy Obiekty klas s ˛
a opisane ni˙zej. Przy wywołaniu obiektu klasy tworzona jest i zwracana
nowa instancja klasy (równie˙z opisana poni˙zej). Je´sli klasa posiada metod˛e
__init__()
, to jest ona
wywoływana w nast˛epnej kolejno´sci. W przeciwnym wypadku klasa mo˙ze by´c wywoływana tylko
bez argumentów.
Instancje klas Instancje klas s ˛
a opisane ni˙zej.
S ˛
a one wywoływalne tylko, je´sli klasa ma metod˛e
__call__()
; zapis
x(argumenty)
jest odpowiednikiem
x.__call__(argumenty)
.
Moduły Moduły s ˛
a importowane przy u˙zyciu instrukcji
import
(patrz rozdział 6.12, „Instrukcja
import
”).
Obiekt modułu posiada przestrze´n nazw, zaimplementowan ˛
a za pomoc ˛
a słownika (dost˛epnego poprzez atry-
but func_globals ka˙zdej z funkcji, zdefiniowanych w module). Odwołania do atrybutów s ˛
a przekształcane
na odwołania do tego słownika, np.
m.x
jest odpowiednikiem
m.__dict__["x"]
. Obiekt modułu nie
zawiera obiektu kodu, wykorzystywanego do zainicjowania modułu, poniewa˙z po pierwszym u˙zyciu nie
jest on ju˙z potrzebny.
Przy przypisaniu do atrybutu modułu automatycznie aktualizowany jest słownik przestrzeni nazw modułu,
np. „
m.x = 1
” jest równowa˙zne „
m.__dict__["x"] = 1
”.
Atrybut specjalny tylko do odczytu:
__dict__
jest słownikiem, daj ˛
acym dost˛ep do przestrzeni nazw
modułu.
Predefiniowane (zapisywalne) atrybuty:
__name__
jest nazw ˛
a modułu;
__doc__
jest napisem dokumen-
tuj ˛
acym modułu, ew. zawiera warto´s´c
None
, je´sli napis dokumentuj ˛
acy nie jest dost˛epny;
__file__
jest
´scie˙zk ˛
a pliku, z którego odczytano moduł, o ile został on pobrany z pliku. W przypadku modułów w C,
statycznie doł ˛
aczonych do interpretera, atrybut
__file__
nie jest dost˛epny, za´s przy modułach rozszerza-
j ˛
acych odczytywanych z bibliotek dzielonych, zawiera on nazw˛e pliku biblioteki.
Klasy Obiekty klas tworzone s ˛
a przez definicje klas (zobacz rozdział 7.6, „Definicje klas”). Ka˙zda klasa ma
własn ˛
a przestrze´n nazw, implementowan ˛
a przy u˙zyciu obiektu słownika. Odwołania do atrybutów klasy s ˛
a
przekształcane na odwołania do tego słownika, np. „
C.x
” jest odpowiednikiem „
C.__dict__["x"]
”.
Je´sli nazwa atrybutu nie zostanie odnaleziona w słowniku, przeszukiwanie jest kontynuowane w klasach
bazowych w kolejno´sci „depth-first” (najpierw w gł ˛
ab) i od lewej do prawej w kolejno´sci wyst ˛
apienia klas
na li´scie klas bazowych.
W przypadku, gdy odwołanie do atrybutu klasy (np. klasy
C
) dałoby w wyniku obiekt funkcji zdefiniowanej
przez u˙zytkownika lub niedowi ˛
azany obiekt metody, powi ˛
azanej z klas ˛
a
C
lub jedn ˛
a z jej klas bazowych,
18
Rozdział 3. Model danych
wówczas obiekt ten jest przekształcany na niedowi ˛
azany obiekt metody zdefiniowanej przez u˙zytkownika,
którego atrybut
im_class
ma warto´s´c
C
. Je´sli wynikiem byłby obiekt metody poziomu klasy, nast˛epuje
jego przekształcenie na dowi ˛
azany obiekt metody zdefiniowanej przez u˙zytkownika, w którym zarówno
atrybut
im_class
, jak i
im_self
ma warto´s´c
C
. Je´sli wynikiem byłby obiekt metody statycznej, obiekt
przekstałcany jest na obiekt opakowany przez obiekt metody statycznej. W sekcji 3.3.2 opisano inny sposób
ró˙znicowania pomi˛edzy atrybutami pobranymi z klasy oraz obiektami rzeczywi´scie przechowywanymi w
jej słowniku
__dict__
.
Przypisanie do atrybutu klasy modyfikuje słownik klasy, nigdy za´s słownik klasy bazowej.
Obiekt klasy mo˙ze zosta´c wywołany (zobacz wy˙zej); w wyniku operacji zwracana jest instancja klasy
(zobacz poni˙zej).
Atrybuty specjalne:
__name__
jest nazw ˛
a klasy;
__module__
jest nazw ˛
a modułu, w którym zdefin-
iowano klas˛e;
__dict__
jest słownikiem, zawieraj ˛
acym przestrze´n nazw klasy;
__bases__
jest krotk ˛
a
(by´c mo˙ze pust ˛
a lub składaj ˛
ac ˛
a si˛e z jednego elementu), zawieraj ˛
ac ˛
a klasy bazowe w porz ˛
adku, w jakim
wyst ˛
apiły na li´scie klas bazowych;
__doc__
jest napisem dokumentuj ˛
acym klasy, ew. zawiera warto´s´c
None
, je´sli napis dokumentuj ˛
acy nie jest dost˛epny.
Instancje klas Instancja klasy jest tworzona poprzez wywołanie obiektu klasy (patrz wy˙zej). Ma ona własn ˛
a
przestrze´n nazw, implementowan ˛
a przy u˙zyciu słownika, b˛ed ˛
acego pierwszym miejscem, w którym
wyszukiwane s ˛
a atrybuty. Je´sli atrybut nie zostanie odnaleziony w tym słowniku, wyszukiwany jest jako
atrybut klasy danej instancji.
W przypadku odnalezienia atrybutu jako atrybutu klasy, b˛ed ˛
acego jed-
nocze´snie obiektem funkcji zdefiniowanej przez u˙zytkownika lub te˙z niedowi ˛
azanym obiektem metody
zdefiniowanej przez u˙zytkownika, której klasa jest klas ˛
a (nazwijmy j ˛
a klas ˛
a
C
) instancji, na rzecz której
nast ˛
apiło odwołanie do atrybutu lub jedn ˛
a z jej klas bazowych, wówczas warto´s´c atrybutu jest przekształ-
cana w dowi ˛
azany obiekt metody u˙zytkownika z atrybutem
im_class
o warto´sci
C
i
im_self
b˛ed ˛
a-
cym odwołaniem do instancji. Przekształceniu podlegaj ˛
a równie˙z obiekty metod statycznych oraz metod
poziomu klasy, przy czym odbywa si˛e to tak, jakby zostały pobrane z klasy
C
. Patrz te˙z punkt „Klasy”
powy˙zej. W sekcji 3.3.2 opisano inny sposób ró˙znicowania pomi˛edzy atrybutami klas pobranymi poprzez
ich instancje oraz obiektami rzeczywi´scie przechowywanymi w słowniku
__dict__
.
Je´sli nie odnaleziono atrybutu klasy, a klasa zawiera metod˛e
__getattr__()
, wówczas to ona jest u˙zy-
wana do pobrania atrybutu.
Przypisanie do atrybutu modyfikuje słownik instancji, nigdy za´s słownik jej klasy. Je´sli klasa zawiera
metod˛e
__setattr__()
lub
__delattr__()
, wówczas wywoływana jest ona zamiast bezpo´sredniej
modyfikacji słownika atrybutów instancji.
Instancje klas mog ˛
a zachowywa´c si˛e jak liczby, sekwencje lub odwzorowania, o ile ich klasy zawieraj ˛
a
metody o pewnych specjalnych nazwach. Patrz rozdział 3.3, „Specjalne nazwy metod”.
Atrybuty specjalne:
__dict__
jest słownikiem atrybutów;
__class__
jest klas ˛
a instancji.
Pliki Obiekt plikowy reprezentuje otwarty plik. Mo˙zna go utworzy´c przy u˙zyciu wbudowanej funkcji
open()
,
funkcji
os.popen()
,
os.fdopen()
oraz metody
makefile()
obiektu gniazda. Prawdopodobnie
równie˙z przy u˙zyciu innych funkcji lub metod udost˛epnianych przez moduły rozszerze´n. Obiekty plikowe
sys.stdin
,
sys.stdout
i
sys.stderr
s ˛
a inicjowane jako odpowiadaj ˛
ace standardowemu wej´sciu,
wyj´sciu oraz wyj´sciu bł˛edów interpretera. Aby uzyska´c pełn ˛
a dokumentacj˛e na temat obiektów plikowych,
zajrzyj do podr˛ecznika
Podr˛ecznik programisty Pythona - opis biblioteki standardowej
.
Typy wewn˛etrzne Cz˛e´s´c typów, u˙zywanych wewn˛etrznie przez interpreter, udost˛epniana jest u˙zytkownikowi.
Dla kompletno´sci zostały one wymienione, lecz ich definicje mog ˛
a w przyszło´sci ulec zmianie.
Obiekty kodu Obiekt kodu reprezentuje kod Pythona skompilowany do kodu bajtowego, a wi˛ec w postaci
wykonywalnej, nazywanej krócej kodem bajtowym. Ró˙znica pomi˛edzy obiektem kodu i obiektem
funkcji polega na tym, ˙ze obiekt funkcji zawiera jawne odwołania do obiektów globalnych funkcji
(modułu, w którym została zdefiniowana), za´s z obiektem kodu nie jest zwi ˛
azany ˙zaden kontekst;
ponadto domy´slne warto´sci argumentów zapisane s ˛
a w obiekcie funkcji, nie w obiekcie kodu (gdy˙z
zawieraj ˛
a warto´sci, obliczone na etapie wykonywania). W odró˙znieniu od obiektów funkcji, obiekty
kodu s ˛
a niezmienne i nie zawieraj ˛
a ˙zadnych odwoła´n (równie˙z po´srednich) do obiektów zmiennych.
Specjalne atrybuty tylko do odczytu:
co_name
zawiera nazw˛e funkcji;
co_argcount
jest liczb ˛
a
argumentów pozycyjnych (wraz z argumentami maj ˛
acymi warto´sci domy´slne);
co_nlocals
jest
liczb ˛
a zmiennych lokalnych, u˙zywanych wewn ˛
atrz funkcji (wraz z argumentami);
co_varnames
3.2. Hierarchia typów standardowych
19
jest krotk ˛
a, zawieraj ˛
ac ˛
a nazwy zmiennych lokalnych (z nazwami argumentów na pocz ˛
atku);
co_cellvars
jest krotk ˛
a z nazwami zmiennych lokalnych, odwołania do których wyst˛epuj ˛
a w
zagnie˙zd˙zonych funkcjach;
co_freevars
jest krotk ˛
a, zawieraj ˛
ac ˛
a nazwy wolnych zmiennych;
co_code
jest napisem, zawiera sekwencj˛e instrukcji kodu bajtowego w postaci obiektu napisowego;
co_consts
jest krotk ˛
a, zawieraj ˛
ac ˛
a literały, u˙zywane w kodzie bajtowym;
co_names
jest krotk ˛
a,
zawieraj ˛
ac ˛
a nazwy u˙zywane w kodzie bajtowym;
co_filename
jest nazw ˛
a pliku, z którego pow-
stał skompilowany kod;
co_firstlineno
jest numerem pierwszego wiersza funkcji;
co_lnotab
jest napisem, w którym zakodowane jest odwzorowanie przesuni˛e´c (adresów) w kodzie bajtowym na
numery wierszy (szczegóły mo˙zna zobaczy´c w kodzie ´zródłowym interpretera);
co_stacksize
jest wymaganym rozmiarem stosu (wraz ze zmiennymi lokalnymi);
co_flags
jest liczb ˛
a całkowit ˛
a,
zawieraj ˛
ac ˛
a pewne znaczniki, u˙zywane przez interpreter.
W
co_flags
zdefiniowane s ˛
a nast˛epuj ˛
ace bity: bit
0x04
jest ustawiony, je´sli funkcja przyjmuje
dowoln ˛
a liczb˛e argumentów pozycyjnych przy u˙zyciu ze składni „
*argumenty
”; bit
0x08
jest
ustawiony, je´sli funkcja przyjmuje argumenty nazwane przy u˙zyciu składni „
**słownik
”; bit
0x04
jest ustawiony, je´sli funkcja jest generatorem.
Deklaracje przyszłych cech („
from __future__ import division
”) równie˙z u˙zywaj ˛
a
pewnych bitów
co_flags
do oznaczenia, czy obiekt kodu został skompilowany z aktywn ˛
a dan ˛
a
cech ˛
a: bit
0x2000
jest ustawiony, je´sli przy kompilacji funkcji była aktywna cecha „division”, bity
0x10
i
0x1000
były u˙zywane we wcze´sniejszych wersjach Pythona.
Pozostałe bity
co_flags
s ˛
a zarezerwowane do u˙zytku wewn˛etrznego.
Je´sli obiekt kodu reprezentuje funkcj˛e, pierwszy element
co_consts
jest napisem dokumentuj ˛
acym
funkcji, ew. zawiera warto´s´c
None
, je´sli napis dokumentuj ˛
acy nie jest dost˛epny;
Obiekty ramki Obiekty ramki reprezentuj ˛
a ramki wykonania. Mog ˛
a si˛e one pojawia´c w obiektach stanu
stosu (zobacz ni˙zej).
Atrybuty specjalne tylko do odczytu:
f_back
jest poprzedni ˛
a ramk ˛
a stosu (w kierunku kodu wywołu-
j ˛
acego) lub
None
, je´sli bie˙z ˛
aca ramka jest na dnie stosu;
f_code
jest obiektem kodu, wykonywanym
w tej ramce;
f_locals
jest słownikiem zawieraj ˛
acym zmienne lokalne;
f_globals
zawiera
zmienne globalne;
f_builtins
zawiera nazwy wbudowane;
f_restricted
jest znacznikiem
okre´slaj ˛
acym, czy funkcja wykonywana jest w trybie z ograniczeniem uprawnie´n;
f_lasti
zaw-
iera wskazanie na odpowiedni ˛
a instrukcj˛e (jest to indeks w napisie kodu binarnego wewn ˛
atrz obiektu
kodu).
Zapisywalne atrybuty specjalne:
f_trace
, je´sli ma warto´s´c ró˙zn ˛
a od
None
, wówczas zawiera
funkcj˛e wywoływan ˛
a przed wykonaniem ka˙zdego wiersza kodu ´zródłowego (mo˙ze on by´c wyko-
rzystywany przez debugger);
f_exc_type
,
f_exc_value
,
f_exc_traceback
opisuj ˛
a ostatni
wyj ˛
atek wychwycony w tej ramce;
f_lineno
jest numerem bie˙z ˛
acego wiersza ramki — przypisanie
warto´sci temu atrybutowi wewn ˛
atrz funkcji ´sledz ˛
acej powoduje skok do wiersza o okre´slonym nu-
merze (tylko dla ramki poło˙zonej najni˙zej). Debugery mog ˛
a implementowa´c polecenie skoku (ustaw-
ienie kolejnej instrukcji) ustawiaj ˛
ac wła´snie warto´s´c atrybutu
f_lineno
.
Obiekty stanu stosu Obiekty stanu stosu tworzone s ˛
a w chwili wyst ˛
apienia wyj ˛
atku i reprezentuj ˛
a aktu-
alny stan stosu. W trakcie wyszukiwania kodu obsługuj ˛
acego wyj ˛
atek rozwijane s ˛
a kolejne poziomy
stosu i ka˙zdy z nich wstawiany jest na pocz ˛
atku bie˙z ˛
acego stanu stosu. W chwili uruchomienia kodu
obsługuj ˛
acego, utworzony stan stosu jest mu udost˛epniany. (Patrz rozdział 7.4, „Instrukcja
try
”) Stan
stosu dost˛epny jest jako
sys.exc_traceback
oraz jako trzeci element krotki, zwracanej przez
sys.exc_info()
. Zaleca si˛e u˙zywanie drugiego sposobu dost˛epu, gdy˙z działa on prawidłowo,
kiedy program u˙zywa wielu w ˛
atków. Je´sli program nie zawiera odpowiedniego kodu obsługuj ˛
acego,
stan stosu jest wypisywany (w czytelnej postaci) do standardowego strumienia bł˛edów; je´sli interpreter
pracuje w trybie interaktywnym, stan stosu udost˛epniany jest równie˙z jako
sys.last_traceback
Atrybuty specjalne tylko do odczytu:
tb_next
jest nast˛epnym poziomem stanu stosu (w kierunku
ramki, w której wyst ˛
apił wyj ˛
atek) lub
None
, je´sli nast˛epnego poziomu nie ma;
tb_frame
to ramka
wykonania bie˙z ˛
acego poziomu;
tb_lineno
zawiera numer wiersza, w którym wyst ˛
apił wyj ˛
atek;
tb_lasti
dokładnie wskazuje instrukcj˛e, przy której on wyst ˛
apił. Numer wiersza i ostatnia in-
strukcja w obiekcie stanu stosu mog ˛
a si˛e ró˙zni´c od tych z obiektu ramki, je´sli wyj ˛
atek wyst ˛
apił
wewn ˛
atrz instrukcji
try
bez pasuj ˛
acej klauzuli except oraz klauzuli finally.
Obiekty wykrojenia Obiekty wykrojenia reprezentuj ˛
a wykrojenie powstałe po u˙zyciu rozszerzonej składni
wykrojenia.
S ˛
a to wykrojenia z dwoma dwukropkami lub wiele wykroje´n oraz wielokropków
20
Rozdział 3. Model danych
rozdzielonych przecinkami, np.
a[i:j:step]
,
a[i:j, k:l]
czy
a[..., i:j]
. Obiekty te
u˙zywane s ˛
a równie˙z przez wbudowan ˛
a funkcj˛e
slice()
.
Atrybuty specjalne tylko do odczytu:
start
jest dolnym ograniczeniem;
stop
jest górnym
ograniczeniem;
step
jest warto´sci ˛
a kroku. Ka˙zdy z pomini˛etych atrybutów ma warto´s´c
None
. Mog ˛
a
one by´c dowolnych typów.
Obiekty wykrojenia obsługuj ˛
a jedn ˛
a metod˛e:
indices(
self, długo´s´c
)
Metoda ta pobiera jeden argument liczbowy długo´s´c i oblicza informacje na temat rozszerzonego
wykrojenia, które opisywałby obiekt wykrojenia po zastosowaniu go do sekwencji o podanej
długo´sci. Metoda zwraca krotk˛e z trzeba liczbami całkowitymi, którymi s ˛
a, odpowiednio, indeksy
pocz ˛
atek i koniec oraz krok lub długo´s´c rozstawu wykrojenia. Brakuj ˛
ace indeksy lub warto´sci
indeksów wykraczaj ˛
ace poza dopuszczalny zakres s ˛
a obsługiwane w sposób zgodny ze zwykłymi
wykrojeniami. Dodano w wersji 2.3.
Obiekty metod statycznych Obiekty metod statycznych umo˙zliwiaj ˛
a udaremnienie opisanego wcze´sniej
przekształcania obiektów funkcji na obiekty metod. Obiekt metody statycznej jest opakowaniem dla
dowolnego innego obiektu, zazwyczaj obiektu metody zdefiniowanej przez u˙zytkownika. Przy po-
bieraniu obiektu metody statycznej z klasy lub instancji klasy przekazywany jest w rzeczywisto´sci
opakowywany obiekt, nie podlegaj ˛
acy ˙zadnym przekształceniom. Obiekty metod statycznych nie s ˛
a
wywoływalne, cho´c wywoływalne s ˛
a zwykle opakowywane przez nie obiekty. Obiekty metod staty-
cznych tworzone s ˛
a przy u˙zyciu wbudowanego konstruktora
staticmethod()
.
Obiekty metod poziomu klasy Obiekt metody poziomu klasy, podobnie jak obiekt metody statycznej, jest
opakowaniem na inny obiekt, modyfikuj ˛
acym sposób, w jaki obiekt ten jest pobierany z klas i instancji
klas. Zachowanie obiektów metod poziomu klasy przy takim pobieraniu zostało opisane w punkcie
„Metody zdefiniowane przez u˙zytkownika”. Obiekty metod poziomu klasy tworzone s ˛
a przy u˙zyciu
wbudowanego konstruktora
classmethod()
.
3.3
Specjalne nazwy metod
Klasy mog ˛
a implementowa´c pewne operacje, które mo˙zemy nast˛epnie wywoływa´c przy u˙zyciu specjalnej składni
(np. u˙zywaj ˛
ac operatorów arytmetycznych, odwołania do indeksu lub wykrojenia). Do ich definicji u˙zywa si˛e
metod o specjalnych nazwach. Mechanizm ten jest stosowanym w Pythonie podej´sciem do przeci ˛
a˙zania opera-
torów, które pozwala definiowa´c zachowanie klas w odniesieniu do operatorów j˛ezyka. Na przykład, je´sli klasa
definiuje metod˛e o nazwie
__getitem__()
, a
x
jest instancj ˛
a tej klasy, wówczas zamiast
x[i]
mo˙zemy u˙zy´c
x.__getitem__(i)
Poza zaznaczonymi przypadkami, próba wykonania operacji przy braku odpowiedniej
metody spowoduje wyst ˛
apienie wyj ˛
atku.
Przy tworzeniu implementacji klasy emuluj ˛
acej typ wbudowany, nale˙zy j ˛
a ograniczy´c do zakresu, który ma sens
w odniesieniu do modelowanych obiektów. Na przykład, do niektórych sekwencji dobrze pasuje pobieranie po-
jedynczych elementów, lecz pobieranie wykroje´n mo˙ze ju˙z nie mie´c sensu (jako przykład mo˙ze słu˙zy´c interfejs
NodeList
w standardzie W3C DOM).
3.3.1
Podstawowa indywidualizacja
__init__(
self
[
, ...
]
)
Wywoływana przy tworzeniu instancji z argumentami przekazanymi konstruktorowi klasy.
Je´sli
klasa bazowa równie˙z ma metod˛e
__init__()
,
to,
aby zapewni´c wła´sciwe zainicjowanie
bazowej cz˛e´sci obiektu, metoda w klasie pochodnej (je´sli istnieje) musi j ˛
a jawnie wywoła´c, np.
„
KlasaBazowa.__init__(
self
, [
argumenty
...])
”.
Na konstruktory nakłada si˛e specjalne
ograniczenie – nie mog ˛
a one zwraca´c warto´sci. Zwrócenie warto´sci przez konstruktor spowoduje wygen-
erowanie wyj ˛
atku
TypeError
.
__del__(
self
)
Wywoływana tu˙z przed zniszczeniem instancji. Nazywana jest te˙z destruktorem. Je´sli klasa bazowa równie˙z
ma metod˛e
__del__()
, to, aby zapewni´c wła´sciw ˛
a finalizacj˛e bazowej cz˛e´sci obiektu, metoda w klasie
pochodnej (je´sli istnieje) musi j ˛
a jawnie wywoła´c. Zauwa˙zmy, ˙ze mo˙zliwe jest (cho´c zdecydowanie nie jest
to zalecane) wstrzymanie usuni˛ecia obiektu wewn ˛
atrz metody
__del__()
poprzez utworzenie nowego
3.3. Specjalne nazwy metod
21
odwołania do niego. Metoda mo˙ze by´c w takim przypadku wywołana pó´zniej, tj. kiedy zostanie usuni˛ete
to odwołanie. Nie gwarantuje si˛e wywołania metod
__del__()
dla obiektów, które istniej ˛
a w chwili
zako´nczenia działania interpretera.
Notka: „
del x
” nie wywołuje bezpo´srednio
x.__del__()
— instrukcja
del
zmniejsza tylko licznik
odwoła´n do obiektu o jeden, za´s metoda
__del__()
jest wywoływana po osi ˛
agni˛eciu przez ten licznik
warto´sci zero. W pewnych sytuacjach licznik mo˙ze nigdy nie osi ˛
agn ˛
a´c warto´sci zero. Do typowych
nale˙z ˛
a: cykliczne odwołania pomi˛edzy obiektami (np. lista z dwukierunkowymi dowi ˛
azaniami lub struktura
drzewiasta z odwołaniami do ojca i potomków); odwołanie do obiektu w ramce stosu funkcji, która wyła-
pała wyj ˛
atek (ramk˛e utrzymuje przy ˙zyciu stan stosu, zapisany w
sys.exc_traceback
); odwołanie do
obiektu w ramce stosu, w której wyst ˛
apił nieobsłu˙zony wyj ˛
atek podczas pracy interaktywnej (ramk˛e utrzy-
muje przy ˙zyciu stan stosu zapisany w
sys.last_traceback
). Pierwszej sytuacji mo˙zna unikn ˛
a´c tylko
poprzez jawne przerwanie cykli, pozostałych za´s, poprzez zapisanie None w
sys.exc_traceback
lub
sys.last_traceback
. Cykliczne odwołania pomi˛edzy nieu˙zywanymi obiektami s ˛
a wykrywane, je´sli
aktywny jest opcjonalny wykrywacz cykli (domy´slnie jest on aktywny), jednak tworz ˛
ace je obiekty mog ˛
a
by´c usuni˛ete tylko, je´sli nie s ˛
a w ich ramach u˙zywane metody
__del__()
na poziomie Pythona. Aby
uzyska´c wi˛ecej informacji na temat sposobu obsługi metody
__del__()
przez wykrywacz cykli (oraz na
temat warto´sci
garbage
), zajrzyj do dokumentacji
modułu
gc
.
Ostrze˙zenie: Ze wzgl˛edu na niepewne warunki, w których wykonywane s ˛
a metody
__del__()
, wyj ˛
atki,
które w nich wyst ˛
api ˛
a, s ˛
a ignorowane, wypisywane jest jedynie ostrze˙zenie na
sys.stderr
. Dodatkowo,
je´sli metoda
__del__()
została wywołana jako odpowied´z na usuni˛ecie modułu (np. przy zako´ncze-
niu pracy programu), inne obiekty globalne, do których chce si˛e odwoływa´c
__del__()
mog ˛
a ju˙z by´c
usuni˛ete. Z tego powodu metody
__del__()
powinny wykonywa´c absolutne minimum operacji, wyma-
ganych do zachowania zewn˛etrznych niezmienników. Poczynaj ˛
ac od wersji 1.5, Python gwarantuje, ˙ze
globalne obiekty modułu, których nazwy rozpoczynaj ˛
a si˛e pojedynczym podkre´sleniem, s ˛
a usuwane przed
wszystkimi innymi; je´sli nie istniej ˛
a inne odwołania do nich, mo˙ze to pomóc w zagwarantowaniu, ˙ze zaim-
portowane moduły s ˛
a nadal dost˛epne w chwili wywołania metody
__del__()
.
__repr__(
self
)
Wywoływana przez wbudowan ˛
a funkcj˛e
repr()
oraz przy konwersjach napisowych (odwrócone apos-
trofy) do wygenerowania „oficjalnej” reprezentacji napisowej obiektu. Je´sli to mo˙zliwe, napis powinien
by´c poprawnym wyra˙zeniem w Pythonie, po przewarto´sciowaniu którego otrzymamy obiekt o tej samej
warto´sci (w odpowiednim ´srodowisku).
Je´sli nie jest mo˙zliwe zapisanie warto´sci w takiej postaci,
zwracany napis powinien wygl ˛
ada´c nast˛epuj ˛
aco: „
<
...u˙zyteczny opis...
>
”. Zwracana warto´s´c musi by´c
obiektem napisowym. Je´sli klasa implementuje metod˛e
__repr__()
, jednak nie implementuje metody
__str__()
, wówczas metoda
__repr__()
stosowana jest w zast˛epstwie
__str__()
w sytuacjach,
w których potrzebna jest „informacyjna” reprezentacja instancji klasy.
Metoda ta jest zwykle u˙zywana podczas debugowania, wa˙zne wi˛ec, aby reprezentacja zawierała pełni˛e
informacji o obiekcie i aby była jednoznaczna.
__str__(
self
)
Wywoływana przez wbudowan ˛
a funkcj˛e
str()
oraz instrukcj˛e
celem wygenerowania napisu za-
wieraj ˛
acego „informacyjn ˛
a” reprezentacj˛e obiektu. Ró˙znica w stosunku do
__repr__()
polega na tym,
˙ze napis nie musi by´c poprawnym wyra˙zeniem w Pythonie, dopuszczalna jest np. forma czytelniejsza lub
bardziej zwi˛ezła. Zwracana warto´s´c musi by´c typu napisowego.
__lt__(
self, inny
)
__le__(
self, inny
)
__eq__(
self, inny
)
__ne__(
self, inny
)
__gt__(
self, inny
)
__ge__(
self, inny
)
Dodano w wersji 2.1.
S ˛
a to tzw.
metody „porówna´n szczegółowych”, a wywoływane s ˛
a przy
u˙zyciu operatorów porównania przed wywołaniem opisanej poni˙zej metody
__cmp__()
.
Zale˙zno´s´c
pomi˛edzy operatorami i nazwami metod przedstawia si˛e nast˛epuj ˛
aco: x
<
y wywołuje x
.__lt__(
y
)
, x
<=
y
wywołuje x
.__le__(
y
)
, x
==
y wywołuje x
.__eq__(
y
)
, x
!=
y oraz x
<>
y wywołuj ˛
a x
.__ne__(
y
)
,
x
>
y wywołuje x
.__gt__(
y
)
, x
>=
y wywołuje x
.__ge__(
y
)
.
Metody te mog ˛
a zwraca´c dowolne
warto´sci, lecz je´sli operator porównania zostanie u˙zyty w kontek´scie logicznym, zwracana warto´s´c
powinna da´c si˛e zinterpretowa´c jako warto´s´c logiczna, w przeciwnym bowiem wypadku wyst ˛
api wyj ˛
atek
TypeError
. Zgodnie z konwencj ˛
a
False
jest u˙zywane w znaczeniu fałszu, za´s
True
– w znaczeniu
22
Rozdział 3. Model danych
prawdy.
Pomi˛edzy operatorami porówna´n nie wyst˛epuj ˛
a ˙zadne zale˙zno´sci maj ˛
ace charakter ogólny. Prawdziwo´s´c
porównania x
==
y nie musi poci ˛
aga´c za sob ˛
a nieprawdziwo´sci porównania x
!=
y. Analogicznie, przy defin-
iowaniu metody
__eq__
nale˙zy równie˙z zdefiniowa´c
__ne__
, tak aby operatory zachowywały si˛e w
oczekiwany sposób.
Nie istniej ˛
a osobne wersje powy˙zszych metod z argumentami zamienionymi miejscami (u˙zywanymi,
je´sli lewy argument nie obsługuje operacji, natomiast prawy j ˛
a obsługuje); jednak metody
__lt__()
i
__gt__()
stanowi ˛
a wzajemnie swoje odwrócenie, podobnie jest z metodami
__le__()
i
__ge__()
oraz
__eq__()
i
__ne__()
.
Argumenty porówna´n szczegółowych nie s ˛
a nigdy uzgadniane. Je´sli metoda porównania szczegółowego nie
implementuje operacji dla podanej pary argumentów, mo˙ze wygenerowa´c wyj ˛
atek
NotImplemented
.
__cmp__(
self, inny
)
Wywoływana przy operacjach porówna´n, je´sli porównanie szczegółowe (patrz wy˙zej) nie jest zdefiniowane.
Je´sli
self < inny
, funkcja powinna zwróci´c całkowit ˛
a liczb˛e ujemn ˛
a, je´sli
self == inny
– zero,
je´sli za´s
self > inny
– całkowit ˛
a liczb˛e dodatni ˛
a. Je´sli klasa nie definiuje operacji
__cmp__()
,
__eq__()
, ani
__ne__()
, jej instancje s ˛
a porównywane według to˙zsamo´sci („adresów”) obiektów.
Wa˙zne uwagi na temat tworzenia obiektów, które obsługuj ˛
a własne operacje porówna´n i mog ˛
a by´c u˙zywane
jako klucze w słownikach, odnajdziesz w opisie metody
__hash__()
. (Uwaga: ograniczenie, polegaj ˛
ace
na tym, ˙ze wyj ˛
atki nie s ˛
a propagowane przez metod˛e
__cmp__()
zostało zniesione w Pythonie 1.5.)
__rcmp__(
self, inny
)
Zmieniono w wersji 2.1: Ju˙z nieobsługiwane.
__hash__(
self
)
Wywoływana dla obiektów kluczy przy operacjach słownikowych i przez wbudowan ˛
a funkcj˛e
hash()
.
Powinna zwróci´c 32-bitow ˛
a liczb˛e całkowit ˛
a, u˙zyteczn ˛
a jako warto´s´c skrótu przy operacjach słownikowych.
Jest tylko jedno ograniczenie: dla obiektów, które przy porównaniu s ˛
a równe, musi zosta´c zwrócona ta
sama warto´s´c; zaleca si˛e powi ˛
azanie w jaki´s sposób (np. przy u˙zyciu alternatywy wykluczaj ˛
acej) warto´sci
skrótu dla tych komponentów obiektów, które s ˛
a wykorzystywane równie˙z przy porównywaniu. Je´sli dla
klasy nie zdefiniowano metody
__cmp__()
, nie nale˙zy równie˙z definiowa´c metody
__hash__()
. Je´sli
zdefiniowana zostanie
__cmp__()
lub
__eq__()
, ale nie
__hash__()
, instancje klasy nie b˛ed ˛
a mogły
by´c wykorzystywane jako klucze w słowników. Je´sli klasa definiuje obiekty zmienne i zdefiniowana jest
metoda
__cmp__()
lub
__eq__()
, nie nale˙zy definiowa´c metody
__hash__()
, gdy˙z implementacja
słownika wymaga, aby warto´sci skrótu jego kluczy były niezmienne (je´sli warto´s´c skrótu obiektu ulegnie
zmianie, znajdzie si˛e on w niewła´sciwym kubełku tablicy skrótów).
__nonzero__(
self
)
Wywoływana w celu sprawdzenia warto´sci logicznej obiektu oraz przez wbudowan ˛
a funkcj˛e
bool()
;
powinna zwróci´c
False
lub
True
, ew. ich liczbowe odpowiedniki,
0
lub
1
. Je´sli metoda ta nie jest
zdefiniowana, wywoływana jest metoda
__len__()
. Je´sli klasa nie definiuje i tej metody, przyjmuje si˛e,
˙ze warto´sci ˛
a logiczn ˛
a wszystkich jej instancji jest prawda.
__unicode__(
self
)
Wywoływana przez wbudowan ˛
a funkcj˛e
unicode()
, powinna zwróci´c obiekt Unicode. Je´sli metoda nie
jest zdefiniowana, zamiast jej wywołania wykonywana jest konwersja napisowa, za´s jej wynik jest nast˛epnie
konwertowany do Unicode przy wykorzystaniu domy´slnego kodowania w ´srodowisku wykonawczym.
3.3.2
Indywidualizacja dost ˛epu do atrybutów
Poprzez zdefiniowanie opisanych poni˙zej metod mo˙zliwa jest zmiana semantyki dost˛epu do atrybutów (u˙zycia,
przypisania lub usuni˛ecia
x.nazwa
dla instancji klas).
__getattr__(
self, nazwa
)
Wywoływana, je´sli przy odwołaniu do atrybutu nie mo˙zna go odnale´z´c w zwykły sposób, tj. je´sli atrybut nie
istnieje w instancji, ani w drzewie klas obiektu
self
. Parametr
nazwa
zawiera nazw˛e atrybutu. Metoda
powinna zwróci´c warto´s´c atrybutu lub wygenerowa´c wyj ˛
atek
AttributeError
.
Zwró´cmy uwag˛e, ˙ze je´sli atrybut zostanie odnaleziony w zwykły sposób, metoda
__getattr__()
nie
b˛edzie wywołana. (Wyst˛epuje tu celowa asymetria pomi˛edzy
__getattr__()
a
__setattr__()
.)
3.3. Specjalne nazwy metod
23
Jest tak zarówno ze wzgl˛edu na wydajno´s´c, jak i dlatego, ˙ze w przeciwnym wypadku
__setattr__()
nie mogłaby w ˙zaden sposób uzyska´c dost˛epu do innych atrybutów instancji. W przypadku zmiennych
instancji mo˙zna zasymulowa´c pełn ˛
a kontrol˛e, nie wstawiaj ˛
ac do słownika atrybutów instancji ˙zadnych
warto´sci (wstawiaj ˛
ac je natomiast wewn ˛
atrz innego obiektu). Sposób przej˛ecia całkowitej kontroli nad
dost˛epem do atrybutów instancji przy klasach w nowym stylu opisano w dalszej cz˛e´sci, dotycz ˛
acej metody
__getattribute__()
.
__setattr__(
self, nazwa, warto´s´c
)
Wywoływana przy operacji przypisania do atrybutu. Jest ona u˙zywana w miejsce zwykłego mechanizmu,
tj. zapisania warto´sci w słowniku instancji. Parametr nazwa jest nazw ˛
a atrybutu, warto´s´c jest przypisywan ˛
a
mu warto´sci ˛
a.
Aby dokona´c przypisania do atrybutu instancji wewn ˛
atrz tej metody, nie nale˙zy u˙zywa´c zwykłej in-
strukcji przypisania („
self.
nazwa
= warto´
s´
c
”), gdy˙z spowodowałoby to rekurencyjne wywołanie tej
samej metody. Zamiast tego nale˙zy bezpo´srednio wstawi´c warto´s´c do słownika atrybutów instancji, np.
„
self.__dict__[
nazwa
] = warto´
s´
c
”. W przypadku klas w nowym stylu, zamiast bezpo´sredniego
odwoływania si˛e do słownika atrybutów nale˙zy wywoła´c metod˛e klasy bazowej o tej samej nazwie, np.
„
obiekt.__setattr__(self, nazwa, warto´
s´
c)
”.
__delattr__(
self, nazwa
)
U˙zywana podobnie jak
__setattr__()
, lecz w odniesieniu do usuni˛ecia atrybutu, zamiast do przypisa-
nia. Metoda powinna by´c implementowana tylko, je´sli „
del obj.
nazwa” ma jaki´s sens.
Rozszerzony dost ˛ep do atrybutów przy klasach w nowym stylu
Opisane poni˙zej metody wyst˛epuj ˛
a wył ˛
acznie w obiektach w nowym stylu.
__getattribute__(
self, nazwa
)
Metoda jest wywoływana bezwarunkowo w celu realizacji dost˛epu do atrybutu instancji klasy.
Je´sli
klasa implementuje równie˙z metod˛e
__getattr__
, nie b˛edzie ona nigdy wywoływana (chyba, ˙ze
zostanie wywołana jawnie).
Wynikiem działania metody powinna by´c (wyliczona) warto´s´c atry-
butu o podanej nazwie lub wygenerowanie wyj ˛
atku
AttributeError
.
Aby unikn ˛
a´c niesko´nc-
zonej rekurencji przy wywołaniach tej metody, wewn ˛
atrz jej implementacji nale˙zy odwoływa´c si˛e do
atrybutów obiektu wył ˛
acznie poprzez wywołanie metody o tej samej nazwie z klasy bazowej, np.:
„
obiekt.__getattribute__(self, nazwa)
”.
Implementowanie deskryptorów
Poni˙zsze metody maj ˛
a zastosowanie tylko w przypadkach, gdy instancja klasy zawieraj ˛
acej metod˛e (tzw. klasa
deskryptora) pojawia si˛e w słowniku innej klasy w nowym stylu, znanej jako klasa wła´sciciela. W przedstaw-
ionych przykładach okre´slenie „atrybut” odnosi si˛e do atrybutu, którego nazwa jest kluczem własno´sci w słowniku
__dict__
klasy wła´sciciela.
__get__(
self, instancja, wła´sciciel
)
Wywoływana w celu uzyskania atrybutu klasy wła´sciciela (dost˛ep do atrybutu klasy) lub instancji tej klasy
(dost˛ep do atrybutu instancji). Argument wła´sciciel odnosi si˛e zawsze do klasy wła´sciciela, natomiast
instancja jest instancj ˛
a poprzez któr ˛
a wyst ˛
apił dost˛ep do atrybutu lub ma warto´s´c
None
, je´sli dost˛ep do
atrybutu wyst˛epuje poprzez klas˛e wła´sciciel. Wynikiem działania metody powinna by´c (wyliczona) warto´s´c
atrybutu lub wygenerowanie wyj ˛
atku
AttributeError
.
__set__(
self, instancja, warto´s´c
)
Wywoływana w celu ustawienia atrybutu instancji instancja klasy, do której nale˙zy metoda, na warto´s´c
warto´s´c.
__delete__(
self, instancja
)
Wywoływana w celu usuni˛ecia atrybutu instancji instancja klasy, do której nale˙zy metoda.
24
Rozdział 3. Model danych
U˙zywanie deskryptorów
W ogólnym przypadku deskryptor jest atrybutem obiektu definiuj ˛
acym „zachowanie dowi ˛
azania”, tj. takim,
do którego dost˛ep jest kontrolowany przez metody deskryptora o nazwach:
__get__()
,
__set__()
i
__delete__()
.
Je´sli obiekt implementuje któr ˛
akolwiek z tych metod, wówczas okre´sla si˛e go mianem
deskryptora.
Domy´slnym zachowaniem przy dost˛epie do atrybutu jest jego pobranie, ustawienie lub usuni˛ecie ze słownika pow-
i ˛
azanego z obiektem. Na przykład zapis
a.x
powoduje uruchomienie ła´ncucha poszukiwa´n, rozpoczynaj ˛
acego si˛e
od
a.__dict__[’x’]
, po którym nast˛epuje
type(a).__dict__[’x’]
oraz ci ˛
ag analogicznych odwoła´n
dla wszystkich klas bazowych klasy
type(a)
z pomini˛eciem metaklas.
Je´sli jednak odnaleziona warto´s´c jest obiektem definiuj ˛
acym jedn ˛
a z metod deskryptora, domy´slne zachowanie
mo˙ze zosta´c zast ˛
apione wywołaniem odpowiedniej metody. Miejsce w ła´ncuchu poszukiwa´n, w którym u˙zywane
s ˛
a deskryptory, zale˙zy od tego, które metody deskryptora zostały zdefiniowane i w jaki sposób s ˛
a wywoływane.
Nale˙zy przy tym podkre´sli´c, ˙ze deskryptory s ˛
a u˙zywane tylko przy obiektach lub klasach w nowym stylu (b˛ed ˛
a-
cych pochodnymi klasy
object()
lub
type()
).
Punktem wyj´scia dla u˙zycia deskryptora jest dowi ˛
azanie,
a.x
. Sposób, w jaki ustalane s ˛
a argumenty, zale˙zy od
tego, czym jest
a
:
Bezpo´srednie wywołanie Najprostsze i najrzadziej spotykane wywołanie wyst˛epuje w przypadku, gdy kod u˙zytkownika bezpo´srednio
wywołuje metod˛e deskryptora:
x.__get__(a)
.
Dowi ˛
azanie do instancji Przy dowi ˛
azaniu do instancji klasy w nowym stylu zapis
a.x
jest przekształcany na wywołanie:
type(a).__dict__[’x’].__get__(a, type(a))
.
Dowi ˛
azanie do klasy Przy dowi ˛
azaniu do klasy w nowym stylu,
zapis
A.x
jest przekształcany na wywołanie:
A.__dict__[’x’].__get__(None, A)
.
Dowi ˛
azanie do klasy super Je´sli
a
jest
instancj ˛
a
klasy
super
,
wówczas
dowi ˛
azanie
super(B, obiekt).m()
powoduje
wyszukanie
w´sród
warto´sci
obj.__class__.__mro__
klasy
bazowej
A
bezpo´srednio
poprzedzaj ˛
acej
B
,
a
nast˛epnie
wywołanie
deskryptora
przy
u˙zyciu
wyra˙zenia:
A.__dict__[’m’].__get__(obiekt, A)
.
W przypadku dowi ˛
azania do instancji priorytet u˙zycia deskryptorów, w stosunku do innych metod dost˛epu do atry-
butu, zale˙zy od tego, jakie implementuje on metody. Deskryptory opisuj ˛
ace dane definiuj ˛
a metody
__get__()
oraz
__set__()
. Deskryptory nie opisuj ˛
ace danych definiuj ˛
a wył ˛
acznie metod˛e
__get__()
. Deskryptory
opisuj ˛
ace dane bior ˛
a zawsze gór˛e nad ponown ˛
a definicj ˛
a atrybutu w słowniku instancji. Z drugiej strony, deskryp-
tory nie opisuj ˛
ace danych mog ˛
a zosta´c nadpisane przez instancje.
Metody Pythona (ł ˛
acznie ze zdefiniowanymi przy u˙zyciu
staticmethod()
lub
classmethod()
) s ˛
a im-
plementowane jako deskryptory nie opisuj ˛
ace danych. W zwi ˛
azku z tym instancje mog ˛
a przedefiniowywa´c i
nadpisywa´c metody, co pozwala ró˙znicowa´c zachowanie poszczególnych instancji tej samej klasy.
Funkcja
property()
jest zaimplementowana przy u˙zyciu deskryptora opisuj ˛
acego dane, w zwi ˛
azku z czym
instancje nie mog ˛
a modyfikowa´c jej zachowania.
__slots__
Domy´slnie z ka˙zd ˛
a instancj ˛
a klasy w starym jak i w nowym stylu zwi ˛
azany jest słownik przechowuj ˛
acy jej atry-
buty. Powoduje to niegospodarne wykorzystanie pami˛eci w przypadku obiektów maj ˛
acych niewielk ˛
a ilo´s´c zmi-
ennych poziomu instancji, szczególnie dolegliwe przy tworzeniu du˙zej liczby instancji.
Domy´slne zachowanie mo˙zna zmieni´c poprzez ustawienie atrybutu wewn ˛
atrz definicji klasy w nowym stylu.
Przypisanie atrybutowi __slots__ sekwencji nazw zmiennych poziomu instancji powoduje przydzielenie w ka˙zdej
instancji ilo´sci miejsca dokładnie odpowiadaj ˛
acej liczbie zmiennych. Oszcz˛edno´s´c miejsca polega na unikni˛eciu
tworzenia słownika __dict__ dla ka˙zdej instancji.
__slots__
Zmienna poziomu klasy, której mo˙zna przypisa´c napis, obiekt iterowalny lub sekwencj˛e napisów, które
s ˛
a nazwami zmiennych u˙zywanych przez instancje. Zdefiniowanie atrybutu __slots__ wewn ˛
atrz klasy w
3.3. Specjalne nazwy metod
25
nowym stylu powoduje zarezerwowanie miejsca na zadeklarowane miejsce i zapobiega automatycznemu
tworzeniu atrybutów __dict__ i __weakref__ przy ka˙zdej instancji. Dodano w wersji 2.2.
Uwagi na temat u˙zycia atrybutu __slots__
• W przypadku instancji, które nie posiadaj ˛
a atrybutu __dict__, nie jest mo˙zliwe przypisywanie zmiennych,
które nie zostały wymienione w definicji __slots__. Próba wykonania takiego przypisania spowoduje
wygenerowanie wyj ˛
atku
AttributeError
. Je´sli wymagana jest mo˙zliwo´s´c dynamicznego dodawa-
nia nowych zmiennych, nale˙zy w sekwencji napisów przypisanej atrybutowi __slots__ zawrze´c nazw˛e
’__dict__’
. Zmieniono w wersji 2.3: W poprzedniej wersji Pythona dodanie do sekwencji __slots__
atrybutu
’__dict__’
nie umo˙zliwiało przypisywania nowych atrybutów, które nie zostały jawnie
wymienione w´sród nazw zmiennych poziomu instancji.
• Klasy definiuj ˛
ace __slots__ nie obsługuj ˛
a słabych odwoła´n do swych instancji, je´sli ka˙zda z instancji nie
zawiera zmiennej __weakref__. Je´sli wymagana jest obsługa słabych odwoła´n, nale˙zy w sekwencji napisów
przypisanej atrybutowi __slots__ zawrze´c nazw˛e
’__weakref__’
. Zmieniono w wersji 2.3: W poprzed-
niej wersji Pythona dodanie do sekwencji __slots__ atrybutu
’__weakref__’
nie umo˙zliwiało obsługi
słabych odwoła´n.
• Obsługa atrybutu __slots__ jest implementowana na poziomie klasy poprzez tworzenie deskryptorów
(3.3.2) dla ka˙zdej nazwy zmiennej. W wyniku tego nie jest mo˙zliwe u˙zycie atrybutów klasy jako domy´sl-
nych warto´sci dla zmiennych poziomu instancji zdefiniowanych poprzez __slots__. Przy próbie ustalenia
warto´sci domy´slnej w taki sposób nast ˛
api nadpisanie deskryptora przez atrybut klasy.
• Je´sli klasa definiuje slot (nazw˛e wymienion ˛
a w warto´sci __slots__), zdefiniowany równie˙z w klasie bazowej,
wówczas zmienna poziomu instancji dost˛epna przez slot w klasie bazowej staje si˛e niedost˛epna (pomijaj ˛
ac
bezpo´srednie pobranie deskryptora z klasy bazowej). Powoduje to niezdefiniowane znaczenie programu.
By´c mo˙ze w przyszło´sci wyst˛epowa´c b˛edzie sprawdzenie, które temu zapobiegnie.
• Działanie atrybutu __slots__ ograniczone jest do klasy, w którym został on zdefiniowany. W wyniku tego
klasy pochodne b˛ed ˛
a w zwykły sposób zawiera´c atrybut __dict__ (chyba, ˙ze w nich równie˙z zostanie zdefin-
iowany __slots__.
• Atrybut __slots__ nie funkcjonuje w przypadku klas odziedziczonych po wbudowanych typach „zmiennej
długo´sci”, takich jak
long
,
str
czy
tuple
.
• Dopuszcza si˛e przypisanie atrybutowi __slots__ dowolnego obiektu iterowalnego nie b˛ed ˛
acego napisem.
Mo˙zliwe jest równie˙z u˙zycie w tym celu słowników, jednak w przyszło´sci warto´sciom odpowiadaj ˛
acym
poszczególnym kluczom mo˙ze zosta´c nadane specjalne znaczenie.
3.3.3
Indywidualizacja tworzenia klas
Domy´slnie klasy w nowym stylu s ˛
a tworzone przy u˙zyciu funkcji
type()
. Definicja klasy jest umieszczana w
odr˛ebnej przestrzeni nazw, za´s do nazwy klasy dowi ˛
azywany jest wynik wywołania
type(nazwa, bazowe,
słownik)
.
Je´sli na etapie odczytywania definicji klasy, zdefiniowana jest zmienna __metaclass__, to zamiast funkcji
type()
zostanie wywołana warto´s´c tej zmiennej. Pozwala to na tworzenie klas lub funkcji monitoruj ˛
acych lub zmieniaj ˛
a-
cych proces tworzenia klas. Do mo˙zliwych zmian nale˙z ˛
a:
• Modyfikacja słownika klasy przed jej utworzeniem.
• Zwrócenie instancji innej klasy, co odpowiada pełnieniu roli funkcji fabrykuj ˛
acej.
__metaclass__
Warto´sci ˛
a zmiennej mo˙ze by´c dowolny obiekt wywoływalny, pobieraj ˛
acy argumenty
nazwa
,
bazowe
oraz
słownik
. Obiekt wywoływany jest w zast˛epstwie wbudowanej funkcji
type()
na etapie tworzenia klasy.
Dodano w wersji 2.2.
Wła´sciwa metaklasa jest wybierana zgodnie z poni˙zszymi regułami ustalaj ˛
acymi priorytety post˛epowania:
26
Rozdział 3. Model danych
• Je´sli istnieje zmienna
dict[’__metaclass__’]
, w roli metaklasy u˙zywana jest jej warto´s´c.
• W przeciwnym wypadku, je´sli istnieje przynajmniej jedna klasa bazowa, wykorzystywana jest powi ˛
azana
z ni ˛
a metaklasa (powoduje to sprawdzenie w pierwszej kolejno´sci atrybutu __class__, a przy jego braku —
u˙zycie typu klasy).
• W przeciwnym wypadku, je´sli istnieje zmienna globalna o nazwie __metaclass__, w roli metaklasy u˙zy-
wana jest jej warto´s´c.
• W przeciwnym wypadku u˙zywana jest klasyczna metaklasa (types.ClassType).
Potencjalne obszary zastosowa´n metaklas s ˛
a nieograniczone. Wykorzystane ju˙z pomysły obejmuj ˛
a rejestrowanie
zdarze´n w dzienniku, sprawdzanie interfejsu, automatyczne delegowanie, automatyczne tworzenie wła´sciwo´sci,
klasy po´srednicz ˛
ace, szkielety, jak te˙z automatyczne synchronizowanie/blokowanie zasobów.
3.3.4
Emulowanie obiektów wywoływalnych
__call__(
self
[
, argumenty...
]
)
Wywoływana przy operacji „wywołania” instancji jak funkcji; je´sli jest ona zdefiniowana, to x
(arg1,
arg2, ...)
jest odpowiednikiem x
.__call__(arg1, arg2, ...)
.
3.3.5
Emulowanie typów kontenerowych
Poni˙zsze metody mog ˛
a by´c zdefiniowane w celu zaemulowania obiektów kontenerowych. Kontenery s ˛
a zwykle
sekwencjami (np. listy czy krotki) lub odwzorowaniami (np. słowniki) lecz obiekty mog ˛
a równie˙z reprezen-
towa´c równie˙z inne kontenery. Pierwszy zbiór metod jest u˙zywany do emulowania albo sekwencji albo odw-
zorowa´n; ró˙znica polega na tym, ˙ze w przypadku sekwencji dopuszczalnymi kluczami powinny by´c warto´sci
całkowite k, takie, ˙ze
0 <=
k
<
N, gdzie N jest długo´sci ˛
a sekwencji, lub te˙z obiekty wykrojenia, definiuj ˛
ace za-
kresy elementów (w celu zachowania zgodno´sci wstecz mo˙zna równie˙z zdefiniowa´c metod˛e
__getslice__()
(patrz ni˙zej), obsługuj ˛
ac ˛
a proste wykrojenia, bez obsługi wykroje´n zło˙zonych). W przypadku odwzorowa´n za-
leca si˛e równie˙z udost˛epnianie metod
keys()
,
values()
,
items()
,
has_key()
,
get()
,
clear()
,
setdefault()
,
iterkeys()
,
itervalues()
,
iteritems()
,
pop()
,
popitem()
,
copy()
oraz
update()
z zachowaniem semantyki zbli˙zonej do tej, która obowi ˛
azuje przy standardowych obiektach słown-
ikowych Pythona. Moduł
UserDict
oferuje klas˛e
DictMixin
, pomocn ˛
a przy tworzeniu tych metod w opar-
ciu o zaimplementowany zestaw metod bazowych:
__getitem__()
,
__setitem__()
,
__delitem__()
oraz
keys()
. Podobnie, sekwencje zmienne powinny udost˛epnia´c metody
append()
,
count()
,
index()
,
extend()
,
insert()
,
pop()
,
remove()
,
reverse()
oraz
sort()
, o działaniu zbli˙zonym do standar-
dowych obiektów listowych Pythona. Ponadto, typy sekwencyjne powinny implementowa´c operacje dodawa-
nia (w znaczeniu doklejenia) oraz mno˙zenia (w znaczeniu powtórzenia) poprzez definicje opisanych poni˙zej
metod
__add__()
,
__radd__()
,
__iadd__()
,
__mul__()
,
__rmul__()
oraz
__imul__()
. Nie
nale˙zy jednak w takich przypadkach definiowa´c
__coerce__()
, ani innych metod, odpowiadaj ˛
acych wył ˛
acznie
operatorom liczbowym. Zaleca si˛e, aby metod˛e
__contains__()
implementowały zarówno odwzorowa-
nia, jak i sekwencje, co pozwala na efektywne u˙zycie operatora
in
. W przypadku odwzorowa´n
in
powinien
by´c odpowiednikiem metody
has_key()
. Przy sekwencjach powinien on powodowa´c przeszukanie kole-
jnych jej warto´sci. Zaleca si˛e ponadto, aby zarówno odwzorowania, jak i sekwencje implementowały metod˛e
__iter__()
, pozwalaj ˛
ac ˛
a na efektywne przebieganie (iterowanie) przez elementy kontenera. Przy odzworowa-
niach metoda
__iter__()
powinna by´c równowa˙znikiem metody
iterkeys()
. Przy sekwencjach powinna
ona przebiega´c przez kolejne elementy sekwencji.
__len__(
self
)
Wywoływana przy u˙zyciu wbudowanej funkcji
len()
. Powinna zwróci´c długo´s´c obiektu jako nieu-
jemn ˛
a liczb˛e całkowit ˛
a. Ponadto, je´sli dla obiektu nie zdefiniowano metody
__nonzero__()
, a metoda
__len__()
zwróci warto´s´c zero, to za warto´s´c logiczn ˛
a obiektu uznaje si˛e prawd˛e.
__getitem__(
self, klucz
)
Wywoływana przy obliczaniu warto´sci self
[
klucz
]
. W przypadku typów sekwencyjnych powinny by´c
akceptowane klucze całkowitoliczbowe oraz obiekty wykrojenia.
Zwró´cmy uwag˛e, ˙ze specjalna in-
terpretacja indeksów ujemnych (je´sli klasa ma emulowa´c typ sekwencyjny) nale˙zy do samej metody
3.3. Specjalne nazwy metod
27
__getitem__()
. Je´sli klucz jest niewła´sciwego typu, mo˙ze zosta´c wygenerowany wyj ˛
atek
TypeError
;
je´sli warto´s´c nie nale˙zy do zbioru dopuszczalnych indeksów sekwencji (po specjalnej interpretacji warto´sci
ujemnych), powinien zosta´c wygenerowany wyj ˛
atek
IndexError
. Notka: Działanie instrukcji
for
za-
le˙zy od faktu, ˙ze przy niedopuszczalnych indeksach zostanie wygenerowany wyj ˛
atek
IndexError
, gdy˙z
w ten sposób wykrywany jest koniec sekwencji.
__setitem__(
self, klucz, warto´s´c
)
Wywoływana przy przypisaniu do self
[
warto´s´c
]
.
Odnosz ˛
a si˛e do niej te same uwagi, co do
__getitem__()
.
Metoda powinna by´c implementowana tylko w odniesieniu do obiektów odw-
zorowawczych, które pozwalaj ˛
a na podmienianie warto´sci przypisanych kluczom ew. na dodawanie nowych
kluczy oraz przy sekwencjach, których elementy mo˙zna podmienia´c. Przy niepoprawnych warto´sciach
klucza powinny by´c generowane te same wyj ˛
atki, co w przypadku metody
__getitem__()
.
__delitem__(
self, klucz
)
Wywoływana przy usuni˛eciu self
[
klucz
]
. Odnosz ˛
a si˛e do niej te same uwagi, co do
__getitem__()
.
Metoda powinna by´c implementowana tylko w odniesieniu do obiektów odwzorowawczych, które
pozwalaj ˛
a na usuwanie kluczy oraz przy sekwencjach, których elementy mo˙zna usuwa´c.
Przy
niepoprawnych warto´sciach klucza powinny by´c generowane te same wyj ˛
atki, co w przypadku metody
__getitem__()
.
__iter__(
self
)
Wywoływana, kiedy potrzebny jest iterator dla podanego kontenera. Metoda powinna zwróci´c nowy obiekt
iteratora, który pozwala na iterowanie po wszystkich obiektach kontenera. W przypadku odwzorowa´n
iterowanie powinno si˛e odbywa´c po jego kluczach, a odpowiedni iterator powinien by´c równie˙z dost˛epny
za po´srednictwem metody
iterkeys()
.
Do zaimplementowania tej metody potrzebne s ˛
a równie˙z obiekty iteratorów, które powinny zwraca´c same
siebie. Aby uzyska´c wi˛ecej informacji na temat obiektów iteratorów, zajrzyj do sekcji „
Typy iteratorów
” w
pozycji
Podr˛ecznik programisty Pythona - opis biblioteki standardowej
.
Operatory sprawdzania przynale˙zno´sci (
in
oraz
not in
) s ˛
a normalnie implementowane jako iteracja przez ele-
menty sekwencji. Obiekty kontenerowe mog ˛
a jednak dostarcza´c bardziej efektywnych implementacji, definiuj ˛
ac
poni˙zsz ˛
a specjaln ˛
a metod˛e, która nie wymaga jednocze´snie, aby obiekt był sekwencj ˛
a.
__contains__(
self, element
)
Wywoływana jako implementacja operatorów sprawdzania przynale˙zno´sci. Powinna zwróci´c prawd˛e, je´sli
element nale˙zy do self , w przeciwnym wypadku za´s fałsz. W przypadku obiektów odwzorowawczych
powinny by´c brane pod uwag˛e same klucze odwzorowania, zamiast par klucz-warto´s´c.
3.3.6
Dodatkowe metody, słu˙z ˛
ace emulowaniu typów sekwencyjnych
Poni˙zsze opcjonalne metody mog ˛
a zosta´c zdefiniowane celem dokładniejszej emulacji obiektów sekwencyjnych.
W przypadku sekwencji niezmiennych nale˙zy zdefiniowa´c co najwy˙zej metod˛e
__getslice__()
; przy sek-
wencjach zmiennych mo˙zna zdefiniowa´c wszystkie trzy metody.
__getslice__(
self, i, j
)
Przestarzałe od wersji 2.0. Dopuszcza si˛e obiekty wykrojenia jako parametry metody
__getitem__()
.
Wywoływana przy obliczaniu wyra˙zenia self
[
i
:
j
]
. Zwracany obiekt powinien by´c tego samego typu, co
self . Brakuj ˛
ace i lub j zast˛epowane jest odpowiednio przez zero i
sys.maxint
. Je´sli w wykrojeniu
zostan ˛
a u˙zyte indeksy ujemne, do odpowiednich indeksów jest dodawana długo´s´c sekwencji. Je´sli instancja
nie implementuje metody
__len__()
, generowany jest wyj ˛
atek
AttributeError
. Nie daje si˛e ˙zad-
nych gwarancji, ˙ze indeksy po dokonaniu korekty nie b˛ed ˛
a nadal ujemne. Ponadto indeksy wi˛eksze od
długo´sci sekwencji nie s ˛
a modyfikowane. Przy braku metody
__getslice__()
utworzony zostanie
obiekt wykrojenia, a nast˛epnie przekazany do metody
__getitem__()
.
__setslice__(
self, i, j, sekwencja
)
Wywoływana przy przypisaniu do self
[
i
:
j
]
, Do i i j odnosz ˛
a si˛e te same uwagi, co przy metodzie
__getslice__()
.
Metoda ta jest przestarzała. Przy braku metody
__setslice__()
lub w przypadku u˙zycia rozszerzonego
wykrojenia o postaci self
[
i
:
j
:
k
]
zamiast wywołania
__setslice__()
tworzony jest obiekt wykroje-
nia, a nast˛epnie przekazywany do metody
__setitem__()
.
28
Rozdział 3. Model danych
__delslice__(
self, i, j
)
Wywoływana przy operacji usuni˛ecia self
[
i
:
j
]
. Do i i j odnosz ˛
a si˛e te same uwagi, co przy metodzie
__getslice__()
. Metoda ta jest przestarzała. Przy braku metody
__delslice__()
lub w przy-
padku u˙zycia rozszerzonego wykrojenia o postaci self
[
i
:
j
:
k
]
zamiast wywołania
__delslice__()
tworzony jest obiekt wykrojenia, a nast˛epnie przekazywany do metody
__delitem__()
.
Powy˙zsze metody s ˛
a wywoływane tylko, je´sli zostało u˙zyte pojedyncze wykrojenie z jednym dwukropkiem oraz
metoda wykrojenia jest dost˛epna. W przypadku operacji wykrojenia opartej na rozszerzonym zapisie wykrojenia
lub w przypadku braku odpowiedniej metody wywoływana jest metoda
__getitem__()
,
__setitem__()
lub
__delitem__()
z obiektem wykrojenia jako argumentem.
Poni˙zszy przykład pokazuje, w jaki sposób mo˙zna przygotowa´c program lub moduł tak, aby był zgodny z
wcze´sniejszymi wersjami Pythona (przy zało˙zeniu, ˙ze metody
__getitem__()
,
__setitem__()
oraz
__delitem__()
dopuszczaj ˛
a obiekty wykrojenia jako argumenty):
class MojaKlasa:
...
def __getitem__(self, indeks):
...
def __setitem__(self, indeks, warto´
s´
c):
...
def __delitem__(self, indeks):
...
if sys.version_info < (2, 0):
# Metody nie b˛
ed ˛
a zdefiniowane, je´
sli wersja jest wcze´
sniejsza od 2.0
def __getslice__(self, i, j):
return self[max(0, i):max(0, j):]
def __setslice__(self, i, j, seq):
self[max(0, i):max(0, j):] = seq
def __delslice__(self, i, j):
del self[max(0, i):max(0, j):]
...
Zwró´cmy uwag˛e na wywołania funkcji
max()
; s ˛
a one potrzebne ze wzgl˛edu na obsługiwanie indeksów
ujemnych przed wywoływaniem metod
__*slice__()
. W przypadku u˙zycia indeksów ujemnych metody
__*item__()
otrzymuj ˛
a je bez zmian, jednak
__*slice__()
otrzymuj ˛
a zmodyfikowane wersje.
Do
ka˙zdego indeksu dodawana jest długo´s´c sekwencji (co nie musi jednak dawa´c warto´sci nieujemnej); jest to
zwyczajowy sposób obsługi ujemnych indeksów przez wbudowane typy sekwencyjne i przyjmuje si˛e, ˙ze metody
__*item__()
zachowuj ˛
a si˛e podobnie. Jednak, poniewa˙z powinny one ju˙z to robi´c, nie mo˙zna przekazywa´c
ujemnych indeksów; musz ˛
a one przed przekazaniem do metod
__*item__()
zosta´c zaw˛e˙zone do granic sek-
wencji. Wywołanie
max(0, i)
w wygodny sposób tworzy poprawn ˛
a warto´s´c.
3.3.7
Emulowanie typów liczbowych
Opisane poni˙zej metody mog ˛
a by´c wykorzystywane do emulacji obiektów liczbowych. Je´sli obiekty danego typu
nie obsługuj ˛
a pewnych operacji (np. operacji bitowych w przypadku liczb niecałkowitych), odpowiadaj ˛
ace im
metody nale˙zy pozostawi´c niezdefiniowane.
__add__(
self, inny
)
__sub__(
self, inny
)
__mul__(
self, inny
)
__floordiv__(
self, inny
)
__mod__(
self, inny
)
__divmod__(
self, inny
)
__pow__(
self, inny
[
, modulo
]
)
__lshift__(
self, inny
)
__rshift__(
self, inny
)
3.3. Specjalne nazwy metod
29
__and__(
self, inny
)
__xor__(
self, inny
)
__or__(
self, inny
)
Metody te wywoływane s ˛
a jako implementacje dwuargumentowych operacji arytmetycznych (
+
,
-
,
*
,
//
,
%
,
divmod()
,
pow()
,
**
,
<<
,
>>
,
&
,
^
,
|
). Na przykład, aby obliczy´c warto´s´c wyra˙zenia x
+
y,
gdzie x jest instancj ˛
a klasy ze zdefiniowan ˛
a metod ˛
a
__add__()
, wywoływane jest x
.__add__(
y
)
.
Metoda
__divmod__()
powinna by´c odpowiednikiem u˙zytych jednocze´snie metod
__floordiv__()
i
__mod__()
. Nie powinna ona by´c powi ˛
azana z opisan ˛
a dalej metod ˛
a
__truediv__()
. Zwró´cmy
uwag˛e, ˙ze je´sli obsługiwana ma by´c trójargumentowa posta´c wbudowanej funkcji
pow()
, to definicja
metody
__pow__()
powinna dopuszcza´c opcjonalny trzeci argument.
__div__(
self, inny
)
__truediv__(
self, inny
)
Metody te wywoływane s ˛
a jako implementacje operacji dzielenia (
/
).
Je´sli aktywna jest cecha
__future__.division
, nast˛epuje u˙zycie metody
__truediv__()
, w przeciwnym wypadku u˙zy-
wana jest
__div__()
. Je´sli zdefiniowana jest tylko jedna z tych metod, to obiekt nie b˛edzie obsługiwał
dzielenia w kontek´scie odmiennym od tego, w którym jest ona stosowana, (tzw. nie jest wywoływana w
zast˛epstwie druga metoda). W tym przypadku generowany jest wyj ˛
atek
TypeError
.
__radd__(
self, inny
)
__rsub__(
self, inny
)
__rmul__(
self, inny
)
__rdiv__(
self, inny
)
__rtruediv__(
self, inny
)
__rfloordiv__(
self, inny
)
__rmod__(
self, inny
)
__rdivmod__(
self, inny
)
__rpow__(
self, inny
)
__rlshift__(
self, inny
)
__rrshift__(
self, inny
)
__rand__(
self, inny
)
__rxor__(
self, inny
)
__ror__(
self, inny
)
Metody te s ˛
a wywoływane jako implementacje dwuargumentowych operacji arytmetycznych (
+
,
-
,
*
,
/
,
%
,
divmod()
,
pow()
,
**
,
<<
,
>>
,
&
,
^
,
|
) z operandami zamienionymi miejscami. Ich wywołanie
nast˛epuje tylko wtedy, gdy lewy operand nie obsługuje okre´slonej operacji. Na przykład, aby obliczy´c
warto´s´c wyra˙zenia x
-
y, gdzie y jest instancj ˛
a klasy ze zdefiniowan ˛
a metod ˛
a
__rsub__()
, wywoływane
jest y
.__rsub__(
x
)
. Zwró´cmy uwag˛e, i˙z przy trójargumentowym
pow()
nie nast ˛
api próba wywołania
__rpow__()
(reguły uzgadniania stałyby si˛e zbyt skomplikowane).
__iadd__(
self, inny
)
__isub__(
self, inny
)
__imul__(
self, inny
)
__idiv__(
self, inny
)
__itruediv__(
self, inny
)
__ifloordiv__(
self, inny
)
__imod__(
self, inny
)
__ipow__(
self, inny
[
, modulo
]
)
__ilshift__(
self, inny
)
__irshift__(
self, inny
)
__iand__(
self, inny
)
__ixor__(
self, inny
)
__ior__(
self, inny
)
Funkcje te s ˛
a wywoływane jako implementacje operacji modyfikacji arytmetycznych (
+=
,
-=
,
*=
,
/=
,
%=
,
**=
,
<<=
,
>>=
,
&=
,
^=
,
|=
). Metody powinny stara´c si˛e wykonywa´c operacje na miejscu (modyfikuj ˛
ac
self ) i zwraca´c wynik (którym mo˙ze, ale nie musi by´c self ). Je´sli dana metoda nie jest zdefiniowana, oper-
acja modyfikacji wykonywana jest przy u˙zyciu odpowiedniej zwykłej metody. Na przykład, aby obliczy´c
warto´s´c wyra˙zenia x
+=
y, gdzie x jest instancj ˛
a klasy ze zdefiniowan ˛
a metod ˛
a
__iadd__()
, wywoływane
jest x
.__iadd__(
y
)
. Je´sli x jest instancj ˛
a klasy bez metody
__iadd()
, brane s ˛
a pod uwag˛e metody
x
.__add__(
y
)
oraz y
.__radd__(
x
)
, podobnie, jak przy wyra˙zeniu x
+
y.
30
Rozdział 3. Model danych
__neg__(
self
)
__pos__(
self
)
__abs__(
self
)
__invert__(
self
)
Wywoływane jako implementacje jednoargumentowych operacji arytmetycznych (
-
,
+
,
abs()
oraz
~
).
__complex__(
self
)
__int__(
self
)
__long__(
self
)
__float__(
self
)
Wywoływane przez wbudowane funkcje
complex()
,
int()
,
long()
, oraz
float()
.
Powinny
zwraca´c warto´sci odpowiednich typów.
__oct__(
self
)
__hex__(
self
)
Wywoływane przez wbudowane funkcje
oct()
oraz
hex()
. Powinny zwraca´c warto´sci napisowe.
__coerce__(
self, inny
)
Wywoływana przy arytmetyce liczbowej z argumentami ró˙znych typów. Powinna zwróci´c krotk˛e dwuele-
mentow ˛
a, zawieraj ˛
ac ˛
a warto´sci self i inny, przekształcone do wspólnego typu liczbowego, lub
None
, je´sli
konwersja nie jest mo˙zliwa. Je´sli wspólny typ ma by´c taki sam, jak typ argumentu
inny
, wygodnie jest
zwróci´c
None
, gdy˙z interpreter spróbuje dokona´c uzgodnienia równie˙z na drugim argumencie (z drugiej
strony, je´sli nie mo˙zna zmieni´c implementacji drugiego typu, czasem warto przeprowadzi´c jego konwersj˛e
przy pierwszym). Zwrócenie warto´sci
NotImplemented
jest równowa˙zne zwróceniu
None
.
3.3.8
Reguły uzgadniania
W przeszło´sci sekcja ta opisywała reguły uzgadniania. Wraz z rozwojem j˛ezyka reguły te stały si˛e jednak zbyt
zło˙zone, aby je precyzyjnie zdefiniowa´c, za´s szczegółowe dokumentowanie zachowania konkretnej wersji jednej
implementacji nie byłoby zbyt u˙zyteczne. Zamiast tego poni˙zej zamieszczono wi˛ec pewne wskazówki dotycz ˛
ace
uzgadniania. W Pythonie 3.0 uzgadnianie nie b˛edzie obsługiwane.
• Je´sli lewy operand operatora % jest napisem lub obiektem Unicode, uzgadnianie nie ma miejsca, a wykony-
wan ˛
a operacj ˛
a jest operacja formatowania napisu.
• Nie zaleca si˛e ju˙z definiowa´c operacji uzgadniania. W przypadku operacji na argumentach ró˙znych typów,
gdy oba typy nie definiuj ˛
a uzgadniania, operacji przekazywane s ˛
a pierwotne argumenty.
• Klasy w nowym stylu (pochodne po
object
) nigdy nie wywołuj ˛
a
__coerce__()
na skutek u˙zycia
operatora dwuargumentowego. Jedyn ˛
a sytuacj ˛
a, w której jest wywoływana metoda
__coerce__()
jest
jawne u˙zycie wbudowanej funkcji
coerce()
.
• W wi˛ekszo´sci przypadków, operator zwracaj ˛
acy
NotImplemented
traktowany jest tak samo, jak ten,
który nie jest w ogóle zaimplementowany.
• W kolejnych akapitach zapisy
__op__()
i
__rop__()
oznaczaj ˛
a nazwy metod odpowiadaj ˛
acych
operatorowi, za´s
__iop__
oznacza odpowiadaj ˛
ac ˛
a mu metod˛e wykonuj ˛
ac ˛
a operacj˛e w miejscu. Na
przykład, przy operatorze „
+
” lewostronnej i prawostronnej odmianie odpowiadaj ˛
a metody
__add__()
i
__radd__()
, za´s
__iadd__
odpowiada odmianie wykonuj ˛
acej operacj˛e w miejscu.
• Przy operacji na obiektach x i y najpier wykonywane jest x
.__op__(
y
)
, je´sli odpowiednia metoda nie
jest zaimplementowana lub zwraca
NotImplemented
, wykonywane jest y
.__rop__(
x
)
is tried. Je´sli
ta metoda równie˙z nie jest zaimplementowana lub zwraca
NotImplemented
, generowany jest wyj ˛
atek
TypeError
. Wyst˛epuje jednak pewien wyj ˛
atek od tej zasady:
• Wyj ˛
atek od powy˙zszej zasady: je´sli lewy operand jest instancj ˛
a wbudowanego typu lub klasy w nowym
stylu, za´s prawy operand jest instancj ˛
a podklasy tego typu lub klasy, próba u˙zycia metody
__rop__()
nast˛epuje przed u˙zyciem metody
__op__()
. Dzieje si˛e tak, aby podklasa mogła całkowicie zmieni´c dzi-
ałanie operatorów dwuargumentowych. Gdyby tego wyj ˛
atku nie było, zawsze wywoływana byłaby metoda
__op__ lewego argumentu, która akceptuje prawy argument (je´sli oczekiwana jest instancja pewnej klasy,
instancja jej podklasy jest zawsze równie˙z akceptowana).
3.3. Specjalne nazwy metod
31
• Je´sli typ któregokolwiek z operandów definiuje uzgadnianie, jest ono stosowane przed wywołaniem jego
metody
__op__()
lub
__rop__()
, jednak nie wcze´sniej. Je´sli operacja uzgadniania da w wyniku obiekt
typu ró˙znego od tego, dla którego j ˛
a wykonano, cz˛e´s´c całego procesu jest ponawiana z nowym obiektem.
• W przypadku u˙zycia przypisania modyfikuj ˛
acego (np. „
+=
”), gdy jego lewy operand implementuje metod˛e
__iop__()
, jest ona wywoływana bez uzgadniania. Je´sli jednak nast ˛
api wykonanie operacji przy u˙zyciu
metody
__op__()
lub
__rop__()
, stosowane s ˛
a zwykłe reguły uzgadniania.
• W przypadku wyra˙zenia x
+
y, je´sli x jest sekwencj ˛
a implementuj ˛
ac ˛
a sklejenie, nast˛epuje sklejenie dwóch
sekwencji.
• W przypadku wyra˙zenia x
*
y, je´sli jeden z argumentów jest sekwencj ˛
a implementuj ˛
ac ˛
a powielenie sek-
wencji, za´s drugi jest liczb ˛
a całkowit ˛
a (
int
lub
long
), nast˛epuje powielenie sekwencji.
• Operacje porówna´n szczegółowych (implementowane przez metody
__eq__()
, itp.) nigdy nie u˙zywaj ˛
a
uzgodnie´n. Porównanie trójwarto´sciowe (implementowane przez
__cmp__()
) u˙zywa uzgadniania na tych
samych zasadach, co inne operacje dwuargumentowe.
• W bie˙z ˛
acej implementacji, wbudowane typy liczbowe
int
,
long
i
float
nie u˙zywaj ˛
a uzgadniania, jed-
nak u˙zywa go typ
complex
. Ró˙znica mo˙ze si˛e objawi´c po utworzeniu klas pochodnych typów liczbowych.
W przyszło´sci prawdopodobnie typ
complex
zostanie poprawiony tak, aby nie u˙zywał uzgadniania.
Wszystkie te typy implementuj ˛
a metod˛e
__coerce__()
na potrzeby wbudowanej funkcji
coerce()
.
32
Rozdział 3. Model danych
ROZDZIAŁ
CZWARTY
Model wykonania
4.1
Nazwy i dowi ˛
azywanie nazw
Nazwy odnosz ˛
a si˛e do obiektów. Ka˙zda z nazw jest wprowadzana poprzez operacj˛e dowi ˛
azania nazwy. Ka˙zde
wyst ˛
apienie nazwy w tek´scie programu odnosi si˛e do dowi ˛
azania tej nazwy ustanowionego w najbardziej zag-
nie˙zd˙zonym bloku funkcji zawieraj ˛
acym jej u˙zycie.
Blok jest fragmentem programu w Pythonie, który mo˙ze by´c wykonany jako jednostka Nast˛epuj ˛
ace elementy s ˛
a
blokami kodu: moduł, tre´s´c funkcji i definicja klasy, polecenie wprowadzone w trybie interaktywnym, plik ze
skryptem (plik podany na standardowym wej´sciu interpretera lub jako pierwszy argument w wierszu polecenia),
polecenie skryptowe (polecenie podane w wierszu polecenia interpretera przy u˙zyciu opcji „-c”), plik odczytany
przez wbudowan ˛
a funkcj˛e
execfile()
, argument napisowy przekazany do wbudowanej funkcji
eval()
lub
w poleceniu
exec
, wyra˙zenie odczytane oraz warto´sciowane przez wbudowan ˛
a funkcj˛e
input()
.
Blok kodu jest wykonywany w ramce wykonania. Ramka wykonania zawiera pewne informacje administracyjne
(wykorzystywane przy debugowaniu) oraz okre´sla gdzie i w jaki sposób kontynuowane ma by´c wykonanie po
zako´nczeniu wykonywania bloku kodu.
Zasi˛eg definiuje widoczno´s´c nazwy wewn ˛
atrz bloku. Je´sli nazwa lokalna jest zdefiniowana wewn ˛
atrz bloku, jej
zasi˛eg zawiera ten blok. Je´sli definicja wyst˛epuje w bloku funkcji, zasi˛eg rozci ˛
aga si˛e na ka˙zdy blok wewn ˛
atrz
bloku zawieraj ˛
acego definicj˛e, chyba, ˙ze wewn˛etrzny blok wprowadza inne dowi ˛
azanie tej samej nazwy. Zasi˛egi
nazw zdefiniowanych w bloku klasy s ˛
a ograniczone do bloku klasy, nie rozci ˛
agaj ˛
a si˛e na bloki kodu jej metod.
Kiedy nazwa zostanie u˙zyta wewn ˛
atrz bloku kodu, nast˛epuje jej odczytanie z wykorzystaniem naj´sci´slej otacza-
j ˛
acego zasi˛egu. Zbiór wszystkich takich zasi˛egów widocznych wewn ˛
atrz bloku kodu jest nazywany ´srodowiskiem
bloku.
Je´sli nazwa jest dowi ˛
azywana gdziekolwiek wewn ˛
atrz bloku, jest nazw ˛
a lokaln ˛
a tego bloku. Je´sli nazwa jest
dowi ˛
azywana na poziomie modułu, jest to nazwa globalna. (Nazwy bloku kodu modułu s ˛
a jednocze´snie lokalne
i globalne.) Je´sli nazwa jest u˙zywana w bloku kodu, lecz nie została w nim zdefiniowana, jest nazywana woln ˛
a
nazw ˛
a
Je´sli nazwa, do której nast˛epuje odwołanie, nie zostanie w ogóle odnaleziona, generowany jest wyj ˛
atek
NameError
. W przypadku odwołania do nazwy lokalnej, która nie została jeszcze dowi ˛
azana, generowany jest
wyj ˛
atek
UnboundLocalError
. Wyj ˛
atek
UnboundLocalError
jest klas ˛
a potomn ˛
a wyj ˛
atku
NameError
.
Do konstrukcji wi ˛
a˙z ˛
acych nazwy nale˙z ˛
a: parametry formalne funkcji, instrukcje
import
, definicje klas i funkcji
(wi ˛
a˙z ˛
a one nazw˛e funkcji lub klasy w bloku mieszcz ˛
acym definicj˛e) oraz cele b˛ed ˛
ace identyfikatorami wyst˛epu-
j ˛
acymi w instrukcjach przypisania, nagłówkach p˛etli
for
lub na drugim miejscu w nagłówku klauzuli
except
.
Instrukcja
import
w postaci „„
from ...import *
”” dowi ˛
azuje wszystkie nazwy zdefiniowane w impor-
towanym module, za wyj ˛
atkiem rozpoczynaj ˛
acych si˛e znakiem podkre´slenia. Postaci tej mo˙zna u˙zywa´c tylko na
poziomie modułu.
Nazwa pojawiaj ˛
aca si˛e w instrukcji
del
jest równie˙z z tego powodu traktowana jako dowi ˛
azana (cho´c rzeczywist ˛
a
semantyk ˛
a instrukcji jest „odwi ˛
azanie” nazwy). Niedozwolone jest usuwanie dowi ˛
aza´n nazw, do których odwoła-
nia wyst˛epuj ˛
a w zagnie˙zd˙zonym zasi˛egu. Kompilator wykrywa takie sytuacje na etapie kompilacji, zgłaszaj ˛
ac ew.
bł ˛
ad
SyntaxError
.
Ka˙zda instrukcja przypisania lub importu wyst˛epuje wewn ˛
atrz bloku zdefiniowanego przez definicj˛e klasy lub
33
funkcji lub na poziomie modułu (w głównym bloku kodu).
Je´sli dowi ˛
azanie nazwy ma miejsce gdziekolwiek w bloku kodu, wszystkie przypadki u˙zycia tej nazwy w bloku
traktowane s ˛
a jako odniesienia do bie˙z ˛
acego bloku. Mo˙ze to prowadzi´c do bł˛edów, je´sli nazwa zostanie u˙zyta
wewn ˛
atrz bloku przed jej dowi ˛
azaniem.
Powy˙zsza reguła jest do´s´c subtelna. W Pythonie nie ma deklaracji i dowi ˛
azywanie nazw mo˙ze wyst˛epowa´c w
dowolnym miejscu bloku kodu. Odnalezienie lokalnych nazw bloku kodu jest mo˙zliwe poprzez przeszukanie
tre´sci całego bloku pod k ˛
atem operacji wi ˛
a˙z ˛
acych nazwy.
Je´sli wewn ˛
atrz bloku wyst˛epuje instrukcja global, wszystkie wyst ˛
apienia nazw wymienionych w tej instrukcji
traktowane s ˛
a jako odniesienia do tych nazw w głównej przestrzeni nazw. W tym przypadku nazwy s ˛
a wyszuki-
wane w globalnej przestrzeni nazw, tj. przestrzeni nazw modułu zawieraj ˛
acego blok kodu oraz wbudowanej
przestrzeni nazw, tj. przestrzeni nazw modułu
__builtin__
. Globalna przestrze´n nazw jest przeszukiwana w
pierwszej kolejno´sci, wbudowana przestrze´n nazw przeszukiwana jest po niej. Wykonanie instrukcji global musi
poprzedza´c wszystkie u˙zycia wymienionych nazw wewn ˛
atrz danego bloku.
Wbudowana przestrze´n nazw, powi ˛
azana z blokiem kodu, jest w rzeczywisto´sci odnajdowana poprzez wyszukanie
nazwy
__builtins__
w jego globalnej przestrzeni nazw. Nazwa ta powinna si˛e odnosi´c do słownika lub
modułu (w ostatnim przypadku u˙zywany jest jego słownik). Normalnie przestrze´n nazw
__builtins__
jest
słownikiem wbudowanego modułu
__builtin__
(zwracamy uwag˛e na brak „s” w nazwie); je´sli nim nie jest,
skutkuje to wykonaniem w trybie o ograniczonym dost˛epie .
Przestrze´n nazw modułu jest tworzona automatycznie przy jego pierwszym zaimportowaniu. Główny moduł
skryptu zawsze nosi nazw˛e
__main__
.
Instrukcja global ma taki sam zasi˛eg, jak operacja wi ˛
a˙z ˛
aca nazw˛e wewn ˛
atrz tego samego bloku. Je´sli naj´sci´slej
otaczaj ˛
acy zasi˛eg wolnej nazwy zawiera instrukcj˛e global, wolna nazwa jest traktowana jak nazwa globalna.
Definicja klasy jest instrukcj ˛
a wykonywaln ˛
a, która mo˙ze u˙zywa´c i definiowa´c nazwy. Wszystkie odwołania podle-
gaj ˛
a zwykłym regułom odnajdywania nazw. Przestrze´n nazw definicji klasy staje si˛e słownikiem atrybutów klasy.
Nazwy zdefiniowane w zasi˛egu klasy nie s ˛
a widoczne wewn ˛
atrz jej metod.
4.1.1
Interakcja z cechami dynamicznymi
Istniej ˛
a pewne przypadki, w których u˙zycie instrukcji Pythona jest niedozwolone w zestawieniu z zagnie˙zd˙zonymi
zasi˛egami zawieraj ˛
acymi wolne nazwy.
Je´sli w którym´s z zagnie˙zd˙zonych zasi˛egów wyst˛epuje odwołanie do nazwy, jej usuwanie jest niedozwolone. W
tym przypadku bł ˛
ad zostanie zgłoszony na etapie kompilacji.
Je´sli funkcja jest blokiem z wolnymi nazwami lub te˙z taki blok zawiera, a jednocze´snie zostanie wewn ˛
atrz funkcji
u˙zyta instrukcja import w postaci z gwiazdk ˛
a — „
import *
” — kompilator zgłosi bł ˛
ad SyntaxError.
Je´sli funkcja jest blokiem z wolnymi nazwami lub te˙z taki blok zawiera, a jednocze´snie zostanie wewn ˛
atrz funkcji
u˙zyta instrukcja exec, wówczas kompilator zgłosi bł ˛
ad SyntaxError, chyba, ˙ze w instrukcji exec zostanie jawnie
okre´slona lokalna przestrze´n nazw. (Innymi słowy, wykonanie „exec kod” jest w takim przypadku niedozwolone
lecz „exec kod in pn” zostanie zaakceptowane.)
Instrukcja
exec
oraz wbudowane funkcje
eval()
,
execfile()
i
input()
przy odnajdywaniu nazw nie maj ˛
a
dost˛epu do pełnego ´srodowiska. Nazwy mog ˛
a by´c wyszukiwane w lokalnej i globalnej przestrzeni nazw bloku
wywołuj ˛
acego. Wolne zmienne nie s ˛
a wyszukiwane w naj´sci´slej otaczaj ˛
acej przestrzeni nazw, lecz w globalnej
przestrzeni nazw.
1
Instrukcja
exec
oraz funkcje
eval()
i
execfile()
maj ˛
a opcjonalne argumenty, które
pozwalaj ˛
a na narzucenie globalnej i lokalnej przestrzeni nazw. Je´sli zostanie podana tylko jedna przestrze´n nazw,
b˛edzie ona spełnia´c obie funkcje.
1
Ograniczenie to wyst˛epuje ze wzgl˛edu na fakt, ˙ze kod wykonywany przez te operacje nie jest dost˛epny w chwili, gdy kompilowany jest
moduł.
34
Rozdział 4. Model wykonania
4.2
Wyj ˛
atki
Wyj ˛
atki stanowi ˛
a przełamanie zwykłego przepływu sterowania w bloku kodu celem obsłu˙zenia bł˛edu lub innej
wyj ˛
atkowej sytuacji. Wyj ˛
atek jest generowany w miejscu wyst ˛
apienia bł˛edu; mo˙ze on by´c obsłu˙zony przez otacza-
j ˛
acy blok kodu lub przez dowolny inny blok kodu, który bezpo´srednio lub po´srednio uaktywnił blok, w którym
wyst ˛
apił wyj ˛
atek.
Interpreter Pythona generuje wyj ˛
atek, je´sli w czasie wykonania zostanie wykryty bł ˛
ad (taki jak np. dzielenie
przez zero). Program w Pythonie mo˙ze równie˙z jawnie wygenerowa´c wyj ˛
atek, wykonuj ˛
ac instrukcj˛e
raise
.
Kod obsługi wyj ˛
atku jest okre´slany przy u˙zyciu instrukcji
try
...
except
. Instrukcja
try
...
finally
okre´sla
kod oczyszczaj ˛
acy, który nie obsługuje wyj ˛
atku lecz jest wykonywany niezale˙znie od tego, czy wyj ˛
atek wyst ˛
apił,
czy te˙z nie.
W Pythonie wykorzystywany jest „niewznawialny” model obsługi bł˛edów: kod obsługi wyj ˛
atku mo˙ze sprawdzi´c
przyczyn˛e jego wyst ˛
apienia oraz kontynuowa´c wykonanie na poziomie przechwycenia. Niemo˙zliwe jednak jest
naprawienie bł˛edu i wznowienie operacji, przy której on wyst ˛
apił (mo˙zna jedynie ponownie spróbowa´c wykona´c
cały odpowiedni fragment kodu z wy˙zszego poziomu).
Je´sli wyj ˛
atek nie zostanie obsłu˙zony, interpreter przerywa wykonywanie programu lub, je´sli pracuje w trybie
interaktywnym, wraca do głównej p˛etli wykonania. W obu przypadkach, o ile wyj ˛
atkiem nie jest
SystemExit
,
wypisywany jest stan stosu z chwili wyst ˛
apienia wyj ˛
atku.
Wyj ˛
atki s ˛
a identyfikowane przy u˙zyciu instancji klas. Wybór pasuj ˛
acej klauzuli
except
oparty jest na to˙zsamo´sci
obiektu. Odpowiednia klauzula
except
musi si˛e odwoływa´c do tej samej klasy lub jednej z jej klas bazowych.
W chwili wyst ˛
apienia wyj ˛
atku, jako jego warto´s´c przekazywany jest obiekt (by´c mo˙ze
None
). Nie wpływa on na
wybór kodu obsługuj ˛
acego wyj ˛
atek, lecz jest przekazywany do wybranego kodu jako dodatkowa informacja. W
przypadku wyj ˛
atków w formie klas obiekt ten musi by´c instancj ˛
a klasy wyj ˛
atku.
Ostrze˙zenie: Komunikaty powi ˛
azane z wyj ˛
atkami nie s ˛
a cz˛e´sci ˛
a API Pythona. Ich zawarto´s´c mo˙ze bez ostrze˙ze-
nia zosta´c zmieniona w której´s z przyszłych wersji Pythona, wi˛ec nie nale˙zy si˛e na nich opiera´c w kodzie, który
ma by´c uruchamiany z u˙zyciem ró˙znych wersji interpretera.
Zobacz te˙z opis instrukcji
try
w sekcji 7.4 oraz instrukcji
raise
w sekcji 6.9.
4.2. Wyj ˛
atki
35
36
ROZDZIAŁ
PI ˛
ATY
Wyra˙zenia
Poni˙zszy rozdział wyja´snia znaczenie poszczególnych elementów wyra˙ze´n w Pythonie.
Uwagi na temat składni: W tym i w kolejnych rozdziałach rozszerzona notacja BNF b˛edzie u˙zywana do opisu
składni, nie struktury leksykalnej. Je´sli reguła składniowa (lub jedna z alternatyw) ma form˛e:
nazwa
::=
inna_nazwa
i nie podano jej semantyki, semantyka symbolu
nazwa
jest taka sama, jak symbolu
inna_nazwa
.
5.1
Konwersje arytmetyczne
Je´sli w którym´s z zamieszczonych w dalszej cz˛e´sci opisów operatorów arytmetycznych zostanie u˙zyty zwrot
„argumenty liczbowe s ˛
a konwertowane do wspólnego typu”, oznacza to, ˙ze argumenty s ˛
a uzgadniane przy u˙zyciu
reguł uzgadniania wymienionych na ko´ncu rozdziału 3. Je´sli oba argumenty s ˛
a warto´sciami standardowych typów
liczbowych, stosowane s ˛
a poni˙zsze uzgodnienia:
• Je´sli który´s z argumentów jest liczb ˛
a zespolon ˛
a, drugi konwertowany jest do liczby zespolonej;
• w przeciwnym wypadku, je´sli który´s z argumentów jest liczb ˛
a zmiennoprzecinkow ˛
a, drugi konwertowany
jest do liczby zmiennoprzecinkowej;
• w przeciwnym wypadku, je´sli który´s z argumentów jest dług ˛
a liczb ˛
a całkowit ˛
a, drugi konwertowany jest do
długiej liczby całkowitej;
• w przeciwnym wypadku oba argumenty musz ˛
a by´c zwykłymi liczbami całkowitymi i konwersja nie jest
konieczna.
Do pewnych operatorów stosuj ˛
a si˛e dodatkowe reguły (np. lewy napisowy argument operatora „%”). Rozszerzenia
mog ˛
a definiowa´c własne reguły uzgadniania.
5.2
Atomy
Atomy s ˛
a najbardziej podstawowymi elementami wyra˙ze´n. Najprostszymi z nich s ˛
a identyfikatory oraz literały.
Składniowo za atomy uznawane s ˛
a równie˙z elementy uj˛ete w odwrócone apostrofy, nawiasy zwykłe lub kwadra-
towe. Składnia atomów przedstawia si˛e nast˛epuj ˛
aco:
atom
::=
identifier | literal | enclosure
enclosure
::=
parenth_form | list_display
| dict_display | string_conversion
5.2.1
Identyfikatory (nazwy)
Identyfikator wyst˛epuj ˛
acy jako atom jest nazw ˛
a. Opis obsługi nazw i ich dowi ˛
aza´n znajduje si˛e w sekcji 4.1.
37
Je´sli nazwa jest powi ˛
azana z obiektem, wynikiem warto´sciowania atomu jest ten obiekt. Je´sli nazwa nie jest z
niczym powi ˛
azana, przy próbie warto´sciowania generowany jest wyj ˛
atek
NameError
.
Maglowanie nazw prywatnych:
w przypadku, gdy identyfikator, mieszcz ˛
acy si˛e tekstowo wewn ˛
atrz definicji
klasy, rozpoczyna si˛e dwoma znakami podkre´slenia i nie ko´nczy si˛e dwoma znakami podkre´slenia, traktowany jest
jako nazwa prywatna tej klasy. Nazwy prywatne s ˛
a przekształcane w dłu˙zsze nazwy na etapie generowania kodu
klasy. Przekształcenie polega na doł ˛
aczeniu nazwy klasy przez nazw ˛
a wła´sciw ˛
a, usuni˛eciu pocz ˛
atkowych znaków
podkre´slenia i dodaniu zamiast tego pojedynczego podkre´slenia przed nazw ˛
a klasy. Na przykład, identyfikator
__spam
wyst˛epuj ˛
acy w klasie o nazwie
Ham
zostanie przekształcony w
_Ham__spam
. Przekształcenie nie
zale˙zy od kontekstu składniowego, w jakim identyfikator został u˙zyty. Je´sli otrzymana w wyniku przekształcenia
nazwa b˛edzie bardzo długa (przekroczy 255 znaków), mo˙ze nast ˛
api´c jej obci˛ecie w sposób zdefiniowany przez
implementacj˛e. Przekształcenie nie ma miejsca, je´sli nazwa klasy składa si˛e wył ˛
acznie ze znaków podkre´slenia.
5.2.2
Literały
Python obsługuje literały napisowe i ró˙zne literały liczbowe:
literal
::=
stringliteral | integer | longinteger
| floatnumber | imagnumber
Wynikiem warto´sciowania literału jest obiekt okre´slonego typu (napisowego, całkowitoliczbowego, długiego
całkowitoliczbowego, zmiennoprzecinkowego, zespolonego) z podan ˛
a warto´sci ˛
a. W przypadku literałów zmi-
ennoprzecinkowych oraz urojonych (zespolonych) warto´s´c mo˙ze zosta´c zaokr ˛
aglona.
Aby uzyska´c wi˛ecej
szczegółów, zajrzyj do sekcji 2.4.
Wszystkie literały odnosz ˛
a si˛e do niezmiennych typów danych, w zwi ˛
azku z czym to˙zsamo´sci takich obiektów s ˛
a
mniej wa˙zne od ich warto´sci. Wielokrotne warto´sciowane literałów o tej samej warto´sci (tych samych lub ró˙znych
wyst ˛
apie´n w tek´scie programu) mo˙ze dawa´c jako wynik ten sam obiekt lub ró˙zne obiekty o tej samej warto´sci.
5.2.3
Elementy uj ˛ete w nawiasy
Elementy uj˛ete w nawiasy to opcjonalna lista wyra˙ze´n, obustronnie otoczona nawiasami okr ˛
agłymi:
parenth_form
::=
"(" [expression_list] ")"
Warto´sci ˛
a listy wyra˙ze´n uj˛etej w nawiasy jest warto´s´c samej listy wyra˙ze´n: je´sli lista zawiera przynajmniej jeden
przecinek, warto´sci ˛
a jest krotka, w przeciwnym wypadku jest to warto´s´c pojedynczego wyra˙zenia.
Warto´sci ˛
a pustej pary nawiasów jest obiekt krotki. Poniewa˙z krotki s ˛
a niezmienne, odnosz ˛
a si˛e do nich reguły
stosowane dla literałów (tj. dwa wyst ˛
apienia pustych krotek mog ˛
a, lecz nie musz ˛
a, dawa´c w wyniku ten sam
obiekt).
Zwró´cmy uwag˛e, ˙ze krotki nie s ˛
a tworzone przez nawiasy okr ˛
agłe, ale przez fakt u˙zycia operatora przecinka.
Jedynym wyj ˛
atkiem jest krotka pusta, w której przypadku nawiasy s ˛
a wymagane — dopuszczenie w wyra˙zeniach
„niczego”, bez obejmuj ˛
acych nawiasów prowadziłoby do niejednoznaczno´sci i mo˙zliwo´sci przeoczenia typowych
literówek.
5.2.4
Drukowalne formy list
Drukowaln ˛
a form ˛
a listy jest (by´c mo˙ze pusta) seria wyra˙ze´n rozdzielonych przecinkami i uj˛etych w nawiasy
kwadratowe:
test
::=
and_test ( "or" and_test )* | lambda_form
testlist
::=
test ( "," test )* [ "," ]
list_display
::=
"[" [listmaker] "]"
listmaker
::=
expression ( list_for | ( "," expression )* [","] )
list_iter
::=
list_for | list_if
list_for
::=
"for" expression_list "in" testlist [list_iter]
list_if
::=
"if" test [list_iter]
Drukowalna posta´c listy daje jako warto´s´c nowy obiekt listy. Jej zawarto´s´c okre´sla podana lista wyra˙ze´n lub
38
Rozdział 5. Wyra˙zenia
wytwornik listy. Je´sli zostanie u˙zyta lista wyra˙ze´n rozdzielonych przecinkami, nast˛epuje ich warto´sciowanie od
lewej do prawej i umieszczanie w tej kolejno´sci jako elementów w obiekcie listy. Je´sli zostanie u˙zyty wytwornik
listy, powinien si˛e on składa´c z pojedynczego wyra˙zenia z wyst˛epuj ˛
ac ˛
a po nim przynajmniej jedn ˛
a klauzul ˛
a
for
,
a nast˛epnie dowoln ˛
a (w tym równ ˛
a zeru) liczb ˛
a klauzul
for
lub
if
. W tym przypadku elementami nowej listy
s ˛
a te, które zostałyby wytworzone po potraktowaniu ka˙zdej z klauzul
for
lub
if
jako bloki zagnie˙zd˙zone od
lewej do prawej i warto´sciowaniu wyra˙zenia daj ˛
acego kolejny element za ka˙zdym razem, gdy zostanie osi ˛
agni˛ety
najbardziej wewn˛etrzny blok.
5.2.5
Drukowalne formy słowników
Drukowaln ˛
a form ˛
a słownika jest (by´c mo˙ze pusta) seria par klucz/dana, uj˛eta w nawiasy klamrowe:
dict_display
::=
"{" [key_datum_list] "}"
key_datum_list
::=
key_datum ("," key_datum)* [","]
key_datum
::=
expression ":" expression
Drukowalna posta´c słownika daje jako warto´s´c nowy obiekt słownika.
Pary klucz/data warto´sciowane s ˛
a od lewej do prawej i definiuj ˛
a elementy słownika: ka˙zdy obiekt klucza u˙zywany
jest jako klucz, pod którym przechowywana jest wyst˛epuj ˛
aca po nim warto´s´c.
Ograniczenia nakładane na typy warto´sci słu˙z ˛
acych za klucze s ˛
a wymienione w sekcji 3.2. (Najkrócej rzecz
ujmuj ˛
ac, typ klucza powinien pozwala´c na obliczenie funkcji skrótu, co wyklucza wszystkie obiekty zmienne.)
Niezgodno´sci pomi˛edzy powtórzonymi kluczami nie s ˛
a wykrywane; w takich przypadkach u˙zyta zostanie ostatnia
dana przypisana okre´slonemu kluczowi (umieszczona w postaci drukowalnej najbardziej na prawo).
5.2.6
Konwersje napisowe
Konwersja napisowa to lista wyra˙ze´n uj˛eta w odwrócone apostrofy:
string_conversion
::=
"‘" expression_list "‘"
Przy konwersji napisowej warto´sciowana jest lista wyra˙ze´n, a otrzymany obiekt jest nast˛epnie konwertowany do
napisu, zgodnie z regułami specyficznymi dla jego typu.
Je´sli obiekt jest napisem, liczb ˛
a, warto´sci ˛
a
None
, ew. krotk ˛
a, list ˛
a lub słownikiem, zawieraj ˛
acymi wył ˛
acznie
obiekty jednego z wymienionych typów, wówczas otrzymany napis jest poprawnym wyra˙zeniem w Pythonie,
które mo˙ze zosta´c przekazane funkcji
eval()
, daj ˛
ac w wyniku wyra˙zenie o tej samej warto´sci, co wyra˙zenie
pierwotne (lub jego przybli˙zenie, je´sli u˙zyto np. liczb zmiennoprzecinkowych).
(W szczególno´sci, konwersja napisowa napisu powoduje otoczenie go odpowiednimi znakami cytowania oraz
u˙zycie odpowiednich sekwencji specjalnych w miejsce „´smiesznych” znaków, tak, aby wynik zawierał tylko znaki
drukowalne.)
Obiekty rekurencyjne (na przykład listy lub słowniki, które zawieraj ˛
a odwołania do nich samych, by´c mo˙ze
po´srednio) odnotowuj ˛
a rekurencyjne odwołania przy u˙zyciu zapisu „
...
”, a napisu otrzymanego w wyniku
takiego zabiegu nie mo˙zna przekaza´c funkcji
eval()
, aby otrzyma´c warto´s´c równ ˛
a pocz ˛
atkowemu obiektowi
(przy napisie w takiej postaci zostanie wygenerowany wyj ˛
atek
SyntaxError
).
Wywołanie wbudowanej funkcji
repr()
powoduje przeprowadzenie na przekazanym jej obiekcie dokładnie tej
samej konwersji, co uj˛ecie go w nawiasy, a nast˛epnie w odwrócone apostrofy. Wbudowana funkcja
str()
przeprowadza podobn ˛
a konwersj˛e, cho´c jej wyniki s ˛
a bardziej przyjazne dla odbiorcy.
5.3
Elementy podstawowe
Elementy podstawowe reprezentuj ˛
a naj´sci´slej powi ˛
azane operacje w j˛ezyku. Ich składnia przedstawia si˛e nast˛epu-
j ˛
aco:
primary
::=
atom | attributeref | subscription | slicing | call
5.3. Elementy podstawowe
39
5.3.1
Odwołania do atrybutów
Odwołanie do atrybutu składa si˛e z elementu podstawowego z wyst˛epuj ˛
ac ˛
a po nim kropk ˛
a i nazw ˛
a:
attributeref
::=
primary "." identifier
Warto´sci ˛
a elementu podstawowego musi by´c obiekt typu obsługuj ˛
acego odwołania do atrybutów, np. moduł, lista
lub egzemplarz klasy. Nast˛epuje wówczas przekazanie do obiektu ˙z ˛
adania podania atrybutu o nazwie takiej, jak
identyfikator po kropce. W przypadku niedost˛epno´sci atrybutu generowany jest wyj ˛
atek
AttributeError
.
Typ i warto´s´c uzyskanego obiektu s ˛
a w cało´sci zale˙zne od obiektu, z którego atrybut pochodzi. Wielokrotne
warto´sciowanie tego samego odwołania do atrybutu mo˙ze ka˙zdorazowo dawa´c inne warto´sci.
5.3.2
Odwołania do indeksów
Odwołanie do indeksu powoduje wybranie elementu sekwencji (napisu, krotki, listy) lub odwzorowania (słown-
ika):
subscription
::=
primary "[" expression_list "]"
Warto´sci ˛
a elementu podstawowego musi by´c obiekt typu sekwencyjnego lub odwzorowawczego.
Je´sli element podstawowy jest odwzorowaniem, warto´sci ˛
a listy wyra˙ze´n musi by´c obiekt, którego warto´s´c jest
jednym z kluczy w odwzorowaniu. Odwołanie do indeksu powoduje w takim przypadku wybranie z odwzorowa-
nia warto´sci, która odpowiada temu kluczowi. (Lista wyra˙ze´n jest krotk ˛
a, chyba, ˙ze zawiera dokładnie jeden
element.)
Je´sli element podstawowy jest sekwencj ˛
a, warto´sci ˛
a listy wyra˙ze´n (w tym przypadku b˛edzie to jedno wyra˙zenie)
musi by´c zwykła liczba całkowita. Je´sli liczba jest ujemna, dodawana jest do niej długo´s´c sekwencji (tak wi˛ec
x[-1]
wybiera ostatni element sekwencji
x
). Po tym opcjonalnym przekształceniu warto´s´c musi by´c nieujemn ˛
a
liczb ˛
a całkowit ˛
a, mniejsz ˛
a od liczby elementów sekwencji. Odwołanie do indeksu powoduje w takim wypadku
wybranie z sekwencji warto´sci o obliczonym indeksie (licz ˛
ac od zera).
Elementami napisów s ˛
a znaki. Znak nie stanowi odr˛ebnego typu danych, lecz jest napisem zawieraj ˛
acym dokład-
nie jeden znak.
5.3.3
Wykrojenia
Wykrojenie wybiera z obiektu sekwencji zakres jej elementów (np. z napisu, krotki lub listy). Wykrojenia mog ˛
a
by´c u˙zywane jako wyra˙zenia lub jako elementy docelowe w instrukcjach przypisania lub usuni˛ecia. Składnia
wykrojenia przedstawia si˛e nast˛epuj ˛
aco:
slicing
::=
simple_slicing | extended_slicing
simple_slicing
::=
primary "[" short_slice "]"
extended_slicing
::=
primary "[" slice_list "]"
slice_list
::=
slice_item ("," slice_item)* [","]
slice_item
::=
expression | proper_slice | ellipsis
proper_slice
::=
short_slice | long_slice
short_slice
::=
[lower_bound] ":" [upper_bound]
long_slice
::=
short_slice ":" [stride]
lower_bound
::=
expression
upper_bound
::=
expression
stride
::=
expression
ellipsis
::=
"..."
W formalnej składni wyst˛epuje tutaj niejednoznaczno´s´c: ka˙zdy zapis b˛ed ˛
acy list ˛
a wyra˙ze´n mo˙zna równie˙z zin-
terpretowa´c jako list˛e wykrojenia, w zwi ˛
azku z czym ka˙zde odwołanie do indeksu mo˙zna zinterpretowa´c jako
wykrojenie. Zamiast dalszego komplikowania składni niejednoznaczno´sci unika si˛e poprzez przyj˛ecie, ˙ze inter-
pretacja jako odwołanie do indeksu ma wy˙zszy priorytet ni˙z interpretacja jako wykrojenie (ma to miejsce, je´sli
lista wykrojenia nie zawiera ˙zadnego elementu wła´sciwego, ani wielokropka). Podobnie, je´sli lista wykrojenia za-
wiera dokładnie jeden krótki element, bez wyst˛epuj ˛
acego po nim przecinka, interpretacja jako proste wykrojenie
bierze gór˛e nad interpretacj ˛
a jako rozszerzone wykrojenie.
40
Rozdział 5. Wyra˙zenia
Semantyka wykrojenia prostego przedstawia si˛e nast˛epuj ˛
aco. Warto´sci ˛
a elementu podstawowego musi by´c sek-
wencj ˛
a. Warto´sci dolnego i górnego ograniczenia (je´sli s ˛
a obecne) musz ˛
a by´c zwykłymi liczbami całkowitymi,
je´sli ich brak, jako warto´sci domy´slne przyjmuje si˛e, odpowiednio, 0 oraz
sys.maxint
. Je´sli które´s z ogranicze´n
jest ujemne, dodawana jest do niego długo´s´c sekwencji. Po ostatecznym ustaleniu ogranicze´n wybierane s ˛
a wszys-
tkie elementy o indeksie k, takim, ˙ze i
<=
k
<
j gdzie i i j to dolne i górne ograniczenie. Wynikiem mo˙ze by´c
pusta sekwencja. Sytuacja, w której i lub j znajduje si˛e poza przedziałem poprawnych indeksów, nie jest bł˛edem
(elementy o takich indeksach nie istniej ˛
a, wi˛ec nie zostan ˛
a wybrane).
Semantyka wykrojenia rozszerzonego przedstawia si˛e nast˛epuj ˛
aco. Warto´sci ˛
a elementu podstawowego musi by´c
obiekt odwzorowawczy. Jest on nast˛epnie indeksowany przy u˙zyciu klucza, który jest konwersj ˛
a listy wykroje-
nia, powstał ˛
a w nast˛epuj ˛
acy sposób. Je´sli lista wykrojenia zawiera przynajmniej jeden przecinek, kluczem jest
krotka, zawieraj ˛
aca konwersj˛e elementów wykrojenia, w przeciwnym wypadku kluczem jest konwersja poje-
dynczego elementu. Konwersj˛e elementu wykrojenia, który jest wyra˙zeniem, stanowi to wyra˙zenie. Konwersj˛e
elementu b˛ed ˛
acego wielokropkiem stanowi wbudowany obiekt
Ellipsis
. Konwersj˛e wykrojenia wła´sciwego
stanowi obiekt wykrojenia (patrz sekcja 3.2), którego atrybuty
start
,
stop
i
step
maj ˛
a warto´sci wyra˙ze´n po-
danych jako dolne ograniczenie, górne ograniczenie oraz krok, z zast ˛
apieniem ewentualnych brakuj ˛
acych wyra˙ze´n
warto´sci ˛
a
None
.
5.3.4
Wywołania
Wywołanie powoduje wywołanie obiektu wywoływalnego (np. funkcji) z przekazaniem (by´c mo˙ze pustej) listy
argumentów:
call
::=
primary "(" [argument_list [","]] ")"
argument_list
::=
positional_arguments ["," keyword_arguments]
["," "*" expression]
["," "**" expression]
| keyword_arguments ["," "*" expression]
["," "**" expression]
| "*" expression ["," "**" expression]
| "**" expression
positional_arguments
::=
expression ("," expression)*
keyword_arguments
::=
keyword_item ("," keyword_item)*
keyword_item
::=
identifier "=" expression
Po li´scie argumentów mo˙ze wyst˛epowa´c dodatkowy przecinek, jednak nie wpływa on na semantyk˛e wywołania.
Warto´sci ˛
a elementu podstawowego musi by´c obiekt obiekt wywoływalny (wywoływalne s ˛
a funkcje zdefiniowane
przez u˙zytkownika, funkcje wbudowane, metody wbudowanych obiektów, obiekty klas, metody egzemplarzy klas
oraz egzemplarze pewnych klas; rozszerzenia mog ˛
a równie˙z definiowa´c dodatkowe typy obiektów wywoływal-
nych). Wszystkie wyra˙zenia u˙zyte jako argumenty s ˛
a warto´sciowane przed przyst ˛
apieniem do samego wywołania.
Aby pozna´c składni˛e list parametrów formalnych, zajrzyj do sekcji 7.5.
Je´sli u˙zyto argumentów nazwanych, s ˛
a one najpierw konwertowane do argumentów pozycyjnych w nast˛epuj ˛
acy
sposób. W pierwszym kroku tworzona jest lista parametrów formalnych z niewypełnionymi pozycjami. Je´sli lista
argumentów pozycyjnych zawiera N elementów, umieszczane s ˛
a one na pierwszych N pozycjach listy. Nast˛ep-
nie, dla ka˙zdego argumentu nazwanego, u˙zywa si˛e jego identyfikatora do okre´slenia pozycji jego przeznaczenia
(je´sli identyfikator jest taki sam, jak nazwa pierwszego parametru formalnego, u˙zywana jest pierwsza pozycja,
itd.). Je´sli okre´slona pozycja została ju˙z wypełniona, generowany jest wyj ˛
atek
TypeError
, w przeciwnym
wypadku warto´s´c argumentu nazwanego jest umieszczana na ustalonej pozycji (nawet, je´sli warto´sci ˛
a wyra˙ze-
nia jest
None
, jego umieszczenie powoduje zapełnienie pozycji). Po przetworzeniu wszystkich argumentów, na
pozycjach, które nie zostały jeszcze wypełnione, umieszczane s ˛
a odpowiadaj ˛
ace im warto´sci domy´slne z definicji
funkcji. (Warto´sci domy´slne s ˛
a obliczane raz, na etapie definiowania funkcji, w zwi ˛
azku z czym u˙zycie w tym
kontek´scie obiektów zmiennych, takich, jak listy, czy słowniki, powoduje ich współdzielenie przez wszystkie
wywołania, w których nie okre´slono warto´sci argumentu dla odpowiedniej pozycji. Sytuacji tej nale˙zy unika´c.)
W przypadku, gdy pozostały jakie´s niewypełnione pozycje, dla których nie okre´slono warto´sci domy´slnych, gen-
erowany jest wyj ˛
atek
TypeError
. Je´sli wszystko przebiegło pomy´slnie, lista z wypełnionymi pozycjami jest
u˙zywana jako lista argumentów w wywołaniu.
Je´sli liczba argumentów pozycyjnych jest wi˛eksza, ni˙z liczba parametrów formalnych, generowany jest
5.3. Elementy podstawowe
41
wyj ˛
atek
TypeError
. Nie dotyczy to sytuacji, w której obecny jest parametr formalny zapisany w postaci
„
*identyfikator
”. Wówczas warto´sci ˛
a przypisan ˛
a temu parametrowi formalnemu jest krotka, zawieraj ˛
aca
wszystkie argumenty pozycyjne, które nie mieszcz ˛
a si˛e na pozycjach wcze´sniejszych argumentów formalnych
(krotka mo˙ze by´c pusta, je´sli nie pozostan ˛
a ˙zadne argumenty pozycyjne).
Je´sli któremu´s z argumentów nazwanych nie odpowiada nazwa ˙zadnego z argumentów formalnych, generowany
jest wyj ˛
atek
TypeError
. Nie dotyczy to sytuacji, w której obecny jest parametr formalny zapisany w postaci
„
**identyfikator
”. Wówczas warto´sci ˛
a przypisan ˛
a temu parametrowi formalnemu jest słownik zawieraj ˛
acy
wszystkie argumenty nazwane, które nie maj ˛
a odpowiedników w´sród argumentów formalnych, przy czym jako
klucze u˙zywane s ˛
a identyfikatory argumentów, a warto´sciami elementów słownika s ˛
a warto´sci argumentów. Je´sli
˙zaden z argumentów nazwanych nie pozostaje bez odpowiednika, utworzony słownik jest (nowym) słownikiem
pustym.
Je´sli w wywołaniu funkcji pojawi si˛e zapis „
*wyra˙
zenie
”, warto´sci ˛
a zawartego w nim wyra˙zenia musi by´c sek-
wencja. Elementy tej sekwencji s ˛
a traktowane tak, jakby były dodatkowymi argumentami pozycyjnymi. Je´sli wi˛ec
podano w wywołaniu argumenty pozycyjne x1,...,xN, za´s warto´sci ˛
a wyra˙zenia zapisanego po gwiazdce jest sek-
wencja y1,...,yM, wówczas wywołanie jest równowa˙zne wywołaniu z M+N argumentami pozycyjnymi o warto´s-
ciach x1,...,xN,y1,...,yM.
Konsekwencj ˛
a tego jest fakt, ˙ze cho´c zapis „
*wyra˙
zenie
” pojawia si˛e po wszystkich argumentach nazwanych,
to jednak przetwarzany jest przed nimi (oraz przed opisanym ni˙zej argumentem postaci „
**wyra˙
zenie
”). Tak
wi˛ec:
>>> def f(a, b):
...
print a, b
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: f() got multiple values for keyword argument ’a’
>>> f(1, *(2,))
1 2
U˙zycie w jednym wywołaniu argumentów nazwanych i argumentu postaci „
*wyra˙
zenie
” jest sytuacj ˛
a do´s´c
niezwykł ˛
a, wi˛ec w praktyce zademonstrowane wy˙zej zamieszanie nie wyst˛epuje.
Je´sli w wywołaniu funkcji pojawi si˛e zapis „
**wyra˙
zenie
”, warto´sci ˛
a zawartego w nim wyra˙zenia musi by´c
słownik (lub jego podklasa). Zawarto´s´c tego słownika jest wykorzystywana jako dodatkowe argumenty nazwane.
W przypadku, gdy pewna nazwa argumentu wyst˛epuje w słowniku oraz w´sród podanych jawnie argumentów
nazwanych, generowany jest wyj ˛
atek
TypeError
.
Parametry formalne zapisane w postaci „
*identyfikator
” lub „
**identyfikator
” nie mog ˛
a by´c u˙zy-
wane jako pozycje ustawiane przez argumenty pozycyjne, ani przez argumenty nazwane. Parametry formalne za-
pisane w postaci „
(podlista)
” nie mog ˛
a by´c ustawiane przy u˙zyciu argumentów nazwanych. W ich przypadku
najbardziej zewn˛etrznej podli´scie odpowiada jedna pozycja, pozbawiona jednak nazwy, za´s warto´s´c odpowiada-
j ˛
acego jej argumentu (w tym przypadku tylko pozycyjnego) jest przypisywana zgodnie ze zwykłymi regułami
przypisa´n krotek po wykonaniu wszystkich innych czynno´sci zwi ˛
azanych z przetwarzaniem parametrów.
Wywołanie zawsze zwraca jak ˛
a´s warto´s´c (by´c mo˙ze
None
), chyba, ˙ze spowoduje wygenerowanie wyj ˛
atku. To, w
jaki sposób warto´s´c jest obliczana, zale˙zy od typu wywoływanego obiektu.
Je´sli obiekt jest —
funkcj ˛
a zdefiniowan ˛
a przez u˙zytkownika: Wykonywany jest blok kodu funkcji, z u˙zyciem przekazanej listy
argumentów. Pierwsz ˛
a operacj ˛
a wykonywan ˛
a przez blok kodu jest dowi ˛
azanie parametrów formalnych do
argumentów, co opisano w sekcji 7.5. Wykonanie przez blok kodu instrukcji
return
okre´sla warto´s´c
zwracan ˛
a przez wywołanie funkcji.
wbudowan ˛
a funkcj ˛
a lub metod ˛
a: Wynik wywołania jest zale˙zny od interpretera. Opisy wbudowanych funkcji i
metod znajduj ˛
a si˛e w pozycji
Podr˛ecznik programisty Pythona - opis biblioteki standardowej
.
42
Rozdział 5. Wyra˙zenia
obiektem klasy: Zwracany jest nowy egzemplarz tej klasy.
metod ˛
a egzemplarza klasy: Wywoływana jest odpowiednia funkcja zdefiniowana przez u˙zytkownika, z list ˛
a ar-
gumentów rozszerzon ˛
a o jeden element w stosunku do listy, z jak ˛
a wywołano metod˛e egzemplarza – jako
pierwszy argument dodawany jest egzemplarz, którego dotyczy wywołanie.
egzemplarzem klasy: Klasa musi definiowa´c metod˛e
__call__()
. Efekt wywołania egzemplarza jest dokład-
nie taki, jaki dałoby wywołanie tej metody.
5.4
Operator pot ˛egowania
Operator pot˛egowania wi ˛
a˙ze silniej, ni˙z operatory jednoargumentowe po jego lewej stronie, jednak słabiej, ni˙z
operatory jednoargumentowe po prawej stronie. Jego składnia przedstawia si˛e nast˛epuj ˛
aco:
power
::=
primary ["**" u_expr]
Tak wi˛ec w przypadku ci ˛
agu operatorów pot˛egowania i operatorów jednoargumentowych, który nie zawiera naw-
iasów, warto´sciowanie operatorów nast˛epuje od lewej do prawej (nie narzuca to kolejno´sci warto´sciowania argu-
mentów).
Semantyka operatora pot˛egowania jest taka sama, jak wbudowanej funkcji
pow()
, wywołanej z dwoma argu-
mentami. Wynikiem jest pierwszy argument podniesiony do pot˛egi okre´slonej przez drugi argument. Argumenty
liczbowe s ˛
a najpierw konwertowane do wspólnego typu. Wynik jest tego typu, co argumenty po uzgodnieniu.
Przy argumentach ró˙znych typów stosuje si˛e reguły uzgadniania obowi ˛
azuj ˛
ace dla dwuargumentowych opera-
torów arytmetycznych. Przy argumentach typu int i long wynik jest tego samego typu co argumenty (po uzgod-
nieniu), chyba, ˙ze drugi argument jest ujemny — w takim wypadku wszystkie argumenty s ˛
a konwertowane do
typu float i otrzymywana warto´s´c jest warto´sci ˛
a tego typu. Na przykład,
10**2
daje w wyniku
100
, jednak
10**-2
daje
0.01
. (Własno´s´c ta pojawiła si˛e w Pythonie 2.2, w wersjach wcze´sniejszych, je´sli oba argumenty
były liczbami całkowitymi i drugi argument był ujemny, generowany był wyj ˛
atek).
Podniesienie
0.0
do pot˛egi ujemnej spowoduje wygenerowanie wyj ˛
atku
ZeroDivisionError
. Podniesienie
liczby ujemnej do pot˛egi ułamkowej wygeneruje wyj ˛
atek
ValueError
.
5.5
Jednoargumentowe operacje arytmetyczne
Wszystkie jednoargumentowe operacje arytmetyczne (i bitowe) maj ˛
a ten sam priorytet:
u_expr
::=
power | "-" u_expr | "+" u_expr | "~" u_expr
Jednoargumentowy
-
(minus) daje w wyniku warto´s´c przeciwn ˛
a do przekazanego argumentu liczbowego.
Jednoargumentowy
+
(plus) daje w wyniku niezmienion ˛
a warto´s´c przekazanego argumentu liczbowego.
Jednoargumentowy operator
~
(inwersja) daje w wyniku inwersj˛e bitow ˛
a przekazanego argumentu całkow-
itoliczbowego lub długiego całkowitoliczbowego. Inwersj˛e bitow ˛
a warto´sci
x
definiuje si˛e jako
-(x+1)
. Stosuje
si˛e to tylko do liczb całkowitych.
We wszystkich trzech przypadkach, je´sli argument jest niewła´sciwego typu, generowany jest wyj ˛
atek
TypeError
.
5.6
Dwuargumentowe operacje arytmetyczne
Dwuargumentowe operacje arytmetyczne maj ˛
a typowe poziomy priorytetów. Niektóre z operatorów mog ˛
a by´c
równie˙z stosowane z pewnymi typami nieliczbowymi. Pomin ˛
awszy operator pot˛egowania, s ˛
a tylko dwa poziomy,
jeden z operatorami multiplikatywnymi, a drugi z addytywnymi:
m_expr
::=
u_expr | m_expr "*" u_expr | m_expr "//" u_expr | m_expr "/" u_expr
| m_expr "%" u_expr
a_expr
::=
m_expr | a_expr "+" m_expr | a_expr "-" m_expr
5.4. Operator pot ˛egowania
43
Dwuargumentowy operator
*
(mno˙zenie) daje w wyniku iloczyn przekazanych argumentów. Oba argumenty
musz ˛
a by´c liczbami albo jeden z nich musi by´c liczb ˛
a całkowit ˛
a (zwykł ˛
a lub dług ˛
a), a drugi sekwencj ˛
a. W
pierwszym przypadku liczby s ˛
a konwertowane do wspólnego typu, a nast˛epnie mno˙zone. W drugim przypadku
wykonywane jest powielenie sekwencji, przy czym ujemny współczynnik powielenia daje w wyniku pust ˛
a sek-
wencj˛e.
Dwuargumentowe operatory:
/
(dzielenie) oraz
//
(dzielenie obcinaj ˛
ace) daj ˛
a w wyniku iloraz przekazanych
argumentów. Argumenty liczbowe s ˛
a najpierw konwertowane do wspólnego typu. Dzielenie liczb całkow-
itych (zwykłych lub długich) daje w wyniku liczb˛e tego samego typu, a wynikiem jest iloraz matematy-
czny z wykonan ˛
a dodatkowo na nim funkcj ˛
a „floor”. Dzielenie przez zero powoduje wygenerowanie wyj ˛
atku
ZeroDivisionError
.
Dwuargumentowy operator
%
(modulo) daje w wyniku reszt˛e z dzielenia pierwszego argumentu przez drugi. Argu-
menty liczbowe s ˛
a najpierw konwertowane do wspólnego typu. Je´sli drugi argument ma warto´s´c zero, generowany
jest wyj ˛
atek
ZeroDivisionError
. Argumenty mog ˛
a by´c liczbami zmiennoprzecinkowymi, np.
3.14%0.7
daje w wyniku
0.34
(poniewa˙z
3.14
jest równe
4*0.7 + 0.34
). Operator dzielenia modulo zawsze zwraca
wynik z tym samym znakiem, co jego drugi argument (ew. warto´s´c zero), warto´s´c bezwzgl˛edna wyniku jest ostro
mniejsza od warto´sci bezwzgl˛ednej drugiego argumentu
1
.
Operatory dzielenia całkowitego i dzielenia modulo na liczbach całkowitych powi ˛
azane s ˛
a nast˛epuj ˛
ac ˛
a zale˙zno´s-
ci ˛
a:
x == (x/y)*y + (x%y)
.
Obie operacje s ˛
a równie˙z zwi ˛
azane z wbudowan ˛
a funkcj ˛
a
divmod()
:
divmod(x, y) == (x/y, x%y)
. Zale˙zno´sci te nie s ˛
a prawdziwe dla liczb zmiennoprzecinkowych – w
tym przypadku istniej ˛
a podobne przybli˙zone zale˙zno´sci, gdzie
x/y
jest zast ˛
apione przez
floor(x/y)
lub
floor(x/y) - 1
2
.
Przestarzałe od wersji 2.3. Operator dzielenia obcinaj ˛
acego, operator modulo oraz funkcja
divmod()
nie s ˛
a ju˙z
zdefiniowane dla liczb zespolonych. Zamiast ich bezpo´sredniego u˙zycia nale˙zy w razie potrzeby przekonwertowa´c
odpowiedni ˛
a warto´s´c na liczb˛e zmiennoprzecinkow ˛
a, wykorzystuj ˛
ac do tego funkcj˛e
abs()
.
Dwuargumentowy operator
+
(dodawanie) daje w wyniku sum˛e przekazanych argumentów. Oba argumenty
musz ˛
a by´c liczbami albo sekwencjami tego samego typu. W pierwszym przypadku liczby s ˛
a konwertowane
do wspólnego typu, a nast˛epnie dodawane. W drugi przypadku nast˛epuje sklejenie sekwencji.
Dwuargumentowy operator
-
(odejmowanie) daje w wyniku ró˙znic˛e przekazanych argumentów. Argumenty
liczbowe s ˛
a najpierw konwertowane do wspólnego typu.
5.7
Operacje przesuni ˛e´c
Operacje przesuni˛e´c maj ˛
a priorytet ni˙zszy od operacji arytmetycznych:
shift_expr
::=
a_expr | shift_expr ( "«" | "»" ) a_expr
Oba operatory akceptuj ˛
a jako argumenty liczby całkowite (zwykłe lub długie). Argumenty s ˛
a konwertowane do
wspólnego typu. Wynikiem jest pierwszy argument przesuni˛ety bitowo w lewo lub prawo o liczb˛e bitów okre´slon ˛
a
przez drugi argument.
Przesuni˛ecie w prawo o n bitów definiuje si˛e jako dzielenie przez
pow(2,
n
)
.
Przesuni˛ecie w lewo o n
bitów definiuje si˛e jako mno˙zenie przez
pow(2,
n
)
. Przy zwykłych liczbach całkowitych nie jest sprawdzane
przepełnienie, wi˛ec operacja wi ˛
a˙ze si˛e z utrat ˛
a bitów i powoduje zmian˛e znaku, je´sli warto´s´c bezwzgl˛edna
wyniku nie jest mniejsza od
pow(2,31)
. Ujemne warto´sci przesuni˛e´c powoduj ˛
a wygenerowanie wyj ˛
atku
ValueError
.
1
Cho´c nierówno´s´c
abs(x%y) < abs(y)
jest matematycznie prawdziwa, to dla liczb zmiennoprzecinkowych, przy których wyst˛epuj ˛
a
zaokr ˛
aglenia, ju˙z tak by´c nie musi. Je´sli na przykład zało˙zymy, ˙ze Python działa na platformie u˙zywaj ˛
acej liczb zmiennoprzecinkowych
odpowiadaj ˛
acych liczbom o podwójnej precyzji z IEEE 754, to aby
-1e-100 %1e100
miało ten sam znak, co
1e100
, obliczon ˛
a warto´sci ˛
a
musi by´c
-1e-100 + 1e100
, co jest numerycznie dokładnie równe
1e100
. Funkcja
fmod()
z modułu
math
zwraca jednak wynik,
którego znak odpowiada znakowi pierwszego argumentu, wi˛ec w tym przypadku otrzymamy
-1e-100
. To, które podej´scie jest bardziej
odpowiednie, zale˙zy od konkretnej aplikacji.
2
Je´sli x jest bardzo bliskie dokładnej całkowitej wielokrotno´sci y, to
floor(x/y)
mo˙ze by´c wi˛eksze ni˙z
(x-x%y)/y
z powodu zaokr ˛
a-
gle´n. W takich przypadkach Python zwraca ostatni wynik, aby zachowa´c znaczn ˛
a blisko´s´c pomi˛edzy
divmod(x,y)[0] * y + x % y
i
x
.
44
Rozdział 5. Wyra˙zenia
5.8
Dwuargumentowe operacje bitowe
Ka˙zda z trzech operacji bitowych ma inny poziom priorytetu:
and_expr
::=
shift_expr | and_expr "&" shift_expr
xor_expr
::=
and_expr | xor_expr "^" and_expr
or_expr
::=
xor_expr | or_expr "|" xor_expr
Operator
&
daje w wyniku bitowe AND (koniunkcj˛e) przekazanych argumentów, które musz ˛
a by´c liczbami
całkowitymi (zwykłymi lub długimi). Argumenty konwertowane s ˛
a do wspólnego typu.
Operator
^
daje w wyniku bitowe XOR (alternatyw˛e wykluczaj ˛
ac ˛
a) przekazanych argumentów, które musz ˛
a by´c
liczbami całkowitymi (zwykłymi lub długimi). Argumenty konwertowane s ˛
a do wspólnego typu.
Operator
|
daje w wyniku bitowe OR (alternatyw˛e) przekazanych argumentów, które musz ˛
a by´c liczbami całkow-
itymi (zwykłymi lub długimi). Argumenty konwertowane s ˛
a do wspólnego typu.
5.9
Porównania
W przeciwie´nstwie do j˛ezyka C, w Pythonie wszystkie operacje porówna´n maj ˛
a taki sam priorytet, który jest
ni˙zszy od priorytetu wszystkich operacji arytmetycznych, przesuni˛e´c i bitowych. Równie˙z w przeciwie´nstwie do
C wyra˙zenia postaci
a < b < c
maj ˛
a tradycyjne matematyczne znaczenie:
comparison
::=
or_expr ( comp_operator or_expr )*
comp_operator
::=
"<" | ">" | "==" | ">=" | "<=" | "<>" | "!="
| "is" ["not"] | ["not"] "in"
Wynikami porówna´n s ˛
a warto´sci logiczne:
True
oznaczaj ˛
aca prawd˛e lub
False
oznaczaj ˛
aca fałsz.
Porównania mog ˛
a by´c dowolnie ł ˛
aczone, np.
x < y <= z
jest równowa˙zne zapisowi
x < y and y <= z
,
z wyj ˛
atkiem tego, ˙ze
y
jest warto´sciowane tylko raz (jednak w obu przypadkach
z
nie jest warto´sciowane w ogóle,
je´sli warunek
x < y
oka˙ze si˛e by´c fałszywy).
Formalnie, je´sli a, b, c, . . . , y, z s ˛
a wyra˙zeniami, a opa, opb, . . . , opy s ˛
a operacjami porówna´n, wówczas a opa b
opb c . . . y opy z jest równowa˙zne zapisowi a opa b
and
b opb c
and
. . . y opy z, z wyj ˛
atkiem tego, ˙ze ka˙zde z
wyra˙ze´n jest warto´sciowane co najwy˙zej raz.
Zwró´cmy uwag˛e, ˙ze z wyra˙zenia postaci a opa b opb c nie wynika ˙zadnego typu porównanie pomi˛edzy a i c, w
zwi ˛
azku z czym np.
x < y > z
jest zapisem w pełni poprawnym (cho´c pewnie niezbyt eleganckim).
Zapisy
<>
oraz
!=
s ˛
a równowa˙zne. Dla spójno´sci z j˛ezykiem C preferowany jest zapis
!=
. W ka˙zdym z miejsc
poni˙zej, w których mowa o
!=
, dopuszczalne jest u˙zycie
<>
. Form˛e
<>
uwa˙za si˛e za przestarzał ˛
a.
Operatory
<
,
>
,
==
,
>=
,
<=
oraz
!=
porównuj ˛
a warto´sci dwóch obiektów. Obiekty nie musz ˛
a by´c tego samego
typu. Je´sli oba s ˛
a liczbami, nast˛epuje ich konwersja do wspólnego typu. W przeciwnym wypadku, obiekty
ró˙znych typów s ˛
a zawsze uznawane za nierówne, za´s ich porz ˛
adek ustalany jest arbitralnie, cho´c w sposób spójny.
(Ta do´s´c niezwykła definicja porówna´n została u˙zyta, aby upro´sci´c definicje pewnych operacji, np. sortowania
oraz operatorów
in
czy
not in
. W przyszło´sci reguły porównywania obiektów ró˙znych typów mog ˛
a ulec
zmianie.)
Porównanie obiektów tego samego typu zale˙zy od typu:
• Liczby s ˛
a porównywane arytmetycznie.
• Napisy s ˛
a porównywane leksykograficznie, przy u˙zyciu liczbowych odpowiedników (wyników działania
wbudowanej funkcji
ord()
) tworz ˛
acych je znaków. Napisy Unicode i 8-bitowe mog ˛
a by´c w tym przypadku
swobodnie mieszane.
• Krotki i listy s ˛
a porównywane leksykograficznie poprzez porównanie odpowiadaj ˛
acych sobie elementów.
Oznacza to, ˙ze aby dwie sekwencje były uznane za równe, ka˙zdy z elementów jednej musi by´c równy
odpowiadaj ˛
acemu mu elementowi w drugiej, ponadto za´s sekwencje musz ˛
a by´c tego samego typu i tej
samej długo´sci.
5.8. Dwuargumentowe operacje bitowe
45
Je´sli sekwencje nie s ˛
a sobie równe, ich porz ˛
adek jest ustalany na podstawie porz ˛
adku pierwszego ró˙zni ˛
acego
si˛e elementu. Na przykład wyra˙zenie
cmp([1,2,x], [1,2,y])
daje tak ˛
a sam ˛
a warto´s´c jak wyra˙zenie
cmp(x,y)
. Je´sli w której´s z sekwencji nie wyst˛epuje element odpowiadaj ˛
acy elementowi z drugiej, za
mniejsz ˛
a uznawana jest krótsza sekwencja (np.
[1,2] < [1,2,3]
).
• Odwzorowania (słowniki) s ˛
a uznawane za równe, tylko, je´sli odpowiadaj ˛
ace im listy par (klucz, warto´s´c)
równie˙z s ˛
a równe.
3
Wyniki inne ni˙z równo´s´c s ˛
a obliczane w sposób konsekwentny, jednak niezdefiniowany
w ˙zaden sposób.
4
• W przypadku wi˛ekszo´sci pozostałych typów wynikiem porównania jest nierówno´s´c, chyba, ˙ze po obu
stronach porównania wyst˛epuje ten sam obiekt. To, który z obiektów uwa˙zany jest za mniejszy, a który
za wi˛ekszy, jest ustalane arbitralnie, lecz konsekwentnie na cały okres wykonywania programu.
Operatory
in
oraz
not in
dokonuj ˛
a sprawdzenia przynale˙zno´sci. Wyra˙zenie x
in
s jest prawdziwe, je´sli x
jest elementem zbioru s, a fałszywe w przeciwnym wypadku. Wyra˙zenie x
not in
s daje w wyniku negacj˛e
logiczn ˛
a warto´sci wyra˙zenia x
in
s. Tradycyjnie sprawdzanie przynale˙zno´sci było zwi ˛
azane z sekwencjami —
obiekt jest elementem zbioru, je´sli zbiór jest sekwencj ˛
a i jeden z elementów sekwencji jest równy temu obiektowi.
Sprawdzanie przynale˙zno´sci mog ˛
a jednak obsługiwa´c równie˙z obiekty nie b˛ed ˛
ace sekwencjami. W szczególno´sci,
typ słownikowy wykorzystuje t˛e operacj˛e jako bardziej eleganck ˛
a form˛e sprawdzenia obecno´sci warto´sci w´sród
kluczy słownika (klucz
in
słownik). Inne typy odwzorowawcze mog ˛
a funkcjonowa´c w podobny sposób.
W przypadku list i krotek, wyra˙zenie x
in
y jest prawdziwe wtedy i tylko wtedy, gdy x jest fragmentem y, co
odpowiada prawdziwo´sci wyra˙zenia
y.find(x) != -1
. Nale˙zy przy tym podkre´sli´c, ˙ze x i y nie musz ˛
a by´c
tego samego typu, wi˛ec
u’ab’ in ’abc’
da warto´s´c
True
. Przyjmuje si˛e, ˙ze napisy puste s ˛
a zawsze cz˛e´sci ˛
a
dowolnego innego napisu, wi˛ec wyra˙zenie
"" in "abc"
da w wyniku warto´s´c
True
.
Zmieniono w wersji
2.3: W poprzednich wersjach Pythona x musiał by´c napisem o długo´sci
1
.
W przypadku typów napisowych oraz Unicode, wyra˙zenie x
in
y jest prawdziwe wtedy i tylko wtedy, gdy
istnieje taki indeks i, dla którego prawdziwe jest wyra˙zenie x
==
y
[
i
]
. Je´sli x nie jest napisem lub obiektem
Unicode o długo´sci
1
, generowany jest wyj ˛
atek
TypeError
.
W przypadku klas zdefiniowanych przez u˙zytkownika, które zawieraj ˛
a metod˛e
__contains__()
, wyra˙zenie x
in
y jest prawdziwe wtedy i tylko wtedy, gdy prawdziwe jest wyra˙zenie y
.__contains__(
x
)
.
W przypadku klas zdefiniowanych przez u˙zytkownika, które nie zawieraj ˛
a metody
__contains__()
, lecz
definiuj ˛
a metod˛e
__getitem__()
, wyra˙zenie x
in
y jest prawdziwe wtedy i tylko wtedy, gdy istnieje nieu-
jemna liczba całkowita i b˛ed ˛
aca indeksem, dla której x
==
y
[
i
]
jest prawdziwe, natomiast przy wszystkich
ni˙zszych indeksach nie jest generowany wyj ˛
atek
IndexError
. (Je´sli przy wywołaniu metody zostanie wygen-
erowany inny wyj ˛
atek, wynik b˛edzie taki, jakby został on wygenerowany przez u˙zycie operatora
in
).
Operator
not in
definiuje si˛e jako zwracaj ˛
acy warto´s´c logiczn ˛
a b˛ed ˛
ac ˛
a negacj ˛
a tej, któr ˛
a zwraca
in
.
Operatory
is
oraz
is not
sprawdzaj ˛
a to˙zsamo´s´c obiektu: x
is
y jest prawdziwe wtedy i tylko wtedy, gdy x i
y s ˛
a tymi samymi obiektami. Warto´sci ˛
a x
is not
y jest negacja logiczna odmiany z operatorem
is
.
5.10
Operacje logiczne
Operacje logiczne maj ˛
a najni˙zszy priorytet spo´sród wszystkich operacji w Pythonie:
expression
::=
or_test | lambda_form
or_test
::=
and_test | or_test "or" and_test
and_test
::=
not_test | and_test "and" not_test
not_test
::=
comparison | "not" not_test
lambda_form
::=
"lambda" [parameter_list]:
expression
W kontek´scie operacji logicznych oraz gdy wyra˙zenia s ˛
a u˙zywane w instrukcjach kontroli przepływu sterowania,
nast˛epuj ˛
ace warto´sci traktowane s ˛
a jak logiczny fałsz:
None
, zero któregokolwiek z typów liczbowych, puste
3
Na poziomie implementacji jest to obliczane w sposób efektywny, bez rzeczywistego tworzenia list i ich sortowania.
4
We wcze´sniejszych wersjach Pythona wykonywane było leksykograficzne porównanie posortowanych list par (klucz, warto´s´c), jednak
operacja ta była zbyt czasochłonna dla do´s´c cz˛estego przypadku sprawdzania równo´sci. W jeszcze wcze´sniejszych wersjach słowniki były
porównywane wył ˛
acznie w oparciu o ich to˙zsamo´sci, co prowadziło cz˛esto do nieoczekiwanych wyników, gdy˙z wiele osób sprawdzało np.
czy słownik jest pusty, poprzez porównanie go z
{}
.
46
Rozdział 5. Wyra˙zenia
sekwencje (napisy, krotki, listy) oraz puste odwzorowania (słowniki). Wszystkie pozostałe warto´sci traktowane
s ˛
a jak logiczna prawda.
Operator
not
zwraca
1
, je´sli jego argumentem jest fałsz, za´s
0
w przeciwnym wypadku.
Wyra˙zenie x
and
y przeprowadza najpierw warto´sciowanie x. Je´sli x jest fałszywe, zwracana jest jego warto´s´c.
W przeciwnym wypadku warto´sciowane jest y i zwracana jest uzyskana warto´s´c.
Wyra˙zenie x
and
y przeprowadza najpierw warto´sciowanie x. Je´sli x jest prawdziwe, zwracana jest jego warto´s´c.
W przeciwnym wypadku warto´sciowane jest y i zwracana jest uzyskana warto´s´c.
(Zwró´cmy uwag˛e, ˙ze operatory
and
i
or
nie ograniczaj ˛
a typu, ani samych zwracanych warto´sci do
0
i
1
, zwraca-
j ˛
ac po prostu ostatni warto´sciowany argument. Jest to czasem przydatne, np. je´sli
s
jest napisem, który powinna
zast ˛
api´c warto´s´c domy´slna w przypadku, gdy napis jest pusty, to po˙z ˛
adan ˛
a warto´s´c uzyskamy przy pomocy
wyra˙zenia
s or ’domy´
slne’
. Poniewa˙z operator
not
zawsze musi utworzy´c now ˛
a warto´s´c, nie próbuje
dopasowywa´c jej typu do typu argumentu. W zwi ˛
azku z tym np.
not ’co´
stam’
daje w wyniku
0
, a nie
”
.)
5.11
Formy lambda
Formy lambda (wyra˙zenia lambda) zajmuj ˛
a składniowo t˛e sam ˛
a pozycj˛e, co wyra˙zenia. S ˛
a to skrótowe zapisy,
tworz ˛
ace funkcje nienazwane. Wyra˙zenie
lambda
argumenty
:
wyra˙zenie daje w wyniku obiekt funkcji, który
zachowuje si˛e w praktyce tak samo, jak ten, który zostanie zdefiniowany przez instrukcj˛e:
def nazwa(argumenty):
return wyra˙
zenie
Aby pozna´c składni˛e list parametrów, zajrzyj do sekcji 7.5. Zwracamy uwag˛e, ˙ze funkcje utworzone przy u˙zyciu
form lambda nie mog ˛
a zawiera´c instrukcji.
5.12
Listy wyra˙ze ´n
expression_list
::=
expression ( "," expression )* [","]
Lista wyra˙ze´n zawieraj ˛
aca co najmniej jeden przecinek daje w wyniku krotk˛e. Długo´s´c krotki jest równa liczbie
wyra˙ze´n na li´scie. Wyra˙zenia warto´sciowane s ˛
a od lewej do prawej.
Ko´ncowy przecinek jest wymagany tylko w przypadku, gdy tworzona krotka jest jednoelementowa (tzw. single-
ton), w pozostałych wypadkach jest on opcjonalny. Pojedyncze wyra˙zenie bez wyst˛epuj ˛
acego po nim przecinka
nie daje w wyniku krotki lecz sam ˛
a warto´s´c tego wyra˙zenia. (Aby utworzy´c pust ˛
a krotk˛e, nale˙zy zapisa´c pust ˛
a
par˛e nawiasów:
()
.)
5.13
Kolejno´s´c warto´sciowania
Python warto´sciuje wyra˙zenia od lewej strony do prawej. Zwracamy jednak uwag˛e, ˙ze przy wykonywaniu przyp-
isania prawa strona warto´sciowana jest przed lew ˛
a.
W poni˙zszych wierszach wyra˙zenia b˛ed ˛
a warto´sciowane w kolejno´sci wyznaczonej przez arytmetyczny porz ˛
adek
ich przyrostków:
wyr1, wyr2, wyr3, wyr4
(wyr1, wyr2, wyr3, wyr4)
{wyr1: wyr2, wyr3: wyr4}
wyr1 + wyr2 * (wyr3 - wyr4)
func(wyr1, wyr2, *wyr3, **wyr4)
wyr3, wyr4 = wyr1, wyr2
5.11. Formy lambda
47
5.14
Zestawienie
Poni˙zsza tabela przedstawia priorytety operatorów w Pythonie, poczynaj ˛
ac od najni˙zszego (najsłabiej wi ˛
a˙z ˛
acego)
do najwy˙zszego (najsilniej wi ˛
a˙z ˛
acego). Operatory umieszczone w tej samej komórce tabeli maj ˛
a ten sam priorytet.
Poza przypadkami, w których jawnie okre´slono składni˛e, operatory s ˛
a dwuargumentowe. Operatory w tej samej
komórce grupowane s ˛
a od lewej do prawej (za wyj ˛
atkiem porówna´n, które wi ˛
azane s ˛
a od lewej do prawej — patrz
wy˙zej oraz pot˛egowania, które grupowane jest od prawej do lewej).
Operator
Opis
lambda
Wyra˙zenie lambda
or
Logiczne OR (lub)
and
Logiczne AND (i)
not
x
Logiczne NOT (nie)
in
,
not in
Testy przynale˙zno´sci
is
,
is not
Testy to˙zsamo´sci
<
,
<=
,
>
,
>=
,
<>
,
!=
,
==
Porównania
|
Bitowe OR (lub)
^
Bitowe XOR (ró˙znica symetryczna)
&
Bitowe AND (i)
<<
,
>>
Przesuni˛ecia
+
,
-
Dodawanie i odejmowanie
*
,
/
,
%
Mno˙zenie, dzielenie, reszta z dzielenia
+
x,
-
x
Identyczno´s´c, negacja
~
x
Bitowe NOT (nie)
**
Pot˛egowanie
x
.
atrybut
Odwołanie do atrybutu
x
[
indeks
]
Odwołanie do indeksu
x
[
indeks
:
indeks
]
Wykrojenie
f
(
argumenty
...)
Wywołanie funkcji
(
wyra˙zenia
...)
Powi ˛
azanie lub drukowalna forma krotki
[
wyra˙zenia
...]
Drukowalna forma listy
{
klucz
:
dana
...}
Drukowalna forma słownika
‘
wyra˙zenia
...‘
Konwersja napisowa
48
Rozdział 5. Wyra˙zenia
ROZDZIAŁ
SZÓSTY
Instrukcje proste
Ka˙zda instrukcja prosta mie´sci si˛e w jednym wierszu logicznym. Aby umie´sci´c w jednym wierszu wiele instrukcji
prostych, nale˙zy je rozdzieli´c ´srednikami. Składnia instrukcji prostych przedstawia si˛e nast˛epuj ˛
aco:
simple_stmt
::=
expression_stmt
| assert_stmt
| assignment_stmt
| augmented_assignment_stmt
| pass_stmt
| del_stmt
| print_stmt
| return_stmt
| yield_stmt
| raise_stmt
| break_stmt
| continue_stmt
| import_stmt
| global_stmt
| exec_stmt
6.1
Instrukcje wyra˙zeniowe
Instrukcje wyra˙zeniowe u˙zywane s ˛
a do obliczenia i wypisania warto´sci (zwykle interaktywnie) lub, co jest na-
jcz˛estszym zastosowaniem, do wywołania procedury, tj. funkcji, która nie zwraca znacz ˛
acego rezultatu. W
Pythonie procedury zwracaj ˛
a warto´s´c
None
. Mo˙zliwe s ˛
a równie˙z inne, czasem przydatne, zastosowania instrukcji
wyra˙zeniowych. Składnia instrukcji wyra˙zeniowych wygl ˛
ada nast˛epuj ˛
aco:
expression_stmt
::=
expression_list
Instrukcja wyra˙zeniowa warto´sciuje list˛e wyra˙ze´n, któr ˛
a w szczególnym przypadku mo˙ze tworzy´c pojedyncze
wyra˙zenie.
Przy pracy w trybie interaktywnym, je´sli obliczon ˛
a warto´sci ˛
a wyra˙zenia nie jest
None
, nast˛epuje jej konwersja do
napisu przy u˙zyciu wbudowanej funkcji
repr()
. Napis jest nast˛epnie wypisywany na standardowe wyj´scie (patrz
sekcja 6.6) w taki sposób, ˙ze ka˙zda z warto´sci pojedynczego wyra˙zenia wyst˛epuje w osobnym wierszu. (Wyra˙ze-
nia, których warto´sci ˛
a jest
None
nie s ˛
a wypisywane, wi˛ec wywołanie procedury pozostaje bez odpowiedzi.)
6.2
Instrukcje assert
Instrukcje assert s ˛
a wygodnym sposobem na wstawienie do programu asercji wspomagaj ˛
acych testowanie:
assert_stmt
::=
"assert" expression ["," expression]
Prosta posta´c instrukcji, „
assert wyra˙
zenie
”, jest odpowiednikiem zapisu:
49
if __debug__:
if not wyra˙
zenie: raise AssertionError
Posta´c rozszerzona, „
assert wyra˙
zenie1, wyra˙
zenie2
”, jest odpowiednikiem zapisu:
if __debug__:
if not wyra˙
zenie1: raise AssertionError, wyra˙
zenie2
Powy˙zsze odpowiedniki maj ˛
a zastosowanie, je´sli
__debug__
oraz
AssertionError
odnosz ˛
a si˛e do wbu-
dowanych obiektów o tych nazwach. W aktualnej implementacji wbudowana zmienna
__debug__
ma normal-
nie warto´s´c 1, przyjmuje natomiast warto´s´c 0, je´sli u˙zyto optymalizacji (opcja -O w wierszu polecenia). Istniej ˛
acy
generator kodu nie generuje dla instrukcji assert ˙zadnego kodu, o ile w czasie kompilacji wł ˛
aczona jest optymal-
izacja. Warto zauwa˙zy´c, ˙ze w kodzie ´zródłowym opisu bł˛edu niepotrzebne jest zapisywanie wyra˙zenia, którego
warto´sciowanie si˛e nie powiodło — b˛edzie ono wypisane jako cz˛e´s´c stanu stosu.
Przypisywanie warto´sci zmiennej
__debug__
jest niedozwolone.
Warto´s´c tej wbudowanej zmiennej jest
okre´slana przy uruchamianiu interpretera.
6.3
Instrukcje przypisania
Instrukcje przypisania u˙zywane s ˛
a do wi ˛
azania warto´sci z nazwami oraz do modyfikowania atrybutów lub ele-
mentów obiektów zmiennych.
assignment_stmt
::=
(target_list "=")+ expression_list
target_list
::=
target ("," target)* [","]
target
::=
identifier
| "(" target_list ")"
| "[" target_list "]"
| attributeref
| subscription
| slicing
(definicje składni ostatnich trzech symboli znajduj ˛
a si˛e w sekcji 5.3.)
Instrukcja przypisania warto´sciuje list˛e wyra˙ze´n (pami˛etajmy, ˙ze mo˙ze to by´c pojedyncze wyra˙zenie lub lista
wyra˙ze´n rozdzielonych przecinkami, gdzie drugi przypadek reprezentuje krotk˛e) i przypisuje ka˙zdemu z elemen-
tów z listy docelowej pojedynczy obiekt wynikowy, w kolejno´sci od lewej do prawej.
Przypisanie jest definiowane rekurencyjnie, w zale˙zno´sci od postaci celu (listy docelowej). Je´sli cel jest cz˛e´sci ˛
a
obiektu zmiennego (odwołaniem do atrybutu, odwołaniem do indeksu lub wykrojeniem), ostateczne przypisanie
z uprzednim sprawdzeniem poprawno´sci i ewentualnym wygenerowaniem wyj ˛
atku w razie operacji niepoprawnej
w cało´sci wykonuje ów zmienny obiekt. Reguły, którym podlegaj ˛
a ró˙zne typy i u˙zywane w ró˙znych wypadkach
wyj ˛
atki podawane s ˛
a z definicjami typów obiektów (patrz sekcja 3.2).
Przypisanie obiektu do listy docelowej jest zdefiniowane rekurencyjnie w sposób przedstawiony poni˙zej.
• Je´sli lista docelowa składa si˛e z jednego celu: obiekt jest przypisywany do tego celu.
• Je´sli lista docelowa jest list ˛
a celów rozdzielonych przecinkami: obiekt musi by´c sekwencj ˛
a z liczb ˛
a el-
ementów równ ˛
a liczbie celów na li´scie docelowej, a elementy sekwencji s ˛
a przypisywane do odpowied-
nich elementów listy docelowej, od lewej do prawej. (Reguła ta została osłabiona w Pythonie 1.5, we
wcze´sniejszych wersjach obiekt musiał by´c krotk ˛
a; Poniewa˙z napisy s ˛
a sekwencjami, przypisania postaci
„
a, b = "xy"
” s ˛
a obecnie poprawne, o ile tylko napis ma odpowiedni ˛
a długo´s´c).
Przypisanie obiektu do pojedynczego celu jest zdefiniowane rekurencyjnie w sposób przedstawiony poni˙zej.
• Je´sli cel jest identyfikatorem (nazw ˛
a):
50
Rozdział 6. Instrukcje proste
– Je´sli nazwa nie wyst˛epuje w instrukcji
global
w bie˙z ˛
acym bloku kodu: nast˛epuje powi ˛
azanie nazwy
z obiektem w lokalnej przestrzeni nazw.
– W przeciwnym wypadku: nast˛epuje powi ˛
azanie nazwy z obiektem w globalnej przestrzeni nazw.
Je´sli nazwa jest ju˙z powi ˛
azana, nast˛epuje jej powi ˛
azanie na nowo. Mo˙ze to spowodowa´c spadek do zera
warto´sci licznika odwoła´n do poprzednio dowi ˛
azanego obiektu, a co za tym idzie, wywołanie jego destruk-
tora (je´sli obiekt go posiada) i zwolnienie zajmowanej przez niego pami˛eci.
• Je´sli cel jest list ˛
a docelow ˛
a uj˛et ˛
a w nawiasy lub nawiasy kwadratowe: obiekt musi by´c sekwencj ˛
a z
liczb ˛
a elementów równ ˛
a liczbie elementów na li´scie docelowej, a elementy sekwencji s ˛
a przypisywane
do odpowiednich elementów listy docelowej, od lewej do prawej.
• Je´sli cel jest odwołaniem do atrybutu: warto´sciowane jest główne wyra˙zenie w odwołaniu. Warto´sci ˛
a
wyra˙zenia powinien by´c obiekt pozwalaj ˛
acy na przypisywanie atrybutów, w przeciwnym wypadku gen-
erowany jest wyj ˛
atek
TypeError
. Nast˛epnie przekazywane jest mu polecenie przypisania przypisy-
wanego obiektu do podanego atrybutu, a w przypadku niepowodzenia generowany jest wyj ˛
atek (zwykle,
cho´c niekoniecznie, wyj ˛
atek
AttributeError
).
• Je´sli cel jest odwołaniem do indeksu: warto´sciowane jest główne wyra˙zenie w odwołaniu. Warto´sci ˛
a
wyra˙zenia powinna by´c zmienna sekwencja (np. lista) lub odwzorowanie (np. słownik). W nast˛epnej
kolejno´sci warto´sciowane jest wyra˙zenie słu˙z ˛
ace za indeks.
Je´sli główne wyra˙zenie jest zmienn ˛
a sekwencj ˛
a (np. list ˛
a), warto´sci ˛
a indeksu musi by´c zwykła liczba
całkowita. W przypadku, gdy liczba jest ujemna, jest do niej dodawana długo´s´c sekwencji. Wynikowa
warto´s´c musi by´c liczb ˛
a nieujemn ˛
a, mniejsz ˛
a od długo´sci sekwencji. Do sekwencji nale˙zy wówczas przyp-
isanie przypisywanego obiektu elementowi o podanym indeksie. Je´sli warto´s´c indeksu wykracza poza
okre´slony zakres, generowany jest wyj ˛
atek
IndexError
(przypisanie do indeksowanego elementu sek-
wencji nie mo˙ze słu˙zy´c dodawaniu do niej elementów).
Je´sli główne wyra˙zenie jest obiektem odwzorowawczym (np. słownikiem), warto´s´c indeksu musi by´c typu
zgodnego z typem klucza odwzorowania. Do słownika nale˙zy wówczas utworzenie pary klucz/dane, która
odwzorowuje warto´s´c indeksu na przypisywany obiekt. Nowy element mo˙ze albo zast ˛
api´c istniej ˛
ac ˛
a par˛e
klucz/warto´s´c (je´sli klucz o tej samej warto´sci ju˙z istnieje), albo zosta´c wstawiony jako nowy (je´sli w
odwzorowaniu nie ma pary o tym kluczu).
• Je´sli główne wyra˙zenie jest wykrojeniem: warto´sciowane jest główne wyra˙zenie w odwołaniu. Warto´sci ˛
a
wyra˙zenia powinna by´c zmienna sekwencja (np. lista). Przypisywany obiekt powinien by´c sekwencj ˛
a tego
samego typu. W nast˛epnej kolejno´sci warto´sciowane s ˛
a wyra˙zenia okre´slaj ˛
ace dolne i górne ograniczenie
wykrojenia, przy czym ka˙zde z nich jest opcjonalne, a ich warto´sciami domy´slnymi s ˛
a: zero i długo´s´c
sekwencji. Oba wyra˙zenia powinny by´c (zwykłymi) liczbami całkowitymi. Je´sli które´s z ogranicze´n jest
ujemne, dodawana jest do niego długo´s´c sekwencji. Wynikowe ograniczenia przycinane s ˛
a do przedziału od
zera do długo´sci sekwencji (wł ˛
acznie). Ostatecznie, do sekwencji nale˙zy zast ˛
apienie okre´slonego wykroje-
nia elementami przypisywanej sekwencji. O ile obiekt na to pozwala, długo´s´c wykrojenia mo˙ze by´c ró˙zna
od długo´sci przypisywanej sekwencji, powoduj ˛
ac tym samym zmian˛e długo´sci sekwencji docelowej.
(W bie˙z ˛
acej implementacji Pythona przyj˛eto dla celów tak ˛
a sam ˛
a składni˛e, jak dla wyra˙ze´n, a zapis niepoprawny
składniowo jest odrzucany na etapie generowania kodu, co skutkuje mniej szczegółowymi komunikatami na temat
bł˛edów.)
UWAGA: Cho´c z definicji przypisania wynika, ˙ze pokrywanie si˛e nazw po lewej i prawej stronie jest „bezpieczne”
(np. „
a, b = b, a
” zamienia warto´sci dwóch zmiennych), jednak pokrywanie si˛e nazw wewn ˛
atrz zestawu
zmiennych, którym przypisujemy warto´sci, ju˙z bezpieczne nie jest. Na przykład, poni˙zszy fragment programu
spowoduje wypisanie warto´sci „
[0, 2]
”:
x = [0, 1]
i = 0
i, x[i] = 1, 2
print x
6.3. Instrukcje przypisania
51
6.3.1
Modyfikuj ˛
ace instrukcje przypisania
Modyfikuj ˛
aca instrukcja przypisania jest poł ˛
aczeniem w jednej instrukcji operacji dwuargumentowej oraz in-
strukcji przypisania:
augmented_assignment_stmt
::=
target augop expression_list
augop
::=
"+=" | "-=" | "*=" | "/=" | "%=" | "**="
| "»=" | "«=" | "&=" | "^=" | "|="
(definicje składni ostatnich trzech symboli znajduj ˛
a si˛e w sekcji 5.3.)
Modyfikuj ˛
aca instrukcja przypisania warto´sciuje cel (który, w odró˙znieniu od zwykłych instrukcji przypisania,
musi by´c celem pojedynczym) oraz list˛e wyra˙ze´n, nast˛epnie za´s wykonuje operacj˛e dwuargumentow ˛
a okre´slon ˛
a
dla danego rodzaju przypisania i przypisuje wynik do celu. Cel warto´sciowany jest tylko raz.
Modyfikuj ˛
ac ˛
a instrukcj˛e przypisania postaci
x += 1
mo˙zna zapisa´c jako
x = x + 1
, otrzymuj ˛
ac podobny,
lecz niezupełnie taki sam efekt. Przy odmianie z przypisaniem modyfikuj ˛
acym
x
warto´sciowane jest bowiem
tylko raz. Dodatkowo, je´sli jest to mo˙zliwe, cała operacja jest przeprowadzana w miejscu, co oznacza, ˙ze zamiast
tworzenia nowego obiektu i przypisania go do celu mo˙ze zosta´c od razu zmodyfikowany obiekt docelowy.
Za wyj ˛
atkiem przypisa´n do krotek i wielu celów w jednej instrukcji, przypisanie wykonane przez instrukcj˛e
modyfikuj ˛
ac ˛
a jest obsługiwane w ten sam sposób, co zwykłe przypisanie. Równie˙z za wyj ˛
atkiem mo˙zliwego
wykonania operacji w miejscu operacje dwuargumentowe wykonywane przez te przypisania s ˛
a takie same, jak
przy samodzielnym u˙zyciu operatorów dwuargumentowych.
W przypadku celów, które s ˛
a odwołaniami do atrybutów, pocz ˛
atkowa warto´s´c jest uzyskiwana poprzez wywołanie
getattr()
, za´s wynik operacji jest przypisywany poprzez wywołanie
setattr()
. Nale˙zy zwróci´c uwag˛e, ˙ze
te dwie metody niekoniecznie musz ˛
a si˛e odwoływa´c do tej samej zmiennej. Nawet, je´sli
getattr()
odwołuje
si˛e do zmiennej klasy,
setattr()
zapisuje zmienn ˛
a instancji. Na przykład:
class A:
x = 3
# zmienna klasy
a = A()
a.x += 1
# zapisuje a.x o warto´
sci 4, pozostawiaj ˛
ac A.x jako 3
6.4
Instrukcja
pass
pass_stmt:
"pass"
Z instrukcj ˛
a
pass
nie jest zwi ˛
azana jakakolwiek operacja — jej wykonanie nie powoduje ˙zadnych skutków.
Przydatna jest w roli wypełniacza, je´sli składnia wymaga obecno´sci instrukcji, lecz nie jest potrzebne wykonanie
˙zadnego kodu, np:
pass_stmt
::=
"pass"
6.5
Instrukcja
del
del_stmt
::=
"del" target_list
Usuni˛ecie jest zdefiniowane rekurencyjnie w podobny sposób co przypisanie. Zamiast wi˛ec jego szczegółowego
opisu poni˙zej zamieszczono pewne wskazówki.
Usuni˛ecie listy celów powoduje rekurencyjne usuni˛ecie ka˙zdego z celów, od lewej do prawej.
Usuni˛ecie nazwy powoduje usuni˛ecie dowi ˛
azania tej nazwy z lokalnej lub globalnej przestrzeni nazw, zale˙znie od
tego, czy w tym samym bloku kodu nazwa jest wymieniona w instrukcji Je´sli nazwa nie jest dowi ˛
azana w ˙zadnej
z tych przestrzeni nazw, generowany jest wyj ˛
atek
NameError
.
global
.
52
Rozdział 6. Instrukcje proste
Usuni˛ecie nazwy z lokalnej przestrzeni nazw jest niedopuszczalne, je´sli wyst˛epuje ona jako wolna zmienna w
jednym z zagnie˙zd˙zonych bloków.
Operacja usuni˛ecia odwołania do atrybutu, indeksu lub wykrojenia jest przekazywana do odnosz ˛
acego si˛e do niej
głównego obiektu. Usuni˛ecie wykrojenia jest zwykle równowa˙zne przypisaniu pustego wykrojenia wła´sciwego
typu, cho´c nawet to zale˙zne jest od samego obiektu.
6.6
Instrukcja
print_stmt
::=
"print" (
[
expression ("," expression)*
[
","
]]
| ">>" expression
[
("," expression)+
[
","
]]
)
Instrukcja
warto´sciuje kolejno ka˙zde z wyra˙ze´n i wypisuje wynikowy obiekt na standardowe wyj´scie
(patrz ni˙zej). Je´sli obiekt nie jest napisem, wcze´sniej nast˛epuje jego konwersja przy u˙zyciu standardowych reguł.
Wypisywany jest zawsze napis – pierwotny lub b˛ed ˛
acy wynikiem konwersji.
Przed ka˙zdym z obiektów (lub napisów b˛ed ˛
acych wynikami konwersji) wypisywany jest odst˛ep. Wyj ˛
atkiem jest
sytuacja, w której z punktu widzenia ´srodowiska wykonawczego bie˙z ˛
ac ˛
a pozycj ˛
a na wyj´sciu jest pocz ˛
atek wiersza.
Ma to miejsce, je´sli: (1) na standardowe wyj´scie nie został wypisany jeszcze ˙zaden znak, (2) ostatnim znakiem,
który był wypisany na standardowe wyj´scie, jest „
\n
” lub (3) ostatnia operacja zapisu na standardowym wyj´sciu
nie była wykonana przez instrukcj˛e
. (Z tego powodu czasem mo˙ze si˛e przyda´c wypisanie na standardowe
wyj´scie pustego napisu.) Notka: Obiekty, które zachowuj ˛
a si˛e jak obiekty plikowe, lecz w rzeczywisto´sci nie s ˛
a
obiektami wbudowanego typu plikowego, cz˛esto nie emuluj ˛
a poprawnie omawianego aspektu zachowania, wi˛ec
nie nale˙zy na nich polega´c.
Na ko´ncu danych wypisywany jest znak „
\n
”, chyba, ˙ze instrukcja
zako´nczona jest przecinkiem. W
przypadku, gdy instrukcja składa si˛e wył ˛
acznie ze słowa kluczowego
, wypisanie tego znaku jest jedyn ˛
a
wykonywan ˛
a operacj ˛
a.
Standardowe wyj´scie zdefiniowane jest jako obiekt plikowy o nazwie
stdout
, dost˛epnej w module
sys
. Je´sli
obiekt ten nie istnieje lub te˙z nie posiada metody
write()
, generowany jest wyj ˛
atek
RuntimeError
.
Instrukcja
wyst˛epuje równie˙z w rozszerzonej formie, zdefiniowanej w drugiej cz˛e´sci przedstawionej
wcze´sniej składni. Form˛e t˛e okre´sla si˛e czasem mianem „
chevron”. Przy instrukcji w postaci rozszer-
zonej warto´sci ˛
a pierwszego z wyra˙ze´n wyst˛epuj ˛
acych po
>>
musi by´c obiekt zachowuj ˛
acy si˛e jak obiekt plikowy,
w szczególno´sci musi on mie´c metod˛e
write()
. W tym przypadku kolejne wyra˙zenia s ˛
a wypisywane do tego
wła´snie obiektu plikowego. Je´sli warto´sci ˛
a pierwszego wyra˙zenia jest
None
, wówczas jako obiekt plikowy u˙zy-
wany jest
sys.stdout
.
6.7
Instrukcja
return
return_stmt
::=
"return" [expression_list]
Instrukcja
return
mo˙ze si˛e pojawi´c tylko w miejscu, które składniowo jest zagnie˙zd˙zone w definicji funkcji,
jednak nie bezpo´srednio w zagnie˙zd˙zonej definicji klasy.
Je´sli obecna jest lista wyra˙ze´n, nast˛epuje jej warto´sciowanie, w przeciwnym wypadku zast˛epowana jest warto´sci ˛
a
None
.
Przy wykonaniu instrukcji
return
nast˛epuje opuszczenie bie˙z ˛
acego wywołania funkcji z list ˛
a wyra˙ze´n (lub
warto´sci ˛
a
None
) jako warto´sci ˛
a zwracan ˛
a.
Je´sli instrukcja
return
powoduje przekazanie sterowania poza instrukcj˛e
try
z klauzul ˛
a
finally
, to przed
rzeczywistym opuszczeniem wywołania funkcji wykonywany jest zestaw z klauzuli
finally
.
Wewn ˛
atrz funkcji generuj ˛
acych nie mo˙zna u˙zywa´c instrukcji
return
zawieraj ˛
acych wyra˙zenie (symbol
expression_list
w gramatyce). W tym kontek´scie napotkanie instrukcji
return
(składaj ˛
acej si˛e wył ˛
acznie
ze słowa kluczowego) oznacza, ˙ze generator zako´nczył działanie, co spowoduje wygenerowanie wyj ˛
atku
StopIteration
.
6.6. Instrukcja
53
6.8
Instrukcja
yield
yield_stmt
::=
"yield" expression_list
Instrukcja
yield
jest u˙zywana wył ˛
acznie przy definiowaniu funkcji generuj ˛
acej i wyst˛epuje wówczas w jej
tre´sci. U˙zycie wewn ˛
atrz definicji funkcji instrukcji
yield
jest warunkiem wystarczaj ˛
acym, aby stała si˛e ona
funkcj ˛
a generuj ˛
ac ˛
a, zamiast zwykłej funkcji.
Wywołanie funkcji generuj ˛
acej zwraca tak zwany iterator generuj ˛
acy, lub po prostu generator. Wykonywanie
tre´sci funkcji generuj ˛
acej nast˛epuje ka˙zdorazowo po wywołaniu metody
next()
generatora, a˙z do czasu, gdy
funkcja wygeneruje wyj ˛
atek.
Przy wykonywaniu instrukcji
yield
nast˛epuje zamro˙zenie stanu generatora, a warto´s´c wyra˙zenia podanego po
słowie
yield
jest przekazywana do punktu wywołania metody
next()
. „Zamro˙zenie” oznacza w tym przy-
padku zapami˛etanie całego stanu lokalnego, wraz z istniej ˛
acymi lokalnymi dowi ˛
azaniami nazw, wska´znikiem
instrukcji oraz wewn˛etrznym stosem warto´sciowania: zachowywana jest wystarczaj ˛
aca ilo´s´c informacji, aby
przy kolejnym wywołaniu metody
next()
wykonywanie funkcji mogło by´c kontynuowane tak, jakby instrukcja
yield
była zwykłym wywołaniem funkcji.
U˙zycie instrukcji
yield
nie jest dozwolone w klauzuli
try
konstrukcji
try
...
finally
. Ograniczenie wynika
z tego, ˙ze nie ma ˙zadnych gwarancji przyszłego wznowienia generatora, wi˛ec nie ma te˙z gwarancji, ˙ze byłby
kiedykolwiek wykonany zestaw klauzuli
finally
.
Notka: W wersji 2.2 Pythona u˙zycie instrukcji
yield
jest mo˙zliwe tylko, je´sli aktywna jest własno´s´c o nazwie
generators
. W Pythonie 2.3 i w kolejnych wersjach cecha ta jest zawsze aktywna. U˙zywana w tym przypadku
instrukcja
__future__
ma posta´c:
from __future__ import generators
Zobacz te˙z:
PEP 0255, „Proste generatory”
Propozycja dodania do Pythona generatorów i instrukcji
yield
.
6.9
Instrukcja
raise
raise_stmt
::=
"raise" [expression ["," expression ["," expression]]]
Je´sli po słowie kluczowym
raise
nie wyst˛epuje ˙zadne wyra˙zenie, instrukcja powoduje ponowne wygenerowanie
ostatniego wyj ˛
atku, który był aktywny w bie˙z ˛
acym zasi˛egu. Je´sli w bie˙z ˛
acym zasi˛egu nie był aktywny ˙zaden
wyj ˛
atek, generowany jest wyj ˛
atek sygnalizuj ˛
acy ten bł ˛
ad.
W przeciwnym wypadku warto´sciowane s ˛
a trzy wyra˙zenia, wyst˛epuj ˛
ace po słowie
raise
, przy czym w miejce
pomini˛etych wyra˙ze´n wstawiana jest warto´s´c
None
. Pierwsze dwa obiekty s ˛
a u˙zywane do okre´slenia typu oraz
warto´sci wyj ˛
atku.
Je´sli pierwszy obiekt jest instancj ˛
a, typem wyj ˛
atku jest klasa tej instancji, instancja jest jego warto´sci ˛
a, za´s warto´s-
ci ˛
a drugiego obiektu musi by´c
None
.
Je´sli pierwszy obiekt jest klas ˛
a, staje si˛e on typem wyj ˛
atku, za´s drugi obiekt u˙zywany jest do okre´slenia warto´sci
wyj ˛
atku. Je´sli drugi obiekt jest instancj ˛
a klasy podanej jako pierwszy obiekt, staje si˛e on warto´sci ˛
a wyj ˛
atku.
Je´sli drugi obiekt nie spełnia tego warunku, tworzona jest nowa instancja klasy, z list ˛
a argumentów konstruktora
ustalon ˛
a w sposób nast˛epuj ˛
acy: je´sli drugi obiekt jest krotk ˛
a, to stanowi list˛e argumentów, je´sli ma warto´s´c
None
,
to lista argumentów jest pusta, w pozostałych przypadkach lista argumentów konstruktora zawiera jeden element,
którym jest drugi obiekt. Utworzona w ten sposób instancja klasy jest u˙zywana jako warto´s´c wyj ˛
atku.
Je´sli w instrukcji wyst˛epuje trzeci obiekt i jego warto´sci ˛
a nie jest
None
, musi to by´c obiekt stanu stosu (patrz
sekcja 3.2). Jest on wówczas u˙zywany zamiast bie˙z ˛
acego poło˙zenia do identyfikacji miejsca, w którym wyst ˛
apił
wyj ˛
atek. Je´sli trzeci obiekt wyst˛epuje, lecz nie jest obiektem stanu stosu, ani warto´sci ˛
a
None
, generowany jest
wyj ˛
atek
TypeError
. Posta´c instrukcji
raise
z trzema wyra˙zeniami jest przydatna przy ponownym generowa-
54
Rozdział 6. Instrukcje proste
niu wyj ˛
atków w klauzuli except w sposób przezroczysty, jednak w przypadku, gdy ponownie generowany wyj ˛
atek
był ostatnim aktywnym wyj ˛
atkiem w bie˙z ˛
acym zasi˛egu, preferowana powinna by´c posta´c instrukcji
raise
bez
wyra˙ze´n.
Dodatkowe informacje na temat wyj ˛
atków mo˙zna odnale´z´c w sekcji 4.2, za´s informacje na temat obsługi
wyj ˛
atków — w sekcji 7.4.
6.10
Instrukcja
break
break_stmt
::=
"break"
Instrukcja
break
mo˙ze si˛e pojawi´c tylko w miejscu, które składniowo jest zagnie˙zd˙zone w p˛etli
for
lub
while
,
jednak nie bezpo´srednio w zagnie˙zd˙zonej definicji klasy lub funkcji.
Wykonanie instrukcji
break
powoduje przerwanie wykonywania naj´sci´slej otaczaj ˛
acej j ˛
a p˛etli, z pomini˛eciem
wyst˛epuj ˛
acej w niej ew. klauzuli
else
.
Je´sli p˛etla
for
zostanie przerwana przez wykonanie instrukcji
break
, zmienna steruj ˛
aca p˛etli zachowuje sw ˛
a
bie˙z ˛
ac ˛
a warto´s´c po jej opuszczeniu.
W przypadku, gdy instrukcja
break
powoduje przekazanie sterowania poza instrukcj˛e
try
z klauzul ˛
a
finally
,
to przed rzeczywistym opuszczeniem wywołania funkcji wykonywany jest zestaw z tej klauzuli
6.11
Instrukcja
continue
continue_stmt
::=
"continue"
Instrukcja
continue
mo˙ze si˛e pojawi´c tylko w miejscu, które składniowo jest zagnie˙zd˙zone w p˛etli
for
lub
while
, jednak nie bezpo´srednio w zagnie˙zd˙zonej definicji klasy, czy funkcji lub te˙z instrukcji
try
1
Wykonanie
instrukcji powoduje przej´scie do nast˛epnego cyklu iteracji naj´sci´slej otaczaj ˛
acej j ˛
a p˛etli.
6.12
Instrukcja
import
import_stmt
::=
"import" module ["as" name] ( "," module ["as" name] )*
| "from" module "import" identifier ["as" name]
( "," identifier ["as" name] )*
| "from" module "import" "*"
module
::=
(identifier ".")* identifier
Instrukcje
import
wykonywane s ˛
a w dwóch krokach: (1) odnalezienie modułu i, w razie konieczno´sci, jego
zainicjowanie, (2) definicja nazwy lub nazw w lokalnej przestrzeni nazw (zasi˛egu, w którym wyst˛epuje instrukcja).
W pierwszej postaci instrukcji (bez słowa kluczowego
from
) kroki te wykonywane s ˛
a dla ka˙zdego identyfikatora
z listy. Instrukcja w postaci ze słowem kluczowym
from
wykonuje krok (1) raz, a nast˛epnie powtarza wykonanie
kroku (2).
W przedstawionym kontek´scie „inicjowanie” modułu wbudowanego lub rozszerzenia oznacza wywołanie
wywołanie udost˛epnianej przez moduł funkcji inicjuj ˛
acej (w implementacji wzorcowej wywoływana jest funkcja
o nazwie uzyskanej poprzez dodanie przedrostka „init” przed nazw ˛
a modułu). „Inicjowanie” modułu napisanego
w Pythonie oznacza wykonanie tre´sci modułu.
´Srodowisko wykonawcze Pythona przechowuje tablic˛e modułów, które zostały ju˙z zainicjowane lub ich
inicjowanie wła´snie trwa, indeksuj ˛
ac j ˛
a przy u˙zyciu nazw modułów.
Tablica dost˛epna jest pod nazw ˛
a
sys.modules
. Je´sli nazwa importowanego modułu zostanie odnaleziona w tej tablicy, ko´nczy si˛e wyko-
nanie kroku (1). W przeciwnym wypadku rozpoczyna si˛e poszukiwanie definicji modułu i, po jej pomy´slnym
odnalezieniu, załadowanie modułu. Szczegóły dotycz ˛
ace procesu wyszukiwania i ładowania modułów s ˛
a zale˙zne
1
Instrukcja
continue
mo˙ze si˛e pojawia´c w klauzulach
except
oraz
else
. Ograniczenie na wyst˛epowanie w klauzuli
try
jest
wynikiem lenistwa autora implementacji i ostatecznie zostanie prawdopodobnie zniesione.
6.10. Instrukcja
break
55
od implementacji i platformy. Ogólnie przeszukuje si˛e najpierw list˛e „wbudowanych” modułów, a nast˛epnie list˛e
lokalizacji okre´slon ˛
a przez warto´s´c
sys.path
.
Je´sli zostanie odnaleziony moduł wbudowany o podanej nazwie, wykonywany jest wbudowany kod inicjuj ˛
acy i
ko´nczy si˛e wykonywanie kroku (1). Je´sli nie zostanie odnaleziony moduł wbudowany, ani te˙z plik odpowiada-
j ˛
acy nazwie modułu, generowany jest wyj ˛
atek
ImportError
. Po odnalezieniu pliku nast˛epuje jego analiza
składniowa, której wynikiem jest blok kodu wykonywalnego. W przypadku napotkania bł˛edu składniowego gen-
erowany jest wyj ˛
atek
SyntaxError
. Po pomy´slnej analizie składniowej tworzony jest pusty moduł o podanej
nazwie, nast˛epnie wstawiany jest do tablicy modułów, a w ko´ncu w jego kontek´scie wykonywany jest uzyskany
wcze´sniej blok kodu. Wyj ˛
atki wygenerowane na tym etapie powoduj ˛
a przerwanie kroku (1).
Je´sli krok (1) zostanie zako´nczony bez wygenerowania wyj ˛
atku, mo˙ze si˛e rozpocz ˛
a´c wykonywanie kroku (2).
Pierwsza posta´c instrukcji
import
wi ˛
a˙ze obiekt modułu z jego nazw ˛
a w lokalnej przestrzeni nazw, a nast˛ep-
nie przechodzi do ewentualnych kolejnych identyfikatorów z listy. Je´sli po nazwie modułu pojawia si˛e słowo
kluczowe
as
, obiekt modułu wi ˛
azany jest z u˙zyciem nazwy podanej po
as
.
Posta´c ze słowem kluczowym
from
nie wi ˛
a˙ze nazwy modułu.
Zamiast tego nast˛epuje przej´scie po li´scie
identyfikatorów, wyszukanie ka˙zdego z nich w module odnalezionym w kroku (1), a nast˛epnie powi ˛
azanie
odnalezionego obiektu pod podan ˛
a nazw ˛
a w lokalnej przestrzeni nazw. Podobnie, jak przy pierwszej postaci
instrukcji, mo˙zliwe jest podanie alternatywnej lokalnej nazwy poprzez u˙zycie zapisu „
as
nazwa_lokalna”. Je´sli
nazwa nie zostanie odnaleziona, generowany jest wyj ˛
atek
ImportError
. Je´sli lista identyfikatorów zostanie za-
st ˛
apiona gwiazdk ˛
a („
*
”), w lokalnej przestrzeni nazw instrukcji
import
wi ˛
azane s ˛
a wszystkie publiczne nazwy
zdefiniowane w module.
Nazwy publiczne definiowane przez moduł s ˛
a okre´slane poprzez odszukanie w przestrzeni nazw modułu nazwy
__all__
. Je´sli nazwa wyst˛epuje, musi si˛e odnosi´c do sekwencji napisów, które s ˛
a nazwami zdefiniowanymi lub
zaimportowanymi przez moduł. Wszystkie te nazwy s ˛
a uznawane za publiczne i musz ˛
a istnie´c po załadowaniu
modułu. Je´sli nazwa
__all__
nie jest zdefiniowana, zbiór nazw publicznych jest ustalany poprzez pobranie z
przestrzeni nazw modułu wszystkich nazw, które nie rozpoczynaj ˛
a si˛e znakiem podkre´slenia („
_
”). Sekwencja
__all__
powinna zawiera´c całe publiczne API modułu. Słu˙zy ona zabezpieczeniu przed przypadkowym ek-
sportem elementów, które nie s ˛
a cz˛e´sci ˛
a API (np. modułów bibliotecznych importowanych przez moduł na jego
wewn˛etrzny u˙zytek).
Posta´c instrukcji
import
ze słowem
from
i gwiazdk ˛
a („
*
”) mo˙ze si˛e pojawi´c tylko w zasi˛egu modułu. Je´sli
posta´c „
import *
” zostanie u˙zyta wewn ˛
atrz funkcji, która zawiera zagnie˙zd˙zony blok z wolnymi zmiennymi,
na etapie kompilacji zostanie zgłoszony bł ˛
ad
SyntaxError
.
Hierarchiczne nazwy modułów: w przypadku, gdy nazwa modułu zawiera przynajmniej jedn ˛
a kropk˛e, zmianie
ulega zastosowanie ´scie˙zki wyszukiwania. Sekwencja identyfikatorów a˙z do ostatniej kropki jest u˙zywana do
odnalezienia „pakietu”, a ko´ncowy identyfikator jest wyszukiwany wewn ˛
atrz pakietu. Pakiet jest zwykle pod-
katalogiem jednego z katalogów wymienionych na li´scie
sys.path
, który zawiera specjalny plik o nazwie
„
__init__.py
”.
Aplikacje, które okre´slaj ˛
a list˛e ładowanych modułów w sposób dynamiczny, mog ˛
a do ich importowania wyko-
rzysta´c wbudowan ˛
a funkcj˛e
__import__()
. Aby uzyska´c szczegółowe informacje na ten temat, zajrzyj do
sekcji
Wbudowane funkcje
w pozycji
Podr˛ecznik programisty Pythona - opis biblioteki standardowej
.
6.12.1
Instrukcje future
Instrukcja future jest dyrektyw ˛
a kompilatora, nakazuj ˛
ac ˛
a skompilowanie danego modułu z u˙zyciem składni lub se-
mantyki, która b˛edzie dost˛epna w okre´slonej przyszłej wersji Pythona. Przeznaczeniem tej instrukcji jest ułatwie-
nie migracji do przyszłych wersji Pythona, zawieraj ˛
acych zmiany w j˛ezyku, które wprowadzaj ˛
a pewne niezgod-
no´sci. Pozwala ona na korzystanie z nowych elementów j˛ezyka w wydzielonych modułach, zanim stan ˛
a si˛e
cz˛e´sci ˛
a standardu.
future_statement
::=
"from" "__future__" "import" feature ["as" name]
("," feature ["as" name])*
feature
::=
identifier
name
::=
identifier
Instrukcja future mo˙ze si˛e pojawi´c tylko na pocz ˛
atku modułu. Jedynymi instrukcjami, jakie mog ˛
a wyst ˛
api´c przed
56
Rozdział 6. Instrukcje proste
ni ˛
a s ˛
a:
• napis dokumentuj ˛
acy modułu (je´sli wyst˛epuje),
• komentarze,
• puste wiersze,
• inne instrukcje future.
Cechami rozpoznawanymi w Pythonie 2.3 s ˛
a: „
generators
” (generatory), „
division
” (dzielenie) oraz
„
nested_scopes
” (zagnie˙zd˙zone zasi˛egi). Wymienianie cech „
generators
” i „
nested_scopes
” jest
w Pythonie 2.3 nadmiarowe, gdy˙z obie s ˛
a domy´slnie aktywne.
Instrukcja future jest rozpoznawana i traktowana w specjalny sposób na etapie kompilacji: Zmiany w semantyce
rdzennych elementów j˛ezyka s ˛
a cz˛esto realizowane poprzez generowanie innego kodu. Wprowadzenie nowej
cechy mo˙ze nawet poci ˛
aga´c za sob ˛
a now ˛
a składni˛e, niezgodn ˛
a ze starsz ˛
a (np. nowe słowo kluczowe), z czym
mo˙ze wi ˛
aza´c si˛e konieczno´s´c odmiennej analizy składniowej przeprowadzanej przez kompilator. Odło˙zenie tego
typu decyzji do etapu wykonania programu nie jest mo˙zliwe.
W przypadku ka˙zdego wydania Pythona kompilator zna nazwy zdefiniowanych cech i przy próbie wykonania
instrukcji future z nieznan ˛
a cech ˛
a zgłasza bł ˛
ad kompilacji.
Bezpo´srednia semantyka wykonania instrukcji future jest taka sama, jak w przypadku ka˙zdej innej instrukcji
import: istnieje standardowy moduł
__future__
(opisany dalej), który jest w zwykły sposób importowany
przy wykonaniu instrukcji future.
Interesuj ˛
aca nas semantyka jest uzale˙zniona od u˙zycia w instrukcji future konkretnej nazwy cechy.
Zauwa˙zmy, ˙ze w poni˙zszej instrukcji nie ma nic specjalnego:
import __future__ [as nazwa]
Nie jest to instrukcja future, a zwykła instrukcja import bez specjalnego znaczenia czy ogranicze´n składniowych.
Kod skompilowany przy u˙zyciu instrukcji exec lub poprzez wywołania wbudowanych funkcji
compile()
i
execfile()
, które wyst˛epuj ˛
a w module
M
, zawieraj ˛
acym instrukcj˛e future, b˛edzie domy´slnie wykorzysty-
wał now ˛
a składni˛e lub semantyk˛e powi ˛
azan ˛
a z u˙zyt ˛
a instrukcj ˛
a future. Poczynaj ˛
ac od Pythona w wersji 2.2,
zachowanie to mo˙ze to by´c kontrolowane przez opcjonalne argumenty przekazane funkcji
compile()
. Aby
pozna´c szczegóły, zajrzyj do dokumentacji tej funkcji w pozycji
Podr˛ecznik programisty Pythona – opis biblioteki
standardowej
.
Instrukcja future u˙zyta w trybie interaktywnym wpływa na działanie interpretera a˙z do zako´nczenia jego sesji. Je´sli
interpreter zostanie uruchomiony z opcj ˛
a -i i nazw ˛
a pliku do wykonania jako parametrem, a w trakcie wykonywa-
nia pliku zostanie napotkana instrukcja future, to jej działanie b˛edzie skutkowało równie˙z podczas interaktywnej
sesji rozpocz˛etej automatycznie po wykonaniu pliku.
6.13
Instrukcja
global
global_stmt
::=
"global" identifier ("," identifier)*
Instrukcja
global
stanowi deklaracj˛e, która odnosi si˛e do całego bie˙z ˛
acego bloku kodu. U˙zycie jej jest informa-
cj ˛
a dla kompilatora, ˙ze wszystkie wymienione identyfikatory powinny by´c interpretowane jako globalne. Przyp-
isywanie do globalnych nazw byłoby bez instrukcji
global
niemo˙zliwe, cho´c wolne nazwy mog ˛
a si˛e odnosi´c do
nazw globalnych bez u˙zycia tej instrukcji.
Nazwy wymienione w instrukcji
global
nie mog ˛
a by´c u˙zywane w tym samym bloku kodu w cz˛e´sci tekstowo
poprzedzaj ˛
acej t˛e instrukcj˛e
global
.
Nazwy wymienione w instrukcji
global
nie mog ˛
a by´c zdefiniowane jako parametry formalne, jako cele w
instrukcji
for
, ani te˙z w instrukcji
class
, definicji funkcji, czy instrukcji
import
.
6.13. Instrukcja
global
57
(Aktualna implementacja nie sankcjonuje dwóch ostatnich ogranicze´n, jednak programy nie powinny nadu˙zy-
wa´c wolno´sci, gdy˙z przyszłe implementacje mog ˛
a zacz ˛
a´c restrykcyjnie przestrzega´c tych reguł, b ˛
ad´z te˙z zmieni´c
zachowanie si˛e programu przy ich ignorowaniu.)
Uwaga dla programistów: słowo
global
jest dyrektyw ˛
a parsera, która odnosi si˛e tylko do kodu analizowanego
w tym samym czasie, co sama instrukcja
global
. W szczególno´sci, instrukcja
global
zawarta w instrukcji
exec
nie wpływa na blok kodu zawieraj ˛
acy instrukcj˛e
exec
, podobnie, jak na kod zawarty w instrukcji
exec
nie wpływaj ˛
a instrukcje
global
w bloku kodu zawieraj ˛
acym
exec
. To samo odnosi si˛e do funkcji
eval()
,
execfile()
oraz
compile()
.
6.14
Instrukcja
exec
exec_stmt
::=
"exec" expression ["in" expression ["," expression]]
Instrukcja
exec
pozwala na dynamiczne wykonywanie kodu w Pythonie. Warto´sci ˛
a pierwszego wyra˙zenia
wchodz ˛
acego w skład instrukcji powinien by´c napis, obiekt plikowy w trybie otwartym lub obiekt kodu. Je´sli
warto´sci ˛
a jest napis, jest on analizowany jako zestaw instrukcji Pythona, a nast˛epnie wykonywany (o ile nie wys-
t ˛
api bł ˛
ad składniowy). Je´sli to otwarty plik, jest on analizowany do napotkania ko´nca pliku a nast˛epnie wykony-
wany (podobnie jak napis). Obiekt kodu podlega bezpo´sredniemu wykonaniu.
W ka˙zdym z przypadków, je´sli zostan ˛
a pomini˛ete cz˛e´sci opcjonalne, kod b˛edzie wykonany w bie˙z ˛
acym zasi˛egu.
je´sli zostanie podane tylko pierwsze wyra˙zenie po słowie
in
, jego warto´sci ˛
a powinien by´c słownik, który zostanie
u˙zyty w roli zarówno globalnej, jak i lokalnej przestrzeni nazw. Je´sli podane zostan ˛
a dwa wyra˙zenia, warto´sciami
obu powinny by´c słowniki, z których pierwszy zostanie u˙zyty jako globalna przestrze´n nazw, za´s drugi jako
lokalna.
Jako efekt uboczny, implementacja instrukcji mo˙ze wstawi´c do słowników dodatkowe klucze, poza tymi, które
s ˛
a wstawiane przez wykonywany kod. Na przykład, aktualna implementacja mo˙ze doda´c odwołanie do słownika
wbudowanego modułu
__builtin__
jako klucz o nazwie
__builtins__
.
Podpowied´z dla programistów: dynamiczne warto´sciowanie wyra˙ze´n jest mo˙zliwe przy u˙zyciu wbudowanej
funkcji
eval()
. Wbudowane funkcje
globals()
oraz
locals()
zwracaj ˛
a, odpowiednio, słownik bie˙z ˛
acej
globalnej oraz lokalnej przestrzeni nazw, co mo˙ze si˛e przyda´c przy przekazywaniu argumentów do funkcji
exec
.
58
Rozdział 6. Instrukcje proste
ROZDZIAŁ
SIÓDMY
Instrukcje zło˙zone
Instrukcje zło˙zone zawieraj ˛
a grupy innych instrukcji i w pewien sposób kontroluj ˛
a ich wykonanie lub wpływaj ˛
a na
nie. W ogólno´sci instrukcje zło˙zone zajmuj ˛
a wiele wierszy, cho´c w prostych przypadkach cała instrukcja zło˙zona
mo˙ze si˛e mie´sci´c w jednym wierszu.
Instrukcje
if
,
while
oraz
for
implementuj ˛
a tradycyjne konstrukcje kontroli przebiegu wykonania. Instrukcja
try
okre´sla dla zawartej w niej grupy instrukcji kod obsługi wyj ˛
atków i/lub kod oczyszczaj ˛
acy. Ze składniowego
punktu widzenia równie˙z definicje funkcji i klas s ˛
a instrukcjami zło˙zonymi.
Instrukcje zło˙zone składaj ˛
a si˛e z jednej lub wi˛ecej „klauzul”. Ka˙zda z klauzul składa si˛e natomiast z nagłówka i
„zestawu”. Wszystkie nagłówki klauzul w ramach jednej instrukcji zło˙zonej znajduj ˛
a si˛e na tym samym poziomie
wci˛ecia. Nagłówki rozpoczynaj ˛
a si˛e słowem kluczowym, jednoznacznie identyfikuj ˛
acym klauzul˛e, a ko´ncz ˛
a
dwukropkiem. Zestaw jest grup ˛
a instrukcji kontrolowan ˛
a przez klauzul˛e. Mo˙ze si˛e on pojawi´c w tym samym
wierszu, co nagłówek, bezpo´srednio po dwukropku — tworzy go wtedy jedna instrukcja prosta lub wiele instrukcji
prostych rozdzielonych przecinkami. Zestaw mog ˛
a te˙z tworzy´c instrukcje pojawiaj ˛
ace si˛e w kolejnych wierszach
ze zwi˛ekszonym wci˛eciem. Tylko w drugim przypadku zestaw mo˙ze zawiera´c zagnie˙zd˙zone instrukcje zło˙zone.
Poni˙zszy przykład jest wi˛ec niepoprawny, co mo˙zna uzasadni´c niemo˙zno´sci ˛
a stwierdzenia, której klauzuli
if
nale˙załoby przypisa´c pojawiaj ˛
ac ˛
a si˛e ewentualnie w dalszej cz˛e´sci klauzul˛e
else
:
if test1: if test2: print x
Zwracamy te˙z uwag˛e na fakt, ˙ze w tym kontek´scie ´srednik wi ˛
a˙ze silniej ni˙z dwukropek, w zwi ˛
azku z czym
poni˙zszym przykładzie nie zostanie wykonana ˙zadna z instrukcji
lub zostan ˛
a wykonane wszystkie:
if x < y < z: print x; print y; print z
Podsumowuj ˛
ac:
compound_stmt
::=
if_stmt
| while_stmt
| for_stmt
| try_stmt
| funcdef
| classdef
suite
::=
stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT
statement
::=
stmt_list NEWLINE | compound_stmt
stmt_list
::=
simple_stmt (";" simple_stmt)* [";"]
Zwró´cmy uwag˛e, ˙ze instrukcje zawsze zako´nczone s ˛
a tokenem
NEWLINE
, ewentualnie z wyst˛epuj ˛
acym po nim
tokenem
DEDENT
. Wa˙zny jest te˙z fakt, ˙ze opcjonalne klauzule kontynuacji zawsze rozpoczynaj ˛
a si˛e słowem kluc-
zowym, które nie mo˙ze rozpoczyna´c instrukcji, w zwi ˛
azku z czym nie pojawiaj ˛
a si˛e wieloznaczno´sci (problem z
„wisz ˛
acymi
else
” został w Pythonie rozwi ˛
azany poprzez wymóg tworzenia wci˛e´c dla zagnie˙zd˙zonych instrukcji
if
).
Dla wi˛ekszej przejrzysto´sci w kolejnych sekcjach reguły gramatyki sformatowano w taki sposób, aby ka˙zda z
59
klauzul znajdowała si˛e w osobnym wierszu.
7.1
Instrukcja
if
Instrukcja
if
jest u˙zywana do wykonania warunkowego:
if_stmt
::=
"if" expression ":" suite
( "elif" expression ":" suite )*
["else" ":" suite]
Instrukcja wybiera dokładnie jeden z zestawów na podstawie wyników warto´sciowania kolejnych wyra˙ze´n, a˙z
do tego, którego warto´sci ˛
a logiczn ˛
a b˛edzie prawda (aby przeczyta´c definicj˛e prawdziwo´sci logicznej, zajrzyj do
sekcji 5.10). Po odnalezieniu spełniaj ˛
acego ten warunek wyra˙zenia jest wykonywany powi ˛
azany z nim zestaw
(wyst˛epuj ˛
acy po nim). Pozostałe wyra˙zenia nie s ˛
a ju˙z wówczas warto´sciowane, nie s ˛
a równie˙z wykonywane inne
zestawy wchodz ˛
ace w skład instrukcji
if
. Je´sli warto´sci ˛
a logiczn ˛
a wszystkich wyra˙ze´n b˛edzie fałsz i w instrukcji
wyst˛epuje klauzula
else
, wykonywany jest zestaw z ni ˛
a zwi ˛
azany.
7.2
Instrukcja
while
Instrukcja
while
jest u˙zywana do powtarzanego wykonywania tak długo, jak długo warto´sci ˛
a logiczn ˛
a wyra˙zenia
jest prawda:
while_stmt
::=
"while" expression ":" suite
["else" ":" suite]
Ka˙zdorazowo warto´sciowane jest wyra˙zenie wyst˛epuj ˛
ace po
while
i, je´sli jest ono prawdziwe, wykonywany
jest pierwszy zestaw. Je´sli za którym´s razem (by´c mo˙ze ju˙z za pierwszym) warto´sci ˛
a wyra˙zenia b˛edzie fałsz,
nast˛epuje przerwanie wykonywania p˛etli. W przypadku obecno´sci klauzuli
else
przerwanie nast˛epuje po up-
rzednim wykonaniu zestawu zapisanego po niej.
Wykonanie instrukcji
break
wewn ˛
atrz pierwszego zestawu przerywa wykonywanie p˛etli bez wykonywania
zestawu po
else
. Wykonanie wewn ˛
atrz p˛etli instrukcji
continue
powoduje natychmiastowe przej´scie do
kolejnej iteracji p˛etli, rozpoczynanej od sprawdzenia warunku poprzez warto´sciowanie wyra˙zenia.
7.3
Instrukcja
for
Instrukcja
for
jest u˙zywana do iterowania po elementach sekwencji (np. napisu, krotki lub listy) lub innego
obiektu iterowalnego:
for_stmt
::=
"for" target_list "in" expression_list ":" suite
["else" ":" suite]
Wyra˙zenie jest warto´sciowane raz, a jego wynikiem powinna by´c sekwencja. Dla ka˙zdego elementu tej sek-
wencji, w kolejno´sci rosn ˛
acych indeksów, wykonywany jest zestaw, przy czym element jest przypisywany do
listy docelowej zgodnie ze standardowymi regułami przypisa´n. Po wyczerpaniu elementów listy (by´c mo˙ze od
razu, je´sli lista jest pusta) p˛etla jest przerywana. Je´sli w instrukcji wyst˛epuje klauzula
else
, wykonywany jest
wówczas zwi ˛
azany z ni ˛
a zestaw.
Wykonanie instrukcji
break
wewn ˛
atrz pierwszego zestawu powoduje przerwane wykonywania p˛etli bez
wykonywania zestawu z klauzuli
else
. Wykonanie w pierwszym zestawie instrukcji
continue
powoduje
natychmiastowe przej´scie do kolejnej iteracji p˛etli (do kolejnego elementu sekwencji) lub do klauzuli
else
, je´sli
przetwarzany element sekwencji był ostatnim.
Wewn ˛
atrz zestawu dopuszczalne jest przypisywanie warto´sci zmiennym z listy docelowej. Nie wpływa to na
automatyczne przypisanie na pocz ˛
atku kolejnej iteracji.
Elementy z listy docelowej nie s ˛
a usuwane po zako´nczeniu p˛etli, lecz je´sli sekwencja jest pusta, instrukcja p˛etli
w ogóle nie przypisze im warto´sci. Przydatna w takich sytuacjach bywa wbudowana funkcja
range()
, która
60
Rozdział 7. Instrukcje zło˙zone
zwraca sekwencj˛e liczb całkowitych, umo˙zliwiaj ˛
ac ˛
a na´sladowanie pascalowej instrukcji
for i := a to b
do
, np.
range(3)
zwraca list˛e
[0, 1, 2]
.
Ostrze˙zenie: Pewna subtelno´s´c pojawia si˛e w przypadku, gdy sekwencja jest modyfikowana w trakcie wykony-
wania p˛etli (dotyczy to tylko sekwencji modyfikowalnych, np. list). Istniej ˛
aca implementacja p˛etli zapami˛e-
tuje numer aktualnie przetwarzanego elementu w postaci zwi˛ekszanego po ka˙zdej iteracji licznika (po zrównaniu
si˛e licznika z długo´sci ˛
a sekwencji nast˛epuje zako´nczenie wykonywania p˛etli). Oznacza to, ˙ze je´sli w trakcie
wykonywania p˛etli zostanie usuni˛ety bie˙z ˛
acy (lub jeden z wcze´sniejszych) element sekwencji, nast˛epny element
b˛edzie pomini˛ety. Podobnie, je´sli jakikolwiek element zostanie wstawiony przed bie˙z ˛
acym, bie˙z ˛
acy zostanie
u˙zyty ponownie w kolejnej iteracji. Przy odrobinie nieuwagi zachowanie to mo˙ze prowadzi´c do trudnych do
wykrycia bł˛edów, których najłatwiej unikn ˛
a´c poprzez utworzenie tymczasowej kopii sekwencji (w postaci wykro-
jenia wszystkich jej elementów), np.:
for x in a[:]:
if x < 0: a.remove(x)
7.4
Instrukcja
try
Instrukcja
try
definiuje kod obsługi wyj ˛
atków oraz (lub) kod oczyszczaj ˛
acy dla grupy instrukcji:
try_stmt
::=
try_exc_stmt | try_fin_stmt
try_exc_stmt
::=
"try" ":" suite
("except" [expression ["," target]] ":" suite)+
["else" ":" suite]
try_fin_stmt
::=
"try" ":" suite "finally" ":" suite
Istniej ˛
a dwie formy instrukcji
try
:
try
...
except
oraz
try
...
finally
. Nie mo˙zna ich ze sob ˛
a miesza´c (cho´c
mog ˛
a by´c w sobie zagnie˙zd˙zane).
Zapis
try
...
except
okre´sla jeden lub wi˛ecej bloków kodu obsługuj ˛
acych wyj ˛
atki (wewn ˛
atrz klauzul
except
).
Je´sli wewn ˛
atrz klauzuli
try
nie wyst ˛
api ˙zaden wyj ˛
atek, nie jest wykonywany zestaw z ˙zadnej z klauzul
except
.
W przeciwnym wypadku rozpoczyna si˛e poszukiwanie kodu obsługuj ˛
acego wyj ˛
atek. Polega ono na analizowaniu
kolejnych klauzul
except
do czasu odnalezienia takiej, która pasuje do wyj ˛
atku. Je´sli zostanie u˙zyta klauzula
except
bez zawartego w niej wyra˙zenia, musi si˛e ona pojawi´c jako ostatnia i pasuje do ka˙zdego wyj ˛
atku. Przy
pozostałych klauzulach nast˛epuje warto´sciowanie wyra˙zenia i klauzul˛e uznaje si˛e za pasuj ˛
ac ˛
a do wyj ˛
atku, je´sli
powstały w wyniku warto´sciowania obiekt jest „zgodny” z wyj ˛
atkiem. Zgodno´s´c rozumiana jest w ten sposób, ˙ze
obiekt musi by´c warto´sci ˛
a wyj ˛
atku, stanowi´c klas˛e bazow ˛
a dla klasy wyj ˛
atku (je´sli wyj ˛
atek jest klas ˛
a), albo te˙z
by´c krotk ˛
a zawieraj ˛
ac ˛
a element, który jest zgodny z wyj ˛
atkiem. Zwró´cmy uwag˛e, ˙ze pasowa´c musz ˛
a do siebie
to˙zsamo´sci obiektów, tzn. warto´sci wyra˙zenia i wyj ˛
atku musz ˛
a opisywa´c ten sam obiekt, nie za´s dwa obiekty o
takiej samej warto´sci.
W przypadku, gdy do wyj ˛
atku nie pasuje ˙zadna z klauzul
except
, poszukiwanie kodu obsługi wyj ˛
atku jest
kontynuowane w kodzie otaczaj ˛
acym instrukcj˛e
try
i na stosie wywoła´n.
Je´sli wyj ˛
atek wyst ˛
api przy warto´sciowaniu wyra˙zenia z nagłówka klauzuli
except
, poszukiwanie kodu obsługi
pierwotnego wyj ˛
atku jest przerywane i rozpoczyna si˛e wyszukiwanie kodu obsługi nowego wyj ˛
atku w kodzie
otaczaj ˛
acym i na stosie wywoła´n (cało´s´c przebiega tak, jakby wyj ˛
atek został wygenerowany przez cał ˛
a instrukcj˛e
try
).
Je´sli zostanie odnaleziona pasuj ˛
aca do wyj ˛
atku klauzula
except
, jego parametr jest przypisywany celowi
okre´slonemu w klauzuli (o ile cel został podany) i nast˛epuje wykonanie zestawu z klauzuli. Z ka˙zd ˛
a z klauzul
except
musi by´c zwi ˛
azany blok wykonywalny. Je´sli sterowanie osi ˛
agnie koniec tego bloku, w zwykły sposób
jest przekazywane za cał ˛
a instrukcj˛e
try
. (Oznacza to, ˙ze je´sli do pewnego wyj ˛
atku pasuj ˛
a dwie zagnie˙zd˙zone
klauzule
except
, a wyj ˛
atek wyst ˛
api w wewn˛etrznej klauzuli
try
, to wyj ˛
atek nie dotrze do zewn˛etrznej klauzuli
except
.)
Przed przyst ˛
apieniem do wykonywania zestawu z klauzuli
except
informacje na temat wyj ˛
atku s ˛
a przypisywane
trzem zmiennym z modułu
sys
:
sys.exc_type
zawiera obiekt identyfikuj ˛
acy wyj ˛
atek;
sys.exc_value
zawiera parametr wyj ˛
atku;
sys.exc_traceback
zawiera obiekt stanu stosu (patrz sekcja 3.2), który identy-
fikuje miejsce w programie, b˛ed ˛
ace ´zródłem wyj ˛
atku. Informacje te s ˛
a równie˙z dost˛epne za po´srednictwem funkcji
7.4. Instrukcja
try
61
sys.exc_info()
, która zwraca krotk˛e
(
exc_type
,
exc_value
,
exc_traceback
)
. Zalecane jest u˙zywanie
tej wła´snie funkcji; bezpo´sredni dost˛ep do zmiennych jest mechanizmem przestarzałym, gdy˙z nie funkcjonuje
poprawnie w programach u˙zywaj ˛
acych wielu w ˛
atków. Od Pythona w wersji 1.5 przy powrocie z funkcji, wewn ˛
atrz
której obsłu˙zono wyj ˛
atek zmiennym tym s ˛
a przywracane ich poprzednie warto´sci (sprzed wywołania).
Zestaw z opcjonalnej klauzuli
else
jest wykonywany, je´sli sterowanie osi ˛
agnie koniec zestawu z klauzuli
try
.
1
Wyj ˛
atki powstałe wewn ˛
atrz klauzuli
else
nie s ˛
a obsługiwane przez poprzedzaj ˛
ace j ˛
a klauzule
except
.
Posta´c
try
...
finally
instrukcji definiuje kod „oczyszczaj ˛
acy” dla grupy instrukcji. W takim wypadku w pier-
wszej kolejno´sci wykonywany zestaw z klauzuli
try
. Je´sli nie wyst ˛
api wyj ˛
atek, wykonywany jest zestaw z
klauzuli
finally
. Je´sli przy wykonywaniu zestawu z
try
wyj ˛
atek si˛e pojawi, jest on czasowo zapisywany,
wykonywany jest zestaw z klauzuli
finally
i dopiero wówczas ponownie generowany jest zapisany wyj ˛
atek.
Je´sli wyj ˛
atek pojawi si˛e w wyniku wykonania zestawu z klauzuli
finally
albo te˙z zostanie wewn ˛
atrz niego
u˙zyta instrukcja
return
lub
break
, zapisany wyj ˛
atek b˛edzie utracony. Wewn ˛
atrz klauzuli
finally
niedoz-
wolone jest u˙zycie instrukcji
continue
. (Przyczyna le˙zy w aktualnej implementacji instrukcji, w zwi ˛
azku z
czym ograniczenie mo˙ze zosta´c w przyszło´sci zniesione). Podczas wykonywania zestawu z klauzuli
finally
informacje o zapisanym wyj ˛
atku nie s ˛
a dost˛epne.
Wykonywanie wewn ˛
atrz zestawu z klauzuli
try
instrukcji
return
,
break
lub
continue
jest dopuszczalne,
jednak równie˙z w tym przypadku przed przekazaniem sterowania poza instrukcj˛e
try
wykonywany jest zestaw z
klauzuli
finally
. U˙zywanie
continue
wewn ˛
atrz klauzuli
finally
jest niedozwolone (jest to ograniczenie
implementacji, by´c mo˙ze zniknie ono w przyszło´sci).
Dodatkowe informacje na temat wyj ˛
atków mo˙zna odnale´z´c w sekcji 4.2, za´s informacje na temat generowania
wyj ˛
atków przy u˙zyciu instrukcji
raise
— w sekcji 7.4.
7.5
Definicje funkcji
Definicja funkcji definiuje obiekt funkcji zdefiniowanej przez u˙zytkownika (patrz sekcja 3.2):
funcdef
::=
"def" funcname "(" [parameter_list] ")" ":" suite
parameter_list
::=
(defparameter ",")*
("*" identifier [, "**" identifier]
| "**" identifier | defparameter [","])
defparameter
::=
parameter ["=" expression]
sublist
::=
parameter ("," parameter)* [","]
parameter
::=
identifier | "(" sublist ")"
funcname
::=
identifier
Definicja funkcji jest instrukcj ˛
a wykonywaln ˛
a. Jej wykonanie powoduje powi ˛
azanie nazwy funkcji w lokalnej
przestrzeni nazw z obiektem funkcji (owijaj ˛
acym wykonywalny kod funkcji). Obiekt ten zawiera odwołanie do
bie˙z ˛
acej globalnej przestrzeni nazw, u˙zywanej jako globalna przestrze´n nazw przy wykonywaniu kodu funkcji.
Definicja funkcji nie powoduje wykonania jej tre´sci. Tre´s´c funkcji jest wykonywana dopiero przy jej wywołaniu.
Je´sli przynajmniej jeden z głównych parametrów funkcji ma posta´c parametr
=
wyra˙zenie, mówimy o funkcji jako
o funkcji z „domy´slnymi warto´sciami parametrów”. W przypadku ka˙zdego parametru z warto´sci ˛
a domy´sln ˛
a przy
wywołaniu funkcji mo˙zemy pomin ˛
a´c odpowiadaj ˛
acy mu argument, co spowoduje u˙zycie zamiast niego domy´slnej
warto´sci parametru. Je´sli parametr ma warto´s´c domy´sln ˛
a, musz ˛
a j ˛
a mie´c równie˙z wszystkie parametry wyst˛epu-
j ˛
ace po nim — jest to ograniczenie składniowe, którego gramatyka nie obejmuje.
Wyra˙zenia opisuj ˛
ace domy´slne warto´sci argumentów s ˛
a warto´sciowane przy wykonywaniu definicji
funkcji. Oznacza to, ˙ze ka˙zde z wyra˙ze´n jest warto´sciowane tylko raz, przy definiowaniu funkcji, i przy ka˙zdym
wywołaniu u˙zywane s ˛
a te same „prekalkulowane” warto´sci. Szczególnie wa˙zne jest zrozumienie tego w przypad-
kach, kiedy domy´slna warto´s´c parametru jest obiektem zmiennym, np. list ˛
a lub słownikiem. Je´sli w takiej sytuacji
funkcja zmodyfikuje warto´s´c parametru (np. doł ˛
aczaj ˛
ac warto´s´c do listy), ulegnie jednocze´snie zmianie warto´s´c
domy´slna. Zwykle oczekiwany jest inny efekt. Jedn ˛
a z metod obej´scia problemu jest u˙zycie
None
jako warto´sci
domy´slnej i jawne sprawdzanie warto´sci argumentu w tre´sci funkcji, np.:
1
Aktualnie okre´slenie „sterowanie osi ˛
agnie koniec zestawu” wyklucza nast˛epuj ˛
ace przypadki: wyst ˛
apienie wyj ˛
atku, wykonanie instrukcji
return
,
continue
lub
break
.
62
Rozdział 7. Instrukcje zło˙zone
def whats_on_the_telly(penguin=None):
if penguin is None:
penguin = []
penguin.append("property of the zoo")
return penguin
Bardziej szczegółowy opis semantyki wywołania funkcji znajduje si˛e w sekcji 5.3.4. Wywołanie funkcji zawsze
powoduje przypisanie warto´sci wszystkim parametrom wymienionym na li´scie parametrów. Warto´sci pochodz ˛
a
albo z argumentów pozycyjnych, z argumentów nazwanych lub z ustalonych warto´sci domy´slnych. Je´sli obecny
jest zapis „
*identyfikator
”, to podany identyfikator jest inicjowany krotk ˛
a, zawieraj ˛
ac ˛
a wszystkie do-
datkowe argumenty (domy´slnie krotka jest pusta). Je´sli obecny jest zapis „
**identyfikator
”, to podany
identyfikator jest inicjowany now ˛
a warto´sci ˛
a słownikow ˛
a, zawieraj ˛
ac ˛
a wszystkie dodatkowe argumenty nazwane
(domy´slnie słownik jest pusty).
Mo˙zliwe jest równie˙z tworzenie funkcji nienazwanych (tj. funkcji, z którymi nie s ˛
a powi ˛
azane nazwy) celem
bezpo´sredniego u˙zycia w wyra˙zeniach. Definicje te powstaj ˛
a przy u˙zyciu form lambda, opisanych w sekcji 5.11.
Zwró´cmy uwag˛e, ˙ze forma lambda jest po prostu skrótem zapisu definicji funkcji; funkcja zdefiniowana za pomoc ˛
a
instrukcji „
def
” mo˙ze by´c przekazywana lub przypisywana innej nazwie dokładnie tak, jak funkcja zdefiniowana
przy u˙zyciu formy lambda. Definicja z u˙zyciem „
def
” daje w rzeczywisto´sci wi˛ecej mo˙zliwo´sci, poniewa˙z
pozwala na wykonywanie wielu instrukcji.
Uwaga dla programistów: Funkcje s ˛
a pełnowarto´sciowymi obiektami. Zapis „
def
” wewn ˛
atrz definicji funkcji
powoduje zdefiniowanie funkcji lokalnej, która, jak ka˙zdy obiekt funkcji, mo˙ze by´c przekazywana dalej. Wolne
nazwy wyst˛epuj ˛
ace w zagnie˙zd˙zonej funkcji mog ˛
a si˛e odwoływa´c do lokalnych nazw funkcji zawieraj ˛
acej jej
definicj˛e. Szczegóły na ten temat odnajdziesz w sekcji 4.1.
7.6
Definicje klas
Definicja klasy definiuje obiekt klasy (zobacz sekcja 3.2):
classdef
::=
"class" classname [inheritance] ":" suite
inheritance
::=
"(" [expression_list] ")"
classname
::=
identifier
Definicja klasy jest instrukcj ˛
a wykonywaln ˛
a. Przy jej wykonywaniu najpierw warto´sciowana jest lista dziedz-
iczenia (je´sli istnieje). Warto´sci ˛
a ka˙zdego jej elementu powinien by´c obiekt klasy. Nast˛epnie wykonywany
jest zestaw klasy w nowej ramce wykonania (patrz sekcja 4.1) przy wykorzystaniu nowoutworzonej lokalnej
przestrzeni nazw i oryginalnej globalnej przestrzeni nazw. Zwykle, cho´c nie musi to by´c reguł ˛
a, zestaw zawiera
tylko definicje funkcji. Po zako´nczeniu wykonywania zestawu klasy utworzona ramka wykonania jest usuwana,
lecz zachowywana jest lokalna przestrze´n nazw. W kolejnym kroku tworzony jest obiekt klasy przy u˙zyciu listy
dziedziczenia w roli listy klas bazowych oraz zachowanej lokalnej przestrzeni nazw jako słownika atrybutów. Z
obiektem tym w oryginalnej lokalnej przestrzeni nazw wi ˛
azana jest nazwa klasy.
Uwaga dla programistów: zmienne zdefiniowane wewn ˛
atrz definicji klasy s ˛
a zmiennymi klasy, dzielonymi
przez wszystkie jej egzemplarze. Aby zdefiniowa´c zmienn ˛
a egzemplarza, nale˙zy nada´c jej warto´s´c w metodzie
__init__()
lub dowolnej innej. Zarówno zmienne klasy, jak i zmienne egzemplarza s ˛
a dost˛epne przy u˙zyciu
zapisu „
self.nazwa
”, przy czym zmienne egzemplarza u˙zywane w ten sposób przykrywaj ˛
a zmienne klasy o
tych samych nazwach. Zmienne klasy o niezmiennych warto´sciach mog ˛
a by´c u˙zywane jako warto´sci domy´slne
dla zmiennych egzemplarza.
7.6. Definicje klas
63
64
ROZDZIAŁ
ÓSMY
Elementy nadrz ˛edne
Interpreter Pythona mo˙ze odczytywa´c wej´scie z jednego z wielu ´zródeł: ze skryptu przekazanego na standar-
dowym wej´sciu lub w postaci argumentu w wierszu polecenia, z wej´scia interaktywnego, z pliku ´zródłowego
modułu, itp. Poni˙zszy rozdział opisuje składni˛e, która jest u˙zywana w ka˙zdym z tych przypadków.
8.1
Pełne programy w Pythonie
Cho´c specyfikacja j˛ezyka nie musi precyzowa´c sposobu uruchamiania interpretera, w pewnych sytuacjach przy-
datne jest wprowadzenie poj˛ecia pełnego programu w Pythonie. Pełny program w Pythonie jest wykonywany w
´srodowisku zainicjowanym w minimalnym stopniu: dost˛epne s ˛
a wszystkie moduły standardowe i wbudowane,
lecz ˙zadne nie s ˛
a zainicjowane, za wyj ˛
atkiem
sys
(oferuj ˛
acego ró˙zne usługi systemowe),
__builtin__
(z
wbudowanymi funkcjami, wyj ˛
atkami i definicj ˛
a
None
) oraz
__main__
(udost˛epniaj ˛
acego lokaln ˛
a i globaln ˛
a
przestrze´n nazw przy wykonywaniu pełnego programu).
Składnia pełnego programu w Pythonie jest taka, jak opisana w dalszej cz˛e´sci dla wej´scia z pliku.
Mo˙zliwe jest równie˙z uruchamianie interpretera w trybie interaktywnym. W tym przypadku nie odczytuje on ani
nie wykonuje pełnego programu, lecz kolejno odczytuje i wykonuje pojedyncze instrukcje (by´c mo˙ze zło˙zone).
´Srodowisko pocz ˛atkowe jest takie same, jak przy wykonywaniu pełnego programu, ka˙zda instrukcja jest wykony-
wana w przestrzeni nazw modułu
__main__
.
W systemach uniksowych mo˙zna przekaza´c interpreterowi pełny program na trzy sposoby: przy u˙zyciu opcji -c
napis wiersza polecenia, w postaci nazwy pliku, przekazanej jako pierwszy argument wiersza polecenia lub na
standardowym wej´sciu interpretera. Je´sli przekazany plik lub standardowe wej´scie jest urz ˛
adzeniem tty, interpreter
przechodzi w tryb interaktywny, w przeciwnym wypadku wykonuje plik (lub napis) jako pełny program.
8.2
Wej´scie z pliku
Wszystkie dane wej´sciowe dla interpretera, odczytywane z plików w trybie nieinteraktywnym, maj ˛
a t˛e sam ˛
a
posta´c:
file_input
::=
(NEWLINE | statement)*
Składnia ta jest u˙zywana w nast˛epuj ˛
acych sytuacjach:
• przy analizie składniowej pełnego programu w Pythonie (uzyskanego z pliku lub napisu);
• przy analizie składniowej modułu;
• przy analizie składniowej napisu przekazanego w instrukcji
exec
;
8.3
Wej´scie w trybie interaktywnym
Wej´scie w trybie interaktywnym jest analizowane przy u˙zyciu nast˛epuj ˛
acej gramatyki:
65
interactive_input
::=
[stmt_list] NEWLINE | compound_stmt NEWLINE
Zwracamy uwag˛e, i˙z w trybie interaktywnym po (głównym) wyra˙zeniu zło˙zonym musi si˛e pojawi´c pusty wiersz.
Wymóg ten narzuca parser, który wykrywa w ten sposób koniec danych na wej´sciu.
8.4
Wej´scie przy analizie wyra˙ze ´n
Przy analizie wyra˙ze´n mo˙zliwe s ˛
a dwie postaci wej´scia. W obu pocz ˛
atkowe odst˛epy s ˛
a ignorowane. Argument
napisowy przekazywany funkcji
eval()
musi mie´c posta´c:
eval_input
::=
expression_list NEWLINE*
Wiersz wej´sciowy odczytywany przez funkcj˛e
input()
musi mie´c posta´c:
input_input
::=
expression_list NEWLINE
Uwaga: aby odczyta´c wiersz wej´sciowy w postaci „surowej”, bez interpretacji, mo˙zesz u˙zy´c wbudowanej funkcji
raw_input()
lub metody obiektów plikowych o nazwie
readline()
.
66
Rozdział 8. Elementy nadrz ˛edne
DODATEK
A
Historia i licencja
A.1
Historia programu
Python powstał we wczesnych latach 90. dwudziestego wieku jako nast˛epca j˛ezyka o nazwie ABC. Stworzył
go Guido van Rossum z Stichting Mathematisch Centrum (CWI, patrz
http://www.cwi.nl/
) w Holandii. Guido
pozostaje najwa˙zniejszym autorem Pythona, cho´c obecnie w pracach nad rozwojem projektu uczestniczy wiele
innych osób.
W 1995 roku Guido kontynuował swoj ˛
a prac˛e w organizacji Corporation for National Research Initiatives (CNRI,
patrz
http://www.cnri.reston.va.us/
) w Reston (USA, stan Virginia), podczas której wydał kilka kolejnych wersji
programu.
W maju 2000 roku Guido wraz z rdzeniem zespołu twórców Pythona przenie´sli si˛e do BeOpen.com, tworz ˛
ac
tam zespół BeOpen PythonLabs. W pa´zdzierniku tego samego roku zespół PythonLabs przeniósł si˛e do firmy
Digital Creations (obecnie Zope Corporation, patrz
http://www.zope.com/
). W 2001 roku została utworzona fun-
dacja Python Software Foundation (PSF, patrz
http://www.python.org/psf/
) — niedochodowa organizacja, podstała
przede wszystkim jako wła´sciciel dorobku intelektualnego zwi ˛
azanego z Pythonem. Firma Zope Corporation jest
sponsoruj ˛
acym członkiem fundacji PSF.
Wszystkie wydania Pythona nale˙z ˛
a do kategorii oprogramowania Open Source (aby pozna´c definicj˛e Open
Source, zajrzyj na witryn˛e
http://www.opensource.org/
). Ponadto wi˛ekszo´s´c z nich (cho´c nie wszystkie) była
zgodna z licencj ˛
a GPL. Zestawienie kolejnych wyda´n Pythona przedstawia poni˙zsza tabela.
Wydanie
Oparte na
Rok
Wła´sciciel
Zgodne z GPL?
0.9.0 do 1.2
b/d
1991-1995
CWI
tak
1.3 do 1.5.2
1.2
1995-1999
CNRI
tak
1.6
1.5.2
2000
CNRI
nie
2.0
1.6
2000
BeOpen.com
nie
1.6.1
1.6
2001
CNRI
nie
2.1
2.0+1.6.1
2001
PSF
nie
2.0.1
2.0+1.6.1
2001
PSF
tak
2.1.1
2.1+2.0.1
2001
PSF
tak
2.2
2.1.1
2001
PSF
tak
2.1.2
2.1.1
2002
PSF
tak
2.1.3
2.1.2
2002
PSF
tak
2.2.1
2.2
2002
PSF
tak
Notka: Okre´slenie „Zgodne z GPL” nie oznacza, ˙ze wydanie Pythona nast ˛
apiło na warunkach licencji GPL.
Wszystkie licencje Pythona, w odró˙znieniu od licencji GPL, pozwalaj ˛
a na rozpowszechnianie zmodyfikowanych
wersji oprogramowania bez udost˛epniania modyfikacji w postaci ´zródłowej. Licencja zgodna z GPL umo˙zliwia
natomiast ł ˛
aczenie Pythona z innym oprogramowaniem, które jest rozpowszechniane na licencji GPL (w przy-
padku licencji niezgodnej z GPL byłoby to niedozwolone.
Podzi˛ekowania nale˙z ˛
a si˛e wielu wolontariuszom z zewn ˛
atrz, którzy, pracuj ˛
ac pod kierunkiem Guido, doprowadzili
do tych wszystkich wyda´n Pythona.
67
A.2
Warunki dost ˛epu do Pythona lub korzystania z niego w inny
sposób
PSF LICENSE AGREEMENT FOR PYTHON 2.3
1. This LICENSE AGREEMENT is between the Python Software Foundation (“PSF”), and the Individual or
Organization (“Licensee”) accessing and otherwise using Python 2.3 software in source or binary form and
its associated documentation.
2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclu-
sive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare
derivative works, distribute, and otherwise use Python 2.3 alone or in any derivative version, provided, how-
ever, that PSF’s License Agreement and PSF’s notice of copyright, i.e., “Copyright c
2001, 2002 Python
Software Foundation; All Rights Reserved” are retained in Python 2.3 alone or in any derivative version
prepared by Licensee.
3. In the event Licensee prepares a derivative work that is based on or incorporates Python 2.3 or any part
thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby
agrees to include in any such work a brief summary of the changes made to Python 2.3.
4. PSF is making Python 2.3 available to Licensee on an “AS IS” basis. PSF MAKES NO REPRESEN-
TATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMI-
TATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MER-
CHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON
2.3 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.3 FOR ANY
INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODI-
FYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.3, OR ANY DERIVATIVE THEREOF,
EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or
joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF
trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or
any third party.
8. By copying, installing or otherwise using Python 2.3, Licensee agrees to be bound by the terms and condi-
tions of this License Agreement.
BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
1. This LICENSE AGREEMENT is between BeOpen.com (“BeOpen”), having an office at 160 Saratoga
Avenue, Santa Clara, CA 95051, and the Individual or Organization (“Licensee”) accessing and otherwise
using this software in source or binary form and its associated documentation (“the Software”).
2. Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants Li-
censee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display
publicly, prepare derivative works, distribute, and otherwise use the Software alone or in any derivative
version, provided, however, that the BeOpen Python License is retained in the Software, alone or in any
derivative version prepared by Licensee.
3. BeOpen is making the Software available to Licensee on an “AS IS” basis. BEOPEN MAKES NO REP-
RESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT
LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
68
Dodatek A. Historia i licencja
4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE
FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT
OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF,
EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
5. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of
California, excluding conflict of law provisions. Nothing in this License Agreement shall be deemed to
create any relationship of agency, partnership, or joint venture between BeOpen and Licensee. This License
Agreement does not grant permission to use BeOpen trademarks or trade names in a trademark sense to
endorse or promote products or services of Licensee, or any third party. As an exception, the “BeOpen
Python” logos available at http://www.pythonlabs.com/logos.html may be used according to the permissions
granted on that web page.
7. By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and
conditions of this License Agreement.
CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an
office at 1895 Preston White Drive, Reston, VA 20191 (“CNRI”), and the Individual or Organization (“Li-
censee”) accessing and otherwise using Python 1.6.1 software in source or binary form and its associated
documentation.
2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a nonexclu-
sive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare
derivative works, distribute, and otherwise use Python 1.6.1 alone or in any derivative version, provided,
however, that CNRI’s License Agreement and CNRI’s notice of copyright, i.e., “Copyright c
1995-2001
Corporation for National Research Initiatives; All Rights Reserved” are retained in Python 1.6.1 alone
or in any derivative version prepared by Licensee. Alternately, in lieu of CNRI’s License Agreement,
Licensee may substitute the following text (omitting the quotes): “Python 1.6.1 is made available sub-
ject to the terms and conditions in CNRI’s License Agreement. This Agreement together with Python
1.6.1 may be located on the Internet using the following unique, persistent identifier (known as a handle):
1895.22/1013. This Agreement may also be obtained from a proxy server on the Internet using the following
URL:
http://hdl.handle.net/1895.22/1013
.”
3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6.1 or any part
thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby
agrees to include in any such work a brief summary of the changes made to Python 1.6.1.
4. CNRI is making Python 1.6.1 available to Licensee on an “AS IS” basis. CNRI MAKES NO REPRESEN-
TATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMI-
TATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MER-
CHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON
1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY
INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFY-
ING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE THEREOF,
EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
7. This License Agreement shall be governed by the federal intellectual property law of the United States, in-
cluding without limitation the federal copyright law, and, to the extent such U.S. federal law does not apply,
by the law of the Commonwealth of Virginia, excluding Virginia’s conflict of law provisions. Notwithstand-
ing the foregoing, with regard to derivative works based on Python 1.6.1 that incorporate non-separable
material that was previously distributed under the GNU General Public License (GPL), the law of the Com-
monwealth of Virginia shall govern this License Agreement only as to issues arising under or with respect
to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this License Agreement shall be deemed to
A.2. Warunki dost ˛epu do Pythona lub korzystania z niego w inny sposób
69
create any relationship of agency, partnership, or joint venture between CNRI and Licensee. This License
Agreement does not grant permission to use CNRI trademarks or trade name in a trademark sense to endorse
or promote products or services of Licensee, or any third party.
8. By clicking on the “ACCEPT” button where indicated, or by copying, installing or otherwise using Python
1.6.1, Licensee agrees to be bound by the terms and conditions of this License Agreement.
ACCEPT
CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
Copyright c
1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands. All rights reserved.
Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee
is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice
and this permission notice appear in supporting documentation, and that the name of Stichting Mathematisch
Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software without specific,
written prior permission.
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT
OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TOR-
TIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
70
Dodatek A. Historia i licencja
INDEKS
Symbole
´scie˙zka
wyszukiwania modułów, 56
´srodowisko, 33
ł ˛
acz ˛
ace
or, 45
ł ˛
aczenie wierszy, 3, 4
ł ˛
aczone
porównania, 45
__abs__()
(metoda klasy obiektu liczbowego),
31
__add__()
(metoda klasy obiektu liczbowego),
29
__add__()
(metoda obiektu sekwencyjnego), 27
__all__
(opcjonalny atrybut modułu), 56
__and__()
(metoda klasy obiektu liczbowego),
30
__bases__
(atrybut klasy), 19
__builtin__
(moduł wbudowany), 58, 65
__builtins__
, 58
__call__()
(metoda klasy obiektu), 27
__call__()
(metoda obiektu), 43
__class__
(atrybut instancji), 19
__cmp__()
(metoda klasy obiektu), 23
__cmp__()
(metoda obiektu), 23
__coerce__()
(metoda
klasy
obiektu
liczbowego), 31
__coerce__()
(metoda obiektu liczbowego), 27
__complex__()
(metoda
klasy
obiektu
liczbowego), 31
__contains__()
(metoda klasy obiektu konten-
erowego), 28
__contains__()
(metoda
obiektu
odw-
zorowawczego), 27
__contains__()
(metoda
obiektu
sekwen-
cyjnego), 27
__debug__
, 50
__del__()
(metoda klasy obiektu), 21
__delattr__()
(metoda klasy obiektu), 24
__delete__()
(metoda klasy obiektu), 24
__delitem__()
(metoda klasy obiektu konten-
erowego), 28
__delslice__()
(metoda klasy obiektu sek-
wencji), 29
__dict__
(atrybut funkcji), 17
__dict__
(atrybut instancji), 19, 24
__dict__
(atrybut klasy), 19
__dict__
(atrybut modułu), 18
__div__()
(metoda klasy obiektu liczbowego),
30
__divmod__()
(metoda
klasy
obiektu
liczbowego), 29
__doc__
(atrybut funkcji), 17
__doc__
(atrybut klasy), 19
__doc__
(atrybut metody), 17
__doc__
(atrybut modułu), 18
__eq__()
(metoda klasy obiektu), 22
__file__
(atrybut modułu), 18
__float__()
(metoda
klasy
obiektu
liczbowego), 31
__floordiv__()
(metoda
klasy
obiektu
liczbowego), 29
__ge__()
(metoda klasy obiektu), 22
__get__()
(metoda klasy obiektu), 24
__getattr__()
(metoda klasy obiektu), 23
__getattribute__()
(metoda klasy obiektu),
24
__getitem__()
(metoda klasy obiektu konten-
erowego), 27
__getitem__()
(metoda
obiektu
odw-
zorowawczego), 21
__getslice__()
(metoda klasy obiektu sek-
wencji), 28
__gt__()
(metoda klasy obiektu), 22
__hash__()
(metoda klasy obiektu), 23
__hex__()
(metoda klasy obiektu liczbowego),
31
__iadd__()
(metoda klasy obiektu liczbowego),
30
__iadd__()
(metoda obiektu sekwencyjnego), 27
__iand__()
(metoda klasy obiektu liczbowego),
30
__idiv__()
(metoda klasy obiektu liczbowego),
30
__ifloordiv__()
(metoda
klasy
obiektu
liczbowego), 30
__ilshift__()
(metoda
klasy
obiektu
liczbowego), 30
__imod__()
(metoda klasy obiektu liczbowego),
30
__import__()
(funkcja wbudowana), 56
71
__imul__()
(metoda klasy obiektu liczbowego),
30
__imul__()
(metoda obiektu sekwencyjnego), 27
__init__()
(metoda klasy obiektu), 21
__init__()
(atrybut obiektu), 18
__init__.py
, 56
__int__()
(metoda klasy obiektu liczbowego),
31
__invert__()
(metoda
klasy
obiektu
liczbowego), 31
__ior__()
(metoda klasy obiektu liczbowego),
30
__ipow__()
(metoda klasy obiektu liczbowego),
30
__irshift__()
(metoda
klasy
obiektu
liczbowego), 30
__isub__()
(metoda klasy obiektu liczbowego),
30
__iter__()
(metoda klasy obiektu konten-
erowego), 28
__iter__()
(metoda obiektu sekwencyjnego), 27
__itruediv__()
(metoda
klasy
obiektu
liczbowego), 30
__ixor__()
(metoda klasy obiektu liczbowego),
30
__le__()
(metoda klasy obiektu), 22
__len__()
(metoda
klasy
obiektu
konten-
erowego), 27
__len__()
(metoda obiektu odwzorowawczego),
23
__long__()
(metoda klasy obiektu liczbowego),
31
__lshift__()
(metoda
klasy
obiektu
liczbowego), 29
__lt__()
(metoda klasy obiektu), 22
__main__
(moduł wbudowany), 34, 65
__metaclass__
(w module ), 26
__mod__()
(metoda klasy obiektu liczbowego),
29
__module__
(atrybut funkcji), 17
__module__
(atrybut klasy), 19
__module__
(atrybut metody), 17
__mul__()
(metoda klasy obiektu liczbowego),
29
__mul__()
(metoda obiektu sekwencyjnego), 27
__name__
(atrybut funkcji), 17
__name__
(atrybut klasy), 19
__name__
(atrybut metody), 17
__name__
(atrybut modułu), 18
__ne__()
(metoda klasy obiektu), 22
__neg__()
(metoda klasy obiektu liczbowego),
31
__nonzero__()
(metoda klasy obiektu), 23
__nonzero__()
(metoda obiektu), 27
__oct__()
(metoda klasy obiektu liczbowego),
31
__or__()
(metoda klasy obiektu liczbowego), 30
__pos__()
(metoda klasy obiektu liczbowego),
31
__pow__()
(metoda klasy obiektu liczbowego),
29
__radd__()
(metoda klasy obiektu liczbowego),
30
__radd__()
(metoda obiektu sekwencyjnego), 27
__rand__()
(metoda klasy obiektu liczbowego),
30
__rcmp__()
(metoda klasy obiektu), 23
__rdiv__()
(metoda klasy obiektu liczbowego),
30
__rdivmod__()
(metoda
klasy
obiektu
liczbowego), 30
__repr__()
(metoda klasy obiektu), 22
__rfloordiv__()
(metoda
klasy
obiektu
liczbowego), 30
__rlshift__()
(metoda
klasy
obiektu
liczbowego), 30
__rmod__()
(metoda klasy obiektu liczbowego),
30
__rmul__()
(metoda klasy obiektu liczbowego),
30
__rmul__()
(metoda obiektu sekwencyjnego), 27
__ror__()
(metoda klasy obiektu liczbowego),
30
__rpow__()
(metoda klasy obiektu liczbowego),
30
__rrshift__()
(metoda
klasy
obiektu
liczbowego), 30
__rshift__()
(metoda
klasy
obiektu
liczbowego), 29
__rsub__()
(metoda klasy obiektu liczbowego),
30
__rtruediv__()
(metoda
klasy
obiektu
liczbowego), 30
__rxor__()
(metoda klasy obiektu liczbowego),
30
__set__()
(metoda klasy obiektu), 24
__setattr__()
(metoda klasy obiektu), 24
__setattr__()
(metoda obiektu), 24
__setitem__()
(metoda klasy obiektu konten-
erowego), 28
__setslice__()
(metoda klasy obiektu sek-
wencji), 28
__slots__
(w module ), 25
__str__()
(metoda klasy obiektu), 22
__sub__()
(metoda klasy obiektu liczbowego),
29
__truediv__()
(metoda
klasy
obiektu
liczbowego), 30
__unicode__()
(metoda klasy object), 23
__xor__()
(metoda klasy obiektu liczbowego),
30
A
abs()
(funkcja wbudowana), 31
analiza leksykalna, 3
and
72
Indeks
bitowe, 45
and
operator, 47
apostrofy
odwrócone, 22, 39
append()
(metoda obiektu sekwencyjnego), 27
argument
funkcji, 16
array
(moduł standardowy), 16
arytmetyczna
konwersja, 37
arytmetyczne
dwuargumentowe operacje, 43
jednoargumentowe operacje, 43
ASCII
, 2, 7, 8, 11, 15
asercje
debugowania, 49
assert
instrukcja, 49
AssertionError
wyj ˛
atek, 50
atom, 37
atrybut, 14
instancji klasy, 19
klasy, 19
podstawowy specjalny, 14
specjalny, 14
atrybutu
instancji klasy, przypisanie, 19
klasy, przypisanie, 19
odwołanie do, 40
przypisanie, 50
usuni˛ecie, 53
AttributeError
wyj ˛
atek, 40
B
bł˛edy, 35
bajt, 15
bitowe
and, 45
dwuargumentowe operacje, 45
jednoargumentowe operacje, 43
or, 45
xor, 45
blok, 33
blok kodu, 33
BNF, 1, 37
break
instrukcja, 55, 60, 62
bsddb
(moduł standardowy), 16
C
C, 8
j˛ezyk, 14, 15, 18, 45
całkowitoliczbowa
reprezentacja, 15
całkowitoliczbowy
obiekt, 14
cel, 50
usuni˛ecia, 52
celów
lista, 50, 60
przypisania, lista, 50
usuni˛ecia, lista, 52
chr()
(funkcja wbudowana), 15
class
instrukcja, 63
clear()
(metoda obiektu odwzorowawczego), 27
cmp()
(funkcja wbudowana), 23
co_argcount
(atrybut obiektu kodu), 20
co_cellvars
(atrybut obiektu kodu), 20
co_code
(atrybut obiektu kodu), 20
co_consts
(atrybut obiektu kodu), 20
co_filename
(atrybut obiektu kodu), 20
co_firstlineno
(atrybut obiektu kodu), 20
co_flags
(atrybut obiektu kodu), 20
co_freevars
(atrybut obiektu kodu), 20
co_lnotab
(atrybut obiektu kodu), 20
co_name
(atrybut obiektu kodu), 20
co_names
(atrybut obiektu kodu), 20
co_nlocals
(atrybut obiektu kodu), 20
co_stacksize
(atrybut obiektu kodu), 20
co_varnames
(atrybut obiektu kodu), 20
compile()
(funkcja wbudowana), 58
complex()
(funkcja wbudowana), 31
continue
instrukcja, 55, 60, 62
copy()
(metoda obiektu odwzorowawczego), 27
count()
(metoda obiektu sekwencyjnego), 27
D
długi całkowitoliczbowy
obiekt, 14
długi literał całkowitoliczbowy, 9
dana, 13, 39
danych
niezmienny typ, 38
typ, 14
dbm
(moduł standardowy), 16
debugowania
asercje, 49
def
instrukcja, 62
definicja
funkcji, 53, 62
klasy, 53, 63
definicje leksykalne, 2
del
instrukcja, 16, 22, 52
destruktor, 21, 51
divmod()
(funkcja wbudowana), 30
dodawanie, 44
domy´slna
warto´s´c parametru, 62
dowi ˛
azanie
Indeks
73
nazwy, 33, 50, 55, 56, 62, 63
dwuargumentowe
operacje arytmetyczne, 43
operacje bitowe, 45
dziedziczenie, 63
dzielenie, 44
E
EBCDIC, 15
egzemplarza
obiekt, 43
wywołanie, 43
egzemplarza klasy
obiekt, 43
wywołanie, 43
element
napisu, 40
sekwencji, 40
element podstawowy, 39
element uj˛ety w nawiasy, 38
elif
słowo kluczowe, 60
Ellipsis
obiekt, 14
else
wisz ˛
ace, 59
else
słowo kluczowe, 55, 60, 62
eval()
(funkcja wbudowana), 58, 66
exc_info
(w module sys), 20
exc_traceback
(w module sys), 20, 62
exc_type
(w module sys), 62
exc_value
(w module sys), 62
except
słowo kluczowe, 61
exec
instrukcja, 58
execfile()
(funkcja wbudowana), 58
extend()
(metoda obiektu sekwencyjnego), 27
F
f_back
(atrybut ramki), 20
f_builtins
(atrybut ramki), 20
f_code
(atrybut ramki), 20
f_exc_traceback
(atrybut ramki), 20
f_exc_type
(atrybut ramki), 20
f_exc_value
(atrybut ramki), 20
f_globals
(atrybut ramki), 20
f_lasti
(atrybut ramki), 20
f_lineno
(atrybut ramki), 20
f_locals
(atrybut ramki), 20
f_restricted
(atrybut ramki), 20
f_trace
(atrybut ramki), 20
False
, 15
finally
słowo kluczowe, 53, 55, 62
float()
(funkcja wbudowana), 31
for
instrukcja, 55, 60
forma
lambda, 47, 63
forma drukowalna
krotki, 38
listy, 38
słownika, 39
from
instrukcja, 33, 56
słowo kluczowe, 55, 56
func_closure
(atrybut funkcji), 17
func_code
(atrybut funkcji), 17
func_defaults
(atrybut funkcji), 17
func_dict
(atrybut funkcji), 17
func_doc
(atrybut funkcji), 17
func_globals
(atrybut funkcji), 17
funkcja
generuj ˛
aca, 54
nienazwane, 47
zdefiniowana przez u˙zytkownika, 16
funkcji
argument, 16
definicja, 53, 62
nazwa, 62
obiekt, 16, 18, 42, 62
wywołanie, 16, 42
zdefiniowanej przez u˙zytkownika, wywołanie,
42
funkcji wbudowanej
obiekt, 18
funkcji zdefiniowanej przez u˙zytkownika
obiekt, 16, 42, 62
future
instrukcja, 56
G
gdbm
(moduł standardowy), 16
generatora
obiekt, 20
generowanie
wyj ˛
atku, 54
generowanie wyj ˛
atku, 35
generuj ˛
aca
funkcja, 18, 54
generuj ˛
acy
iterator, 18, 54
get()
(metoda obiektu odwzorowawczego), 27
global
instrukcja, 51, 52, 57
globalna
przestrze´n nazw, 17
globalne
wi ˛
azanie nazw, 57
globals()
(funkcja wbudowana), 58
gramatyka, 1
grupowanie, 5
grupowanie instrukcji, 5
74
Indeks
H
has_key()
(metoda obiektu odwzorowawczego),
27
hash()
(funkcja wbudowana), 23
hex()
(funkcja wbudowana), 31
hierarchia
typów, 14
hierarchiczne
nazwy modułów, 56
I
id()
(funkcja wbudowana), 13
identyfikator, 6, 37
if
instrukcja, 60
im_class
(atrybut metody), 17
im_func
(atrybut metody), 17
im_self
(atrybut metody), 17
import
instrukcja, 18, 55
ImportError
wyj ˛
atek, 56
importowanie
modułu, 55
in
operator, 46
słowo kluczowe, 60
indeksu
przypisanie, 51
index()
(metoda obiektu sekwencyjnego), 27
indices()
(metoda klasy wykrojenia), 21
initialization
module, 56
input()
(funkcja wbudowana), 66
insert()
(metoda obiektu sekwencyjnego), 27
instancja
klasy, 19
wywołania, 27
instancji
obiekt, 18, 19
instancji klasy
atrybut, 19
obiekt, 18, 19
przypisanie atrybutu, 19
instrukcja
assert
, 49
break
, 55, 60, 62
class
, 63
continue
, 55, 60, 62
def
, 62
del
, 16, 22, 52
exec
, 58
for
, 55, 60
from
, 33, 56
future, 56
global
, 51, 52, 57
if
, 60
import
, 18, 55
modyfikuj ˛
acego przypisania, 52
p˛etli, 55, 60
pass
, 52
, 22, 53
prosta, 49
przypisania, 16, 50
raise
, 54
return
, 53, 62
try
, 20, 61
while
, 55, 60
wyra˙zeniowa, 49
yield
, 54
zło˙zona, 59
int()
(funkcja wbudowana), 31
interpreter, 65
inwersja, 43
is
operator, 46
is not
operator, 46
items()
(metoda obiektu odwzorowawczego), 27
iteritems()
(metoda
obiektu
odw-
zorowawczego), 27
iterkeys()
(metoda
obiektu
odw-
zorowawczego), 27
itervalues()
(metoda
obiektu
odw-
zorowawczego), 27
J
j˛ezyk
C, 14, 15, 18, 45
Java, 15
Pascal, 61
Java
j˛ezyk, 15
jednoargumentowe
operacje arytmetyczne, 43
operacje bitowe, 43
jednoelementowa
krotka, 16
K
keys()
(metoda obiektu odwzorowawczego), 27
klasy
atrybut, 19
definicja, 53, 63
instancja, 19
konstruktor, 21
nazwa, 63
obiekt, 18, 19, 43, 63
przypisanie atrybutu, 19
klauzula, 59
klucz, 39
ko´nca wiersza
pomini˛ecie, 53
ko´ncowy
przecinek, 47, 53
kod bajtowy, 19
Indeks
75
kod obsługi wyj ˛
atku, 35
kod obsługuj ˛
acy
wyj ˛
atku, 20
kodu
obiekt, 19
kolejno´s´c
warto´sciowania, 47
komentarz, 4
konstruktor
klasy, 21
kontener, 14, 19
kontynuacja wiersza, 4
konwersja
arytmetyczna, 37
napisowa, 22, 39, 49
krotka
jednoelementowa, 16
pusta, 16, 38
krotki
forma drukowalna, 38
obiekt, 16, 40, 47
L
lambda
forma, 47, 63
wyra˙zenie, 47
last_traceback
(w module sys), 20
len()
(funkcja wbudowana), 15, 16, 27
liczba, 9
zespolona, 15
zmiennoprzecinkowa, 15
liczba całkowita, 16
liczbowy
obiekt, 14, 19
liczenie odwoła´n, 13
list
wytworniki, 38, 39
lista
celów, 50, 60
celów przypisania, 50
celów usuni˛ecia, 52
pusta, 39
wyra˙ze´n, 47, 49, 50
listy
forma drukowalna, 38
obiekt, 16, 39, 40, 51
literał, 7, 38
zespolony, 9
literał ósemkowy, 9
literał całkowitoliczbowy, 9
literał dziesi˛etny, 9
literał liczbowy, 9
literał napisowy, 7
literał szesnastkowy, 9
literał urojony, 9
literał zmiennoprzecinkowy, 9
locals()
(funkcja wbudowana), 58
logiczna
operacja, 46
logiczny
obiekt, 15
long()
(funkcja wbudowana), 31
M
maglowanie
nazw, 38
makefile()
(metoda gniazda), 19
metoda
wbudowana, 18
zdefiniowana przez u˙zytkownika, 17
metody
obiekt, 17, 18, 42
wywołanie, 42
metody zdefiniowanej przez u˙zytkownika
obiekt, 17
minus, 43
mno˙zenie, 44
model wykonania, 33
moduł
rozszerzenia, 14
wbudowany, 56
zdefiniowany przez u˙zytkownika, 56
modułów
´scie˙zka wyszukiwania, 56
hierarchiczne nazwy, 56
modułu
importowanie, 55
nazwa, 56
obiekt, 18, 40
przestrze´n nazw, 18
module
initialization, 56
modules
(w module sys), 56
modulo, 44
modyfikuj ˛
ace
przypisanie, 52
N
NameError
wyj ˛
atek, 38
NameError
(wbudowany wyj ˛
atek), 33
napis
Unicode, 7
napis dokumentuj ˛
acy, 20
napisowa
konwersja, 22, 39, 49
napisu
element, 40
obiekt, 15, 40
porównanie, 15
nazw
globalne wi ˛
azanie, 57
maglowanie, 38
nazwa, 6, 37
funkcji, 62
klasy, 63
76
Indeks
modułu, 56
wolna, 33
nazwy
dowi ˛
azanie, 33, 50, 55, 56, 62, 63
modułów, hierarchiczne, 56
prywatne, 38
usuni˛ecie dowi ˛
azania, 52
wi ˛
azanie, 55
zmiana dowi ˛
azania, 50
nazwy pliku
rozszerzenie, 56
negacja, 43
nienazwane
funkcja, 47
nierozpoznana sekwencja specjalna, 8
niewznawialny model, 35
niezmiennej sekwencji
obiekt, 15
niezmienny
obiekt, 15, 38, 39
typ danych, 38
None
, 14, 49
obiekt, 14
not
operator, 47
not in
operator, 46
notacja, 1
NotImplemented
, 14
obiekt, 14
O
obiekt, 13
całkowitoliczbowy, 14
długi całkowitoliczbowy, 14
egzemplarza, 43
egzemplarza klasy, 43
Ellipsis, 14
funkcji, 16, 18, 42, 62
funkcji wbudowanej, 18
funkcji zdefiniowanej przez u˙zytkownika, 16,
42, 62
generatora, 20
instancji, 18, 19
instancji klasy, 18, 19
klasy, 18, 19, 43, 63
kodu, 19
krotki, 16, 40, 47
liczbowy, 14, 19
listy, 16, 39, 40, 51
logiczny, 15
metody, 17, 18, 42
metody zdefiniowanej przez u˙zytkownika, 17
modułu, 18, 40
napisu, 15, 40
niezmiennej sekwencji, 15
niezmienny, 15, 38, 39
None
, 14
NotImplemented
, 14
odwzorowawczy, 16, 19, 40, 51
plikowy, 19, 66
ramki, 20
rekurencyjny, 39
słownika, 16, 19, 23, 39, 40, 51
sekwencji, 15, 19, 40, 46, 51, 60
stanu stosu, 20, 54, 61
unicode, 16
wbudowanej funkcji, 42
wbudowanej metody, 18, 42
wykrojenia, 27
wywoływalny, 16, 41
zespolony, 15
zmiennej sekwencji, 16
zmiennoprzecinkowy, 15
zmienny, 16, 50, 51
zwykły całkowitoliczbowy, 14
obiekt nieosi ˛
agalny, 13
obiekt niezmienny, 13
obiekt zmienny, 13
obiektu klasy
wywołanie, 18, 19, 43
obsługa bł˛edów, 35
obsługa wyj ˛
atku, 35
oct()
(funkcja wbudowana), 31
od´smiecanie, 13
odejmowanie, 44
odst˛ep, 5
odwołanie do
atrybutu, 40
odwołanie do indeksu, 16, 40
odwrócone
apostrofy, 22, 39
odwrócone apostrofy, 22, 39
odwzorowawczy
obiekt, 16, 19, 40, 51
ograniczone
wykonanie, 34
open()
(funkcja wbudowana), 19
operacja
logiczna, 46
przesuni˛ecia, 44
pusta, 52
operacja na indeksie, 15
operacje
arytmetyczne, dwuargumentowe, 43
arytmetyczne, jednoargumentowe, 43
bitowe, dwuargumentowe, 45
bitowe, jednoargumentowe, 43
operator
and
, 47
in
, 46
is
, 46
is not
, 46
not
, 47
not in
, 46
or
, 47
Indeks
77
operatora
priorytet, 48
przeci ˛
a˙zanie, 21
operatory, 10
or
ł ˛
acz ˛
ace, 45
bitowe, 45
wykluczaj ˛
ace, 45
or
operator, 47
ord()
(funkcja wbudowana), 15, 16
OverflowError
(wbudowany wyj ˛
atek), 14
P
p˛etla
po zmiennej sekwencji, 61
p˛etli
instrukcja, 55, 60
zmienna steruj ˛
aca, 55
pakiety, 56
para klucz/dana, 39
parametru
domy´slna warto´s´c, 62
parser, 3
Pascal
j˛ezyk, 61
pass
instrukcja, 52
plikowy
obiekt, 19, 66
plus, 43
pocz ˛
atkowy odst˛ep, 5
podstawowy
specjalny atrybut, 14
pomini˛ecie
ko´nca wiersza, 53
pop()
metoda obiektu odwzorowawczego, 27
metoda obiektu sekwencyjnego, 27
popen()
(w module os), 19
popitem()
(metoda obiektu odwzorowawczego),
27
porównania, 23
ł ˛
aczone, 45
porównanie, 45
napisu, 15
potrójnie zacytowany napis, 7
pow()
(funkcja wbudowana), 30
instrukcja, 22, 53
priorytet
operatora, 48
procedury
wywołanie, 49
program, 65
prosta
instrukcja, 49
prywatne
nazwy, 38
przeci ˛
a˙zanie
operatora, 21
przecinek, 38
ko´ncowy, 47, 53
przestrze´n nazw, 33
globalna, 17
modułu, 18
przesuni˛ecia
operacja, 44
przynale˙zno´sci
sprawdzenie, 46
przypisania
instrukcja, 16, 50
lista celów, 50
przypisanie
atrybutu, 50
atrybutu instancji klasy, 19
atrybutu klasy, 19
indeksu, 51
modyfikuj ˛
ace, 52
wykrojenia, 51
pusta
krotka, 16, 38
lista, 39
operacja, 52
pusty wiersz, 5
Python Enhancement Proposals
PEP 0255, 54
R
raise
instrukcja, 54
ramka
wykonania, 33, 63
ramki
obiekt, 20
range()
(funkcja wbudowana), 61
raw_input()
(funkcja wbudowana), 66
readline()
(metoda obiektu plikowego), 66
rekurencyjny
obiekt, 39
remove()
(metoda obiektu sekwencyjnego), 27
repr()
(funkcja wbudowana), 22, 39, 49
reprezentacja
całkowitoliczbowa, 15
return
instrukcja, 53, 62
reverse()
(metoda obiektu sekwencyjnego), 27
rozgraniczniki, 11
rozszerzenia
moduł, 14
rozszerzenie
nazwy pliku, 56
rozszerzona instrukcja wypisywania, 53
rozszerzone
wykrojenie, 40
rozszerzone wykrojenia, 15
78
Indeks
RuntimeError
wyj ˛
atek, 53
S
słownika
forma drukowalna, 39
obiekt, 16, 19, 23, 39, 40, 51
słowo kluczowe, 7
elif
, 60
else
, 55, 60, 62
except
, 61
finally
, 53, 55, 62
from
, 55, 56
in
, 60
słowo zarezerwowane, 7
sekwencja specjalna, 8
sekwencji
element, 40
obiekt, 15, 19, 40, 46, 51, 60
setdefault()
(metoda
obiektu
odw-
zorowawczego), 27
składnia, 1, 37
slice()
(funkcja wbudowana), 21
sort()
(metoda obiektu sekwencyjnego), 27
spacja, 5
specjalny
atrybut, 14
atrybut, podstawowy, 14
sprawdzenie
przynale˙zno´sci, 46
to˙zsamo´sci, 46
stała, 7
stan
stosu, 20
Standard C, 8
standardowe
wyj´scie, 49, 53
standardowe wej´scie, 65
stanu stosu
obiekt, 20, 54, 61
start
(atrybut obiektu wykrojenia), 21, 41
stderr
(w module sys), 19
stdin
(w module sys), 19
stdio, 19
stdout
(w module sys), 19, 53
step
(atrybut obiektu wykrojenia), 21, 41
stop
(atrybut obiektu wykrojenia), 21, 41
StopIteration
wyj ˛
atek, 54
stos
wykonania, 20
stosu
stan, 20
str()
(funkcja wbudowana), 22, 39
struktura wiersza, 3
surowe wej´scie, 66
surowy napis, 8
SyntaxError
wyj ˛
atek, 56
sys
(moduł wbudowany), 53, 56, 61, 65
sys.exc_info
, 20
sys.exc_traceback
, 20
sys.last_traceback
, 20
sys.modules
, 56
sys.stderr
, 19
sys.stdin
, 19
sys.stdout
, 19
SystemExit
(wbudowany wyj ˛
atek), 35
T
tabulacja, 5
tb_frame
(atrybut stanu stosu), 20
tb_lasti
(atrybut stanu stosu), 20
tb_lineno
(atrybut stanu stosu), 20
tb_next
(atrybut stanu stosu), 20
to˙zsamo´s´c obiektu, 13
to˙zsamo´sci
sprawdzenie, 46
token, 3
token DEDENT, 5, 59
token INDENT, 5
token NEWLINE, 3, 59
True
, 15
try
instrukcja, 20, 61
tryb interaktywny, 65
typ, 14
danych, 14
danych, niezmienny, 38
typ obiektu, 13
typów
hierarchia, 14
type()
(funkcja wbudowana), 13
TypeError
wyj ˛
atek, 43
typy wewn˛etrzne, 19
U
UnboundLocalError
, 33
unichr()
(funkcja wbudowana), 16
Unicode, 16
unicode
obiekt, 16
unicode()
(funkcja wbudowana), 16, 23
Unicode Consortium, 7
UNIX, 65
update()
(metoda obiektu odwzorowawczego),
27
usuni˛ecia
cel, 52
lista celów, 52
usuni˛ecie, 16
atrybutu, 53
usuni˛ecie dowi ˛
azania
nazwy, 52
Indeks
79
V
ValueError
wyj ˛
atek, 44
values()
(metoda obiektu odwzorowawczego),
27
W
warto´s´c
parametru, domy´slna, 62
warto´s´c obiektu, 13
warto´sci
wypisywanie, 49, 53
warto´sciowania
kolejno´s´c, 47
wbudowana
metoda, 18
wbudowanej funkcji
obiekt, 42
wywołanie, 42
wbudowanej metody
obiekt, 18, 42
wywołanie, 42
wbudowany
moduł, 56
wci˛ecie, 5
wej´scie, 66
surowe, 66
wewn˛etrzne, typy, 19
while
instrukcja, 55, 60
wi ˛
azanie
nazw, globalne, 57
nazwy, 55
wiersz fizyczny, 3, 4, 8
wiersz logiczny, 3
wiersz polecenia, 65
wisz ˛
ace
else, 59
wolna
nazwa, 33
zmienna, 53
wybór elementu, 15
wybór indeksu, 15
wyj´scie, 49, 53
standardowe, 49, 53
wyj ˛
atek, 35, 54
AssertionError
, 50
AttributeError
, 40
ImportError
, 56
NameError
, 38
RuntimeError
, 53
StopIteration
, 54
SyntaxError
, 56
TypeError
, 43
ValueError
, 44
ZeroDivisionError
, 44
wyj ˛
atku
generowanie, 54
kod obsługuj ˛
acy, 20
wykluczaj ˛
ace
or, 45
wykonania
ramka, 33, 63
stos, 20
wykonanie
ograniczone, 34
wykrojenia
obiekt, 27
przypisanie, 51
wykrojenie, 15, 16, 40
rozszerzone, 40
wypisywanie
warto´sci, 49, 53
wyra˙ze´n
lista, 47, 49, 50
wyra˙zenie, 37
lambda, 47
wyra˙zeniowa
instrukcja, 49
wyszukiwania
modułów, ´scie˙zka, 56
wytworniki
list, 38, 39
wywołania
instancja, 27
wywołanie, 16, 41
egzemplarza, 43
egzemplarza klasy, 43
funkcji, 16, 42
funkcji zdefiniowanej przez u˙zytkownika, 42
metody, 42
obiektu klasy, 18, 19, 43
procedury, 49
wbudowanej funkcji, 42
wbudowanej metody, 42
wywoływalny
obiekt, 16, 41
X
xor
bitowe, 45
Y
yield
instrukcja, 54
Z
zło˙zona
instrukcja, 59
zdefiniowana przez u˙zytkownika
funkcja, 16
metoda, 17
zdefiniowanej przez u˙zytkownika
wywołanie funkcji, 42
zdefiniowany przez u˙zytkownika
moduł, 56
80
Indeks
ZeroDivisionError
wyj ˛
atek, 44
zespolona
liczba, 15
zespolony
obiekt, 15
zestaw, 59
zestaw znaków, 15
zmiana dowi ˛
azania
nazwy, 50
zmienna
wolna, 53
zmienna steruj ˛
aca
p˛etli, 55
zmiennej sekwencji
obiekt, 16
p˛etla po, 61
zmiennoprzecinkowa
liczba, 15
zmiennoprzecinkowy
obiekt, 15
zmienny
obiekt, 16, 50, 51
znak, 15, 16, 40
znak krzy˙zyka, 4
znak odwróconego uko´snika, 4
zwykły całkowitoliczbowy
obiekt, 14
zwykły literał całkowitoliczbowy, 9
Indeks
81
Document Outline
- 1 Wstep
- 2 Analiza leksykalna
- 3 Model danych
- 3.1 Obiekty, warto±ci i typy
- 3.2 Hierarchia typów standardowych
- 3.3 Specjalne nazwy metod
- 3.3.1 Podstawowa indywidualizacja
- 3.3.2 Indywidualizacja dostepu do atrybutów
- 3.3.3 Indywidualizacja tworzenia klas
- 3.3.4 Emulowanie obiektów wywoywalnych
- 3.3.5 Emulowanie typów kontenerowych
- 3.3.6 Dodatkowe metody, su»ace emulowaniu typów sekwencyjnych
- 3.3.7 Emulowanie typów liczbowych
- 3.3.8 Reguy uzgadniania
- 4 Model wykonania
- 5 Wyra»enia
- 5.1 Konwersje arytmetyczne
- 5.2 Atomy
- 5.3 Elementy podstawowe
- 5.4 Operator potegowania
- 5.5 Jednoargumentowe operacje arytmetyczne
- 5.6 Dwuargumentowe operacje arytmetyczne
- 5.7 Operacje przesunie¢
- 5.8 Dwuargumentowe operacje bitowe
- 5.9 Porównania
- 5.10 Operacje logiczne
- 5.11 Formy lambda
- 5.12 Listy wyra»e«
- 5.13 Kolejno±¢ warto±ciowania
- 5.14 Zestawienie
- 6 Instrukcje proste
- 6.1 Instrukcje wyra»eniowe
- 6.2 Instrukcje assert
- 6.3 Instrukcje przypisania
- 6.4 Instrukcja pass
- 6.5 Instrukcja del
- 6.6 Instrukcja print
- 6.7 Instrukcja return
- 6.8 Instrukcja yield
- 6.9 Instrukcja raise
- 6.10 Instrukcja break
- 6.11 Instrukcja continue
- 6.12 Instrukcja import
- 6.13 Instrukcja global
- 6.14 Instrukcja exec
- 7 Instrukcje zo»one
- 8 Elementy nadrzedne
- A Historia i licencja
- Indeks
Wyszukiwarka
Podobne podstrony:
pythondoc tut pl
download Zarządzanie Produkcja Archiwum w 09 pomiar pracy [ www potrzebujegotowki pl ]
Wyklad 6 Testy zgodnosci dopasowania PL
WYKŁAD PL wersja ostateczna
Course hydro pl 1
PERFORMANCE LEVEL, PL
struktura organizacyjna BTS [ www potrzebujegotowki pl ]
wyklad 2 Prezentacja danych PL
2a esperienza haccp PL
Sesja 58 pl 1
3a prerequisiti PL
animeo solo PL ext
wyklad 6 Testy zgodnosci dopasowania PL
Sesja 34 pl 1
Lec04 PL Oprogramowanie fin
więcej podobnych podstron