Darmowy fragment publikacji:
Tytuł oryginału: Python Pocket Reference, Fifth Edition
Tłumaczenie: Radosław Meryk
ISBN: 978-83-283-6035-8
© 2014, 2019 Helion S.A.
Authorized Polish translation of the English edition Python Pocket Reference,
5th Edition ISBN 9781449357016 © 2014 Mark Lutz.
This translation is published and sold by permission of O’Reilly Media, Inc.,
which owns or controls all rights to publish and sell the same.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości
lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione.
Wykonywanie kopii metodą kserograficzną, fotograficzną, a także
kopiowanie książki na nośniku filmowym, magnetycznym lub innym
powoduje naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi
bądź towarowymi ich właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte
w tej książce informacje były kompletne i rzetelne. Nie bierze jednak żadnej
odpowiedzialności ani za ich wykorzystanie, ani za związane z tym
ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo
HELION nie ponosi również żadnej odpowiedzialności za ewentualne
szkody wynikłe z wykorzystania informacji zawartych w książce.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/pylk5v
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis tre(cid:316)ci
Opcje polece(cid:254) Pythona
Specyfikacja programu w wierszu polecenia
Opcje polece(cid:254) Pythona 2.X
Zmienne operacyjne
Zmienne opcji wiersza polece(cid:254)
Dyrektywy plikowe launchera
Wiersz polece(cid:254) launchera
Zmienne (cid:264)rodowiskowe launchera
Wprowadzenie ...................................................................................................7
Konwencje ..........................................................................................................8
Opcje wiersza polece(cid:295) Pythona .........................................................................9
9
11
12
Zmienne (cid:316)rodowiskowe ................................................................................... 13
13
14
Python Launcher dla systemu Windows .......................................................... 15
15
16
17
Wbudowane typy i operatory ...........................................................................17
17
19
21
25
Specyficzne typy wbudowane .........................................................................26
26
29
46
50
56
60
61
66
68
Liczby
Ci(cid:241)gi znaków
(cid:227)a(cid:254)cuchy znaków Unicode
Listy
S(cid:228)owniki
Krotki
Pliki
Zbiory
Inne typy i konwersje
Operatory i priorytet ich stosowania
Uwagi na temat stosowania operatorów
Operacje wed(cid:228)ug kategorii
Uwagi na temat dzia(cid:228)a(cid:254) na sekwencjach
3
Poleć książkęKup książkę Instrukcja przypisania
Instrukcja wyra(cid:276)eniowa
Instrukcja print
Instrukcja if
Instrukcja while
Instrukcja for
Instrukcja pass
Instrukcja break
Instrukcja continue
Instrukcja del
Instrukcja def
Instrukcja return
Instrukcja yield
Instrukcja global
Instrukcja nonlocal
Instrukcja import
Instrukcja from
Instrukcja class
Instrukcja try
Instrukcja raise
Instrukcja assert
Instrukcja with
Instrukcje w Pythonie 2.X
Instrukcje i ich sk(cid:293)adnia ....................................................................................70
70
72
Instrukcje ...........................................................................................................75
75
79
80
82
83
83
84
84
84
84
85
89
89
91
91
92
95
97
99
102
104
104
106
Przestrzenie nazw i regu(cid:293)y zasi(cid:253)gu ............................................................... 107
107
107
109
Programowanie obiektowe ............................................................................110
111
112
113
114
Nazwy kwalifikowane — przestrzenie nazw obiektów
Nazwy niekwalifikowane — zasi(cid:246)gi leksykalne
Zasi(cid:246)gi zagnie(cid:276)d(cid:276)one i domkni(cid:246)cia
Regu(cid:228)y sk(cid:228)adniowe
Regu(cid:228)y dotycz(cid:241)ce nazw
Klasy i egzemplarze
Atrybuty pseudoprywatne
Klasy nowego stylu
Formalne regu(cid:228)y dziedziczenia
4
(cid:95)
Python. Leksykon kieszonkowy
Poleć książkęKup książkę Funkcje wbudowane w Pythonie 2.X
Klasy bazowe (kategorie)
Wyj(cid:241)tki szczegó(cid:228)owe
Szczegó(cid:228)owe wyj(cid:241)tki OSError
Wyj(cid:241)tki kategorii ostrze(cid:276)e(cid:254)
Framework ostrze(cid:276)e(cid:254)
Wbudowane wyj(cid:241)tki w Pythonie 3.2
Wbudowane wyj(cid:241)tki w Pythonie 2.X
Funkcje i klasy modu(cid:228)u
Sta(cid:228)e
Wszystkie typy
Kolekcje (sekwencje, mapy)
Liczby (operatory dwuargumentowe)
Liczby (inne dzia(cid:228)ania)
Deskryptory
Mened(cid:276)ery kontekstu
Metody przeci(cid:241)(cid:276)aj(cid:241)ce operatory w Pythonie 2.X
Metody przeci(cid:233)(cid:348)aj(cid:233)ce operatory ....................................................................118
119
125
127
130
130
131
132
Funkcje wbudowane ...................................................................................... 135
157
Wbudowane wyj(cid:233)tki ...................................................................................... 163
163
165
169
170
171
172
173
Wbudowane atrybuty .....................................................................................173
Standardowe modu(cid:293)y biblioteczne ............................................................... 174
Modu(cid:293) sys .........................................................................................................175
Modu(cid:293) string ................................................................................................... 183
183
184
Modu(cid:293) systemowy os ...................................................................................... 185
186
187
188
190
191
194
198
201
Modu(cid:293) dopasowywania wzorców re .............................................................204
204
206
Narz(cid:246)dzia administracyjne
Sta(cid:228)e wykorzystywane do zapewnienia przeno(cid:264)no(cid:264)ci
Polecenia pow(cid:228)oki
Narz(cid:246)dzia do obs(cid:228)ugi (cid:264)rodowiska
Narz(cid:246)dzia do obs(cid:228)ugi deskryptorów plików
Narz(cid:246)dzia do obs(cid:228)ugi nazw (cid:264)cie(cid:276)ek
Zarz(cid:241)dzanie procesami
Modu(cid:228) os.path
Funkcje modu(cid:228)u
Obiekty wyra(cid:276)e(cid:254) regularnych
Spis tre(cid:316)ci
(cid:95)
5
Poleć książkęKup książkę Obiekty dopasowania
Sk(cid:228)adnia wzorców
Modu(cid:228)y dbm i shelve
Modu(cid:228) pickle
Przyk(cid:228)ad u(cid:276)ycia modu(cid:228)u tkinter
Podstawowe widgety modu(cid:228)u tkinter
Wywo(cid:228)ania okien dialogowych
Dodatkowe klasy i narz(cid:246)dzia modu(cid:228)u tkinter
Porównanie biblioteki Tcl/Tk z modu(cid:228)em tkinter Pythona
207
208
Modu(cid:293)y utrwalania obiektów ........................................................................ 210
212
214
Modu(cid:293) GUI tkinter i narz(cid:253)dzia .........................................................................217
217
218
218
220
220
Modu(cid:293)y i narz(cid:253)dzia do obs(cid:293)ugi internetu ......................................................222
Inne standardowe modu(cid:293)y biblioteczne ........................................................224
225
225
227
228
228
228
229
230
230
231
API baz danych Python SQL ...........................................................................232
233
234
234
235
236
Idiomy Pythona i dodatkowe wskazówki .....................................................236
236
238
239
241
Skorowidz .......................................................................................................243
Modu(cid:228) math
Modu(cid:228) time
Modu(cid:228) timeit
Modu(cid:228) datetime
Modu(cid:228) random
Modu(cid:228) json
Modu(cid:228) subprocess
Modu(cid:228) enum
Modu(cid:228) struct
Modu(cid:228)y obs(cid:228)ugi w(cid:241)tków
Przyk(cid:228)ad u(cid:276)ycia interfejsu API
Interfejs modu(cid:228)u
Obiekty po(cid:228)(cid:241)cze(cid:254)
Obiekty kursora
Obiekty typów i konstruktory
Wskazówki dotycz(cid:241)ce rdzenia j(cid:246)zyka
Wskazówki dotycz(cid:241)ce (cid:264)rodowiska
Wskazówki dotycz(cid:241)ce u(cid:276)ytkowania
Ró(cid:276)ne wskazówki
6
(cid:95)
Python. Leksykon kieszonkowy
Poleć książkęKup książkę Instrukcje
W kolejnych podrozdzia(cid:228)ach zostan(cid:241) opisane wszystkie instrukcje
wyst(cid:246)puj(cid:241)ce w Pythonie. W ka(cid:276)dym podrozdziale zamieszczono format
sk(cid:228)adni instrukcji, a za nim szczegó(cid:228)owe informacje na temat jej wyko-
rzystania. W przypadku instrukcji z(cid:228)o(cid:276)onych ka(cid:276)de wyst(cid:241)pienie ci(cid:241)gu
grupa wewn(cid:241)trz formatu instrukcji oznacza jedn(cid:241) lub wi(cid:246)cej innych
instrukcji. Instrukcje te mog(cid:241) tworzy(cid:232) blok pod wierszem nag(cid:228)ówka.
Dla grupy trzeba zastosowa(cid:232) wci(cid:246)cie pod nag(cid:228)ówkiem, je(cid:264)li zawiera
inn(cid:241) instrukcj(cid:246) z(cid:228)o(cid:276)on(cid:241) (if, while itp.). W przeciwnym razie mo(cid:276)e si(cid:246)
znale(cid:274)(cid:232) w tym samym wierszu co nag(cid:228)ówek instrukcji. Obie poni(cid:276)-
sze konstrukcje s(cid:241) prawid(cid:228)owe:
if x 42:
print(x)
while x: x = x (cid:344) 1
if x 42: print(x)
Poni(cid:276)ej zamieszczono szczegó(cid:228)owe informacje wspólne dla wersji Pytho-
na 3.X i 2.X. Szczegó(cid:228)y obowi(cid:241)zuj(cid:241)ce jedynie w wersji 2.X zestawiono
na ko(cid:254)cu podrozdzia(cid:228)u „Instrukcje w Pythonie 2.X”.
Instrukcja przypisania
cel = wyra(cid:285)enie
cel1 = cel2 = wyra(cid:285)enie
cel1, cel2 = wyra(cid:285)enie1, wyra(cid:285)enie2
cel1 += wyra(cid:285)enie
cel1, cel2, ... = obiekt_iterowalny-o-tej-samej-d(cid:239)ugo(cid:258)ci
(cel1, cel2, ...) = obiekt_iterowalny-o-tej-samej-d(cid:239)ugo(cid:258)ci
[cel1, cel2, ...] = obiekt_iterowalny-o-tej-samej-d(cid:239)ugo(cid:258)ci
cel1, *cel2, ... = obiekt_iterowalny-o-odpowiedniej-d(cid:239)ugo(cid:258)ci
W instrukcjach przypisania cele zawieraj(cid:241) referencje do obiektów. Instruk-
cje przypisania powinny mie(cid:232) jawny format zamieszczony powy(cid:276)ej,
w którym:
Instrukcje
(cid:95)
75
Poleć książkęKup książkę (cid:120) wyra(cid:276)enia generuj(cid:241) obiekty;
(cid:120) cele mog(cid:241) by(cid:232) prostymi nazwami (X), kwalifikowanymi atrybu-
tami (X.attr) albo indeksami i wycinkami (X[i], X[i:j:k]);
(cid:120) zmienne wewn(cid:241)trz celów nie s(cid:241) deklarowane wcze(cid:264)niej, ale przed
u(cid:276)yciem ich w wyra(cid:276)eniu trzeba nada(cid:232) im warto(cid:264)(cid:232) (patrz podroz-
dzia(cid:228) „Wyra(cid:276)enia atomowe i dynamiczne okre(cid:264)lanie typów”).
Pierwszy format wymieniony powy(cid:276)ej to proste przypisanie. Drugi
z formatów — przypisanie wielocelowe (ang. multiple-target) — s(cid:228)u(cid:276)y do
przypisania tego samego wyra(cid:276)enia do ka(cid:276)dego z celów. Trzeci for-
mat — przypisanie krotek — (cid:228)(cid:241)czy w pary cele z wyra(cid:276)eniami, od lewej
do prawej. Czwarty format — przypisanie z aktualizacj(cid:241) — jest skrótem
dla po(cid:228)(cid:241)czenia operacji dodawania z przypisaniem (patrz nast(cid:246)pny
podrozdzia(cid:228)).
Ostatnie cztery formaty to przypisanie sekwencji, które s(cid:228)u(cid:276)y do przy-
pisywania komponentów dowolnej sekwencji (b(cid:241)d(cid:274) innego obiektu
iterowalnego) do odpowiadaj(cid:241)cych im celów — od lewej do prawej.
Sekwencja lub obiekt iterowalny wyst(cid:246)puj(cid:241)ce po prawej stronie mog(cid:241)
by(cid:232) dowolnego typu, ale musz(cid:241) by(cid:232) tej samej d(cid:228)ugo(cid:264)ci, chyba (cid:276)e w(cid:264)ród
celów z lewej strony znajdzie si(cid:246) nazwa rozpoczynaj(cid:241)ca si(cid:246) gwiazdk(cid:241)
(*X), tak jak w ostatnim formacie. Ten ostatni format jest znany jako
rozszerzone przypisanie sekwencji. Instrukcja o takim formacie jest dost(cid:246)pna
wy(cid:228)(cid:241)cznie w Pythonie 3.X. Pozwala ona na pobranie dowolnej liczby
elementów (patrz podrozdzia(cid:228) „Rozszerzone instrukcje przypisania
sekwencji (3.X)”).
Przypisania mog(cid:241) równie(cid:276) wyst(cid:246)powa(cid:232) niejawnie w innych kontekstach
w Pythonie (np. zmienne p(cid:246)tli for oraz mechanizm przekazywania
argumentów funkcji). Niektóre z formatów instrukcji przypisania mo(cid:276)na
równie(cid:276) stosowa(cid:232) w innych miejscach (np. przypisania sekwencji
w instrukcjach for).
Przypisanie z aktualizacj(cid:233)
W Pythonie dost(cid:246)pny jest zbiór dodatkowych formatów instrukcji przy-
pisania. Zestawiono je w tabeli 13. S(cid:241) to tzw. przypisania z aktualizacj(cid:241) —
formaty te implikuj(cid:241) wyra(cid:276)enie dwuargumentowe razem z przypi-
saniem. Na przyk(cid:228)ad poni(cid:276)sze dwa formaty w przybli(cid:276)eniu s(cid:241) sobie
równowa(cid:276)ne:
X = X + Y
X += Y
76
(cid:95)
Python. Leksykon kieszonkowy
Poleć książkęKup książkę Tabela 13. Instrukcje przypisania z aktualizacj(cid:241)
X -= Y
X /= Y
X **= Y
X = Y
X ^= Y
X = Y
X += Y
X *= Y
X = Y
X |= Y
X = Y
X //= Y
Jednak warto(cid:264)(cid:232) celu X w instrukcji drugiego formatu mo(cid:276)e by(cid:232) wyzna-
czona tylko raz. Dodatkowo format ten pozwala na zastosowanie dzia(cid:228)a(cid:254)
w miejscu dla typów mutowalnych (np. wyra(cid:276)enie list1 += list2 auto-
matycznie wywo(cid:228)uje metod(cid:246) list1.extend(list2) zamiast wolniejszej
operacji konkatenacji implikowanej przez operator +). W klasach przypi-
sania w miejscu mog(cid:241) by(cid:232) przeci(cid:241)(cid:276)ane za pomoc(cid:241) nazw metod roz-
poczynaj(cid:241)cych si(cid:246) od i (np. __iadd__() dla operatora +=, __add__() dla
operatora +). W Pythonie w wersji 2.2 wprowadzono nowy format:
X //= Y (dzielenie ca(cid:228)kowite).
Zwyk(cid:293)e instrukcje przypisania sekwencji
W Pythonie 2.X i 3.X dowoln(cid:241) sekwencj(cid:246) (b(cid:241)d(cid:274) te(cid:276) inny obiekt itero-
walny) z(cid:228)o(cid:276)on(cid:241) z warto(cid:264)ci mo(cid:276)na przypisa(cid:232) do dowolnej sekwencji
nazw, pod warunkiem (cid:276)e ich d(cid:228)ugo(cid:264)ci s(cid:241) takie same. Podstawowa
forma instrukcji przypisania sekwencji dzia(cid:228)a w wi(cid:246)kszo(cid:264)ci kontek-
stów przypisania:
a, b, c, d = [1, 2, 3, 4]
a, d
(1, 4)
for (a, b, c) in [[1, 2, 3], [4, 5, 6]]:
... print(a, b, c)
...
1 2 3
4 5 6
Rozszerzone instrukcje przypisania sekwencji (3.X)
W Pythonie 3.X (wy(cid:228)(cid:241)cznie) instrukcja przypisania sekwencji zosta(cid:228)a
rozszerzona, by umo(cid:276)liwi(cid:232) obs(cid:228)ug(cid:246) przypisania sekwencji o dowol-
nej liczbie elementów — wystarczy poprzedzi(cid:232) gwiazdk(cid:241) jedn(cid:241) ze
zmiennych celu przypisania. W takim przypadku d(cid:228)ugo(cid:264)ci sekwencji
nie musz(cid:241) by(cid:232) identyczne, natomiast nazwa poprzedzona gwiazdk(cid:241)
pobiera niepasuj(cid:241)ce elementy do nowej listy:
a, *b = [1, 2, 3, 4]
a, b
(1, [2, 3, 4])
Instrukcje
(cid:95)
77
Poleć książkęKup książkę a, *b, c = (1, 2, 3, 4)
a, b, c
(1, [2, 3], 4)
*a, b = spam
a, b
([ s , p , a ], m )
for (a, *b) in [[1, 2, 3], [4, 5, 6]]:
... print(a, b)
...
1 [2, 3]
4 [5, 6]
UWAGA
Uogólnienie gwiazdki w Pythonie 3.5 lub w wersjach pó(cid:274)niejszych?
W Pythonie 3.3 i wcze(cid:264)niejszych wersjach specjalne formy sk(cid:228)adni
*X i **X mog(cid:241) wyst(cid:246)powa(cid:232) w trzech miejscach: w instrukcjach przypi-
sania, gdzie *X pobiera niedopasowane elementy w instrukcjach
przypisania sekwencji; w nag(cid:228)ówkach funkcji, w których te dwie formy
s(cid:228)u(cid:276)(cid:241) do zbierania niepasuj(cid:241)cych argumentów pozycyjnych i argu-
mentów w postaci s(cid:228)ów kluczowych; oraz w wywo(cid:228)aniach funkcji,
gdzie wymienione dwie formy rozpakowuj(cid:241) obiekty iterowalne
i s(cid:228)owniki do indywidualnych elementów (argumentów).
W Pythonie 3.4 deweloperzy planowali uogólni(cid:232) sk(cid:228)adni(cid:246) z gwiazd-
k(cid:241) w taki sposób, by mo(cid:276)na jej by(cid:228)o u(cid:276)ywa(cid:232) tak(cid:276)e w litera(cid:228)ach opisu-
j(cid:241)cych struktury danych, w których mia(cid:228)aby ona powodowa(cid:232) rozpa-
kowywanie kolekcji do postaci pojedynczych elementów, podobnie
jak dzia(cid:228)a to obecnie w wywo(cid:228)aniach funkcji. Rozpakowuj(cid:241)ca sk(cid:228)ad-
nia z gwiazdk(cid:241) b(cid:246)dzie mog(cid:228)a by(cid:232) wykorzystywana dla krotek, list,
zbiorów, s(cid:228)owników i obiektów sk(cid:228)adanych. Na przyk(cid:228)ad:
[x, *iter] # rozpakowanie elementów obiektu iterowalnego iter: lista
(x, *iter), {x, *iter} # to samo dla krotki, zbiór
{ x : 1, **dict} # rozpakowanie elementów s(cid:228)ownika: s(cid:228)owniki
[*iter for iter in x] # rozpakowanie elementów obiektu iterowalnego:
obiekty sk(cid:225)adane
S(cid:241) to dodatkowe miejsca zastosowania sk(cid:228)adni z gwiazdk(cid:241) oprócz
instrukcji przypisania, nag(cid:228)ówków funkcji i wywo(cid:228)a(cid:254) funkcji. Dodat-
kowo by(cid:232) mo(cid:276)e zostan(cid:241) zniesione niektóre obecne ograniczenia
w zakresie korzystania z tej sk(cid:228)adni. Proponowana zmiana zosta(cid:228)a
przesuni(cid:246)ta na wydanie po wersji 3.4, tu(cid:276) przed ukazaniem si(cid:246)
niniejszej ksi(cid:241)(cid:276)ki, i pozostaje niepewna. W istocie dyskutowano
o niej od 2008 roku. Zmiana ta nie b(cid:246)dzie rozpatrywana do wyda-
nia Pythona 3.5 lub wersji pó(cid:274)niejszej i by(cid:232) mo(cid:276)e nie pojawi si(cid:246)
w ogóle. Szczegó(cid:228)owe informacje mo(cid:276)na znale(cid:274)(cid:232) w dokumencie
„What’s New”.
78
(cid:95)
Python. Leksykon kieszonkowy
Poleć książkęKup książkę Instrukcja wyra(cid:348)eniowa
wyra(cid:285)enie
funkcja([warto(cid:258)(cid:202), nazwa=warto(cid:258)(cid:202), *nazwa, **nazwa...])
obiekt.metoda([warto(cid:258)(cid:202), nazwa=warto(cid:258)(cid:202), *nazwa, **nazwa...])
Dowolne wyra(cid:276)enie mo(cid:276)e by(cid:232) instrukcj(cid:241) (np. wyst(cid:246)puj(cid:241)ce samodziel-
nie w wierszu). Z drugiej strony instrukcje nie mog(cid:241) wyst(cid:246)powa(cid:232)
w (cid:276)adnym innym kontek(cid:264)cie wyra(cid:276)enia (np. instrukcje przypisania nie
zwracaj(cid:241) wyników i nie mog(cid:241) by(cid:232) zagnie(cid:276)d(cid:276)ane).
Wyra(cid:276)enia s(cid:241) powszechnie u(cid:276)ywane do wywo(cid:228)ywania funkcji i metod,
które nie zwracaj(cid:241) warto(cid:264)ci, oraz do wy(cid:264)wietlania w trybie interak-
tywnym. Instrukcje wyra(cid:276)eniowe s(cid:241) tak(cid:276)e najpopularniejszym sposo-
bem kodowania dla wyra(cid:276)e(cid:254) yield oraz wywo(cid:228)a(cid:254) wbudowanej funkcji
print() z Pythona 3.X (cho(cid:232) w tej ksi(cid:241)(cid:276)ce instrukcje te opisano osobno).
Sk(cid:293)adnia wywo(cid:293)ania
W wywo(cid:228)aniach funkcji i metod aktualne argumenty wywo(cid:228)ania s(cid:241)
od siebie oddzielone przecinkami i zwykle s(cid:241) dopasowywane wed(cid:228)ug
pozycji do argumentów w nag(cid:228)ówkach def funkcji. W wywo(cid:228)aniach
mo(cid:276)na opcjonalnie wymieni(cid:232) specyficzne nazwy argumentów, do któ-
rych b(cid:246)d(cid:241) przekazywane warto(cid:264)ci. W tym celu nale(cid:276)y skorzysta(cid:232) ze
sk(cid:228)adni argumentu kluczowego nazwa=warto(cid:258)(cid:202). Argumenty kluczowe s(cid:241)
dopasowywane wed(cid:228)ug nazwy zamiast pozycji.
Sk(cid:293)adnia dowolnych argumentów wywo(cid:293)ania
W listach argumentów wywo(cid:228)ania funkcji i metod mo(cid:276)na zastosowa(cid:232)
specjaln(cid:241) sk(cid:228)adni(cid:246) w celu rozpakowania kolekcji do dowolnej liczby
argumentów. Je(cid:264)li pargs i kargs to odpowiednio sekwencja (lub inny
obiekt iterowalny) oraz s(cid:228)ownik:
f(*pargs, **kargs)
to instrukcja o tym formacie wywo(cid:228)a funkcj(cid:246) f z argumentami pozy-
cyjnymi z obiektu iterowalnego pargs oraz z argumentami kluczowymi
ze s(cid:228)ownika kargs. Na przyk(cid:228)ad:
def f(a, b, c, d): print(a, b, c, d)
...
f(*[1, 2], **dict(c=3, d=4))
1 2 3 4
Sk(cid:228)adni(cid:246) t(cid:246) dodano po to, by by(cid:228)a symetryczna ze sk(cid:228)adni(cid:241) argumentów
nag(cid:228)ówka funkcji, na przyk(cid:228)ad def f(*pargs, **kargs), która pobiera
Instrukcje
(cid:95)
79
Poleć książkęKup książkę niedopasowane argumenty. W wywo(cid:228)aniach elementy poprzedzone
gwiazdkami s(cid:241) rozpakowywane do pojedynczych argumentów i mog(cid:241)
by(cid:232) (cid:228)(cid:241)czone z innymi argumentami pozycyjnymi i kluczowymi zgodnie
z regu(cid:228)ami porz(cid:241)dkowania (np. g(1, 2, foo=3, bar=4, *pargs, **kargs)).
W Pythonie 2.X podobny efekt mo(cid:276)na osi(cid:241)gn(cid:241)(cid:232) za pomoc(cid:241) wbudo-
wanej funkcji apply(), która w Pythonie 3.X zosta(cid:228)a usuni(cid:246)ta:
apply(f, pargs, kargs)
Wi(cid:246)cej informacji na temat sk(cid:228)adni wywo(cid:228)ania mo(cid:276)na znale(cid:274)(cid:232) w pod-
rozdziale „Instrukcja def” (w(cid:228)(cid:241)cznie z tabel(cid:241) 15.).
Instrukcja print
W Pythonie 3.X wy(cid:264)wietlanie tekstu do standardowego strumienia
wyj(cid:264)ciowego przyj(cid:246)(cid:228)o posta(cid:232) wywo(cid:228)ania wbudowanej funkcji. Zwykle
jest ona kodowana jako instrukcja wyra(cid:276)eniowa (w oddzielnym wier-
szu). Jej sygnatura wywo(cid:228)ania jest nast(cid:246)puj(cid:241)ca:
print([warto(cid:258)(cid:202) [, warto(cid:258)(cid:202)]*]
[, sep=(cid:239)a(cid:241)cuch-znaków] [, end=(cid:239)a(cid:241)cuch-znaków]
[, file=obiekt] [, flush=bool])
Ka(cid:276)da warto(cid:258)(cid:202) jest wyra(cid:276)eniem generuj(cid:241)cym obiekt, dla którego ma
by(cid:232) wy(cid:264)wietlony (cid:228)a(cid:254)cuch znaków str(). To wywo(cid:228)anie konfiguruje si(cid:246)
za pomoc(cid:241) trzech argumentów, które mog(cid:241) by(cid:232) wy(cid:228)(cid:241)cznie argumen-
tami kluczowymi (je(cid:264)li argument b(cid:246)dzie pomini(cid:246)ty lub zostanie prze-
kazana warto(cid:264)(cid:232) None, przyjmie on warto(cid:264)(cid:232) domy(cid:264)ln(cid:241)):
sep
(cid:227)a(cid:254)cuch znaków, który ma by(cid:232) umieszczony pomi(cid:246)dzy warto-
(cid:264)ciami (domy(cid:264)lnie spacja: ).
end
file
flush
(cid:227)a(cid:254)cuch znaków do umieszczenia na ko(cid:254)cu wy(cid:264)wietlanego tekstu
(domy(cid:264)lnie znak nowego wiersza: \n ).
Obiekt postaci pliku, do którego jest zapisywany tekst (domy(cid:264)lnie
standardowe wyj(cid:264)cie: sys.stdout).
Warto(cid:264)(cid:232) true lub false umo(cid:276)liwiaj(cid:241)ca w(cid:228)(cid:241)czenie lub wy(cid:228)(cid:241)czenie
wymuszonego opró(cid:276)nienia strumienia wyj(cid:264)ciowego (wprowa-
dzone w Pythonie 3.3 — domy(cid:264)lnie False).
80
(cid:95)
Python. Leksykon kieszonkowy
Poleć książkęKup książkę Aby wy(cid:228)(cid:241)czy(cid:232) separatory w postaci spacji oraz znaki wysuwu wiersza,
mo(cid:276)na przekaza(cid:232) puste lub dostosowane do w(cid:228)asnych potrzeb argu-
menty sep i end. W celu przekierowania wyj(cid:264)cia mo(cid:276)na przekaza(cid:232) nazw(cid:246)
pliku za pomoc(cid:241) argumentu file (patrz tak(cid:276)e podrozdzia(cid:228) „Pliki”):
print(2 ** 32, spam )
4294967296 spam
print(2 ** 32, spam , sep= )
4294967296spam
print(2 ** 32, spam , end= ); print(1, 2, 3)
4294967296 spam 1 2 3
print(2 ** 32, spam , sep= ,
... file=open( out , w ))
open( out ).read()
4294967296spam\n
Poniewa(cid:276) domy(cid:264)lnie funkcja print po prostu wywo(cid:228)uje metod(cid:246) write()
obiektu, do którego w danym momencie odwo(cid:228)uje si(cid:246) urz(cid:241)dzenie sys.
(cid:180)stdout, to poni(cid:276)sza sekwencja jest równowa(cid:276)na wywo(cid:228)aniu print(X):
import sys
sys.stdout.write(str(X) + \n )
Aby przekierowa(cid:232) polecenie wy(cid:264)wietlania tekstu do plików b(cid:241)d(cid:274) obiek-
tów klasy, nale(cid:276)y albo przekaza(cid:232) dowolny obiekt z implementacj(cid:241) me-
tody write() do argumentu kluczowego file, tak jak pokazano wcze-
(cid:264)niej, albo przypisa(cid:232) urz(cid:241)dzenie sys.stdout do dowolnego takiego
obiektu (patrz tak(cid:276)e podrozdzia(cid:228) „Pliki”):
sys.stdout = open( log , a ) # dowolny obiekt z metod(cid:241) write()
print( Ostrze(cid:285)enie: spam! ) # wywo(cid:228)anie jest kierowane do metody write() obiektu
Poniewa(cid:276) do urz(cid:241)dzenia wyj(cid:264)ciowego sys.stdout mo(cid:276)na przypisa(cid:232) now(cid:241)
warto(cid:264)(cid:232), argument kluczowy file nie jest konieczny. Cz(cid:246)sto jednak
pozwala on na unikni(cid:246)cie zarówno jawnych wywo(cid:228)a(cid:254) metody write(),
jak i zapisywania i odtwarzania oryginalnej warto(cid:264)ci sys.stdout wokó(cid:228)
wywo(cid:228)ania metody print, w przypadku gdy pierwotny strumie(cid:254) danych
jest w dalszym ci(cid:241)gu wymagany. Wi(cid:246)cej informacji na temat dzia(cid:228)a-
nia instrukcji print() w Pythonie 3.X mo(cid:276)na znale(cid:274)(cid:232) w podrozdziale
„Funkcje wbudowane”.
Instrukcja print w Pythonie 2.X
W Pythonie 2.X wy(cid:264)wietlanie jest instrukcj(cid:241), a nie funkcj(cid:241) wbudo-
wan(cid:241). Jest to instrukcja o nast(cid:246)puj(cid:241)cej postaci:
Instrukcje
(cid:95)
81
Poleć książkęKup książkę print [warto(cid:258)(cid:202) [, warto(cid:258)(cid:202)]* [,]]
print plik [, warto(cid:258)(cid:202) [, warto(cid:258)(cid:202)]* [,]]
Instrukcja print z Pythona 2.X wy(cid:264)wietla drukowalne reprezentacje
warto(cid:264)ci w strumieniu stdout (u(cid:276)ywaj(cid:241)c bie(cid:276)(cid:241)cego ustawienia sys.stdout)
oraz dodaje spacje pomi(cid:246)dzy warto(cid:264)ciami. Dodanie przecinka na ko(cid:254)cu
powoduje wy(cid:228)(cid:241)czenie znaku wysuwu wiersza, który jest standardowo
dodawany na ko(cid:254)cu listy. Jest to równowa(cid:276)ne u(cid:276)yciu klauzuli end=
w Pythonie 3.X:
print 2 ** 32, spam
4294967296 spam
print 2 ** 32, spam ,; print 1, 2, 3
4294967296 spam 1 2 3
Instrukcja print z Pythona 2.X pozwala tak(cid:276)e na podanie nazwy pliku
wyj(cid:264)ciowego (lub podobnego mu obiektu), który b(cid:246)dzie pe(cid:228)ni(cid:228) funk-
cj(cid:246) celu dla wy(cid:264)wietlanego tekstu zamiast strumienia sys.stdout.
fileobj = open( log , a )
print fileobj, Ostrze(cid:285)enie: spam!
Je(cid:264)li obiekt pliku ma warto(cid:264)(cid:232) None, wykorzystywany jest strumie(cid:254) sys.
(cid:180)stdout. Sk(cid:228)adnia Pythona 2.X jest równowa(cid:276)na u(cid:276)yciu argumentu
kluczowego file=F z Pythona 3.X. W instrukcji print Pythona 2.X nie
istnieje odpowiednik argumentu sep=S, chocia(cid:276) wiersze mog(cid:241) by(cid:232) sfor-
matowane i wy(cid:264)wietlone jako pojedynczy element.
W instrukcji print Pythona 2.X mo(cid:276)na u(cid:276)ywa(cid:232) nawiasów okr(cid:241)g(cid:228)ych.
W przypadku wielu elementów tworz(cid:241) one krotki. Aby skorzysta(cid:232)
z funkcji wy(cid:264)wietlania Pythona 3.X w Pythonie 2.X, nale(cid:276)y uruchomi(cid:232)
poni(cid:276)sze instrukcje (w interaktywnej sesji lub na pocz(cid:241)tku skryptu) —
z tego mechanizmu mo(cid:276)na skorzysta(cid:232) zarówno w Pythonie 2.X (w celu
zachowania zgodno(cid:264)ci w przód z wersj(cid:241) 3.X), jak i w Pythonie 3.X
(w celu zachowania wstecznej zgodno(cid:264)ci z Pythonem 2.X):
from __future__ import print_function
Instrukcja if
if warunek:
grupa
[elif warunek:
grupa]*
[else:
grupa]
Instrukcja if pozwala na wybór jednego lub kilku dzia(cid:228)a(cid:254) (bloków
instrukcji) i uruchamia grup(cid:246) instrukcji powi(cid:241)zan(cid:241) z pierwszym warun-
82
(cid:95)
Python. Leksykon kieszonkowy
Poleć książkęKup książkę kiem if lub elif, który jest prawdziwy, albo wykonuje grup(cid:246) else, je(cid:264)li
wszystkie warunki if (elif) maj(cid:241) warto(cid:264)(cid:232) false. Cz(cid:228)ony elif i else s(cid:241)
opcjonalne.
Instrukcja while
while warunek:
grupa
[else:
grupa]
P(cid:246)tla while to instrukcja p(cid:246)tli ogólnego przeznaczenia, która wykonuje
pierwsz(cid:241) grup(cid:246) instrukcji, gdy warunek na pocz(cid:241)tku instrukcji jest
prawdziwy. Instrukcja uruchamia grup(cid:246) else, w przypadku gdy nast(cid:241)pi
zako(cid:254)czenie dzia(cid:228)ania p(cid:246)tli bez wykonania instrukcji break.
Instrukcja for
for cel in obiekt_iterowalny:
grupa
[else:
grupa]
P(cid:246)tla for realizuje iteracj(cid:246) po sekwencji (b(cid:241)d(cid:274) innym obiekcie itero-
walnym). Przypisuje elementy obiektu iterowalnego do zmiennej cel
i w ka(cid:276)dej iteracji wykonuje pierwsz(cid:241) grup(cid:246) instrukcji. Instrukcja for
uruchamia opcjonaln(cid:241) grup(cid:246) else, w przypadku gdy nast(cid:241)pi zako(cid:254)-
czenie dzia(cid:228)ania p(cid:246)tli bez wykonania instrukcji break. Zmienn(cid:241) cel
instrukcji for mo(cid:276)e by(cid:232) dowolny obiekt, który mo(cid:276)e si(cid:246) znale(cid:274)(cid:232) po
lewej stronie instrukcji przypisania (np. for (x, y) in lista_krotek).
Od Pythona w wersji 2.2 instrukcja for najpierw próbuje uzyska(cid:232) obiekt
iteratora I za pomoc(cid:241) metody iter(obiekt_iterowalny), a nast(cid:246)pnie wielo-
krotnie wywo(cid:228)uje metod(cid:246) I.__next__() obiektu — do czasu wyst(cid:241)pie-
nia wyj(cid:241)tku StopIteration (w Pythonie 2.X metoda I.__next__() ma
nazw(cid:246) I.next()). Je(cid:264)li nie mo(cid:276)na uzyska(cid:232) (cid:276)adnego obiektu iteratora
(np. nie zdefiniowano metody __iter__), to instrukcja for dzia(cid:228)a poprzez
wielokrotne indeksowanie obiektu obiekt_iterowalny z u(cid:276)yciem coraz
wi(cid:246)kszych warto(cid:264)ci przesuni(cid:246)cia, a(cid:276) zostanie zg(cid:228)oszony wyj(cid:241)tek
IndexError.
Iteracja w Pythonie odbywa si(cid:246) w wielu kontekstach, w(cid:228)(cid:241)cznie z instruk-
cjami p(cid:246)tli for, obiektami sk(cid:228)adanymi i instrukcjami map(). Wi(cid:246)cej infor-
macji na temat mechanizmów u(cid:276)ywanych przez p(cid:246)tl(cid:246) for oraz w pozo-
sta(cid:228)ych kontekstach iteracji mo(cid:276)na znale(cid:274)(cid:232) w podrozdziale „Protokó(cid:228)
iteracji”.
Instrukcje
(cid:95)
83
Poleć książkęKup książkę Instrukcja pass
pass
Instrukcja-wype(cid:228)niacz, która nie wykonuje (cid:276)adnych dzia(cid:228)a(cid:254). U(cid:276)ywa si(cid:246)
jej wtedy, gdy jest to syntaktycznie konieczne (np. w odniesieniu do
namiastek funkcji). W Pythonie 3.X podobny efekt mo(cid:276)na uzyska(cid:232) za
pomoc(cid:241) wielokropka (...).
Instrukcja break
break
Powoduje natychmiastowe zako(cid:254)czenie najbli(cid:276)szej instrukcji p(cid:246)tli while
lub for z pomini(cid:246)ciem powi(cid:241)zanych z nimi grup else (o ile takie ist-
niej(cid:241)). Wskazówka: w celu wyj(cid:264)cia z wielopoziomowych p(cid:246)tli mo(cid:276)na
skorzysta(cid:232) z instrukcji raise i try.
Instrukcja continue
continue
Powoduje natychmiastowe przej(cid:264)cie na pocz(cid:241)tek najbli(cid:276)szej instrukcji
p(cid:246)tli while lub for i wznowienie wykonywania grupy instrukcji w p(cid:246)tli.
Instrukcja del
del nazwa
del nazwa[i]
del nazwa[i:j:k]
del nazwa.atrybut
Instrukcja del usuwa nazwy, elementy, wycinki i atrybuty, a tak(cid:276)e
powi(cid:241)zania. W pierwszej postaci nazwa jest dos(cid:228)own(cid:241) nazw(cid:241) zmien-
nej. W ostatnich trzech formach instrukcji nazwa mo(cid:276)e by(cid:232) dowolnym
wyra(cid:276)eniem (z u(cid:276)yciem nawiasów, je(cid:264)li s(cid:241) potrzebne do okre(cid:264)lenia
priorytetu). Na przyk(cid:228)ad: del a.b()[1].c.d.
Instrukcja ta s(cid:228)u(cid:276)y przede wszystkim do struktur danych, a nie zarz(cid:241)-
dzania pami(cid:246)ci(cid:241). Usuwa równie(cid:276) referencje do obiektów wywo(cid:228)ywa-
nych wcze(cid:264)niej. Mo(cid:276)e spowodowa(cid:232) ich usuni(cid:246)cie przez mechanizm
od(cid:264)miecania, w przypadku gdy nie b(cid:246)dzie do nich odwo(cid:228)ania w innych
miejscach. Proces od(cid:264)miecania zachodzi jednak automatycznie i nie
musi by(cid:232) wymuszany za pomoc(cid:241) instrukcji del.
84
(cid:95)
Python. Leksykon kieszonkowy
Poleć książkęKup książkę Skorowidz
ABCDEFGHIJKLMNOPQRST
UVWXYZ , 184
formatowanie, 32, 33, 34
internowanie, 178
przestankowych, 185
D
debugger, 182
decimal, Patrz: liczba dziesi(cid:246)tna
dekodowanie Unicode, 153
dekorator, 88, 98, 110, 150
@staticmethod, 152
depth first left right, Patrz: DFLR
deskryptor, 131
klas, 192
plików, 192
pliku, 191, 193, 200
destruktor, 120
DFLR, 114
diament, 113, 115
diamond pattern, Patrz: diament
dictionary comprehension, Patrz:
s(cid:228)ownik sk(cid:228)adany
domkni(cid:246)cie, 109, 110
dowi(cid:241)zanie symboliczne, 202
dziedziczenie, 111, 114, 163, 192
nowego stylu, 115, 116, 117
wielokrotne, 113
A
ASCII, Patrz: typ tekstowy ASCII
asercja, 104
B
backport, Patrz: poprawka
bajt, 22, 23
baza danych relacyjna, 232
biblioteka
Tk, 217, 220
tkinter, 217
b(cid:228)(cid:241)d
interpretera, 168
sekwencji, 164
sk(cid:228)adni, 167, 171
systemowy, 164, 169
bufor, 158
C
cel
operatora , 33, 34
zagnie(cid:276)d(cid:276)anie, 35
zast(cid:246)powanie, 33, 35, 36
ci(cid:241)g
pusty, 30
tekstowy, 39, 46
znaków, 22, 23, 30, 138, 159
\t\n\r\v\f , 185
01234567 , 185
0123456789 , 184
0123456789abcdefABCDEF , 185
abcdefghijklmnopqrstuvwxyz ,
184
E
egzemplarz
atrybut, 117
tworzenie, 119
element widok, 57
243
Poleć książkęKup książkę F
fraction, Patrz: u(cid:228)amek
funkcja, Patrz te(cid:276): instrukcja, modu(cid:228)
__import__, 141
abs, 135
adnotacja, 86
all, 135
anonimowa, 18
any, 135
apply, 157
argument, 85
domy(cid:264)lny, 87
kluczowy, 86
ascii, 136, 157
basestring, 158
bin, 136
bool, 121, 136
buffer, 158
bytearray, 136
bytes, 121, 136
callable, 137
chr, 137
classmethod, 89, 98, 137
cmp, 158
coerce, 158
compile, 106, 137, 204, 206
complex, 138
deklaracja opisuj(cid:241)ca, Patrz:
dekorator
delattr, 138
dict, 57, 138
dir, 125, 138
divmod, 138
enumerate, 138
eval, 106, 139, 150, 167
exec, 106, 139, 157, 167
execfile, 106, 158
execv, 198, 199
execve, 198
execvp, 198
fabryka, 88
file, 159
filter, 54, 139
float, 140
format, 121, 140
frozenset, 66, 140
244 (cid:95)
Python. Leksykon kieszonkowy
generatora, 18, 89, 90
getattr, 140
getswitchinterval, 177, 178
globals, 140
hasattr, 140
hash, 140
help, 72, 141
hex, 134, 141
id, 141
imp.reload, 93, 160
importlib.import_module, 93
input, 141, 159, 160, 165
int, 142
intern, 159
isinstance, 142
issubclass, 142
iter, 54, 142
len, 125, 143
list, 143
locals, 143
lokalna, 85
long, 159
map, 53, 54, 143
max, 144
memoryview, 144, 157
metoda klasy, 75, 98
min, 144
namiastka, 84
next, 54, 55, 126, 142, 144, 167
normpath, 201
object, 145
oct, 145
okalaj(cid:241)ca, 108, 109
open, 61, 145, 149, 159, 162, 192
operator.index, 130
ord, 149, 160
os. popen, 189
os._exit, 199
os.abort, 198
os.access, 197
os.altsep, 187
os.chdir, 191, 194
os.chmod, 194
os.chown, 194
os.close, 192
os.defpath, 188
os.devnull, 188
Poleć książkęKup książkę os.dup, 192
os.environ, 190
os.execl, 198
os.execle, 198
os.execlp, 198
os.execv, 199
os.execve, 198
os.execvp, 199
os.execvpe, 199
os.extsep, 187
os.fdopen, 192
os.fork, 199
os.fstat, 192
os.ftruncate, 192
os.getcwd, 191, 194
os.getenv, 190
os.geteuid, 199
os.getpid, 199
os.getppid, 199
os.getuid, 199
os.isatty, 193
os.kill, 200
os.linesep, 188
os.link, 194
os.listdir, 194
os.lseek, 193
os.lstat, 195
os.makedirs, 195
os.mkdir, 195
os.mkfifo, 195, 200
os.nice, 200
os.open, 193, 194
os.path.abspath, 201
os.path.basename, 201
os.path.commonprefix, 201
os.path.dirname, 202
os.path.exists, 202
os.path.expanduser, 202
os.path.expandvars, 202
os.path.getatime, 202
os.path.getmtime, 202
os.path.getsize, 202
os.path.isabs, 202
os.path.isdir, 202
os.path.isfile, 202
os.path.islink, 202
os.path.ismount, 202
os.path.join, 203
os.path.normcase, 203
os.path.normpath, 203
os.path.realpath, 203
os.path.samefile, 203
os.path.sameopenfile, 203
os.path.samestat, 203
os.path.split, 203
os.path.splitdrive, 203
os.pathsep, 188
os.pipe, 193, 200
os.plock, 200
os.putenv, 190
os.read, 193
os.readlink, 196
os.remove, 196
os.removedirs, 196
os.rename, 196
os.renames, 196
os.rmdir, 196
os.spawnv, 200
os.spawnve, 200
os.startfile, 189
os.stat, 196
os.strerror, 191
os.symlink, 196
os.system, 188
os.times, 191
os.umask, 191
os.uname, 191
os.unlink, 196
os.utime, 197
os.wait, 200
os.waitpid, 201
os.walk, 197
os.write, 193
pow, 149
print, 149, 150, 157
property, 89, 113, 150
range, 150, 161
raw_input, 160, 165
re.compile, 106, 137, 204, 206
reduce, 160
reload, 93, 160
repr, 120, 136, 150, 157
reversed, 151
round, 151
Skorowidz
(cid:95) 245
Poleć książkęKup książkę funkcja, Patrz te(cid:276): instrukcja, modu(cid:228)
równoleg(cid:228)a, 231
set, 66, 151
setattr, 151
setcheckinterval, 232
setswitchinterval, 232
slice, 151
sorted, 152
staticmethod, 89, 98, 152
str, 121, 150, 152, 153, 161
string.capwords, 184
string.Formatter, 184
string.maketrans, 184
string.Template, 184
sum, 153
super, 8, 115, 153, 154
sys.__stderr__, 182
sys.__stdin__, 182
sys.__stdout__, 182
sys._getframe, 177
sys.argv, 175
sys.builtin_module_names, 175
sys.byteorder, 175
sys.copyright, 176
sys.displayhook, 176
sys.dont_write_bytecode, 176
sys.exc_info, 176
sys.excepthook, 176
sys.exec_prefix, 176
sys.executable, 177
sys.exit, 177
sys.flags, 177
sys.float_info, 177
sys.getcheckinterval, 177
sys.getdefaultencoding, 177
sys.getfilesystemencoding, 177
sys.getrecursionlimit, 178
sys.getrefcount, 178
sys.getsizeof, 178
sys.getswitchinterval, 177, 178
sys.getwindowsversion, 178
sys.hexversion, 178
sys.implementation, 178
sys.int_info, 178
sys.intern, 178
sys.last_traceback, 179
sys.last_type, 179
246 (cid:95)
Python. Leksykon kieszonkowy
sys.last_value, 179
sys.maxsize, 179
sys.maxunicode, 179
sys.modules, 179
sys.path, 179
sys.platform, 180
sys.prefix, 180
sys.ps1, 180
sys.ps2, 180
sys.setcheckinterval, 180
sys.setdefaultencoding, 181
sys.setprofile, 181
sys.setrecursionlimit, 181
sys.setswitchinterval, 181
sys.settrace, 182
sys.stderr, 182
sys.stdin, 182
sys.stdout, 182
sys.sys.version, 183
sys.thread_info, 183
sys.tracebacklimit, 183
sys.version_info, 183
sys.winver, 183
(cid:264)ladu systemu, 182
tuple, 155
tworzenie, 85
type, 68, 113, 155
unichr, 160
unicode, 161
vars, 156
warnings.warn, 171
wbudowana, 108
nazwa, 74
wspó(cid:228)bie(cid:276)na, 231
xrange, 161
zagnie(cid:276)d(cid:276)ona, 91, 109
zip, 156
G
garbage collector, Patrz: od(cid:264)miecanie
geometry manager, Patrz: mened(cid:276)er
geometrii
gniazdo, 113
GUI, 15, 217
Poleć książkęKup książkę H
hash, Patrz: skrót
I
indeksowanie, 19, 25
instrukcja, 71, 75, Patrz te(cid:276): funkcja
assert, 104, 165
blok, 71
break, 84, 100
class, 74, 97, 98, 111
continue, 84, 100
def, 85, 87, 106, 111
del, 84, 138
exec, 106, 141
for, 53, 54, 83, 84, 90, 152
from, 95, 96, 97, 141, 165
global, 91
if, 82
import, 92, 93, 95, 141, 165
pakiet, 93
nonlocal, 91, 106, 109
pass, 84
print, 80, 81, 82, 106
przypisania, 75, 98, 107, 111
krotek, 76
sekwencji, 76, 77, 78
wielocelowego, 76
raise, 84, 100, 102, 103, 106
return, 89, 91, 100
sk(cid:228)adnia, 70
try, 84, 99, 100, 101, 103, 104, 106,
109, 164, 168
klauzula, 100, 101
while, 83, 84
with, 104, 105, 106, 131
wyra(cid:276)eniowa, 79
yield, 20, 89, 90
interfejs
API, 232, 233
Berkeley DB, 211
dopasowywania wyra(cid:276)e(cid:254)
regularnych, 204
mened(cid:276)era geometrii, 218
modu(cid:228)u, 234
obiektów zwracanych, 148
PyDoc, 72
us(cid:228)ug systemu operacyjnego, 185
internet, 222
interpreter, 175, 178
interaktywny, 74
(cid:264)cie(cid:276)ka dost(cid:246)pu, 177
w(cid:241)tek, 181
wersja, 183
inwersja, Patrz: operacja bitowa NOT
iteracja, 55, 138
kontekst, 54
protokó(cid:228), 54, 55, 89, 126
widoku, 57
iterator, 54, 83, 89
K
klasa, 69, 97, 98, 110
atrybut, 98, 111, 117
prywatny, 112
bazowa, Patrz: klasa nadrz(cid:246)dna
egzemplarz, 102, 111
Exception, 103
gniazdo, Patrz: gniazdo
klasyczna, 113, 114
metoda, 111
nadrz(cid:246)dna, 97
nazwa, 74
nowego stylu, 103, 111, 113, 114,
116, 117, 150
Pickler, 216
String, 39
Unpickler, 216
wyj(cid:241)tków, Patrz: wyj(cid:241)tek klasa
klasa-deskryptor, 130
klasa-w(cid:228)a(cid:264)ciciel, 130
klauzula
as, 92, 96, 101, 104
else, 100
except, 100, 101, 102, 109
finally, 100, 102, 104, 168
from, 90, 102
klucz, 21, 23, 57, 126, 144, 212
krotki, 57
mapowania, 166
rejestru, 183
skrótu, 121
Skorowidz
(cid:95) 247
Poleć książkęKup książkę klucz
s(cid:228)ownika, 178
widok, 57
wyszukiwania, 178
klucz-warto(cid:264)(cid:232), 57
kod
bajtowy, 92
blok
wej(cid:264)ciowy, 104
zagnie(cid:276)d(cid:276)ony, 104
zamykaj(cid:241)cy, 104
wielokrotne wykorzystanie, 98
(cid:274)ród(cid:228)owy, 92
wci(cid:246)cia, 166
kolejka FIFO, 195
kolekcja, 125
d(cid:228)ugo(cid:264)(cid:232), 143
komentarz, 72
komunikat, 104
konstruktor, 120
krotka, 19, 22, 23, 33, 60, 61, 134, 155
klucz, 57
kodowanie, 33
przypisanie, 76
zagnie(cid:276)d(cid:276)ona, 33
kursor, 235
L
launcher, 15, 17
liczba, 26
ca(cid:228)kowita, 142, 159
dziesi(cid:246)tna, 26, 28
u(cid:228)amkowa, Patrz: u(cid:228)amek
zespolona, 26, 27, 138
zmiennoprzecinkowa, 27, 140,
142, 151
lista, 22, 23, 50, 156, 228
litera(cid:228), 50
obiekt
wstawianie, 52
wyszukiwanie, 51
pozycja, 50
sk(cid:228)adana, 52, 53, 54, 55, 56, 110
z zagnie(cid:276)d(cid:276)onymi p(cid:246)tlami for, 53
sortowanie, 51
wyra(cid:276)e(cid:254), 52
248 (cid:95)
Python. Leksykon kieszonkowy
litera(cid:228), 18, 26
b ccc , 49
bytes, 29
ccc , 46
listy, Patrz: lista litera(cid:228)
(cid:228)a(cid:254)cuchowy, 31
s(cid:228)ownikowy, Patrz: s(cid:228)ownik litera(cid:228)
tworzenie, 30
u ccc , 47, 49
znakowy, 31
(cid:292)
(cid:228)a(cid:254)cuch
wyj(cid:241)tków, Patrz: wyj(cid:241)tek (cid:228)a(cid:254)cuch
znaków, Patrz: ci(cid:241)g znaków
M
mapa, 110, 125
indeksowanie, 126
mened(cid:276)er
geometrii, 218
kontekstu, 104, 131
protokó(cid:228), 105
zagnie(cid:276)d(cid:276)ony, 105
metaklasa, 99, 156
Method Resolution Order, Patrz: MRO
metoda, 21
__abs__, 24, 130
__add__, 119, 127
__and__, 128
__bool__, 121, 125, 132, 133
__bytes__, 121, 132
__call__, 99, 122, 137, 221
__cmp__, 22, 123, 124, 133, 158
__coerce__, 134
__complex__, 25, 130
__contains__, 22, 125
__del__, 120, 234, 235
__delattr__, 123
__delete__, 113, 131
__delitem__, 23, 24, 41, 127, 133
__delslice__, 23, 134
__dict__, 123
__dir__, 125, 132
__div__, 127, 134
Poleć książkęKup książkę __divmod__, 128
__enter__, 105, 131
__eq__, 121, 123, 124, 133
__exit__, 105, 106, 132
__float__, 25, 130
__floordiv__, 128
__format__, 121
__ge__, 123, 124, 133
__get__, 113, 116, 117, 131
__getattr__, 112, 113, 114, 116, 118,
122, 123, 125, 132
__getattribute__, 113, 116
__getitem__, 22, 23, 54, 118, 119,
125, 126, 127, 133, 151
__getslice__, 23, 133
__gt__, 123
__hash__, 57, 121, 140
__hex__, 130, 133, 134, 141
__iadd__, 41, 77, 129
__iand__, 129
__ifloordiv__, 129
__ilshift__, 129
__imod__, 129
__import__, 93
__imul__, 41, 129
__index__, 130, 133, 134, 136, 141,
145
__init__, 90, 93, 94, 99, 103, 119,
120, 156
__instancecheck__, 125, 132
__int__, 24, 130
__invert__, 24, 130
__ior__, 129
__ipow__, 129
__irshift__, 129
__isub__, 129
__iter__, 22, 23, 54, 55, 83, 90, 125,
126, 143
__itruediv__, 129, 134
__ixor__, 129
__le__, 123
__len__, 23, 24, 121, 125, 126, 127,
132, 133, 151
__long__, 24, 134
__lshift__, 128
__lt__, 22, 123, 124, 133
__metaclass__, 99, 135
__mod__, 128
__mul__, 127
__ne__, 123, 124
__neg__, 24, 130
__new__, 99, 119, 120, 156
__next__, 54, 90, 126, 132, 142, 144
__nonzero__, 121, 125, 132, 133
__oct__, 130, 133, 134, 145
__or__, 128
__pos__, 24, 130
__pow__, 128
__radd__, 128, 129
__rand__, 128
__rcmp__, 133
__rdivmod__, 128
__repr__, 120, 121
__reversed__, 127, 151
__rfloordiv__, 128
__rlshift__, 128
__rmod__, 41, 128
__rmul__, 128
__ror__, 128
__round__, 130, 132
__rpow__, 128
__rrshift__, 128
__rshift__, 128
__rsub__, 128
__rtruediv__, 128, 134
__rxor__, 128
__set__, 113, 117, 131
__setattr__, 112, 114, 117, 118, 122,
123
__setitem__, 23, 41, 126, 133
__setslice__, 23, 134
__slots__, 113, 124, 125, 132
__str__, 120, 121, 135, 153
__sub__, 127
__subclasscheck__, 125, 132
__truediv__, 127, 132
__unicode__, 135, 161
__X__, 98
__xor__, 128
bytes.translate, 184
close, 90, 165
D.clear, 58
D.copy, 58
D.get, 59
Skorowidz
(cid:95) 249
Poleć książkęKup książkę metoda
D.has_key, 59
D.items, 58
D.iteritems, 59
D.keys, 58
D.pop, 59
D.popitem, 59
D.setdefault, 59
D.update, 59
D.values, 58
D.viewitems, 59
delim.join, 46
destruktora, 120
dict.fromkeys, 59
dzia(cid:228)ania dwuargumentowego,
128, 129
dzia(cid:228)ania na zbiorach, 67
file, 61
file.close, 64
file.closed, 65
file.fileno, 64
file.flush, 64
file.isatty, 64
file.mode, 65
file.name, 65
file.seek, 64
file.tell, 64
file.truncate, 64
for line in infile, 63
formatuj(cid:241)ca, 34, 38
sk(cid:228)adnia, 36
generatora, 90
has_key, 56, 57
I.__class__, 113
I.__next__, 54, 55, 83, 142, 143, 167
I.next, 54, 55, 143
infile, 62
infile.read, 62
infile.readline, 63
infile.readlines, 63
io.BytesIO, 62, 148
io.StringIO, 62, 148
isinstance, 125
issubclass, 125
items, 56, 57
iter, 83
iteratora, 56
250 (cid:95)
Python. Leksykon kieszonkowy
iteritems, 56
iterkeys, 56
itervalues, 56
keys, 56, 57
klasy, 137
abstrakcyjnej, 166
String, 39
konstruktora, 120
L.append, 51
L.clear, 52
L.copy, 52
L.count, 52
L.extend, 51
L.index, 51
L.insert, 52
L.pop, 52
L.remove, 52
L.reverse, 51
L.sort, 51, 52, 57
obiektgniazda.makefile, 62
obiektu string, 183
open, 61, 62, 63, 66, 212
outfile, 63
outfile.write, 63
outfile.writelines, 64
prawostronna, 128
przeci(cid:241)(cid:276)aj(cid:241)ca operator, 98
przeci(cid:241)(cid:276)ania klas, 118
przeci(cid:241)(cid:276)ania operatorów, 68, 118, 132
przypisania z aktualizacj(cid:241), 129
reversed, 51
s.capitalize, 184
S.capitalize, 44
S.casefold, 44
S.center, 45
S.count, 43
S.endswith, 43
S.expandtabs, 44
S.find, 42
S.format, 44
S.index, 42
s.join, 184
S.join, 43
S.ljust, 44
S.lower, 44
S.lstrip, 44
S.replace, 43
Poleć książkęKup książkę S.rfind, 42
S.rindex, 42
S.rjust, 45
S.rstrip, 44
s.split, 184
S.split, 43
S.splitlines, 43
S.startswith, 43
S.strip, 44
S.swapcase, 44
S.title, 45
S.translate, 45
S.upper, 44
S.zfill, 45
send, 90
separatora, 46
statyczna, 152
str.format, 38, 41, 121, 140, 184
StringIO.stringIO, 148
sys.exit, 168
T.count, 61
T.index, 61
throw, 90
values, 56, 57
viewitems, 57
viewkeys, 57
viewvalues, 57
write, 81
X.__iter__, 54
X.__round__, 151
xreadlines, 66
modu(cid:228), 94, Patrz te(cid:276): funkcja
__builtin__, 135, 157
anydbm, 211
atrybut prywatny, 112
biblioteczny, 174, 175
builtins, 135
datetime, 228
dbm, 61, 210, 211, 212, 213
docelowy, 92
dopasowywania wzorców
tekstowych re, 41
enum, 230
glob, 186
imp, 160
importowanie, 92, 95, 96
interfejs, 234
internetowy, 222
json, 228
kwalifikacja, 92
math, 225
multiprocessing, 186
nazwa, 75
obiekt, Patrz:(cid:3)obiekt modu(cid:371)u
obs(cid:228)ugi w(cid:241)tków, 231
os, 62, 185
os.path, 185, 201
pickle, 61, 210, 211, 214, 215
queue, 186, 232
re, 204
shelve, 61, 211, 212
signal, 186
socket, 186
string, 183, 184
struct, 230
subprocess, 186, 229
sys, 159, 175, 186
tempfile, 186, 194
threading, 186, 232
time, 225
timeit, 227
tkinter, 217, 218, 219, 220
utrwalania obiektów, 210
weakref, 167
MRO, 8, 114, 115, 154
N
nazwa
kwalifikowana, 107
niekwalifikowana, 107, 108
zasi(cid:246)g, 108
O
obiekt, 145
bufora, Patrz: bufor
dopasowania, 207
egzemplarza, 98
file, 192
generatora, 55, 89
integer, 130
iteratora, 142
Skorowidz
(cid:95) 251
Poleć książkęKup książkę obiekt
iterowalny, 54, 66, 67, 83, 89, 143,
151, 156, 160
klasy, 97, 111
kursora, Patrz: kursor
modu(cid:228)u, 92
NotImplemented, 124, 127
pliku, 61
ramki, 177
referencja, 75
rozmiar, 178
serializacja, 214
shelve, 212
sk(cid:228)adany, 109
str, 29, 39
string, 39, 183
utrwalanie, 210
widoku, 57
widoku pami(cid:246)ci, 144
wyra(cid:276)e(cid:254) regularnych, 206
object-oriented programming,
Patrz: programowanie obiektowe
od(cid:264)miecanie, 18, 120
odwzorowanie, 21, 23, 24
OOP, Patrz: programowanie obiektowe
operacja
bitowa
AND, 18
NOT, 19
OR, 18
XOR, 18
katalogowa, 170
logiczna, 21, 22
AND, 18
negacja, 18
OR, 18
matematyczna, 225
plikowa, 170
porównania, 22
wej(cid:264)ciowa, 146
wycinania, 126
wyj(cid:264)ciowa, 147
zmiennoprzecinkowa, 165, 177
operator, 19, 127
, 33, 34
dwuargumentowy, 128
porównania, 20, 123
252 (cid:95)
Python. Leksykon kieszonkowy
równo(cid:264)ci, 18
trójargumentowy, 18
wyra(cid:276)eniowy, 18, 19
ostrze(cid:276)enie, 170, 171
blokowanie, 171
P
pakiet, 93, 94, 96
pami(cid:246)(cid:232)
globalna, 231
wyczerpywanie si(cid:246), 166
parsowanie, 230
plik, 61
.pth, 92
.pyc, 93
__init__.py, 93, 94
buforowanie, 66
dbm, 213
deskryptor, 148, 191, 193, 200
JSON, 228
koniec, 165
modyfikacja, 202
otwieranie, 145, 162, 212
tryb, 146
py.exe, 15
pyw.exe, 15
rozmiar, 202
shelve, 213
(cid:264)cie(cid:276)ka, 194, 195, 196, 197, 201
tryb otwarcia, 65
tworzenie, 212
wej(cid:264)ciowy, 62
wykonywalny, 199
zamykanie, 192
polecenie
help, 40
pow(cid:228)oki, 185, 188
python -m pydoc -b, 72
poprawka, 57
print, 121
proces
potomny, 199, 200, 201
tworzenie, 198, 199
uprzejmo(cid:264)(cid:232), 200
Poleć książkęKup książkę programowanie
funkcyjne, 110
obiektowe, 110
protokó(cid:228)
iteracji, Patrz: iteracja protokó(cid:228)
mened(cid:276)era kontekstu, Patrz:
mened(cid:276)er kontekstu protokó(cid:228)
sekwencji, Patrz: sekwencja
protokó(cid:228)
przepe(cid:228)nienie, 167
przerwanie, 166
przestrze(cid:254) nazw, 91, 94, 107, 111, 138,
160
obiektu, 107
punkt montowania, 202
Python
idiomy, 236
implementacja, 7
launcher, Patrz: launcher
rdze(cid:254) j(cid:246)zyka, 236
(cid:264)rodowisko, 238
u(cid:276)ytkowanie, 239, 240
wersja, 15, 178, 183
S
sekwencja, 21, 22, 23, 25, 125
dzia(cid:228)anie, 32
indeksowanie, 126
modyfikowalna, Patrz: sekwencja
mutowalna
mutowalna, 23, 29, 46, 50
niemutowalna, 29, 46, 60
protokó(cid:228), 126
przypisanie, 77
serializacja, 214
set comprehension, Patrz: zbiór
sk(cid:228)adany
skrót, 121
slicing, Patrz: rozcinanie
slot, 124, Patrz: gniazdo
s(cid:228)ownik, 23, 24, 56, 138, 140, 156, 213,
228
litera(cid:228), 57
modu(cid:228)ów, 179
poprawka, Patrz: poprawka
porównywanie, 57
sk(cid:228)adany, 56, 57
s(cid:228)owo zarezerwowane, 73, 74, 118
SQL, 232
SQLite, 233
sta(cid:228)a
ascii_letters, 184
ascii_lowercase, 184
ascii_uppercase, 184
digits, 184
hexdigits, 185
octdigits, 185
printable, 185
punctuation, 185
tekstowa, 31
whitespace, 185
stos, 168, 177, 178, 181
strumie(cid:254), 229
standardowy, 182
symbol zach(cid:246)ty, 180
synonim, 92, 96
system, 180
operacyjny, 185
plików, 212
(cid:315)
(cid:264)cie(cid:276)ka, 201
nazwa, 194, 195, 196, 197
T
tabela translacji, 184
tablica bajtowa, 22, 23
target, Patrz: cel
test
diagnostyczny, 104
is*, 45
zawarto(cid:264)ci, 45
tryb
otwarcia
tekstowy Unicode, 63
typ, 113
Boolean, 21, 69
Ellipsis, 68
konwersja, 69
liczbowy, 24, 25, 26, 27
logiczny, 68
otwarcia plików, Patrz: plik tryb
Skorowidz
(cid:95) 253
Poleć książkęKup książkę typ
(cid:228)a(cid:254)cuchowy, 29, 32
bytearray, 41, 46, 48, 49
bytes, 41, 46, 48
str, 29, 32, 41, 46
model dynamiczny, 17
None, 68
NotImplemented, 68
numeryczny, 21
obiektowy, 17
odpowiadaj(cid:241)cy jednostkom
programu, 69
set, 28
tekstowy
ASCII, 48, 136, 149
Unicode, 41, 46, 47, 48, 49, 135,
149, 153, 160, 161, 179
wbudowany, 127
wyliczeniowy, 230
U
u(cid:228)amek, 26, 28
Unicode, Patrz: typ tekstowy Unicode
uprawnienia dost(cid:246)pu, 170
W
warto(cid:264)(cid:232) widok, 57
w(cid:241)tek, 183, 231
widget, 217, 218, 219, 220
widok
elementu, 57
klucza, Patrz: klucz widok
warto(cid:264)ci, 57
wiersz polece(cid:254), 175, 177, 186, 229
flaga -O, 104
format, 9, 12
opcja, 9, 12, 14
specyfikacja programu, 11
wycinanie, 126
wycinek, 151, 166
prosty, 25
przypisanie, 26
rozszerzony, 25
254 (cid:95)
Python. Leksykon kieszonkowy
wyj(cid:241)tek, 103
ArithmeticError, 164
AssertionError, 104, 165
AttributeError, 165
BaseException, 163
BlockingIOError, 169
BrokenPipeError, 169
BufferError, 164
BytesWarning, 171
ChildProcessError, 169
ConnectionAbortedError, 169, 170
ConnectionError, 169
ConnectionRefusedError, 169, 170
ConnectionResetError, 170
DeprecationWarning, 171
EnvironmentError, 172
EOFError, 165
Exception, 164, 173
FileExistsError, 170
FileNotFoundError, 170
FloatingPointError, 164, 165
FutureWarning, 171
GeneratorExit, 90, 164, 165
ImportError, 165
ImportWarning, 171
IndentationError, 166
IndexError, 54, 166
InterruptedError, 170
IOError, 145, 162, 172
IsADirectoryError, 170
KeyboardInterrupt, 164, 166
KeyError, 166
klasa, 103
bazowa, 163
LookupError, 164
(cid:228)a(cid:254)cuch, 102
MemoryError, 166
NameError, 165, 166
nazwa, 74
nieobs(cid:228)u(cid:276)ony, 183
nieprzechwycony, 179
NotImplemented, 166
NotImplementedError, 166
OSError, 164, 172, 173
OverflowError, 164, 167
PendingDeprecationWarning, 171
Poleć książkęKup książkę PermissionError, 170
ProcessLookupError, 170
przechwytywanie, 100
ReferenceError, 167
ResourceWarning, 171
RuntimeError, 165, 167
RuntimeWarning, 171
StopIteration, 54, 91, 126, 142,
145, 167
SyntaxError, 165, 167
SyntaxWarning, 171
SystemError, 168
SystemExit, 164, 168
TabError, 168
TimeoutError, 170
TypeError, 168
UnboundLocalError, 168
UnicodeDecodeError, 169
UnicodeEncodeError, 169
UnicodeError, 168
UnicodeTranslateError, 169
UnicodeWarning, 171
UserWarning, 171
ValueError, 165, 169
VMSError, 173
Warning, 170
wbudowany, 163
WindowsError, 173
ZeroDivisionError, 164, 169
zg(cid:228)aszanie, 100, 102
wyra(cid:276)enie
formatuj(cid:241)ce (cid:228)a(cid:254)cuch znaków, 33,
34, 38
generatorowe, 54, 55
in, 57
jako instrukcja, 79
lambda, 86, 87, 110
listowe, Patrz: lista sk(cid:228)adana
regularne, 204, 206, 207, 208, 211
sk(cid:228)adnia, 209, 210
rozcinaj(cid:241)ce, 20
yield, 89
wywo(cid:228)anie zwrotne, 182
wzorzec
diamentu, 113, 115
wyra(cid:276)e(cid:254) regularnych, 171, 204
Z
zakres, 166
zasi(cid:246)g
funkcji wbudowanych, 108
globalny, 108
leksykalny, 107
lokalny, 108
nazw niekwalifikowanych, 108
zagnie(cid:276)d(cid:276)ony statycznie, 109
zbiór, 66
dzia(cid:228)ania, 67
sk(cid:228)adany, 56
zamro(cid:276)ony, 140
zmienna, 17, 72
globalna, 91
lokalna, 107, 143
nazwa, 17, 72, 73, 74
operacyjna, 13
p(cid:246)tli wyra(cid:276)e(cid:254) generatorowych, 55
PYTHONCASEOK, 14
PYTHONDEBUG, 15
PYTHONDONTWRITEBYTECODE,
15
PYTHONFAULTHANDLER, 14
PYTHONHASHSEED, 14
PYTHONHOME, 14
PYTHONINSPECT, 15
PYTHONIOENCODING, 14
PYTHONNOUSERSITE, 15
PYTHONOPTIMIZE, 15
PYTHONPATH, 13, 92, 179
PYTHONSTARTUP, 14
PYTHONUNBUFFERED, 15
PYTHONVERBOSE, 15
PYTHONWARNINGS, 15
sys.path, 92
(cid:264)rodowiska pow(cid:228)oki, 198
(cid:264)rodowiskowa, 13
znak, 29
, 71
#, 72
$, 73
, 33, 34, 36
=, 129
=, 129
*, 33, 78, 86
Skorowidz
(cid:95) 255
Poleć książkęKup książkę znak
**, 78
**=, 129
*=, 129
,, 36
..., 68
/, 201
//=, 129
/=, 129
;, 72
?, 73
@, 88
[.], 52
^=, 129
_, 74
__, 74, 118
{}, 56, Patrz: znak nawias klamrowy
|=, 129
~, 202
+=, 129
=, 129
-=, 129
=, 129
apostrof, 30
cudzys(cid:228)ów, 30
desygnatora, 30
nawias klamrowy, 34
oddzielaj(cid:241)cy
komponenty (cid:264)cie(cid:276)ki
wyszukiwania, 188
nazw(cid:246) pliku od rozszerzenia,
187
przestankowy, 185
spacja bia(cid:228)a, 42, 72
256 (cid:95)
Python. Leksykon kieszonkowy
Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)
