Idź do
• Spis treści
• Przykładowy rozdział
• Katalog online
• Dodaj do koszyka
• Zamów cennik
• Zamów informacje
o nowościach
• Fragmenty książek
online
Helion SA
ul. Kościuszki 1c
44-100 Gliwice
tel. 32 230 98 63
e-mail: helion@helion.pl
© Helion 1991–2010
Katalog książek
Twój koszyk
Cennik i informacje
Czytelnia
Kontakt
• Zamów drukowany
katalog
Python. Wprowadzenie.
Wydanie IV
Autor:
Mark Lutz
Tłumaczenie: Anna Trojan, Marek Pętlicki
ISBN: 978-83-246-2694-6
Tytuł oryginału:
Learning Python, 4th edition
Format: 172×245, stron: 1184
Poznaj język, który wykorzystuje Google i YouTube!
• Jak tworzyć i przetwarzać obiekty za pomocą instrukcji Pythona?
• Jak stworzyć strukturę kodu i wykorzystać go ponownie?
• Jak programować obiektowo w Pythonie?
Czy wiesz, dlaczego ponad milion programistów na całym świecie używa właśnie tego języka
skryptowego? Jego atuty to niezwykła czytelność, spójność i wydajność – pewnie dlatego także
i Ty chcesz opanować słynnego Pythona. Kod napisany w tym języku można z łatwością
utrzymywać, przenosić i używać go ponownie. Pozostaje on zrozumiały nawet wówczas, jeśli
analizuje go ktoś, kto nie jest jego autorem. Co więcej, taki kod ma rozmiary średnio o dwie
trzecie do czterech piątych mniejsze od kodu w językach C++ czy Java, co wielokrotnie zwiększa
wydajność pracy używających go programistów. Python obsługuje także zaawansowane
mechanizmy pozwalające na ponowne wykorzystanie kodu, takie jak programowanie
zorientowane obiektowo, a programy w nim napisane działają natychmiast, bez konieczności
przeprowadzania długiej kompilacji, niezależnie od wykorzystywanej platformy.
Naukę rozpoczniesz od najważniejszych wbudowanych typów danych – liczb, list czy słowników.
Przyjrzysz się również typom dynamicznym oraz ich interfejsom. Później poznasz instrukcje oraz
ogólny model składni Pythona. Poszerzysz wiedzę na temat powiązanych z nim narzędzi, takich
jak system PyDoc, a także alternatywnych możliwości tworzenia kodu. Dowiesz się wszystkiego
na temat modułów: jak się je tworzy, przeładowuje i jak się ich używa. W końcu poznasz klasy oraz
zagadnienia związane z programowaniem zorientowanym obiektowo i nauczysz się obsługiwać
wyjątki. Czwarte wydanie tej książki zostało wzbogacone
o wiele nowych, ciekawych i bardzo zaawansowanych zagadnień, dzięki czemu stanowi doskonałą
lekturę także dla zawodowców, na co dzień piszących kod w tym języku. Dzięki tej książce:
• zapoznasz się z podstawowymi typami wbudowanymi Pythona,
• nauczysz się tworzyć i przetwarzać obiekty za pomocą instrukcji Pythona, a także
opanujesz ogólny model składni tego języka
• stworzysz strukturę kodu i wykorzystasz kod ponownie dzięki podstawowym narzędziom
proceduralnym Pythona
• dowiesz się wszystkiego o modułach Pythona – pakietach instrukcji i funkcji oraz innych
narzędziach zorganizowanych w większe komponenty
• odkryjesz narzędzie programowania zorientowanego obiektowo, umożliwiające
strukturyzację kodu
• opanujesz model obsługi wyjątków i narzędzia programistyczne służące do pisania
większych programów
• zapoznasz się z zaawansowanymi narzędziami Pythona, w tym dekoratorami,
deskryptorami, metaklasami i przetwarzaniem tekstu Unicode
Opanuj Pythona z Markiem Lutzem – najbardziej znanym ekspertem w tej dziedzinie!
5
Spis treļci
Przedmowa .............................................................................................................................29
Czýļë I Wprowadzenie .................................................................................. 47
1. Pytania i odpowiedzi dotyczéce Pythona ..................................................................49
Dlaczego ludzie uĔywajñ Pythona?
49
JakoĈè oprogramowania
50
WydajnoĈè programistów
51
Czy Python jest jözykiem skryptowym?
51
Jakie sñ zatem wady Pythona?
53
Kto dzisiaj uĔywa Pythona?
53
Co mogö zrobiè za pomocñ Pythona?
55
Programowanie systemowe
55
Graficzne interfejsy uĔytkownika
55
Skrypty internetowe
56
Integracja komponentów
56
Programowanie bazodanowe
57
Szybkie prototypowanie
57
Programowanie numeryczne i naukowe
57
Gry, grafika, porty szeregowe, XML, roboty i tym podobne
58
Jakie wsparcie techniczne ma Python?
58
Jakie sñ techniczne mocne strony Pythona?
59
Jest zorientowany obiektowo
59
Jest darmowy
59
Jest przenoĈny
60
Ma duĔe moĔliwoĈci
61
MoĔna go äñczyè z innymi jözykami
62
Jest äatwy w uĔyciu
62
Jest äatwy do nauczenia siö
62
Zawdziöcza swojñ nazwö Monty Pythonowi
63
Jak Python wyglñda na tle innych jözyków?
63
Podsumowanie rozdziaäu
64
6
_
Spis treļci
SprawdĒ swojñ wiedzö — quiz
65
SprawdĒ swojñ wiedzö — odpowiedzi
65
2. Jak Python wykonuje programy? ................................................................................69
Wprowadzenie do interpretera Pythona
69
Wykonywanie programu
71
Z punktu widzenia programisty
71
Z punktu widzenia Pythona
72
Warianty modeli wykonywania
74
Alternatywne implementacje Pythona
75
Narzödzia do optymalizacji wykonywania
76
ZamroĔone pliki binarne
78
Inne opcje wykonywania
78
Przyszäe moĔliwoĈci?
79
Podsumowanie rozdziaäu
80
SprawdĒ swojñ wiedzö — quiz
80
SprawdĒ swojñ wiedzö — odpowiedzi
80
3. Jak wykonuje siý programy? ....................................................................................... 81
Interaktywny wiersz poleceþ
81
Interaktywne wykonywanie kodu
82
Do czego säuĔy sesja interaktywna?
83
Wykorzystywanie sesji interaktywnej
85
Systemowe wiersze poleceþ i pliki
87
Pierwszy skrypt
87
Wykonywanie plików za pomocñ wiersza poleceþ
88
Wykorzystywanie wierszy poleceþ i plików
90
Skrypty wykonywalne Uniksa (#!)
91
Klikniöcie ikony pliku
92
Klikniöcie ikony w systemie Windows
93
Sztuczka z funkcjñ input
94
Inne ograniczenia klikania ikon
95
Importowanie i przeäadowywanie moduäów
96
Wiöcej o moduäach — atrybuty
98
Uwagi na temat uĔywania instrukcji import i reload
100
Wykorzystywanie exec do wykonywania plików moduäów
101
Interfejs uĔytkownika IDLE
102
Podstawy IDLE
103
Korzystanie z IDLE
105
Zaawansowane opcje IDLE
106
Inne IDE
107
Inne opcje wykonywania kodu
108
Osadzanie wywoäaþ
108
ZamroĔone binarne pliki wykonywalne
109
Uruchamianie kodu w edytorze tekstowym
110
Spis treļci
_
7
Jeszcze inne moĔliwoĈci uruchamiania
110
Przyszäe moĔliwoĈci
110
Jakñ opcjö wybraè?
111
Podsumowanie rozdziaäu
112
SprawdĒ swojñ wiedzö — quiz
113
SprawdĒ swojñ wiedzö — odpowiedzi
113
SprawdĒ swojñ wiedzö — èwiczenia do czöĈci pierwszej
114
Czýļë II Typy i operacje ..................................................................................117
4. Wprowadzenie do typów obiektów Pythona ...........................................................119
Po co korzysta siö z typów wbudowanych?
120
NajwaĔniejsze typy danych w Pythonie
121
Liczby
122
ãaþcuchy znaków
124
Operacje na sekwencjach
124
NiezmiennoĈè
126
Metody specyficzne dla typu
126
Otrzymanie pomocy
127
Inne sposoby kodowania äaþcuchów znaków
128
Dopasowywanie wzorców
129
Listy
130
Operacje na sekwencjach
130
Operacje specyficzne dla typu
130
Sprawdzanie granic
131
ZagnieĔdĔanie
131
Listy skäadane
132
Säowniki
133
Operacje na odwzorowaniach
134
ZagnieĔdĔanie raz jeszcze
134
Sortowanie kluczy — pötle for
136
Iteracja i optymalizacja
137
Brakujñce klucze — testowanie za pomocñ if
138
Krotki
139
Czemu säuĔñ krotki?
140
Pliki
140
Inne narzödzia podobne do plików
142
Inne typy podstawowe
142
Jak zepsuè elastycznoĈè kodu
143
Klasy zdefiniowane przez uĔytkownika
144
I wszystko inne
145
Podsumowanie rozdziaäu
145
SprawdĒ swojñ wiedzö — quiz
146
SprawdĒ swojñ wiedzö — odpowiedzi
146
8
_
Spis treļci
5. Typy liczbowe ............................................................................................................ 149
Podstawy typów liczbowych Pythona
149
Literaäy liczbowe
150
Wbudowane narzödzia liczbowe
151
Operatory wyraĔeþ Pythona
152
Liczby w akcji
156
Zmienne i podstawowe wyraĔenia
157
Formaty wyĈwietlania liczb
158
Porównania — zwykäe i äñczone
160
Dzielenie — klasyczne, bez reszty i prawdziwe
161
Precyzja liczb caäkowitych
164
Liczby zespolone
165
Notacja szesnastkowa, ósemkowa i dwójkowa
165
Operacje poziomu bitowego
167
Inne wbudowane narzödzia liczbowe
168
Inne typy liczbowe
170
Typ liczby dziesiötnej
170
Typ liczby uäamkowej
172
Zbiory
176
WartoĈci Boolean
181
Dodatkowe rozszerzenia numeryczne
182
Podsumowanie rozdziaäu
183
SprawdĒ swojñ wiedzö — quiz
183
SprawdĒ swojñ wiedzö — odpowiedzi
184
6. Wprowadzenie do typów dynamicznych ................................................................. 185
Sprawa brakujñcych deklaracji typu
185
Zmienne, obiekty i referencje
186
Typy powiñzane sñ z obiektami, a nie ze zmiennymi
187
Obiekty sñ uwalniane
188
Referencje wspóädzielone
190
Referencje wspóädzielone a modyfikacje w miejscu
191
Referencje wspóädzielone a równoĈè
193
Typy dynamiczne sñ wszödzie
194
Podsumowanie rozdziaäu
194
SprawdĒ swojñ wiedzö — quiz
195
SprawdĒ swojñ wiedzö — odpowiedzi
195
7. Ĥaħcuchy znaków ...................................................................................................... 197
Literaäy äaþcuchów znaków
199
ãaþcuchy znaków w apostrofach i cudzysäowach sñ tym samym
200
Sekwencje ucieczki reprezentujñ bajty specjalne
200
Surowe äaþcuchy znaków blokujñ sekwencje ucieczki
203
Potrójne cudzysäowy i apostrofy kodujñ äaþcuchy znaków
bödñce wielowierszowymi blokami
204
Spis treļci
_
9
ãaþcuchy znaków w akcji
205
Podstawowe operacje
206
Indeksowanie i wycinki
207
Narzödzia do konwersji äaþcuchów znaków
210
Modyfikowanie äaþcuchów znaków
213
Metody äaþcuchów znaków
214
Przykäady metod äaþcuchów znaków — modyfikowanie
215
Przykäady metod äaþcuchów znaków — analiza skäadniowa tekstu
218
Inne znane metody äaþcuchów znaków w akcji
219
Oryginalny moduä string (usuniöty w 3.0)
220
WyraĔenia formatujñce äaþcuchy znaków
221
Zaawansowane wyraĔenia formatujñce
222
WyraĔenia formatujñce z uĔyciem säownika
224
Metoda format
225
Podstawy
225
UĔycie kluczy, atrybutów i przesuniöè
226
Formatowanie specjalizowane
227
Porównanie z wyraĔeniami formatujñcymi
229
Po co nam kolejny mechanizm formatujñcy?
232
Generalne kategorie typów
235
Typy z jednej kategorii wspóädzielñ zbiory operacji
235
Typy zmienne moĔna modyfikowaè w miejscu
236
Podsumowanie rozdziaäu
236
SprawdĒ swojñ wiedzö — quiz
236
SprawdĒ swojñ wiedzö — odpowiedzi
237
8. Listy oraz sĥowniki .....................................................................................................239
Listy
239
Listy w akcji
241
Podstawowe operacje na listach
241
Iteracje po listach i skäadanie list
242
Indeksowanie, wycinki i macierze
243
Modyfikacja list w miejscu
244
Säowniki
248
Säowniki w akcji
249
Podstawowe operacje na säownikach
250
Modyfikacja säowników w miejscu
251
Inne metody säowników
252
Przykäad z tabelñ jözyków programowania
253
Uwagi na temat korzystania ze säowników
254
Inne sposoby tworzenia säowników
257
Zmiany dotyczñce säowników w 3.0
258
Podsumowanie rozdziaäu
264
SprawdĒ swojñ wiedzö — quiz
264
SprawdĒ swojñ wiedzö — odpowiedzi
264
10
_
Spis treļci
9. Krotki, pliki i pozostaĥe .............................................................................................. 267
Krotki
267
Krotki w akcji
268
Dlaczego istniejñ listy i krotki?
271
Pliki
271
Otwieranie plików
272
Wykorzystywanie plików
273
Pliki w akcji
274
Inne narzödzia powiñzane z plikami
280
Raz jeszcze o kategoriach typów
281
ElastycznoĈè obiektów
282
Referencje a kopie
283
Porównania, równoĈè i prawda
285
Porównywanie säowników w Pythonie 3.0
287
Znaczenie True i False w Pythonie
288
Hierarchie typów Pythona
290
Obiekty typów
291
Inne typy w Pythonie
291
Puäapki typów wbudowanych
292
Przypisanie tworzy referencje, nie kopie
292
Powtórzenie dodaje jeden poziom zagäöbienia
293
Uwaga na cykliczne struktury danych
293
Typów niezmiennych nie moĔna modyfikowaè w miejscu
294
Podsumowanie rozdziaäu
294
SprawdĒ swojñ wiedzö — quiz
294
SprawdĒ swojñ wiedzö — odpowiedzi
295
SprawdĒ swojñ wiedzö — èwiczenia do czöĈci drugiej
295
Czýļë III Instrukcje i skĥadnia ........................................................................ 299
10. Wprowadzenie do instrukcji Pythona ...................................................................... 301
Raz jeszcze o strukturze programu Pythona
301
Instrukcje Pythona
301
Historia dwóch if
303
Co dodaje Python
304
Co usuwa Python
304
Skñd bierze siö skäadnia indentacji?
306
Kilka przypadków specjalnych
308
Szybki przykäad — interaktywne pötle
310
Prosta pötla interaktywna
310
Wykonywanie obliczeþ na danych uĔytkownika
311
Obsäuga bäödów za pomocñ sprawdzania danych wejĈciowych
312
Obsäuga bäödów za pomocñ instrukcji try
313
Kod zagnieĔdĔony na trzy poziomy gäöbokoĈci
314
Spis treļci
_
11
Podsumowanie rozdziaäu
315
SprawdĒ swojñ wiedzö — quiz
315
SprawdĒ swojñ wiedzö — odpowiedzi
315
11. Przypisania, wyraŜenia i wyļwietlanie .....................................................................317
Instrukcje przypisania
317
Formy instrukcji przypisania
318
Przypisanie sekwencji
319
Rozszerzona skäadnia rozpakowania sekwencji w 3.0
322
Przypisanie z wieloma celami
325
Przypisania rozszerzone
326
Reguäy dotyczñce nazw zmiennych
329
Instrukcje wyraĔeþ
332
Instrukcje wyraĔeþ i modyfikacje w miejscu
333
Polecenia print
334
Funkcja print Pythona 3.0
334
Instrukcja print w Pythonie 2.6
337
Przekierowanie strumienia wyjĈciowego
338
WyĈwietlanie niezaleĔne od wersji
341
Podsumowanie rozdziaäu
343
SprawdĒ swojñ wiedzö — quiz
344
SprawdĒ swojñ wiedzö — odpowiedzi
344
12. Testy if i reguĥy skĥadni .............................................................................................345
Instrukcje if
345
Ogólny format
345
Proste przykäady
346
Rozgaäözienia kodu
346
Reguäy skäadni Pythona
348
Ograniczniki bloków — reguäy indentacji
349
Ograniczniki instrukcji — wiersze i kontynuacje
351
Kilka przypadków specjalnych
352
Testy prawdziwoĈci
353
WyraĔenie trójargumentowe if/else
355
Podsumowanie rozdziaäu
356
SprawdĒ swojñ wiedzö — quiz
357
SprawdĒ swojñ wiedzö — odpowiedzi
358
13. Pýtle while i for ..........................................................................................................359
Pötle while
359
Ogólny format
360
Przykäady
360
Instrukcje break, continue, pass oraz else w pötli
361
Ogólny format pötli
361
Instrukcja pass
361
12
_
Spis treļci
Instrukcja continue
363
Instrukcja break
363
Instrukcja else
364
Pötle for
365
Ogólny format
365
Przykäady
367
Techniki tworzenia pötli
372
Pötle liczników — while i range
373
Przechodzenie niewyczerpujñce — range i wycinki
374
Modyfikacja list — range
375
Przechodzenie równolegäe — zip oraz map
376
Generowanie wartoĈci przesuniöcia i elementów — enumerate
379
Podsumowanie rozdziaäu
380
SprawdĒ swojñ wiedzö — quiz
380
SprawdĒ swojñ wiedzö — odpowiedzi
380
14. Iteracje i skĥadanie list — czýļë 1. .............................................................................383
Pierwsze spojrzenie na iteratory
383
Protokóä iteracyjny, iteratory plików
384
Kontrola iteracji — iter i next
386
Inne iteratory typów wbudowanych
388
Listy skäadane — wprowadzenie
390
Podstawy list skäadanych
390
Wykorzystywanie list skäadanych w plikach
391
Rozszerzona skäadnia list skäadanych
392
Inne konteksty iteracyjne
393
Nowe obiekty iterowane w Pythonie 3.0
397
Iterator range()
397
Iteratory map(), zip() i filter()
398
Kilka iteratorów na tym samym obiekcie
399
Iteratory widoku säownika
400
Inne zagadnienia zwiñzane z iteratorami
402
Podsumowanie rozdziaäu
402
SprawdĒ swojñ wiedzö — quiz
402
SprawdĒ swojñ wiedzö — odpowiedzi
403
15. Wprowadzenie do dokumentacji ..............................................................................405
đródäa dokumentacji Pythona
405
Komentarze ze znakami #
406
Funkcja dir
406
ãaþcuchy znaków dokumentacji — __doc__
407
PyDoc — funkcja help
410
PyDoc — raporty HTML
412
Zbiór standardowej dokumentacji
415
Zasoby internetowe
415
Publikowane ksiñĔki
416
Spis treļci
_
13
Czösto spotykane problemy programistyczne
417
Podsumowanie rozdziaäu
419
SprawdĒ swojñ wiedzö — quiz
419
SprawdĒ swojñ wiedzö — odpowiedzi
419
çwiczenia do czöĈci trzeciej
420
Czýļë IV Funkcje ............................................................................................ 423
16. Podstawy funkcji .......................................................................................................425
Po co uĔywa siö funkcji?
426
Tworzenie funkcji
426
Instrukcje def
428
Instrukcja def uruchamiana jest w czasie wykonania
428
Pierwszy przykäad — definicje i wywoäywanie
429
Definicja
429
Wywoäanie
430
Polimorfizm w Pythonie
430
Drugi przykäad — przecinajñce siö sekwencje
431
Definicja
432
Wywoäania
432
Raz jeszcze o polimorfizmie
433
Zmienne lokalne
433
Podsumowanie rozdziaäu
434
SprawdĒ swojñ wiedzö — quiz
434
SprawdĒ swojñ wiedzö — odpowiedzi
434
17. Zakresy .......................................................................................................................437
Podstawy zakresów w Pythonie
437
Reguäy dotyczñce zakresów
438
Rozwiñzywanie konfliktów w zakresie nazw — reguäa LEGB
440
Przykäad zakresu
441
Zakres wbudowany
442
Instrukcja global
443
Minimalizowanie stosowania zmiennych globalnych
445
Minimalizacja modyfikacji dokonywanych pomiödzy plikami
446
Inne metody dostöpu do zmiennych globalnych
447
Zakresy a funkcje zagnieĔdĔone
448
Szczegóäy dotyczñce zakresów zagnieĔdĔonych
449
Przykäad zakresu zagnieĔdĔonego
449
Instrukcja nonlocal
455
Podstawy instrukcji nonlocal
455
Instrukcja nonlocal w akcji
456
Czemu säuĔñ zmienne nielokalne?
458
Podsumowanie rozdziaäu
462
14
_
Spis treļci
SprawdĒ swojñ wiedzö — quiz
462
SprawdĒ swojñ wiedzö — odpowiedzi
463
18. Argumenty .................................................................................................................465
Podstawy przekazywania argumentów
465
Argumenty a wspóädzielone referencje
466
Unikanie modyfikacji zmiennych argumentów
468
Symulowanie parametrów wyjĈcia
469
Specjalne tryby dopasowania argumentów
470
Podstawy
470
Skäadnia dopasowania
471
Dopasowywanie argumentów — szczegóäy
472
Przykäady ze säowami kluczowymi i wartoĈciami domyĈlnymi
473
Przykäad dowolnych argumentów
475
Argumenty mogñce byè tylko säowami kluczowymi z Pythona 3.0
479
Przykäad z funkcjñ obliczajñcñ minimum
482
Peäne rozwiñzanie
483
Dodatkowy bonus
484
Puenta
485
Uogólnione funkcje dziaäajñce na zbiorach
485
Emulacja funkcji print z Pythona 3.0
486
Wykorzystywanie argumentów mogñcych byè tylko säowami kluczowymi
487
Podsumowanie rozdziaäu
488
SprawdĒ swojñ wiedzö — quiz
489
SprawdĒ swojñ wiedzö — odpowiedzi
490
19. Zaawansowane zagadnienia dotyczéce funkcji ...................................................... 491
Koncepcje projektowania funkcji
491
Funkcje rekurencyjne
493
Sumowanie z uĔyciem rekurencji
493
Implementacje alternatywne
494
Pötle a rekurencja
495
Obsäuga dowolnych struktur
496
Obiekty funkcji — atrybuty i adnotacje
497
PoĈrednie wywoäania funkcji
497
Introspekcja funkcji
498
Atrybuty funkcji
499
Adnotacje funkcji w Pythonie 3.0
499
Funkcje anonimowe — lambda
501
WyraĔenia lambda
501
Po co uĔywa siö wyraĔenia lambda?
503
Jak äatwo zaciemniè kod napisany w Pythonie
504
ZagnieĔdĔone wyraĔenia lambda a zakresy
505
Odwzorowywanie funkcji na sekwencje — map
507
Narzödzia programowania funkcyjnego — filter i reduce
508
Spis treļci
_
15
Podsumowanie rozdziaäu
510
SprawdĒ swojñ wiedzö — quiz
510
SprawdĒ swojñ wiedzö — odpowiedzi
510
20. Iteracje i skĥadanie list — czýļë 2. ............................................................................. 513
Listy skäadane, podejĈcie drugie — narzödzia funkcyjne
513
Listy skäadane kontra map
514
Dodajemy warunki i pötle zagnieĔdĔone — filter
515
Listy skäadane i macierze
517
Zrozumieè listy skäadane
518
Iteratorów ciñg dalszy — generatory
520
Funkcje generatorów — yield kontra return
520
WyraĔenia generatorów — iteratory spotykajñ zäoĔenia
524
Funkcje generatorów kontra wyraĔenia generatorów
525
Generatory sñ jednorazowymi iteratorami
526
Emulacja funkcji zip i map za pomocñ narzödzi iteracyjnych
527
Generowanie wyników we wbudowanych typach i klasach
531
Podsumowanie obiektów skäadanych w 3.0
533
Zrozumieè zbiory i säowniki skäadane
534
Rozszerzona skäadnia zbiorów i säowników skäadanych
534
Pomiary wydajnoĈci implementacji iteratorów
535
Moduä mytimer
536
Skrypt mierzñcy wydajnoĈè
536
Pomiary czasu
537
Alternatywne moduäy mierzñce wydajnoĈè
539
Inne sugestie
543
Puäapki zwiñzane z funkcjami
544
Lokalne nazwy sñ wykrywane w sposób statyczny
544
WartoĈci domyĈlne i obiekty mutowalne
546
Funkcje niezwracajñce wyników
548
Funkcje zagnieĔdĔone a zmienne modyfikowane w pötli
548
Podsumowanie rozdziaäu
548
SprawdĒ swojñ wiedzö — quiz
549
SprawdĒ swojñ wiedzö — odpowiedzi
549
SprawdĒ swojñ wiedzö — èwiczenia do czöĈci czwartej
550
Czýļë V Moduĥy ............................................................................................. 553
21. Moduĥy — wprowadzenie ........................................................................................555
Po co uĔywa siö moduäów?
555
Architektura programu w Pythonie
556
Struktura programu
556
Importowanie i atrybuty
557
Moduäy biblioteki standardowej
558
16
_
Spis treļci
Jak dziaäa importowanie
559
1. Odnalezienie moduäu
560
2. (Ewentualne) Kompilowanie
560
3. Wykonanie
561
ćcieĔka wyszukiwania moduäów
561
Konfiguracja ĈcieĔki wyszukiwania
563
Wariacje ĈcieĔki wyszukiwania moduäów
564
Lista sys.path
564
Wybór pliku moduäu
565
Zaawansowane zagadnienia zwiñzane z wyborem moduäów
566
Podsumowanie rozdziaäu
566
SprawdĒ swojñ wiedzö — quiz
567
SprawdĒ swojñ wiedzö — odpowiedzi
568
22. Podstawy tworzenia moduĥów .................................................................................569
Tworzenie moduäów
569
UĔycie moduäów
570
Instrukcja import
570
Instrukcja from
571
Instrukcja from *
571
Operacja importowania odbywa siö tylko raz
571
Instrukcje import oraz from sñ przypisaniami
572
Modyfikacja zmiennych pomiödzy plikami
573
RównowaĔnoĈè instrukcji import oraz from
573
Potencjalne puäapki zwiñzane z uĔyciem instrukcji from
574
Przestrzenie nazw moduäów
575
Pliki generujñ przestrzenie nazw
576
Kwalifikowanie nazw atrybutów
577
Importowanie a zakresy
578
ZagnieĔdĔanie przestrzeni nazw
579
Przeäadowywanie moduäów
580
Podstawy przeäadowywania moduäów
581
Przykäad przeäadowywania z uĔyciem reload
581
Podsumowanie rozdziaäu
582
SprawdĒ swojñ wiedzö — quiz
583
SprawdĒ swojñ wiedzö — odpowiedzi
584
23. Pakiety moduĥów .......................................................................................................585
Podstawy importowania pakietów
585
Pakiety a ustawienia ĈcieĔki wyszukiwania
586
Pliki pakietów __init__.py
586
Przykäad importowania pakietu
588
Instrukcja from a instrukcja import w importowaniu pakietów
589
Do czego säuĔy importowanie pakietów?
590
Historia trzech systemów
590
Spis treļci
_
17
Wzglödne importowanie pakietów
593
Zmiany w Pythonie 3.0
593
Podstawy importów wzglödnych
594
Do czego säuĔñ importy wzglödne?
595
Zakres importów wzglödnych
597
Podsumowanie reguä wyszukiwania moduäów
598
Importy wzglödne w dziaäaniu
598
Podsumowanie rozdziaäu
603
SprawdĒ swojñ wiedzö — quiz
604
SprawdĒ swojñ wiedzö — odpowiedzi
604
24. Zaawansowane zagadnienia zwiézane z moduĥami .............................................. 607
Ukrywanie danych w moduäach
607
Minimalizacja niebezpieczeþstw uĔycia from * — _X oraz __all__
608
Wäñczanie opcji z przyszäych wersji Pythona
608
Mieszane tryby uĔycia — __name__ oraz __main__
609
Testy jednostkowe z wykorzystaniem __name__
610
UĔycie argumentów wiersza poleceþ z __name__
611
Modyfikacja ĈcieĔki wyszukiwania moduäów
613
Rozszerzenie as dla instrukcji import oraz from
614
Moduäy sñ obiektami — metaprogramy
615
Importowanie moduäów za pomocñ äaþcucha znaków nazwy
617
Przechodnie przeäadowywanie moduäów
618
Projektowanie moduäów
621
Puäapki zwiñzane z moduäami
622
W kodzie najwyĔszego poziomu kolejnoĈè instrukcji ma znaczenie
622
Instrukcja from kopiuje nazwy, jednak äñcza juĔ nie
623
Instrukcja from * moĔe zaciemniè znaczenie zmiennych
624
Funkcja reload moĔe nie mieè wpäywu na obiekty importowane
za pomocñ from
624
Funkcja reload i instrukcja from a testowanie interaktywne
625
Rekurencyjne importowanie za pomocñ from moĔe nie dziaäaè
626
Podsumowanie rozdziaäu
627
SprawdĒ swojñ wiedzö — quiz
627
SprawdĒ swojñ wiedzö — odpowiedzi
628
SprawdĒ swojñ wiedzö — èwiczenia do czöĈci piñtej
628
Czýļë VI Klasy i programowanie zorientowane obiektowo ........................631
25. Programowanie zorientowane obiektowo ..............................................................633
Po co uĔywa siö klas?
634
Programowanie zorientowane obiektowo z dystansu
635
Wyszukiwanie dziedziczenia atrybutów
635
Klasy a instancje
637
18
_
Spis treļci
Wywoäania metod klasy
638
Tworzenie drzew klas
638
Programowanie zorientowane obiektowo oparte jest na ponownym
wykorzystaniu kodu
641
Podsumowanie rozdziaäu
643
SprawdĒ swojñ wiedzö — quiz
644
SprawdĒ swojñ wiedzö — odpowiedzi
644
26. Podstawy tworzenia klas ..........................................................................................647
Klasy generujñ wiökszñ liczbö obiektów instancji
647
Obiekty klas udostöpniajñ zachowania domyĈlne
648
Obiekty instancji sñ rzeczywistymi elementami
648
Pierwszy przykäad
649
Klasy dostosowuje siö do wäasnych potrzeb przez dziedziczenie
651
Drugi przykäad
652
Klasy sñ atrybutami w moduäach
653
Klasy mogñ przechwytywaè operatory Pythona
654
Trzeci przykäad
655
Po co przeciñĔa siö operatory?
657
Najprostsza klasa Pythona na Ĉwiecie
658
Klasy a säowniki
660
Podsumowanie rozdziaäu
662
SprawdĒ swojñ wiedzö — quiz
662
SprawdĒ swojñ wiedzö — odpowiedzi
663
27. Bardziej realistyczny przykĥad ..................................................................................665
Krok 1. — tworzenie instancji
666
Tworzenie konstruktorów
666
Testowanie w miarö pracy
667
Wykorzystywanie kodu na dwa sposoby
668
Krok 2. — dodawanie metod
669
Tworzenie kodu metod
671
Krok 3. — przeciñĔanie operatorów
673
Udostöpnienie wyĈwietlania
674
Krok 4. — dostosowanie zachowania do wäasnych potrzeb
za pomocñ klas podrzödnych
675
Tworzenie klas podrzödnych
675
Rozszerzanie metod — niewäaĈciwy sposób
676
Rozszerzanie metod — wäaĈciwy sposób
676
Polimorfizm w akcji
678
Dziedziczenie, dostosowanie do wäasnych potrzeb i rozszerzenie
679
Programowanie zorientowane obiektowo — idea
680
Krok 5. — dostosowanie do wäasnych potrzeb takĔe konstruktorów
680
Programowanie zorientowane obiektowo jest prostsze, niĔ siö wydaje
682
Inne sposoby äñczenia klas
683
Spis treļci
_
19
Krok 6. — wykorzystywanie narzödzi do introspekcji
684
Specjalne atrybuty klas
686
Uniwersalne narzödzie do wyĈwietlania
687
Atrybuty instancji a atrybuty klas
688
RozwaĔania na temat nazw w klasach narzödzi
689
Ostateczna postaè naszych klas
690
Krok 7. i ostatni — przechowanie obiektów w bazie danych
691
Obiekty pickle i shelve
691
Przechowywanie obiektów w bazie danych za pomocñ shelve
692
Interaktywne badanie obiektów shelve
694
Uaktualnianie obiektów w pliku shelve
695
Przyszäe kierunki rozwoju
697
Podsumowanie rozdziaäu
699
SprawdĒ swojñ wiedzö — quiz
699
SprawdĒ swojñ wiedzö — odpowiedzi
700
28. Szczegóĥy kodu klas ................................................................................................... 703
Instrukcja class
703
Ogólna forma
703
Przykäad
704
Metody
706
Przykäad metody
707
Wywoäywanie konstruktorów klas nadrzödnych
708
Inne moĔliwoĈci wywoäywania metod
708
Dziedziczenie
708
Tworzenie drzewa atrybutów
709
Specjalizacja odziedziczonych metod
710
Techniki interfejsów klas
711
Abstrakcyjne klasy nadrzödne
712
Abstrakcyjne klasy nadrzödne z Pythona 2.6 oraz 3.0
713
Przestrzenie nazw — caäa historia
714
Pojedyncze nazwy — globalne, o ile nie przypisane
715
Nazwy atrybutów — przestrzenie nazw obiektów
715
Zen przestrzeni nazw Pythona — przypisania klasyfikujñ zmienne
715
Säowniki przestrzeni nazw
718
ãñcza przestrzeni nazw
720
Raz jeszcze o äaþcuchach znaków dokumentacji
722
Klasy a moduäy
723
Podsumowanie rozdziaäu
724
SprawdĒ swojñ wiedzö — quiz
724
SprawdĒ swojñ wiedzö — odpowiedzi
724
20
_
Spis treļci
29. PrzeciéŜanie operatorów .......................................................................................... 727
Podstawy
727
Konstruktory i wyraĔenia — __init__ i __sub__
728
Czösto spotykane metody przeciñĔania operatorów
728
Indeksowanie i wycinanie — __getitem__ i __setitem__
730
Wycinki
730
Iteracja po indeksie — __getitem__
731
Obiekty iteratorów — __iter__ i __next__
733
Iteratory zdefiniowane przez uĔytkownika
734
Wiele iteracji po jednym obiekcie
735
Test przynaleĔnoĈci — __contains__, __iter__ i __getitem__
737
Metody __getattr__ oraz __setattr__ przechwytujñ referencje do atrybutów
740
Inne narzödzia do zarzñdzania atrybutami
741
Emulowanie prywatnoĈci w atrybutach instancji
741
Metody __repr__ oraz __str__ zwracajñ reprezentacje äaþcuchów znaków
742
Metoda __radd__ obsäuguje dodawanie prawostronne i modyfikacjö w miejscu
745
Dodawanie w miejscu
746
Metoda __call_ przechwytuje wywoäania
747
Interfejsy funkcji i kod oparty na wywoäaniach zwrotnych
748
Porównania — __lt__, __gt__ i inne
750
Metoda __cmp__ w 2.6 (usuniöta w 3.0)
750
Testy logiczne — __bool__ i __len__
751
Destrukcja obiektu — __del__
752
Podsumowanie rozdziaäu
754
SprawdĒ swojñ wiedzö — quiz
755
SprawdĒ swojñ wiedzö — odpowiedzi
755
30. Projektowanie z uŜyciem klas ................................................................................... 757
Python a programowanie zorientowane obiektowo
757
PrzeciñĔanie za pomocñ sygnatur wywoäaþ (lub bez nich)
758
Programowanie zorientowane obiektowo i dziedziczenie — zwiñzek „jest”
759
Programowanie zorientowane obiektowo i kompozycja — zwiñzki typu „ma”
760
Raz jeszcze procesor strumienia danych
762
Programowanie zorientowane obiektowo a delegacja — obiekty „opakowujñce”
765
Pseudoprywatne atrybuty klas
767
Przeglñd znieksztaäcania nazw zmiennych
767
Po co uĔywa siö atrybutów pseudoprywatnych?
768
Metody sñ obiektami — z wiñzaniem i bez wiñzania
770
Metody niezwiñzane w 3.0
772
Metody zwiñzane i inne obiekty wywoäywane
773
Dziedziczenie wielokrotne — klasy mieszane
775
Tworzenie klas mieszanych
776
Klasy sñ obiektami — uniwersalne fabryki obiektów
785
Do czego säuĔñ fabryki?
787
Spis treļci
_
21
Inne zagadnienia zwiñzane z projektowaniem
788
Podsumowanie rozdziaäu
788
SprawdĒ swojñ wiedzö — quiz
789
SprawdĒ swojñ wiedzö — odpowiedzi
789
31. Zaawansowane zagadnienia zwiézane z klasami .................................................. 791
Rozszerzanie typów wbudowanych
791
Rozszerzanie typów za pomocñ osadzania
792
Rozszerzanie typów za pomocñ klas podrzödnych
793
Klasy w nowym stylu
795
NowoĈci w klasach w nowym stylu
796
Zmiany w modelu typów
797
Zmiany w dziedziczeniu diamentowym
801
NowoĈci w klasach w nowym stylu
805
Sloty
805
WäaĈciwoĈci klas
809
PrzeciñĔanie nazw — __getattribute__ i deskryptory
811
Metaklasy
811
Metody statyczne oraz metody klasy
811
Do czego potrzebujemy metod specjalnych?
812
Metody statyczne w 2.6 i 3.0
812
Alternatywy dla metod statycznych
814
UĔywanie metod statycznych i metod klas
815
Zliczanie instancji z uĔyciem metod statycznych
817
Zliczanie instancji z metodami klas
818
Dekoratory i metaklasy — czöĈè 1.
820
Podstawowe informacje o dekoratorach funkcji
820
Przykäad dekoratora
821
Dekoratory klas i metaklasy
822
Dalsza lektura
823
Puäapki zwiñzane z klasami
824
Modyfikacja atrybutów klas moĔe mieè efekty uboczne
824
Modyfikowanie mutowalnych atrybutów klas równieĔ moĔe mieè
efekty uboczne
825
Dziedziczenie wielokrotne — kolejnoĈè ma znaczenie
826
Metody, klasy oraz zakresy zagnieĔdĔone
827
Klasy wykorzystujñce delegacjö w 3.0 — __getattr__ i funkcje wbudowane
829
Przesadne opakowywanie
829
Podsumowanie rozdziaäu
830
SprawdĒ swojñ wiedzö — quiz
830
SprawdĒ swojñ wiedzö — odpowiedzi
830
SprawdĒ swojñ wiedzö — èwiczenia do czöĈci szóstej
831
22
_
Spis treļci
Czýļë VII Wyjétki oraz narzýdzia ................................................................. 839
32. Podstawy wyjétków .................................................................................................. 841
Po co uĔywa siö wyjñtków?
841
Role wyjñtków
842
Wyjñtki w skrócie
843
DomyĈlny program obsäugi wyjñtków
843
Przechwytywanie wyjñtków
844
Zgäaszanie wyjñtków
845
Wyjñtki zdefiniowane przez uĔytkownika
845
Dziaäania koþcowe
846
Podsumowanie rozdziaäu
847
SprawdĒ swojñ wiedzö — quiz
849
SprawdĒ swojñ wiedzö — odpowiedzi
849
33. Szczegóĥowe informacje dotyczéce wyjétków ........................................................ 851
Instrukcja try/except/else
851
CzöĈci instrukcji try
853
CzöĈè try/else
855
Przykäad — zachowanie domyĈlne
856
Przykäad — przechwytywanie wbudowanych wyjñtków
857
Instrukcja try/finally
857
Przykäad — dziaäania koþczñce kod z uĔyciem try/finally
858
Poäñczona instrukcja try/except/finally
859
Skäadnia poäñczonej instrukcji try
860
ãñczenie finally oraz except za pomocñ zagnieĔdĔania
861
Przykäad poäñczonego try
862
Instrukcja raise
863
Przekazywanie wyjñtków za pomocñ raise
864
ãaþcuchy wyjñtków w Pythonie 3.0 — raise from
865
Instrukcja assert
865
Przykäad — wyäapywanie ograniczeþ (ale nie bäödów!)
866
MenedĔery kontekstu with/as
867
Podstawowe zastosowanie
867
Protokóä zarzñdzania kontekstem
868
Podsumowanie rozdziaäu
870
SprawdĒ swojñ wiedzö — quiz
871
SprawdĒ swojñ wiedzö — odpowiedzi
871
34. Obiekty wyjétków .....................................................................................................873
Wyjñtki — powrót do przyszäoĈci
874
Wyjñtki oparte na äaþcuchach znaków znikajñ
874
Wyjñtki oparte na klasach
875
Tworzenie klas wyjñtków
875
Spis treļci
_
23
Do czego säuĔñ hierarchie wyjñtków?
877
Wbudowane klasy wyjñtków
880
Kategorie wbudowanych wyjñtków
881
DomyĈlne wyĈwietlanie oraz stan
882
Wäasne sposoby wyĈwietlania
883
Wäasne dane oraz zachowania
884
Udostöpnianie szczegóäów wyjñtku
884
Udostöpnianie metod wyjñtków
885
Podsumowanie rozdziaäu
886
SprawdĒ swojñ wiedzö — quiz
886
SprawdĒ swojñ wiedzö — odpowiedzi
886
35. Projektowanie z wykorzystaniem wyjétków ...........................................................889
ZagnieĔdĔanie programów obsäugi wyjñtków
889
Przykäad — zagnieĔdĔanie przebiegu sterowania
891
Przykäad — zagnieĔdĔanie skäadniowe
891
Zastosowanie wyjñtków
893
Wyjñtki nie zawsze sñ bäödami
893
Funkcje mogñ sygnalizowaè warunki za pomocñ raise
893
Zamykanie plików oraz poäñczeþ z serwerem
894
Debugowanie z wykorzystaniem zewnötrznych instrukcji try
895
Testowanie kodu wewnñtrz tego samego procesu
895
Wiöcej informacji na temat funkcji sys.exc_info
896
Wskazówki i puäapki dotyczñce projektowania wyjñtków
897
Co powinniĈmy opakowaè w try
897
Jak nie przechwytywaè zbyt wiele — unikanie pustych except i wyjñtków
898
Jak nie przechwytywaè zbyt maäo — korzystanie z kategorii
opartych na klasach
900
Podsumowanie jñdra jözyka Python
901
Zbiór narzödzi Pythona
901
Narzödzia programistyczne przeznaczone do wiökszych projektów
902
Podsumowanie rozdziaäu
906
SprawdĒ swojñ wiedzö — quiz
906
SprawdĒ swojñ wiedzö — odpowiedzi
906
SprawdĒ swojñ wiedzö — èwiczenia do czöĈci siódmej
907
Czýļë VIII Zagadnienia zaawansowane ...................................................... 909
36. Ĥaħcuchy znaków Unicode oraz ĥaħcuchy bajtowe ..................................................911
Zmiany w äaþcuchach znaków w Pythonie 3.0
912
Podstawy äaþcuchów znaków
913
Kodowanie znaków
913
Typy äaþcuchów znaków Pythona
915
Pliki binarne i tekstowe
916
24
_
Spis treļci
ãaþcuchy znaków Pythona 3.0 w akcji
918
Literaäy i podstawowe wäaĈciwoĈci
918
Konwersje
919
Kod äaþcuchów znaków Unicode
920
Kod tekstu z zakresu ASCII
921
Kod tekstu spoza zakresu ASCII
921
Kodowanie i dekodowanie tekstu spoza zakresu ASCII
922
Inne techniki kodowania äaþcuchów Unicode
923
Konwersja kodowania
925
ãaþcuchy znaków Unicode w Pythonie 2.6
925
Deklaracje typu kodowania znaków pliku Ēródäowego
928
Wykorzystywanie obiektów bytes z Pythona 3.0
929
Wywoäania metod
929
Operacje na sekwencjach
930
Inne sposoby tworzenia obiektów bytes
931
Mieszanie typów äaþcuchów znaków
931
Wykorzystywanie obiektów bytearray z Pythona 3.0 (i 2.6)
932
Wykorzystywanie plików tekstowych i binarnych
935
Podstawy plików tekstowych
935
Tryby tekstowy i binarny w Pythonie 3.0
936
Brak dopasowania typu i zawartoĈci
938
Wykorzystywanie plików Unicode
939
Odczyt i zapis Unicode w Pythonie 3.0
939
Obsäuga BOM w Pythonie 3.0
941
Pliki Unicode w Pythonie 2.6
943
Inne zmiany narzödzi äaþcuchów znaków w Pythonie 3.0
944
Moduä dopasowywania wzorców re
944
Moduä danych binarnych struct
945
Moduä serializacji obiektów pickle
947
Narzödzia do analizy skäadniowej XML
948
Podsumowanie rozdziaäu
951
SprawdĒ swojñ wiedzö — quiz
952
SprawdĒ swojñ wiedzö — odpowiedzi
952
37. Zarzédzane atrybuty .................................................................................................955
Po co zarzñdza siö atrybutami?
955
Wstawianie kodu wykonywanego w momencie dostöpu do atrybutów
956
WäaĈciwoĈci
957
Podstawy
957
Pierwszy przykäad
958
Obliczanie atrybutów
959
Zapisywanie wäaĈciwoĈci w kodzie za pomocñ dekoratorów
960
Deskryptory
961
Podstawy
962
Pierwszy przykäad
964
Obliczone atrybuty
966
Spis treļci
_
25
Wykorzystywanie informacji o stanie w deskryptorach
967
Powiñzania pomiödzy wäaĈciwoĈciami a deskryptorami
968
Metody __getattr__ oraz __getattribute__
970
Podstawy
971
Pierwszy przykäad
973
Obliczanie atrybutów
974
Porównanie metod __getattr__ oraz __getattribute__
975
Porównanie technik zarzñdzania atrybutami
976
Przechwytywanie atrybutów wbudowanych operacji
979
Powrót do menedĔerów opartych na delegacji
983
Przykäad — sprawdzanie poprawnoĈci atrybutów
986
Wykorzystywanie wäaĈciwoĈci do sprawdzania poprawnoĈci
986
Wykorzystywanie deskryptorów do sprawdzania poprawnoĈci
988
Wykorzystywanie metody __getattr__ do sprawdzania poprawnoĈci
990
Wykorzystywanie metody __getattribute__ do sprawdzania poprawnoĈci
991
Podsumowanie rozdziaäu
992
SprawdĒ swojñ wiedzö — quiz
992
SprawdĒ swojñ wiedzö — odpowiedzi
993
38. Dekoratory .................................................................................................................995
Czym jest dekorator?
995
Zarzñdzanie wywoäaniami oraz instancjami
996
Zarzñdzanie funkcjami oraz klasami
996
Wykorzystywanie i definiowanie dekoratorów
997
Do czego säuĔñ dekoratory?
997
Podstawy
998
Dekoratory funkcji
998
Dekoratory klas
1002
ZagnieĔdĔanie dekoratorów
1004
Argumenty dekoratorów
1006
Dekoratory zarzñdzajñ takĔe funkcjami oraz klasami
1006
Kod dekoratorów funkcji
1007
ćledzenie wywoäaþ
1007
MoĔliwoĈci w zakresie zachowania informacji o stanie
1009
Uwagi na temat klas I — dekorowanie metod klas
1012
Mierzenie czasu wywoäania
1017
Dodawanie argumentów dekoratora
1019
Kod dekoratorów klas
1021
Klasy singletona
1021
ćledzenie interfejsów obiektów
1023
Uwagi na temat klas II — zachowanie wiökszej liczby instancji
1027
Dekoratory a funkcje zarzñdzajñce
1028
Do czego säuĔñ dekoratory? (raz jeszcze)
1029
BezpoĈrednie zarzñdzanie funkcjami oraz klasami
1031
Przykäad — atrybuty „prywatne” i „publiczne”
1033
Implementacja atrybutów prywatnych
1033
26
_
Spis treļci
Szczegóäy implementacji I
1035
Uogólnienie kodu pod kñtem deklaracji atrybutów jako publicznych
1036
Szczegóäy implementacji II
1038
Znane problemy
1039
W Pythonie nie chodzi o kontrolö
1043
Przykäad: Sprawdzanie poprawnoĈci argumentów funkcji
1044
Cel
1044
Prosty dekorator sprawdzajñcy przedziaäy dla argumentów pozycyjnych
1045
Uogólnienie kodu pod kñtem säów kluczowych i wartoĈci domyĈlnych
1047
Szczegóäy implementacji
1050
Znane problemy
1052
Argumenty dekoratora a adnotacje funkcji
1053
Inne zastosowania — sprawdzanie typów (skoro nalegamy!)
1054
Podsumowanie rozdziaäu
1055
SprawdĒ swojñ wiedzö — quiz
1056
SprawdĒ swojñ wiedzö — odpowiedzi
1056
39. Metaklasy ..................................................................................................................1061
Tworzyè metaklasy czy tego nie robiè?
1061
Zwiökszajñce siö poziomy magii
1062
Wady funkcji pomocniczych
1064
Metaklasy a dekoratory klas — runda 1.
1066
Model metaklasy
1068
Klasy sñ instancjami obiektu type
1068
Metaklasy sñ klasami podrzödnymi klasy type
1070
Protokóä instrukcji class
1071
Deklarowanie metaklas
1071
Tworzenie metaklas
1073
Prosta metaklasa
1073
Dostosowywanie tworzenia do wäasnych potrzeb oraz inicjalizacja
1074
Pozostaäe sposoby tworzenia metaklas
1074
Instancje a dziedziczenie
1077
Przykäad — dodawanie metod do klas
1078
Röczne rozszerzanie
1078
Rozszerzanie oparte na metaklasie
1080
Metaklasy a dekoratory klas — runda 2.
1081
Przykäad — zastosowanie dekoratorów do metod
1084
Röczne Ĉledzenie za pomocñ dekoracji
1084
ćledzenie metaklas oraz dekoratorów
1085
Zastosowanie dowolnego dekoratora do metod
1086
Metaklasy a dekoratory klas — runda 3.
1088
Podsumowanie rozdziaäu
1091
SprawdĒ swojñ wiedzö — quiz
1092
SprawdĒ swojñ wiedzö — odpowiedzi
1092
Spis treļci
_
27
Dodatki .........................................................................................................1093
Dodatek A Instalacja i konfiguracja ................................................................................... 1095
Instalowanie interpretera Pythona
1095
Czy Python jest juĔ zainstalowany?
1095
Skñd pobraè Pythona
1096
Instalacja Pythona
1097
Konfiguracja Pythona
1098
Zmienne Ĉrodowiskowe Pythona
1098
Jak ustawiè opcje konfiguracyjne?
1100
Opcje wiersza poleceþ Pythona
1103
Uzyskanie pomocy
1104
Dodatek B Rozwiézania ëwiczeħ podsumowujécych poszczególne czýļci ksiéŜki .........1105
CzöĈè I Wprowadzenie
1105
CzöĈè II Typy i operacje
1107
CzöĈè III Instrukcja i skäadnia
1112
CzöĈè IV Funkcje
1114
CzöĈè V Moduäy
1121
CzöĈè VI Klasy i programowanie zorientowane obiektowo
1125
CzöĈè VII Wyjñtki oraz narzödzia
1132
Skorowidz ............................................................................................................................1139
119
ROZDZIAĤ 4.
Wprowadzenie
do typów obiektów Pythona
Niniejszy rozdziaä rozpoczyna naszñ wycieczkö po jözyku Python. W pewnym sensie w Pytho-
nie „robi siö coĈ z róĔnymi rzeczami”. To „coĈ” ma postaè operacji (dziaäaþ), takich jak doda-
wanie czy konkatenacja, natomiast „róĔne rzeczy” to obiekty, na których wykonuje siö owe
operacje. W tej czöĈci ksiñĔki skupimy siö wäaĈnie na owych „róĔnych rzeczach”, jak równieĔ
na tym, co mogñ z nimi robiè nasze programy.
Mówiñc bardziej formalnym jözykiem, w Pythonie dane przybierajñ postaè obiektów — albo
wbudowanych obiektów udostöpnianych przez Pythona, albo obiektów tworzonych za pomocñ
Pythona lub innych narzödzi zewnötrznych, takich jak biblioteki rozszerzeþ jözyka C. Choè
definicjö tö nieco póĒniej rozbudujemy, obiekty sñ generalnie fragmentami pamiöci z warto-
Ĉciami i zbiorami powiñzanych operacji.
PoniewaĔ obiekty sñ najbardziej podstawowym elementem Pythona, ten rozdziaä rozpoczniemy
od przeglñdu obiektów wbudowanych w sam jözyk.
Tytuäem wstöpu warto jednak najpierw ustaliè, jak niniejszy rozdziaä wpisuje siö w caäoĈè
Pythona. Programy napisane w Pythonie moĔna rozbiè na moduäy, instrukcje, wyraĔenia
i obiekty — w nastöpujñcy sposób:
1.
Programy skäadajñ siö z moduäów.
2.
Moduäy zawierajñ instrukcje.
3.
Instrukcje zawierajñ wyraĔenia.
4.
WyraĔenia tworzñ i przetwarzajñ obiekty.
Omówienie moduäów zamieszczone w rozdziale 3. uwzglödnia najwyĔszy poziom w tej hie-
rarchii. Rozdziaäy tej czöĈci ksiñĔki odwoäujñ siö do najniĔszego jej poziomu, czyli wbudowanych
obiektów oraz wyraĔeþ, które tworzy siö w celu korzystania z tych obiektów.
120
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
Po co korzysta siý z typów wbudowanych?
Osoby uĔywajñce jözyków niĔszego poziomu, takich jak C czy C++, wiedzñ, Ĕe wiökszoĈè ich
pracy polega na implementowaniu obiektów — znanych równieĔ jako struktury danych — tak
by reprezentowaäy one komponenty w dziedzinie naszej aplikacji. Konieczne jest rozplano-
wanie struktur pamiöci, zarzñdzanie przydzielaniem pamiöci czy zaimplementowanie procedur
wyszukiwania i dostöpu. Te zadania sñ tak Ĕmudne (i podatne na bäödy), na jakie wyglñdajñ,
i zazwyczaj odciñgajñ programistö od prawdziwych celów programu.
W typowych programach napisanych w Pythonie wiökszoĈè tej przyziemnej pracy nie jest
konieczna. PoniewaĔ Python udostöpnia typy obiektów jako nieodäñcznñ czöĈè samego jözyka,
zazwyczaj nie istnieje koniecznoĈè kodowania implementacji obiektów przed rozpoczöciem
rozwiñzywania prawdziwych problemów. Tak naprawdö, o ile oczywiĈcie nie mamy potrzeby
korzystania ze specjalnych metod przetwarzania, które nie sñ dostöpne w obiektach wbudo-
wanych, prawie zawsze lepiej bödzie skorzystaè z gotowego typu obiektu, zamiast tworzyè
wäasny. PoniĔej znajduje siö kilka przyczyn takiego stanu rzeczy.
x
Obiekty wbudowane sprawiajñ, Ĕe programy äatwo siö pisze. W przypadku prostych zadaþ
obiekty wbudowane czösto wystarczñ nam do stworzenia struktur wäaĈciwych dla okre-
Ĉlonych problemów. Od röki dostöpne sñ narzödzia o sporych moĔliwoĈciach, jak zbiory
(listy) i tabele, które moĔna przeszukiwaè (säowniki). Wiele zadaþ moĔna wykonaè, korzy-
stajñc z samych obiektów wbudowanych.
x
Obiekty wbudowane sñ komponentami rozszerzeþ. W przypadku bardziej zaawanso-
wanych zadaþ byè moĔe nadal konieczne bödzie udostöpnianie wäasnych obiektów, wyko-
rzystywanie klas Pythona czy interfejsów jözyka C. Jednak jak okaĔe siö w dalszej czöĈci
ksiñĔki, obiekty implementowane röcznie sñ czösto zbudowane na bazie typów wbudo-
wanych, takich jak listy czy säowniki. Strukturö danych stosu moĔna na przykäad zaim-
plementowaè jako klasö zarzñdzajñcñ wbudowanñ listñ lub dostosowujñcñ tö listö do
wäasnych potrzeb.
x
Obiekty wbudowane czösto sñ bardziej wydajne od wäasnych struktur danych. Wbu-
dowane obiekty Pythona wykorzystujñ juĔ zoptymalizowane algorytmy struktur danych,
które zostaäy zaimplementowane w jözyku C w celu zwiökszenia szybkoĈci ich dziaäania.
Choè moĔemy samodzielnie napisaè podobne typy obiektów, zazwyczaj trudno nam bödzie
osiñgnñè ten sam poziom wydajnoĈci, jaki udostöpniajñ obiekty wbudowane.
x
Obiekty wbudowane sñ standardowñ czöĈciñ jözyka. W pewien sposób Python zapoĔycza
zarówno od jözyków opierajñcych siö na obiektach wbudowanych (jak na przykäad LISP),
jak i jözyków, w których to programista udostöpnia implementacje narzödzi czy wäasnych
platform (jak C++). Choè moĔna w Pythonie implementowaè wäasne, unikalne typy
obiektów, nie trzeba tego robiè, by zaczñè programowaè w tym jözyku. Co wiöcej, ponie-
waĔ obiekty wbudowane sñ standardem, zawsze pozostanñ one takie same. Rozwiñzania
wäasnoĈciowe zazwyczaj majñ tendencjö do zmian ze strony na stronö.
Innymi säowy, obiekty wbudowane nie tylko uäatwiajñ programowanie, ale majñ takĔe wiöksze
moĔliwoĈci i sñ bardziej wydajne od wiökszoĈci tego, co tworzy siö od podstaw. Bez wzglödu
na to, czy zdecydujemy siö implementowaè nowe typy obiektów, obiekty wbudowane sta-
nowiñ podstawö kaĔdego programu napisanego w Pythonie.
Po co korzysta siý z typów wbudowanych?
_
121
NajwaŜniejsze typy danych w Pythonie
W tabeli 4.1 zaprezentowano przeglñd wbudowanych obiektów Pythona wraz ze skäadniñ
wykorzystywanñ do kodowania ich literaäów — czyli wyraĔeþ generujñcych te obiekty.
1
Nie-
które z typów powinny dla osób znajñcych inne jözyki programowania wyglñdaè znajomo.
Liczby i äaþcuchy znaków reprezentujñ, odpowiednio, wartoĈci liczbowe i tekstowe. Pliki
udostöpniajñ natomiast interfejsy säuĔñce do przetwarzania plików przechowywanych na
komputerze.
Tabela 4.1. Przeglñd obiektów wbudowanych Pythona
Typ obiektu
Przykĥadowy literaĥ (tworzenie)
Liczby
1234
,
3.1415
,
3+4j
,
Decimal
,
Fraction
Ĥaħcuchy znaków
'mielonka'
,
"Brian"
,
b'a\x01c'
Listy
[1, [2, 'trzy'], 4]
Sĥowniki
{'jedzenie': 'mielonka', 'smak': 'mniam'}
Krotki
(1,'mielonka', 4, 'U')
Pliki
myfile = open('jajka', 'r')
Zbiory
set('abc')
,
{'a', 'b', 'c'}
Inne typy podstawowe
Wartoļci
Boolean
, typy,
None
Typy jednostek programu
Funkcje, moduĥy, klasy (czýļë IV, V i VI ksiéŜki)
Typy powiézane z implementacjé
Kod skompilowany, ļlady stosu (czýļë IV i VII ksiéŜki)
Tabela 4.1 nie jest kompletna, poniewaĔ wszystko, co przetwarzamy w programie napisanym
w Pythonie, jest tak naprawdö rodzajem obiektu. Kiedy na przykäad wykonujemy w Pytho-
nie dopasowanie tekstu do wzorca, tworzymy obiekty wzorców, natomiast kiedy tworzymy
skrypty sieciowe, wykorzystujemy obiekty gniazd. Te pozostaäe typy obiektów tworzy siö
przede wszystkim za pomocñ importowania i wykorzystywania moduäów; kaĔdy z nich wiñĔe
siö z pewnym typem zachowania.
Jak zobaczymy w dalszych czöĈciach ksiñĔki, jednostki programów, takie jak funkcje, moduäy
i klasy, takĔe sñ w Pythonie obiektami — sñ one tworzone za pomocñ instrukcji oraz wyraĔeþ,
takich jak
def
,
class
,
import
czy
lambda
, i moĔna je swobodnie przekazywaè w skryptach
bñdĒ przechowywaè w innych obiektach. Python udostöpnia równieĔ zbiór typów powiñza-
nych z implementacjñ, takich jak obiekty skompilowanego kodu, które sñ zazwyczaj bardziej
przedmiotem zainteresowania osób tworzñcych narzödzia niĔ twórców aplikacji. Zostanñ one
omówione w póĒniejszych czöĈciach ksiñĔki.
Pozostaäe typy obiektów z tabeli 4.1 nazywane sñ zazwyczaj typami podstawowymi, poniewaĔ
sñ one tak naprawdö wbudowane w sam jözyk. Oznacza to, Ĕe istnieje okreĈlona skäadnia wyra-
Ĕeþ säuĔñca do generowania wiökszoĈci z nich. Na przykäad kiedy wykonamy poniĔszy kod:
>>> 'mielonka'
1
W niniejszej ksiñĔce pojöcie literaä oznacza po prostu wyraĔenie, którego skäadnia generuje obiekt — czasami
nazywane równieĔ staäñ. Warto zauwaĔyè, Ĕe „staäa” nie oznacza wcale obiektów czy zmiennych, które nigdy
nie mogñ byè zmienione (czyli pojöcie to nie ma zwiñzku z
const
z jözyka C++ czy okreĈleniem „niezmienny”
[ang. immutable] z Pythona — zagadnienie to omówione zostanie w dalszej czöĈci rozdziaäu).
122
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
z technicznego punktu widzenia wykonujemy wäaĈnie wyraĔenie z literaäem, które generuje
i zwraca nowy obiekt äaþcucha znaków. Istnieje specyficzna skäadnia Pythona, która tworzy ten
obiekt. Podobnie wyraĔenie umieszczone w nawiasach kwadratowych tworzy listö, a w nawia-
sach klamrowych — säownik. Choè — jak siö niedäugo okaĔe — w Pythonie nie istnieje dekla-
rowanie typu, skäadnia wykonywanego wyraĔenia okreĈla typy tworzonych i wykorzystywa-
nych obiektów. WyraĔenia generujñce obiekty, jak te z tabeli 4.1, to wäaĈnie miejsca, z których
pochodzñ typy obiektów.
Co równie waĔne: kiedy tworzymy jakiĈ obiekt, wiñĔemy go z okreĈlonym zbiorem operacji.
Na äaþcuchach znaków moĔna wykonywaè tylko operacje dostöpne dla äaþcuchów znaków,
natomiast na listach — tylko te dla list. Jak siö za chwilö okaĔe, Python jest jözykiem z typami
dynamicznymi (to znaczy automatycznie przechowuje za nas informacje o typach, zamiast wyma-
gaè kodu z deklaracjñ), jednak jego typy sñ silne (to znaczy na obiekcie moĔna wykonaè tylko
te operacje, które sñ poprawne dla okreĈlonego typu).
Z funkcjonalnego punktu widzenia typy obiektów z tabeli 4.1 sñ bardziej ogólne i majñ wiök-
sze moĔliwoĈci, niĔ bywa to w innych jözykach. Jak siö okaĔe, juĔ same listy i säowniki majñ
wystarczajñco duĔe moĔliwoĈci, by zlikwidowaè wiökszoĈè pracy zwiñzanej z obsäugñ zbio-
rów i wyszukiwania w jözykach niĔszego poziomu. Listy udostöpniajñ uporzñdkowane zbio-
ry innych obiektów, natomiast säowniki przechowujñ obiekty i ich klucze. Oba typy danych
mogñ byè zagnieĔdĔane, mogñ rosnñè i kurczyè siö na Ĕyczenie oraz mogñ zawieraè obiekty
dowolnego typu.
W kolejnych rozdziaäach szczegóäowo omówimy poszczególne typy obiektów zaprezentowane
w tabeli 4.1. Zanim jednak zagäöbimy siö w szczegóäy, najpierw przyjrzyjmy siö podstawo-
wym obiektom Pythona w dziaäaniu. Pozostaäa czöĈè rozdziaäu zawiera przeglñd operacji,
które bardziej dokäadnie omówimy w kolejnych rozdziaäach. Nie naleĔy oczekiwaè, Ĕe zosta-
nie tutaj zaprezentowane wszystko — celem niniejszego rozdziaäu jest tylko zaostrzenie ape-
tytu i wprowadzenie pewnych kluczowych koncepcji. Najlepszym sposobem na rozpoczöcie
czegoĈ jest… samo rozpoczöcie, zatem czas zabraè siö za prawdziwy kod.
Liczby
Dla osób, które zajmowaäy siö juĔ programowaniem czy tworzeniem skryptów, niektóre typy
danych z tabeli 4.1 bödñ wyglñdaäy znajomo. Nawet dla osób niemajñcych nic wspólnego z pro-
gramowaniem liczby wyglñdajñ doĈè prosto. Zbiór podstawowych obiektów Pythona obejmuje
typowe rodzaje liczb: caäkowite (liczby bez czöĈci uäamkowej), zmiennoprzecinkowe (w przy-
bliĔeniu liczby z przecinkiem), a takĔe bardziej egzotyczne typy liczbowe (liczby zespolone
z liczbami urojonymi, liczby staäoprzecinkowe, liczby wymierne z mianownikiem i licznikiem,
a takĔe peäne zbiory).
Choè oferujñ kilka bardziej zaawansowanych opcji, podstawowe typy liczbowe Pythona sñ…
wäaĈnie podstawowe. Liczby w Pythonie obsäugujñ normalne dziaäania matematyczne. Znak
+
wykonuje dodawanie, znak
*
mnoĔenie, natomiast
**
potögowanie.
>>> 123 + 222 # Dodawanie liczb caäkowitych
345
>>> 1.5 * 4 # MnoĔenie liczb zmiennoprzecinkowych
6.0
>>> 2 ** 100 # 2 do potögi 100
1267650600228229401496703205376
Liczby
_
123
Warto zwróciè uwagö na wynik ostatniego dziaäania. Typ liczby caäkowitej Pythona 3.0 auto-
matycznie udostöpnia dodatkowñ precyzjö dla tak duĔych liczb, kiedy jest to potrzebne (w Pytho-
nie 2.6 osobny typ däugiej liczby caäkowitej w podobny sposób obsäugiwaä liczby zbyt duĔe
dla zwykäego typu liczby caäkowitej). MoĔna na przykäad w Pythonie obliczyè 2 do potögi
1000000 jako liczbö caäkowitñ (choè pewnie lepiej byäoby nie wyĈwietlaè wyniku tego dziaäa-
nia — z ponad trzystoma tysiñcami cyfr bödziemy musieli trochö poczekaè!).
>>> len(str(2 ** 1000000)) # Ile cyfr bödzie w naprawdö DUēEJ liczbie?
301030
Kiedy zaczniemy eksperymentowaè z liczbami zmiennoprzecinkowymi, z pewnoĈciñ natkniemy
siö na coĈ, co na pierwszy rzut oka moĔe wyglñdaè nieco dziwnie:
>>> 3.1415 * 2 # repr: jako kod
6.2830000000000004
>>> print(3.1415 * 2) # str: w postaci przyjaznej dla uĔytkownika
6.283
Pierwszy wynik nie jest bäödem — to kwestia sposobu wyĈwietlania. Okazuje siö, Ĕe kaĔdy
obiekt moĔna wyĈwietliè na dwa sposoby — z peänñ precyzjñ (jak w pierwszym wyniku powy-
Ĕej) oraz w formie przyjaznej dla uĔytkownika (jak w drugim wyniku). Pierwsza postaè znana
jest jako
repr
obiektu (jak w kodzie), natomiast druga jest przyjaznñ dla uĔytkownika
str
. RóĔ-
nica ta zacznie mieè znaczenie, kiedy przejdziemy do uĔywania klas. Na razie, kiedy coĈ bödzie
dziwnie wyglñdaäo, naleĔy wyĈwietliè to za pomocñ wywoäania wbudowanej instrukcji
.
Poza wyraĔeniami w Pythonie znajduje siö kilka przydatnych moduäów liczbowych. Moduäy
sñ po prostu pakietami dodatkowych narzödzi, które musimy zaimportowaè, by móc z nich
skorzystaè.
>>> import math
>>> math.pi
3.1415926535897931
>>> math.sqrt(85)
9.2195444572928871
Moduä
math
zawiera bardziej zaawansowane narzödzia liczbowe w postaci funkcji, natomiast
moduä
random
wykonuje generowanie liczb losowych, a takĔe losowe wybieranie (tutaj z listy
Pythona omówionej w dalszej czöĈci rozdziaäu):
>>> import random
>>> random.random()
0.59268735266273953
>>> random.choice([1, 2, 3, 4])
1
Python zawiera równieĔ bardziej egzotyczne obiekty liczb, takie jak liczby zespolone, liczby
staäoprzecinkowe, liczby wymierne, a takĔe zbiory i wartoĈci Boolean (logiczne). MoĔna rów-
nieĔ znaleĒè róĔne dodatkowe rozszerzenia na licencji open source (na przykäad dla matryc
czy wektorów). Szczegóäowe omówienie tych typów zostawimy sobie na póĒniej.
Jak na razie omawialiĈmy Pythona w funkcji prostego kalkulatora. ēeby jednak oddaè sprawie-
dliwoĈè jego typom wbudowanym, warto przejĈè do omówienia äaþcuchów znaków.
124
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
Ĥaħcuchy znaków
ãaþcuchy znaków (ang. strings) wykorzystywane sñ do przechowywania informacji teksto-
wych, a takĔe dowolnych zbiorów bajtów. Sñ pierwszym przykäadem tego, co w Pythonie
znane jest pod nazwñ sekwencji — czyli uporzñdkowanych zbiorów innych obiektów. Sekwen-
cje zachowujñ porzñdek zawieranych elementów od lewej do prawej strony. Elementy te sñ
przechowywane i pobierane zgodnie z ich pozycjñ wzglödnñ. Mówiñc dokäadnie, äaþcuchy zna-
ków to sekwencje äaþcuchów skäadajñcych siö z pojedynczych znaków. Pozostaäe typy sekwencji
to omówione póĒniej listy oraz krotki.
Operacje na sekwencjach
Jako sekwencje äaþcuchy znaków obsäugujñ operacje zakäadajñce pozycyjne uporzñdkowanie
elementów. JeĈli na przykäad mamy äaþcuch czteroznakowy, moĔemy zweryfikowaè jego däu-
goĈè za pomocñ wbudowanej funkcji
len
i pobraè jego elementy za pomocñ wyraĔeþ indek-
sujñcych:
>>> S = 'Mielonka'
>>> len(S) # DäugoĈè
8
>>> S[0] # Pierwszy element w S, indeksowanie rozpoczyna siö od zera
'M'
>>> S[1] # Drugi element od lewej
'i'
W Pythonie indeksy zakodowane sñ jako wartoĈè przesuniöcia od poczñtku äaþcucha, dlatego
rozpoczynajñ siö od zera. Pierwszy element znajduje siö pod indeksem 0, kolejny pod indek-
sem 1 i tak dalej.
Warto tutaj zwróciè uwagö na przypisanie äaþcucha znaków do zmiennej o nazwie
S
. Szcze-
góäowe omówienie tego, jak to dziaäa, odäoĔymy na póĒniej (zwäaszcza do rozdziaäu 6.), nato-
miast warto wiedzieè, Ĕe zmiennych Pythona nigdy nie trzeba deklarowaè z wyprzedzeniem.
Zmienna tworzona jest, kiedy przypisujemy do niej wartoĈè; moĔna do niej przypisaè dowolny
typ obiektu i zostanie zastñpiona swojñ wartoĈciñ, kiedy pojawi siö w wyraĔeniu. Przed uĔy-
ciem jej wartoĈci musi najpierw zostaè przypisana. Na cele niniejszego rozdziaäu wystarczy
nam wiedza, Ĕe by móc zapisaè obiekt w celu póĒniejszego uĔycia, musimy przypisaè ten
obiekt do zmiennej.
W Pythonie moĔna równieĔ indeksowaè od koþca — indeksy dodatnie odliczane sñ od lewej
strony do prawej, natomiast ujemne od prawej do lewej:
>>> S[-1] # Pierwszy element od koþca S
'a'
>>> S[-2] # Drugi element od koþca S
'k'
Z formalnego punktu widzenia indeks ujemny jest po prostu dodawany do rozmiaru äaþcu-
cha znaków, dziöki czemu dwie poniĔsze operacje sñ równowaĔne (choè pierwszñ äatwiej jest
zapisaè, a trudniej siö w niej pomyliè):
>>> S[-1] # Ostatni element w S
'a'
>>> S[len(S)-1] # Indeks ujemny zapisany w trudniejszy sposób
'a'
Ĥaħcuchy znaków
_
125
Warto zauwaĔyè, Ĕe w nawiasach kwadratowych moĔemy wykorzystaè dowolne wyraĔenie,
a nie tylko zakodowany na staäe literaä liczbowy. W kaĔdym miejscu, w którym Python ocze-
kuje wartoĈci, moĔna uĔyè literaäu, zmiennej lub dowolnego wyraĔenia. Skäadnia Pythona jest
w tym zakresie bardzo ogólna.
Poza prostym indeksowaniem zgodnie z pozycjñ sekwencje obsäugujñ równieĔ bardziej ogólnñ
formö indeksowania znanñ jako wycinki (ang. slice). Polega ona na ekstrakcji caäej czöĈci (wycinka)
za jednym razem, jak na przykäad:
>>> S # ãaþcuch z oĈmioma znakami
'Mielonka'
>>> S[1:3] # Wycinek z S z indeksami od 1 do 2 (bez 3)
'ie'
Wycinki najäatwiej jest sobie wyobraziè jako sposób pozwalajñcy na ekstrakcjö caäej kolumny
z äaþcucha znaków za jednym razem. Ich ogólna forma,
X[I:J]
, oznacza: „Zwróè wszystko z
X
od
przesuniöcia
I
aĔ do przesuniöcia
J
, ale bez niego”. Wynik zwracany jest w nowym obiekcie.
Druga operacja z listingu wyĔej zwraca na przykäad wszystkie znaki w äaþcuchu znaków
S
od
przesuniöcia 1 do przesuniöcia 2 (czyli 3–1) jako nowy äaþcuch znaków. Wynikiem jest wycinek
skäadajñcy siö z dwóch znaków znajdujñcych siö w Ĉrodku äaþcucha
S
.
W wycinku lewñ granicñ jest domyĈlnie zero, natomiast prawñ — däugoĈè sekwencji, z której
coĈ wycinamy. Dziöki temu moĔna spotkaè róĔne warianty uĔycia wycinków:
>>> S[1:] # Wszystko poza pierwszym znakiem (1:len(S))
'ielonka'
>>> S # ãaþcuch S siö nie zmieniä
'Mielonka'
>>> S[0:7] # Wszystkie elementy bez ostatniego
'Mielonk'
>>> S[:7] # To samo co S[0:7]
'Mielonk'
>>> S[:-1] # Wszystkie elementy bez ostatniego w äatwiejszej postaci
'Mielonk'
>>> S[:] # CaäoĈè S jako kopia najwyĔszego poziomu (0:len(S))
'Mielonka'
Warto zwróciè uwagö na to, Ĕe do ustalenia granic wycinków mogñ równieĔ zostaè wykorzy-
stane ujemne wartoĈci przesuniöcia. Widaè równieĔ, Ĕe ostatnia operacja w rezultacie kopiuje
caäy äaþcuch znaków. Jak siö okaĔe póĒniej, kopiowanie äaþcucha znaków nie ma sensu, jednak
to polecenie moĔe siö przydaè w przypadku sekwencji takich, jak listy.
Wreszcie tak samo jak pozostaäe sekwencje, äaþcuchy znaków obsäugujñ równieĔ konkatenacjö
(ang. concatenation) z uĔyciem znaku
+
(äñczñcñ dwa äaþcuchy znaków w jeden), a takĔe powtó-
rzenie (ang. repetition), czyli zbudowanie nowego äaþcucha znaków poprzez powtórzenie innego:
>>> S
'Mielonka'
>>> S + 'xyz' # Konkatenacja
'Mielonkaxyz'
>>> S # S pozostaje bez zmian
'Mielonka'
>>> S * 8 # Powtórzenie
'MielonkaMielonkaMielonkaMielonkaMielonkaMielonkaMielonkaMielonka'
Warto zwróciè uwagö na to, Ĕe znak plusa (
+
) oznacza coĈ innego w przypadku róĔnych
obiektów — dodawanie dla liczb, a konkatenacjö dla äaþcuchów znaków. Jest to wäaĈciwoĈè
Pythona, którñ w dalszej czöĈci ksiñĔki bödziemy nazywali polimorfizmem. Oznacza to, Ĕe kaĔda
126
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
operacja uzaleĔniona jest od typu obiektów, na jakich siö jñ wykonuje. Jak siö okaĔe przy
okazji omawiania typów dynamicznych, polimorfizm odpowiada za zwiözäoĈè i elastycznoĈè
kodu napisanego w Pythonie. PoniewaĔ typy nie sñ ograniczone, operacja napisana w Pythonie
moĔe zazwyczaj automatycznie dziaäaè na wielu róĔnych typach obiektów, o ile obsäugujñ
one zgodny z niñ interfejs (jak operacja
+
powyĔej). W Pythonie jest to bardzo waĔna koncepcja,
do której jeszcze powrócimy.
Niezmiennoļë
Warto zauwaĔyè, Ĕe w poprzednich przykäadach Ĕadna operacja wykonana na äaþcuchu zna-
ków nie zmieniäa oryginalnego äaþcucha. KaĔda operacja na äaþcuchach znaków zdefiniowana
jest w taki sposób, by w rezultacie zwracaè nowy äaþcuch znaków, poniewaĔ äaþcuchy sñ
w Pythonie niezmienne (ang. immutable). Nie mogñ byè zmienione w miejscu juĔ po utworzeniu.
Nie moĔna na przykäad zmieniè äaþcucha znaków, przypisujñc go do jednej z jego pozycji.
MoĔna jednak zawsze stworzyè nowy äaþcuch znaków i przypisaè go do tej samej nazwy
(zmiennej). PoniewaĔ Python czyĈci stare obiekty w miarö przechodzenia dalej (o czym prze-
konamy siö nieco póĒniej), nie jest to aĔ tak niewydajne, jak mogäoby siö wydawaè.
>>> S
'Mielonka'
>>> S[0] = 'z' # Niezmienne obiekty nie mogñ byè modyfikowane
...pominiĂto tekst bĪĂdu...
TypeError: 'str' object does not support item assignment
>>> S = 'z' + S[1:] # MoĔna jednak tworzyè wyraĔenia budujñce nowe obiekty
>>> S
'zielonka'
KaĔdy obiekt Pythona klasyfikowany jest jako niezmienny (niemodyfikowalny) bñdĒ zmienny
(modyfikowalny). WĈród typów podstawowych niezmienne sñ liczby, äaþcuchy znaków oraz
krotki. Listy i säowniki moĔna dowolnie zmieniaè w miejscu. NiezmiennoĈè moĔna wykorzystaè
do zagwarantowania, Ĕe obiekt pozostanie staäy w czasie caäego cyklu dziaäania programu.
Metody specyficzne dla typu
KaĔda z omówionych dotychczas operacji na äaþcuchach znaków jest tak naprawdö operacjñ
na sekwencjach, która bödzie dziaäaäa na innych typach sekwencji Pythona, w tym na listach
i krotkach. Poza tymi wspólnymi dla sekwencji operacjami äaþcuchy znaków obsäugujñ równieĔ
wäasne operacje dostöpne w formie metod (funkcji doäñczanych do obiektu i wywoäywanych
za pomocñ odpowiedniego wyraĔenia).
Metoda
find
jest na przykäad podstawowñ operacjñ dziaäajñcñ na podäaþcuchach znaków
(zwraca ona wartoĈè przesuniöcia przekazanego podäaþcucha znaków lub
-1
, jeĈli podäaþcuch
ten nie jest obecny). Metoda
replace
säuĔy z kolei do globalnego odszukiwania i zastöpowania.
>>> S.find('ie') # Odnalezienie przesuniöcia podäaþcucha
1
>>> S
'Mielonka'
>>> S.replace('ie', 'XYZ') # Zastñpienie wystñpieþ podäaþcucha innym
'MXYZlonka'
>>> S
'Mielonka'
Ĥaħcuchy znaków
_
127
I znów, mimo Ĕe w metodach äaþcucha znaków wystöpuje nazwa zmiennej, nie zmieniamy
oryginalnych äaþcuchów znaków, lecz tworzymy nowe. PoniewaĔ äaþcuchy znaków sñ nie-
zmienne, trzeba to robiè wäaĈnie w taki sposób. Metody äaþcuchów znaków to pierwsza pomoc
w przetwarzaniu tekstu w Pythonie. Inne dostöpne metody pozwalajñ dzieliè äaþcuch znaków
na podäaþcuchy w miejscu wystñpienia ogranicznika (co przydaje siö w analizie skäadniowej),
zmieniaè wielkoĈè liter, sprawdzaè zawartoĈè äaþcuchów znaków (cyfry, litery i inne znaki)
lub usuwaè biaäe znaki (ang. whitespace) z koþca äaþcucha.
>>> line = 'aaa,bbb,ccccc,dd'
>>> line.split(',') # Podzielenie na ograniczniku na listö podäaþcuchów
['aaa', 'bbb', 'ccccc', 'dd']
>>> S = 'mielonka'
>>> S.upper() # Konwersja na wielkie litery
'MIELONKA'
>>> S.isalpha() # Sprawdzenie zawartoĈci: isalpha, isdigit
True
>>> line = 'aaa,bbb,ccccc,dd\n'
>>> line = line.rstrip() # Usuniöcie biaäych znaków po prawej stronie
>>> line
'aaa,bbb,ccccc,dd'
ãaþcuchy znaków obsäugujñ równieĔ zaawansowane operacje zastöpowania znane jako forma-
towanie, dostöpne zarówno w postaci wyraĔeþ (oryginalne rozwiñzanie), jak i wywoäania metody
äaþcuchów znaków (nowoĈè w wersjach 2.6 oraz 3.0):
>>> '%s, jajka i %s' % ('mielonka', 'MIELONKA!') # WyraĔenie formatujñce (wszystkie wersje)
'mielonka, jajka i MIELONKA!'
>>> '{0}, jajka i {1}'.format('mielonka', 'MIELONKA!') # Metoda formatujñca (2.6, 3.0)
'mielonka, jajka i MIELONKA!'
Jedna uwaga: choè operacje na sekwencjach sñ uniwersalne, metody takie nie sñ — choè nie-
które typy wspóädzielñ pewne nazwy metod. Metody äaþcuchów znaków dziaäajñ wyäñcznie
na äaþcuchach znaków i na niczym innym. Generalnie zbiór narzödzi Pythona skäada siö
z warstw — uniwersalne operacje, które dostöpne sñ dla wiökszej liczby typów danych, wystö-
pujñ jako wbudowane funkcje lub wyraĔenia (na przykäad
len(X), X[0]
), natomiast operacje
specyficzne dla okreĈlonego typu sñ wywoäaniami metod (jak
aString.upper()
). Odnalezienie
odpowiednich narzödzi w tych kategoriach stanie siö bardziej naturalne z czasem, natomiast
w kolejnym podrozdziale znajduje siö kilka wskazówek przydatnych juĔ teraz.
Otrzymanie pomocy
Metody wprowadzone w poprzednim podrozdziale sñ reprezentatywnñ, choè doĈè niewielkñ
próbkñ tego, co dostöpne jest dla äaþcuchów znaków. Generalnie w niniejszej ksiñĔce omówienie
metod obiektów nie jest kompletne. W celu uzyskania wiökszej liczby szczegóäów zawsze moĔna
wywoäaè wbudowanñ funkcjö
dir
, która zwraca listö wszystkich atrybutów dostöpnych dla
danego obiektu. PoniewaĔ metody sñ atrybutami obiektów, zostanñ na tej liĈcie wyĈwietlone.
Zakäadajñc, Ĕe zmienna
S
nadal jest äaþcuchem znaków, oto jej atrybuty w Pythonie 3.0
(w wersji 2.6 nieznacznie siö one róĔniñ):
>>> dir(S)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__',
´'__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__',
´'__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
´'__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
128
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
´'__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__',
´'__subclasshook__', '_formatter_field_name_split', '_formatter_parser',
´'capitalize', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find',
´'format', 'index', 'isalnum','isalpha', 'isdecimal', 'isdigit', 'isidentifier',
´'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join',
´'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex',
´'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith',
´'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
Nazwy z dwoma znakami
_
nie bödñ nas raczej interesowaè aĔ do póĒniejszej czöĈci ksiñĔki,
kiedy bödziemy omawiaè przeciñĔanie operatorów w klasach. Reprezentujñ one implementa-
cjö obiektu äaþcucha znaków i sñ dostöpne w celu uäatwienia dostosowania obiektu do wäasnych
potrzeb. Ogólna reguäa jest taka, Ĕe podwójne znaki
_
na poczñtku i koþcu to konwencja wyko-
rzystywana w Pythonie do szczegóäów implementacyjnych. Nazwy bez tych znaków sñ meto-
dami, które moĔna wywoäywaè na äaþcuchach znaków.
Funkcja
dir
podaje same nazwy metod. ēeby dowiedzieè siö, co te metody robiñ, moĔna prze-
kazaè je do funkcji
help
.
>>> help(S.replace)
Help on built-in function replace:
replace(...)
S.replace (old, new[, count]) -> str
Return a copy of S with all occurrences of substring old replaced by new. If the
´optional argument count is given, only the first count occurrences are replaced.
Funkcja
help
jest jednym z kilku interfejsów do systemu kodu udostöpnianego wraz z Pytho-
nem i znanego pod nazwñ PyDoc — narzödzia säuĔñcego do pobierania dokumentacji z obiek-
tów. W dalszej czöĈci ksiñĔki pokaĔemy, Ĕe PyDoc moĔe równieĔ zwracaè swoje raporty
w formacie HTML.
MoĔna równieĔ próbowaè uzyskaè pomoc dla caäego äaþcucha znaków (na przykäad
help(S)
),
jednak w rezultacie otrzymamy wiöcej, niĔ chcielibyĈmy zobaczyè, to znaczy informacje
o kaĔdej metodzie äaþcuchów znaków. Lepiej jest pytaè o okreĈlonñ metodö, jak na listingu
powyĔej.
Wiöcej szczegóäowych informacji moĔna równieĔ znaleĒè w dokumentacji biblioteki standardo-
wej Pythona lub publikowanych komercyjnie ksiñĔkach, jednak to
dir
oraz
help
sñ w Pythonie
pierwszym Ēródäem pomocy.
Inne sposoby kodowania ĥaħcuchów znaków
Dotychczas przyglñdaliĈmy siö operacjom na sekwencjach na przykäadzie äaþcuchów znaków,
a takĔe metodom przeznaczonym dla tego typu danych. Python udostöpnia równieĔ róĔne
sposoby kodowania äaþcuchów znaków, które bardziej szczegóäowo omówione zostanñ nieco
póĒniej. Przykäadowo znaki specjalne moĔna reprezentowaè jako sekwencje ucieczki z uko-
Ĉnikiem lewym.
>>> S = 'A\nB\tC' # \n to koniec wiersza, \t to tabulator
>>> len(S) # KaĔde jest jednym znakiem
5
>>> ord('\n') # \n jest bajtem z wartoĈciñ binarnñ 10 w ASCII
10
Ĥaħcuchy znaków
_
129
>>> S = 'A\0B\0C' # \0, binarny bajt zerowy, nie koþczy äaþcucha znaków
>>> len(S)
5
Python pozwala na umieszczanie äaþcuchów znaków zarówno w cudzysäowach, jak i apo-
strofach (oznaczajñ one to samo). Zawiera równieĔ wielowierszowñ postaè literaäu äaþcucha
znaków umieszczanñ w trzech cudzysäowach lub trzech apostrofach. Kiedy uĔyta zostanie ta
forma, wszystkie wiersze sñ ze sobñ äñczone, a w miejscu zäamania wiersza dodawane sñ odpo-
wiednie znaki zäamania wiersza. Jest to pewna konwencja syntaktyczna, która przydaje siö do
osadzania kodu HTML czy XML w skrypcie Pythona.
>>> msg = """ aaaaaaaaaaaaa
bbb'''bbbbbbbbbb""bbbbbbb'bbbb
cccccccccccccc"""
>>> msg
'\naaaaaaaaaaaaa\nbbb\'\'\'bbbbbbbbbb""bbbbbbb\'bbbb\ncccccccccccccc'
Python obsäuguje równieĔ „surowy” literaä äaþcucha znaków wyäñczajñcy mechanizm ucieczki
z ukoĈnikiem lewym (rozpoczyna siö on od litery
r
), a takĔe format Unicode obsäugujñcy
znaki miödzynarodowe. W wersji 3.0 podstawowy typ äaþcucha znaków
str
obsäuguje takĔe
znaki Unicode (co ma sens, biorñc pod uwagö, Ĕe tekst ASCII jest po prostu czöĈciñ Unicode),
natomiast typ
bytes
reprezentuje surowe äaþcuchy bajtowe. W Pythonie 2.6 Unicode jest odröb-
nym typem, natomiast
str
obsäuguje zarówno äaþcuchy oĈmiobitowe, jak i dane binarne.
W wersji 3.0 zmieniäy siö takĔe pliki zwracajñce i przyjmujñce
str
dla tekstu i
bytes
dla danych
binarnych. Ze wszystkimi specjalnymi formami äaþcuchów znaków spotkamy siö w kolejnych
rozdziaäach.
Dopasowywanie wzorców
Zanim przejdziemy dalej, warto odnotowaè, Ĕe Ĕadna z metod äaþcuchów znaków nie obsäu-
guje przetwarzania tekstu opartego na wzorcach. Dopasowywanie wzorców tekstowych jest
zaawansowanym narzödziem pozostajñcym poza zakresem niniejszej ksiñĔki, jednak osoby
znajñce inne skryptowe jözyki programowania pewnie bödñ zainteresowane tym, Ĕe dopaso-
wywanie wzorców w Pythonie odbywa siö z wykorzystaniem moduäu o nazwie
re
. Moduä ten
zawiera analogiczne wywoäania dla wyszukiwania, dzielenia czy zastöpowania, jednak dziöki
uĔyciu wzorców do okreĈlania podäaþcuchów znaków moĔemy byè o wiele bardziej ogólni.
>>> import re
>>> match = re.match('Witaj,[ \t]*(.*)Robinie', 'Witaj, sir Robinie')
>>> match.group(1)
'sir '
PowyĔszy przykäad szuka podäaþcucha znaków zaczynajñcego siö od säowa
Witaj,
, po którym
nastöpuje od zera do wiökszej liczby tabulatorów lub spacji, po nich dowolne znaki, które bödñ
zapisane jako dopasowana grupa, a na koþcu säowo
Robinie
. Kiedy taki podäaþcuch zostanie
odnaleziony, jego czöĈci dopasowane przez czöĈci wzorca umieszczone w nawiasach dostöpne
sñ jako grupy. PoniĔszy wzorzec wybiera na przykäad trzy grupy rozdzielone ukoĈnikami
prawymi:
>>> match = re.match('/(.*)/(.*)/(.*)', '/usr/home/drwal')
>>> match.groups()
('usr', 'home', 'drwal')
Dopasowywanie wzorców samo w sobie jest doĈè zaawansowanym narzödziem do prze-
twarzania tekstu, natomiast w Pythonie udostöpniana jest nawet obsäuga jeszcze bardziej
130
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
zaawansowanych technik przetwarzania tekstu i jözyka, w tym analizy skäadniowej XML
i analizy jözyka naturalnego. DoĈè jednak informacji o äaþcuchach znaków — czas przejĈè do
kolejnego typu danych.
Listy
Obiekt listy jest w Pythonie najbardziej ogólnym rodzajem sekwencji dostöpnym w tym jözyku.
Listy to uporzñdkowane pod wzglödem pozycji zbiory obiektów dowolnego typu; nie majñ
one ustalonej wielkoĈci. Sñ równieĔ zmienne (ang. mutable) — w przeciwieþstwie do äaþcuchów
znaków listy moĔna modyfikowaè w miejscu, przypisujñc coĈ do odpowiednich wartoĈci prze-
suniöcia, a takĔe za pomocñ róĔnych metod.
Operacje na sekwencjach
PoniewaĔ listy sñ sekwencjami, obsäugujñ wszystkie operacje na sekwencjach przedstawione
przy okazji omawiania äaþcuchów znaków. Jedynñ róĔnicñ jest to, Ĕe wynikiem zazwyczaj sñ
listy, a nie äaþcuchy znaków. Majñc na przykäad listö trzyelementowñ:
>>> L = [123, 'mielonka', 1.23] # Trzyelementowa lista z elementami róĔnego typu
>>> len(L) # Liczba elementów listy
3
moĔemy jñ zindeksowaè, sporzñdziè z niej wycinki i wykonaè pozostaäe operacje zaprezento-
wane na przykäadzie äaþcuchów znaków:
>>> L[0] # Indeksowanie po pozycji
123
>>> L[:-1] # Wycinkiem listy jest nowa lista
[123, 'mielonka']
>>> L + [4, 5, 6] # Konkatenacja takĔe zwraca nowñ listö
[123, 'mielonka', 1.23, 4, 5, 6]
>>> L # Oryginalna lista pozostaje bez zmian
[123, 'mielonka', 1.23]
Operacje specyficzne dla typu
Listy Pythona powiñzane sñ z tablicami obecnymi w innych jözykach programowania, jednak
zazwyczaj majñ wiöksze moĔliwoĈci. Przede wszystkim nie majñ Ĕadnych ograniczeþ odno-
Ĉnie typów danych — przykäadowo lista z listingu powyĔej zawiera trzy obiekty o zupeänie
róĔnych typach (liczbö caäkowitñ, äaþcuch znaków i liczbö zmiennoprzecinkowñ). Co wiöcej,
wielkoĈè listy nie jest okreĈlona. Oznacza to, Ĕe moĔe ona rosnñè i kurczyè siö zgodnie z potrze-
bami i w odpowiedzi na operacje specyficzne dla list.
>>> L.append('NI') # RoĈniöcie: dodanie obiektu na koþcu listy
>>> L
[123, 'mielonka', 1.23, 'NI']
>>> L.pop(2) # Kurczenie siö: usuniöcie obiektu ze Ĉrodka listy
1.23
>>> L # "del L[2]" równieĔ usuwa element z listy
[123, 'mielonka', 'NI']
Listy
_
131
Na powyĔszym listingu metoda
append
rozszerza rozmiar listy i wstawia na jej koþcu element.
Metoda
pop
(lub jej odpowiednik, instrukcja
del
) usuwa nastöpnie element znajdujñcy siö na
pozycji o podanej wartoĈci przesuniöcia, co sprawia, Ĕe lista siö kurczy. Pozostaäe metody list
pozwalajñ na wstawienie elementu w dowolnym miejscu listy (
insert
) czy usuniöcie elementu
o podanej wartoĈci (
remove
). PoniewaĔ listy sñ zmienne, wiökszoĈè ich metod zmienia obiekt
listy w miejscu, a nie tworzy nowy obiekt.
>>> M = ['bb', 'aa', 'cc']
>>> M.sort()
>>> M
['aa', 'bb', 'cc']
>>> M.reverse()
>>> M
['cc', 'bb', 'aa']
Zaprezentowana wyĔej metoda listy o nazwie
sort
porzñdkuje listö w kolejnoĈci rosnñcej,
natomiast metoda
reverse
odwraca jñ. W obu przypadkach lista modyfikowana jest w sposób
bezpoĈredni.
Sprawdzanie granic
Choè listy nie majñ ustalonej wielkoĈci, Python nie pozwala na odnoszenie siö do elementów,
które nie istniejñ. Indeksowanie poza koþcem listy zawsze jest bäödem, podobnie jak przypi-
sywanie elementu poza jej koþcem.
>>> L
[123, 'mielonka', 'NI']
>>> L[99]
...pominiĂto tekst bĪĂdu...
IndexError: list index out of range
>>> L[99] = 1
...pominiĂto tekst bĪĂdu...
IndexError: list assignment index out of range
Takie rozwiñzanie jest celowe, poniewaĔ zazwyczaj bäödem jest próba przypisania elementu
poza koþcem listy (szczególnie paskudne jest to w jözyku C, który nie sprawdza bäödów w tak
duĔym stopniu jak Python). Zamiast w odpowiedzi po cichu powiökszaè listö, Python zgäasza
bäñd. By powiökszyè listö, naleĔy zamiast tego wywoäaè odpowiedniñ metodö, takñ jak
append
.
ZagnieŜdŜanie
Jednñ z miäych wäaĈciwoĈci podstawowych typów danych w Pythonie jest obsäuga dowolnego
zagnieĔdĔania. MoĔliwe jest zagnieĔdĔanie tych obiektów w dowolnej kombinacji i na dowolnñ
gäöbokoĈè (czyli moĔna na przykäad utworzyè listö zawierajñcñ säownik, który z kolei zawiera
kolejnñ listö). BezpoĈrednim zastosowaniem tej wäaĈciwoĈci jest reprezentowanie w Pythonie
macierzy czy, inaczej, tablic wielowymiarowych. Lista mieszczñca zagnieĔdĔone listy doskonale
siö sprawdzi w prostych aplikacjach:
>>> M = [[1, 2, 3], # Macierz 3x3 w postaci list zagnieĔdĔonych
[4, 5, 6], # Kod moĔe siö rozciñgaè na kilka wierszy, jeĈli znajduje siö w nawiasach
[7, 8, 9]]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
132
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
PowyĔej zakodowaliĈmy listö zawierajñcñ trzy inne listy. W rezultacie otrzymujemy reprezen-
tacjö macierzy liczb 3×3. Dostöp do takiej struktury moĔna uzyskaè na wiele sposobów:
>>> M[1] # Pobranie drugiego wiersza
[4, 5, 6]
>>> M[1][2] # Pobranie drugiego wiersza, a z niego trzeciego elementu
6
Pierwsza operacja pobiera caäy drugi wiersz, natomiast druga pobiera trzeci element z tego wier-
sza. ãñczenie ze sobñ indeksów wciñga nas coraz gäöbiej i gäöbiej w zagnieĔdĔonñ strukturö.
2
Listy skĥadane
Poza operacjami dla sekwencji i metodami list Python zawiera bardziej zaawansowanñ ope-
racjö znanñ pod nazwñ list skäadanych (ang. list comprehension), która Ĉwietnie siö przydaje do
przetwarzania struktur takich, jak nasza macierz. PrzypuĈèmy na przykäad, Ĕe potrzebujemy
pobraè drugñ kolumnö naszej prostej macierzy. ãatwo jest za pomocñ zwykäego indeksowania
pobieraè wiersze, poniewaĔ macierz przechowywana jest wierszami. Podobnie äatwo jest pobraè
kolumnö za pomocñ wyraĔenia listy skäadanej:
>>> col2 = [row[1] for row in M] # Zebranie elementów z drugiej kolumny
>>> col2
[2, 5, 8]
>>> M # Macierz pozostaje bez zmian
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Listy skäadane pochodzñ z notacji zbiorów. SäuĔñ do budowania nowej listy poprzez wyko-
nanie wyraĔenia na kaĔdym elemencie po kolei, jeden po drugim, od lewej strony do prawej.
Listy skäadane kodowane sñ w nawiasach kwadratowych (by podkreĈliè fakt, Ĕe tworzñ listö)
i skäadajñ siö z wyraĔenia i konstrukcji pötli, które dzielñ ze sobñ nazwö zmiennej (tutaj
row
).
PowyĔsza lista skäadana oznacza mniej wiöcej: „Zwróè
row[1]
dla kaĔdego wiersza w macie-
rzy
M
w nowej liĈcie”. Wynikiem jest nowa lista zawierajñca drugñ kolumnö macierzy.
Listy skäadane mogñ w praktyce byè bardziej skomplikowane:
>>> [row[1] + 1 for row in M] # Dodanie 1 do kaĔdego elementu w drugiej kolumnie
[3, 6, 9]
>>> [row[1] for row in M if row[1] % 2 == 0] # Odfiltrowanie elementów nieparzystych
[2, 8]
Pierwsza operacja z listingu powyĔej dodaje 1 do kaĔdego pobranego elementu, natomiast
druga wykorzystuje wyraĔenie
if
do odfiltrowania liczb nieparzystych z wyniku, uĔywajñc
do tego reszty z dzielenia (wyraĔenia z
%
). Listy skäadane tworzñ nowe listy wyników, jednak
mogñ równieĔ zostaè wykorzystane do iteracji po dowolnym obiekcie, na którym jest to moĔliwe.
Listing poniĔej prezentuje uĔycie list skäadanych do przejĈcia zakodowanej listy wspóärzödnych
oraz äaþcucha znaków:
2
Taka struktura macierzy jest dobra dla zadaþ na maäñ skalö, jednak w przypadku powaĔniejszego przetwarzania
liczb lepiej bödzie skorzystaè z jednego z rozszerzeþ liczbowych do Pythona, takiego jak system NumPy na licencji
open source. Takie narzödzia sñ w stanie przechowywaè i przetwarzaè duĔe macierze o wiele bardziej wydajnie od
zagnieĔdĔonej struktury list. O NumPy mówi siö, Ĕe zmienia Pythona w darmowy i bardziej zaawansowany odpo-
wiednik systemu MatLab, a organizacje takie, jak NASA, Los Alamos czy JPMorgan Chase wykorzystujñ to narzö-
dzie w swojej pracy naukowej i finansowej. Wiöcej informacji na ten temat moĔna znaleĒè w Internecie.
Sĥowniki
_
133
>>> diag = [M[i][i] for i in [0, 1, 2]] # Pobranie przekñtnej z macierzy
>>> diag
[1, 5, 9]
>>> doubles = [c * 2 for c in 'mielonka'] # Powtórzenie znaków w äaþcuchu
>>> doubles
['mm', 'ii', 'ee', 'll', 'oo', 'nn', 'kk', 'aa']
Listy skäadane i pokrewne konstrukcje, takie jak funkcje wbudowane
map
oraz
filter
, sñ trochö
zbyt zaawansowane, by omawiaè je teraz bardziej szczegóäowo. NajwaĔniejsze w tym krót-
kim wprowadzeniu jest to, Ĕe Python zawiera zarówno narzödzia podstawowe, jak i bardziej
zaawansowane. Listy skäadane sñ opcjonalne, jednak w praktyce czösto okazujñ siö przydatne
i nierzadko pozwalajñ zyskaè na szybkoĈci przetwarzania. Dziaäajñ na kaĔdym typie danych
bödñcym sekwencjñ, a takĔe na pewnych typach, które sekwencjami nie sñ. Wrócimy do nich
w dalszej czöĈci ksiñĔki.
Jako zapowiedĒ tego, co bödzie dalej, moĔemy napisaè, Ĕe w nowszych wersjach Pythona skäad-
nia zäoĔeþ w nawiasach moĔe byè wykorzystywana do tworzenia generatorów produkujñcych
wyniki na Ĕñdanie (wbudowana funkcja
sum
sumuje na przykäad elementy w sekwencji):
>>> G = (sum(row) for row in M) # Utworzenie generatora sum wierszy
>>> next(G) # iter(G) nie jest tu wymagane
6
>>> next(G) # Wykonanie protokoäu iteracji
15
Funkcja wbudowana
map
wykonuje podobne zadanie, generujñc wyniki wykonania funkcji dla
elementów. Opakowanie jej w wywoäanie
list
wymusza zwrócenie wszystkich wartoĈci
w Pythonie 3.0.
>>> list(map(sum, M)) # Wykonanie funkcji sum dla elementów M
[6, 15, 24]
W Pythonie 3.0 skäadniö zäoĔeþ moĔna takĔe wykorzystaè do tworzenia zbiorów oraz säowników:
>>> {sum(row) for row in M} # Utworzenie zbioru sum wierszy
{24, 6, 15}
>>> {i : sum(M[i]) for i in range(3)} # Utworzenie tabeli klucz-wartoĈè sum wierszy
{0: 6, 1: 15, 2: 24}
Tak naprawdö listy, zbiory oraz säowniki moĔna w wersji 3.0 tworzyè za pomocñ zäoĔeþ:
>>> [ord(x) for x in 'mieloonka'] # Lista numerów porzñdkowych znaków
[109, 105, 101, 108, 111, 111, 110, 107, 97]
>>> {ord(x) for x in 'mieloonka'} # Zbiory usuwajñ duplikaty
{97, 101, 105, 107, 108, 109, 110, 111}
>>> {x: ord(x) for x in 'mieloonka'} # Klucze säownika sñ unikalne
{'a': 97, 'e': 101, 'i': 105, 'k': 107, 'm': 109, 'l': 108, 'o': 111, 'n': 110}
By jednak zrozumieè obiekty, takie jak generatory, zbiory oraz säowniki, musimy przejĈè nieco
dalej.
Sĥowniki
Säowniki sñ w Pythonie czymĈ zupeänie innym — nie sñ zupeänie sekwencjami, sñ za to znane
jako odwzorowania (ang. mapping). Odwzorowania sñ równieĔ zbiorami innych obiektów, jednak
obiekty te przechowujñ po kluczu, a nie ich pozycji wzglödnej. Odwzorowania nie zachowujñ
134
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
Ĕadnej niezawodnej kolejnoĈci od lewej do prawej strony, po prostu äñczñ klucze z powiñza-
nymi z nimi wartoĈciami. Säowniki, jedyny typ odwzorowania w zbiorze typów podstawowych
Pythona, sñ równieĔ zmienne — mogñ byè modyfikowane w miejscu i podobnie do list, mogñ
rosnñè i kurczyè siö na Ĕyczenie.
Operacje na odwzorowaniach
Kiedy säowniki zapisze siö w formie literaäów, znajdujñ siö w nawiasach klamrowych i skäadajñ
siö z serii par
klucz: wartoŁð
. Säowniki sñ przydatne wtedy, gdy chcemy powiñzaè zbiór
wartoĈci z kluczami — na przykäad opisaè wäaĈciwoĈci czegoĈ. RozwaĔmy na przykäad poniĔszy
säownik skäadajñcy siö z trzech elementów (których kluczami bödñ
jedzenie
,
iloŁð
i
kolor
):
>>> D = {'jedzenie': 'Mielonka', 'iloĿî': 4, 'kolor': 'róşowy'}
W celu zmiany wartoĈci powiñzanych z kluczami säownik moĔna zindeksowaè po kluczu.
Operacja indeksowania säownika wykorzystuje tö samñ skäadniö co wykorzystywana w sekwen-
cjach, jednak elementem znajdujñcym siö w nawiasach kwadratowych jest klucz, a nie pozycja
wzglödna.
>>> D['jedzenie'] # Pobranie wartoĈci klucza "jedzenie"
'Mielonka'
>>> D['iloĿî'] += 1 # Dodanie 1 do wartoĈci klucza "iloĈè"
>>> D
{'jedzenie': 'Mielonka', 'kolor': 'róšowy', 'iloŁð': 5}
Choè forma literaäu z nawiasami klamrowymi jest czasami uĔywana, czöĈciej widzi siö säow-
niki tworzone w inny sposób. PoniĔszy przykäad rozpoczyna siö od pustego säownika, który
jest nastöpnie wypeäniany po jednym kluczu na raz. W przeciwieþstwie do przypisania poza
granicami listy, co jest zakazane, przypisania do nowych kluczy säownika tworzñ te klucze.
>>> D = {}
>>> D['imiĀ'] = 'Robert' # Tworzenie kluczy przez przypisanie
>>> D['zawód'] = 'programista'
>>> D['wiek'] = 40
>>> D
{'wiek': 40, 'zawód': 'programista', 'imiĂ': 'Robert'}
>>> print(D['imiĀ'])
Robert
PowyĔej wykorzystaliĈmy klucze jako nazwy pól w spisie opisujñcym kogoĈ. W innych zasto-
sowaniach säowniki mogñ byè równieĔ wykorzystywane do zastöpowania operacji wyszuki-
wania — zindeksowanie säownika po kluczu jest czösto najszybszñ metodñ zakodowania
wyszukiwania w Pythonie. Jak dowiemy siö póĒniej, säowniki moĔna takĔe tworzyè przez
przekazywanie argumentów bödñcych säowami kluczowymi do nazwy typu, jak w przykäadzie
dict(imiĂ='Robert', zawód='programista', wiek=40)
tworzñcym ten sam säownik.
ZagnieŜdŜanie raz jeszcze
W poprzednim przykäadzie säownik wykorzystaliĈmy do opisania hipotetycznej osoby za
pomocñ trzech kluczy. ZaäóĔmy jednak, Ĕe informacje sñ bardziej zäoĔone. Byè moĔe konieczne
bödzie zanotowanie imienia i nazwiska, a takĔe kilku zawodów czy tytuäów. Prowadzi to do
Sĥowniki
_
135
innego zastosowania zagnieĔdĔania obiektów w praktyce. PoniĔszy säownik — zakodowany
od razu jako literaä — zawiera bardziej ustrukturyzowane informacje:
>>> rec = {'dane osobowe': {'imiĀ': 'Robert', 'nazwisko': 'Zielony'},
'zawód': ['programista', 'inşynier'],
'wiek': 40.5}
W powyĔszym przykäadzie znowu mamy na górze säownik z trzema kluczami (o kluczach
dane osobowe
,
zawód
oraz
wiek
), natomiast wartoĈci stajñ siö nieco bardziej skomplikowane.
ZagnieĔdĔony säownik z danymi osobowymi moĔe pomieĈciè kilka informacji, natomiast
zagnieĔdĔona lista z zawodem mieĈci kilka ról i moĔna jñ w przyszäoĈci rozszerzyè. Dostöp
do elementów tej struktury moĔna uzyskaè w podobny sposób jak w przypadku pokazanej
wczeĈniej macierzy, jednak tym razem indeksami bödñ klucze säownika, a nie wartoĈci prze-
suniöcia listy.
>>> rec['dane osobowe'] # 'dane osobowe' to zagnieĔdĔony säownik
{'nazwisko': 'Zielony', 'imiĂ': 'Robert'}
>>> rec['dane osobowe']['nazwisko'] # Indeksowanie zagnieĔdĔonego säownika
'Zielony'
>>> rec['zawód'] # 'zawód' to zagnieĔdĔona lista
['programista', 'inšynier']
>>> rec['zawód'][-1] # Indeksowanie zagnieĔdĔonej listy
'inšynier'
>>> rec['zawód'].append('leĿniczy') # Rozszerzenie listy zawodów Roberta
>>> rec
{'wiek': 40.5, 'zawód': ['programista', 'inšynier', 'leŁniczy'], 'dane osobowe':
´{'nazwisko': 'Zielony', 'imiĂ': 'Robert'}}
Warto zwróciè uwagö na to, jak ostatnia operacja rozszerza osadzonñ listö z zawodami. Ponie-
waĔ lista zawodów jest fragmentem pamiöci oddzielnym od zawierajñcego jñ säownika, moĔe
dowolnie rosnñè i kurczyè siö (rozkäad pamiöci obiektów omówiony zostanie w dalszej czöĈci
ksiñĔki).
Prawdziwym powodem pokazania tego przykäadu jest chöè zademonstrowania elastycznoĈci
podstawowych typów obiektów Pythona. Jak widaè, zagnieĔdĔanie pozwala na budowanie
skomplikowanych struktur informacji w sposób äatwy i bezpoĈredni. Zbudowanie podobnej
struktury w jözyku niskiego poziomu, takim jak C, byäoby Ĕmudne i wymagaäoby o wiele wiök-
szej iloĈci kodu. MusielibyĈmy zaprojektowaè i zadeklarowaè ukäad struktury i tablic, wypeäniè
je wartoĈciami i wreszcie poäñczyè wszystko ze sobñ. W Pythonie wszystko to dzieje siö auto-
matycznie — jedno wyraĔenie tworzy za nas caäñ zagnieĔdĔonñ strukturö obiektów. Tak
naprawdö jest to jedna z najwaĔniejszych zalet jözyków skryptowych, takich jak Python.
Co równie waĔne, w jözyku niĔszego poziomu musielibyĈmy uwaĔnie czyĈciè przestrzeþ
zajmowanñ przez obiekty, które jej juĔ däuĔej nie potrzebujñ. W Pythonie, kiedy znika ostat-
nia referencja do obiektu (na przykäad gdy do zmiennej przypisze siö coĈ innego), caäe miejsce
w pamiöci zajmowane przez tö strukturö obiektu jest automatycznie zwalniane.
>>> rec = 0 # Miejsce zajmowane przez obiekt zostaje odzyskane
Z technicznego punktu widzenia Python korzysta z czegoĈ, co znane jest pod nazwñ czyszczenia
pamiöci (ang. garbage collection). NieuĔywana pamiöè jest czyszczona w miarö wykonywania pro-
gramu, co zwalnia nas z odpowiedzialnoĈci za zarzñdzanie takimi szczegóäami w naszym kodzie.
W Pythonie miejsce to jest odzyskiwane natychmiast, kiedy tylko zniknie ostatnia referencja do
136
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
obiektu. W dalszej czöĈci ksiñĔki omówimy tö kwestiö bardziej szczegóäowo. Na razie powinna
nam wystarczyè wiedza, Ĕe moĔemy swobodnie korzystaè z obiektów, bez koniecznoĈci trosz-
czenia siö o tworzenie dla nich miejsca w pamiöci i zwalnianie go.
3
Sortowanie kluczy — pýtle for
Säowniki, bödñc odwzorowaniami, obsäugujñ jedynie dostöp do elementów po ich kluczu.
Obsäugujñ jednak równieĔ operacje specyficzne dla tego typu z wywoäaniami metod przydat-
nymi w wielu czösto spotykanych sytuacjach.
Jak wspomniano wczeĈniej, poniewaĔ säowniki nie sñ sekwencjami, nie zachowujñ Ĕadnej kolej-
noĈci elementów od lewej do prawej strony. Oznacza to, Ĕe jeĈli utworzymy säownik i wyĈwie-
tlimy jego zawartoĈè, klucze mogñ zostaè zwrócone w innej kolejnoĈci, niĔ je wpisaliĈmy.
>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D
{'a': 1, 'c': 3, 'b': 2}
Co jednak moĔna zrobiè, kiedy potrzebne nam jest wymuszenie okreĈlonej kolejnoĈci elemen-
tów säownika? Jednym z czösto spotykanych rozwiñzaþ jest tu pobranie listy kluczy za pomocñ
metody säownika
keys
, posortowanie tej listy za pomocñ metody listy
sort
, a nastöpnie przej-
Ĉcie wyników za pomocñ pötli
for
. NaleĔy pamiötaè o dwukrotnym naciĈniöciu przycisku
Enter po utworzeniu poniĔszego kodu pötli — zgodnie z informacjami z rozdziaäu 3. pusty wiersz
oznacza w sesji interaktywnej „dalej”, natomiast w niektórych interfejsach znak zachöty siö
zmienia.
>>> Ks = list(D.keys()) # Nieuporzñdkowana lista kluczy
>>> Ks
['a', 'c', 'b']
>>> Ks.sort() # Posortowana lista kluczy
>>> Ks
['a', 'b', 'c']
>>> for key in Ks: # Iteracja przez posortowane klucze
print(key, '=>', D[key]) # <== Tutaj naleĔy dwukrotnie nacisnñè Enter
a => 1
b => 2
c => 3
Ten proces skäada siö jednak z trzech etapów, natomiast jak zobaczymy w kolejnych roz-
dziaäach, w nowszych wersjach Pythona moĔna go wykonaè w jednym etapie — dziöki now-
szej funkcji wbudowanej o nazwie
sorted
. Wywoäanie
sorted
zwraca wynik i sortuje róĔne
typy obiektów; w tym przypadku automatycznie sortuje klucze säownika.
>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> for key in sorted(D):
3
Jedna uwaga: naleĔy pamiötaè, Ĕe utworzony przed chwilñ spis
rec
mógäby byè prawdziwym wpisem do
bazy danych, gdybyĈmy uĔyli systemu trwaäoĈci obiektów (ang. object persistence) Pythona — äatwego sposobu
przechowywania obiektów Pythona w plikach lub bazach danych dostöpnych za pomocñ klucza. Nie bödziemy
teraz omawiaè szczegóäów tego rozwiñzania; po wiöcej informacji na ten temat naleĔy siögnñè do omówionych
w dalszej czöĈci ksiñĔki moduäów
pickle
oraz
shelve
.
Sĥowniki
_
137
print(key, '=>', D[key])
a => 1
b => 2
c => 3
Poza zaprezentowaniem säowników powyĔszy przypadek posäuĔyä nam jako pretekst do wpro-
wadzenia pötli
for
dostöpnej w Pythonie. Pötla
for
jest prostym i wydajnym sposobem przej-
Ĉcia wszystkich elementów sekwencji i wykonania bloku kodu dla kaĔdego elementu po kolei.
Zdefiniowana przez uĔytkownika zmienna pötli (tutaj:
key
) wykorzystana jest do referencji do
aktualnie przechodzonego elementu. Wynikiem tego kodu jest wyĈwietlenie kluczy i wartoĈci
säownika w kolejnoĈci posortowanej po kluczach.
Pötla
for
, a takĔe jej bardziej ogólny kuzyn — pötla
while
, sñ podstawowymi sposobami kodo-
wania powtarzalnych zadaþ w skryptach jako instrukcji. Tak naprawdö jednak pötla
for
, a takĔe
jej krewniak — listy skäadane, to operacja na sekwencjach. Zadziaäa na kaĔdym obiekcie bödñ-
cym sekwencjñ, podobnie do list skäadanych — a nawet na pewnych obiektach, które sekwen-
cjami nie sñ. PoniĔej widaè przykäad przechodzenia znaków w äaþcuchu i wyĈwietlenia wersji
kaĔdego z tych znaków napisanego wielkñ literñ.
>>> for c in 'mielonka':
print(c.upper())
M
I
E
L
O
N
K
A
Pötla
while
Pythona jest narzödziem bardziej ogólnym i nie jest ograniczona do przechodzenia
sekwencji:
>>> x = 4
>>> while x > 0:
print('mielonka!' * x)
x -= 1
mielonka!mielonka!mielonka!mielonka!
mielonka!mielonka!mielonka!
mielonka!mielonka!
mielonka!
Instrukcje, skäadnia i narzödzia powiñzane z pötlami omówione zostanñ bardziej szczegóäowo
w dalszej czöĈci ksiñĔki.
Iteracja i optymalizacja
JeĈli pötla
for
z poprzedniego podrozdziaäu przypomina nam omówione wczeĈniej wyraĔe-
nie z listami skäadanymi, tak wäaĈnie powinno byè — oba sñ ogólnymi narzödziami iteracyj-
nymi. Tak naprawdö oba rozwiñzania bödñ dziaäaäy na kaĔdym obiekcie zgodnym z protokoäem
iteracji — rozpowszechnionñ w Pythonie koncepcjñ, która oznacza fizycznie przechowywanñ
sekwencjö w pamiöci czy obiekt generujñcy jeden element na raz w kontekĈcie operacji iteracji.
Obiekt mieĈci siö w tej drugiej kategorii, jeĈli odpowiada na wbudowane wywoäanie
iter
obiektem, który posuwa siö naprzód w odpowiedzi na
next
. WyraĔenie skäadane generatora,
które widzieliĈmy wczeĈniej, jest takim wäaĈnie typem obiektu.
138
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
Na temat protokoäu iteracji bödö miaä wiöcej do powiedzenia w dalszej czöĈci ksiñĔki. Na razie
naleĔy pamiötaè, Ĕe kaĔde narzödzie Pythona, które przeglñda obiekt od lewej do prawej strony,
wykorzystuje protokóä iteracji. Dlatego wäaĈnie wywoäanie
sorted
wykorzystane wyĔej dziaäa
bezpoĈrednio na säowniku. Nie musimy wywoäywaè metody
keys
w celu otrzymania sekwen-
cji, poniewaĔ säowniki poddajñ siö iteracji, a
next
zwraca w ich przypadku kolejne klucze.
Oznacza to takĔe, Ĕe kaĔde wyraĔenie list skäadanych — jak poniĔsze, obliczajñce kwadrat
z listy liczb:
>>> squares = [x ** 2 for x in [1, 2, 3, 4, 5]]
>>> squares
[1, 4, 9, 16, 25]
zawsze moĔe zostaè zapisane w kodzie jako odpowiednik pötli
for
tworzñcej listö röcznie —
poprzez dodanie do niej kolejnych przechodzonych elementów:
>>> squares = []
>>> for x in [1, 2, 3, 4, 5]: # To robi lista skäadana
squares.append(x ** 2) # Wewnötrznie wykonujñ protokóä iteracji
>>> squares
[1, 4, 9, 16, 25]
Lista skäadana, a takĔe powiñzane z niñ narzödzia programowania funkcjonalnego, takie jak
map
oraz
filter
, zazwyczaj bödñ obecnie dziaäaäy szybciej od pötli
for
(byè moĔe nawet dwa
razy szybciej) — ta cecha moĔe mieè znaczenie w przypadku wiökszych zbiorów danych.
Mimo to warto podkreĈliè, Ĕe pomiar wydajnoĈci moĔe byè w Pythonie doĈè podchwytliwy,
poniewaĔ jözyk ten tak duĔo optymalizuje, a wydajnoĈè zmienia siö z wydania na wydanie.
NajwaĔniejszñ reguäñ jest w Pythonie kodowanie w sposób prosty oraz czytelny i martwienie
siö o wydajnoĈè dopiero póĒniej, kiedy sam program juĔ dziaäa i przekonamy siö, Ĕe wydaj-
noĈè jest dla nas rzeczywistym problemem. NajczöĈciej kod bödzie wystarczajñco szybki. JeĈli
musimy w nim trochö pomajstrowaè pod kñtem wydajnoĈci, Python zawiera narzödzia, które
mogñ nam w tym pomóc, w tym moduäy
time
,
timeit
i
profile
. Wiöcej informacji na ten
temat znajduje siö w dalszej czöĈci ksiñĔki, a takĔe w dokumentacji Pythona.
Brakujéce klucze — testowanie za pomocé if
Zanim przejdziemy dalej, warto odnotowaè jeszcze jednñ kwestiö dotyczñcñ säowników.
Choè moĔemy przypisaè wartoĈè do nowego klucza w celu rozszerzenia säownika, próba pobra-
nia nieistniejñcego klucza jest bäödem.
>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> D['e'] = 99 # Przypisanie nowego klucza rozszerza säownik
>>> D
{'a': 1, 'c': 3, 'b': 2, 'e': 99}
>>> D['f'] # Referencja do nieistniejñcego klucza jest bäödem
...pominiĂto tekst bĪĂdu...
KeyError: 'f'
Tego wäaĈnie oczekujemy — zazwyczaj pobieranie czegoĈ, co nie istnieje, jest bäödem pro-
gramistycznym. Jednak w pewnych ogólnych programach nie zawsze bödziemy w momencie
pisania kodu wiedzieè, jakie klucze bödñ obecne. W jaki sposób moĔna sobie poradziè w takim
przypadku i uniknñè bäödów? Jednym z rozwiñzaþ jest sprawdzenie tego zawczasu. WyraĔenie
Krotki
_
139
säownika
in
pozwala na sprawdzenie istnienia klucza i odpowiednie zachowanie w zaleĔnoĈci
od wyniku tego sprawdzenia — dziöki instrukcji
if
. Tak jak w przypadku
for
, naleĔy pamiötaè
o dwukrotnym naciĈniöciu przycisku Enter w celu wykonania instrukcji
if
w sesji interaktywnej.
>>> 'f' in D
False
>>> if not 'f' in D:
print('nie ma')
nie ma
Na temat instrukcji
if
i ogólnej skäadni instrukcji powiemy wiöcej nieco póĒniej, jednak forma
wykorzystywana w kodzie powyĔej jest doĈè prosta. Instrukcja skäada siö ze säowa
if
, po nim
nastöpuje wyraĔenie, którego wynik interpretowany jest jako prawdziwy lub faäszywy, a nastöp-
nie blok kodu do wykonania, jeĈli wyraĔenie bödzie prawdziwe. W peänej formie instrukcja
if
moĔe równieĔ zawieraè instrukcjö
else
z przypadkiem domyĈlnym, a takĔe jednñ lub wiök-
szñ liczbö instrukcji
elif
(od „else if”) sprawdzajñcych inne testy. Jest to podstawowe narzö-
dzie wyboru w Pythonie, a takĔe sposób kodowania logiki w skryptach.
Istniejñ inne sposoby tworzenia säowników, które pozwalajñ na unikniöcie prób uzyskania
dostöpu do nieistniejñcych kluczy, w tym metoda
get
(warunkowe indeksowanie z wartoĈciñ
domyĈlnñ), w Pythonie 2.X metoda
has_key
(w wersji 3.0 juĔ niedostöpna), instrukcja
try
(narzödzie, z którym spotkamy siö w rozdziale 10. przy okazji przechwytywania wyjñtków
i radzenia sobie z nimi), a takĔe wyraĔenie
if
/
else
(instrukcja
if
zmieszczona w jednym
wierszu). PoniĔej znajduje siö kilka przykäadów:
>>> value = D.get('x', 0) # Indeks, ale z wartoĈciñ domyĈlnñ
>>> value
0
>>> value = D['x'] if 'x' in D else 0 # Forma wyraĔenia if/else
>>> value
0
Szczegóäowe informacje na temat tych alternatywnych rozwiñzaþ odäoĔymy jednak do jed-
nego z kolejnych rozdziaäów. Teraz czas przejĈè do omawiania krotek.
Krotki
Obiekt krotki (ang. tuple) jest w przybliĔeniu listñ, której nie moĔna zmodyfikowaè. Krotki sñ
sekwencjami, podobnie do list, jednak sñ teĔ niezmienne — tak jak äaþcuchy znaków. Z punktu
widzenia skäadni kodowane sñ w zwykäych nawiasach, a nie w nawiasach kwadratowych.
Krotki obsäugujñ dowolne typy danych, zagnieĔdĔanie i zwykäe operacje na sekwencjach.
>>> T = (1, 2, 3, 4) # Krotka z 4 elementami
>>> len(T) # DäugoĈè krotki
4
>> T + (5, 6) # Konkatenacja
(1, 2, 3, 4, 5, 6)
>>> T[0] # Indeksowanie i wycinki
1
Krotki majñ w Pythonie 3.0 dwie metody wywoäywalne specyficzne dla tego typu — nie jest
ich zatem tak wiele jak w przypadku list.
140
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
>>> T.index(4) # Metody krotek — 4 znajduje siö na wartoĈci przesuniöcia 3
3
>>> T.count(4) # 4 pojawia siö raz
1
Podstawowñ wyróĔniajñcñ cechñ krotek jest to, Ĕe po utworzeniu nie moĔna ich zmodyfikowaè.
Oznacza to, Ĕe sñ sekwencjami niezmiennymi.
>>> T[0] = 2 # Krotki sñ niezmienne
...pominiĂto tekst bĪĂdu...
TypeError: 'tuple' object does not support item assignment
Tak jak listy i säowniki, krotki obsäugujñ obiekty o mieszanych typach i zagnieĔdĔanie, jednak nie
rosnñ i nie kurczñ siö, poniewaĔ sñ niezmienne.
>>> T = ('mielonka', 3.0, [11, 22, 33])
>>> T[1]
3.0
>>> T[2][1]
22
>>> T.append(4)
AttributeError: 'tuple' object has no attribute 'append'
Czemu sĥuŜé krotki?
Po co nam zatem typ podobny do listy, który obsäuguje mniejszñ liczbö operacji? Szczerze
mówiñc, w praktyce krotki nie sñ uĔywane tak czösto jak listy, jednak ich niezmiennoĈè jest
ich zaletñ. Kiedy w programie przekazujemy zbiór obiektów w postaci listy, obiekty te mogñ
siö w dowolnym momencie zmieniè. W przypadku uĔycia krotki zmieniè siö nie mogñ. Krotki
nakäadajñ pewne ograniczenia w zakresie integralnoĈci, które przydajñ siö w programach wiök-
szych od pisanych tutaj. O krotkach powiemy jeszcze w dalszej czöĈci ksiñĔki. Najpierw jednak
omówmy nasz ostatni gäówny typ podstawowy, czyli pliki.
Pliki
Obiekty plików sñ w Pythonie gäównym interfejsem do plików zewnötrznych znajdujñcych
siö na komputerze. Sñ typem podstawowym, jednak nieco innym od pozostaäych. Nie istnieje
Ĕadna skäadnia literaäu säuĔñca do ich tworzenia. Zamiast tego w celu utworzenia obiektu
wywoäuje siö wbudowanñ funkcjö
open
, przekazujñc nazwö pliku zewnötrznego jako äaþcuch
znaków wraz z äaþcuchem okreĈlajñcym tryb przetwarzania. By na przykäad utworzyè plik wyj-
Ĉciowy, naleĔy przekazaè jego nazwö wraz z äaþcuchem znaków
'w'
okreĈlajñcym tryb prze-
twarzania umoĔliwiajñcy zapis danych:
>>> f = open('data.txt', 'w') # Utworzenie nowego pliku w trybie do zapisu
>>> f.write('Witaj,\n') # Zapisanie do niego äaþcuchów bajtów
6
>>> f.write('Brian\n') # Zwraca liczbö zapisanych bajtów w Pythonie 3.0
6
>>> f.close() # Zamkniöcie pliku i wyczyszczenie bufora wyjĈciowego na dysku
PowyĔszy kod tworzy plik w katalogu bieĔñcym i zapisuje do niego tekst (nazwa pliku moĔe
byè peänñ ĈcieĔkñ do katalogu, jeĈli potrzebny jest nam dostöp do pliku znajdujñcego siö
w innym miejscu komputera). By wczytaè z powrotem to, co napisaliĈmy, naleĔy ponownie
Pliki
_
141
otworzyè plik, tym razem w trybie przetwarzania
'r'
, w celu odczytania danych tekstowych
(jest to wartoĈè domyĈlna, jeĈli pominiemy tryb w wywoäaniu). Nastöpnie naleĔy wczytaè
zawartoĈè pliku do äaþcucha znaków i wyĈwietliè go. ZawartoĈè pliku jest zawsze dla naszego
skryptu äaþcuchem znaków, bez wzglödu na typ danych umieszczonych w pliku.
>>> f = open('data.txt')
# 'r'
jest domyĈlnym trybem przetwarzania
>>> text = f.read() # Wczytanie caäego pliku do äaþcucha znaków
>>> text
'Witaj,\nBrian\n'
>>> print(text) # Instrukcja print interpretuje znaki sterujñce
Witaj,
Brian
>>> text.split() # ZawartoĈè pliku jest zawsze äaþcuchem znaków
['Witaj,', 'Brian']
Inne metody plików obsäugujñ dodatkowe wäaĈciwoĈci, których nie mamy teraz czasu omawiaè.
Obiekty plików udostöpniajñ na przykäad wiökszñ liczbö sposobów odczytywania i zapisy-
wania (
read
przyjmuje opcjonalny rozmiar w bajtach,
readLine
wczytuje po jednym wierszu
naraz), a takĔe inne narzödzia (
seek
przechodzi do nowej pozycji pliku). Jak jednak zoba-
czymy póĒniej, najlepszym obecnie sposobem na wczytanie pliku jest niewczytywanie go —
pliki udostöpniajñ iterator, który automatycznie wczytuje wiersz po wierszu w pötlach
for
oraz
innych kontekstach.
Z peänym zbiorem metod plików spotkamy siö w dalszej czöĈci ksiñĔki, a osoby juĔ teraz
chcñce przyjrzeè siö tym metodom mogñ wywoäaè funkcjö
dir
dla dowolnego otwartego pliku
oraz funkcjö
help
dla dowolnej ze zwróconych nazw metod:
>>> dir(f)
[ ...pominiĂto wiele nazw...
'buffer', 'close', 'closed', 'encoding', 'errors', 'fileno', 'flush', 'isatty',
´'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline',
´'readlines', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write',
´'writelines']
>>> help(f.seek)
...przekonaj siĂ sam!...
W dalszej czöĈci ksiñĔki zobaczymy takĔe, Ĕe pliki w Pythonie 3.0 zachowujñ rozróĔnienie
pomiödzy danymi tekstowymi a binarnymi. Pliki tekstowe reprezentujñ zawartoĈè w postaci
äaþcuchów znaków i automatycznie wykonujñ kodowanie Unicode, natomiast pliki binarne
reprezentujñ zawartoĈè w postaci specjalnego typu äaþcucha bajtowego
bytes
i pozwalajñ na
dostöp do niezmienionej zawartoĈci. PoniĔszy fragment kodu zakäada, Ĕe w katalogu bieĔñcym
znajduje siö juĔ plik binarny.
>>> data = open('data.bin', 'rb').read() # Otwarcie pliku binarnego
>>> data # ãaþcuch bajtowy przechowuje dane binarne
b'\x00\x00\x00\x07mielonka\x00\x08'
>>> data[4:12]
b'spam'
Osoby, które bödñ miaäy do czynienia jedynie z tekstem w formacie ASCII, nie bödñ siö musiaäy
przejmowaè tym rozróĔnieniem. ãaþcuchy znaków i pliki Pythona 3.0 sñ jednak bardzo cenne,
jeĈli mamy do czynienia z aplikacjami miödzynarodowymi lub danymi bajtowymi.
142
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
Inne narzýdzia podobne do plików
Funkcja
open
jest koniem pociñgowym dla wiökszoĈci czynnoĈci zwiñzanych z przetwarza-
niem plików w Pythonie. Dla bardziej zaawansowanych zadaþ Python udostöpnia jednak
dodatkowe narzödzia podobne do plików: potoki, kolejki FIFO, gniazda, pliki dostöpne po
kluczu, trwaäoĈè obiektów, pliki oparte na deskryptorze czy interfejsy do relacyjnych i zorien-
towanych obiektowo baz danych. Pliki deskryptorów obsäugujñ na przykäad blokowanie pliku
i inne narzödzia niskiego poziomu, natomiast gniazda udostöpniajñ interfejs do zadaþ siecio-
wych i komunikacji miödzyprocesowej. Niewiele z tych zagadnieþ poruszymy w niniejszej
ksiñĔce, jednak osobom, które zajmñ siö programowaniem w Pythonie na powaĔnie, z pewnoĈciñ
wiele z nich siö przyda.
Inne typy podstawowe
Poza omówionymi dotychczas typami podstawowymi istniejñ inne, które mogñ siö zaliczaè
do tej kategorii — w zaleĔnoĈci od tego, jak szeroko jñ zdefiniujemy. Zbiory sñ na przykäad
nowym dodatkiem do jözyka, który nie jest ani odwzorowaniem, ani sekwencjñ. Zbiory to
raczej nieuporzñdkowane kolekcje unikalnych i niezmiennych obiektów. Tworzy siö je, wywo-
äujñc wbudowanñ funkcjö
set
lub za pomocñ nowych literaäów i wyraĔeþ zbiorów z Pythona 3.0.
Obsäugujñ one zwykäe operacje matematyczne na zbiorach. Wybór nowej skäadni
{...}
dla
literaäów zbiorów w wersji 3.0 ma sens, poniewaĔ zbiory przypominajñ klucze säownika bez
wartoĈci.
>>> X = set('mielonka') # Utworzenie zbioru z sekwencji w wersjach 2.6 oraz 3.0
>>> Y = {'s', 'z', 'y', 'n', 'k', 'a'} # Utworzenie zbioru za pomocñ nowego literaäu z wersji 3.0
>>> X, Y
({'a', 'e', 'i', 'k', 'm', 'l', 'o', 'n'}, {'a', 'k', 'n', 's', 'y', 'z'})
>>> X & Y # CzöĈè wspólna zbiorów
{'a', 'k', 'n'}
>>> X | Y # Suma zbiorów
{'a', 'e', 'i', 'k', 'm', 'l', 'o', 'n', 's', 'y', 'z'}
>>> X – Y # RóĔnica
{'i', 'm', 'e', 'l', 'o'}
>>> {x ** 2 for x in [1, 2, 3, 4]} # Zbiory skäadane z wersji 3.0
{16, 1, 4, 9}
Dodatkowo Python od niedawna urósä o kilka nowych typów liczbowych: liczby dziesiötne
(liczby zmiennoprzecinkowe o staäej precyzji) oraz liczby uäamkowe (liczby wymierne zawierajñce
licznik i mianownik). Oba typy moĔna wykorzystaè do obejĈcia ograniczeþ i niedokäadnoĈci
bödñcych nierozerwalnñ czöĈciñ arytmetyki liczb zmiennoprzecinkowych.
>>> 1 / 3 # Liczby zmiennoprzecinkowe (w Pythonie 2.6 naleĔy uĔyè .0)
0.33333333333333331
>>> (2/3) + (1/2)
1.1666666666666665
>>> import decimal # Liczby dziesiötne — staäa precyzja
>>> d = decimal.Decimal('3.141')
>>> d + 1
Decimal('4.141')
>>> decimal.getcontext().prec = 2
Inne typy podstawowe
_
143
>>> decimal.Decimal('1.00') / decimal.Decimal('3.00')
Decimal('0.33')
>>> from fractions import Fraction # Uäamki — licznik i mianownik
>>> f = Fraction(2, 3)
>>> f + 1
Fraction(5, 3)
>>> f + Fraction(1, 2)
Fraction(7, 6)
Python zawiera takĔe wartoĈci typu Boolean (ze zdefiniowanymi obiektami
True
i
False
, które
sñ tak naprawdö liczbami caäkowitymi
1
i
0
z wäasnñ logikñ wyĈwietlania). Od dawna obsäuguje
równieĔ specjalny obiekt pojemnika o nazwie
None
, wykorzystywany najczöĈciej do inicjalizo-
wania zmiennych i obiektów.
>>> 1 > 2, 1 < 2 # WartoĈci typu Boolean
(False, True)
>>> bool('mielonka')
True
>>> X = None # Pojemnik None
>>> print(X)
None
>>> L = [None] * 100 # Inicjalizacja listy stu None
>>> L
[None, None, None, None, None, None, None, None, None, None, None, None, None,
´...lista stu None...]
Jak zepsuë elastycznoļë kodu
Wiöcej o tych typach obiektów Pythona powiemy w dalszej czöĈci ksiñĔki, jednak jeden z nich
zasäuguje na kilka säów juĔ teraz. Obiekt typu, zwracany przez funkcjö wbudowanñ
type
, to
obiekt dajñcy typ innego obiektu. Jego wynik róĔni siö nieco w Pythonie 3.0 z uwagi na caäkowite
zlanie siö typów i klas (coĈ, co omówimy w szóstej czöĈci ksiñĔki w kontekĈcie klas w nowym
stylu). Zakäadajñc, Ĕe
L
nadal jest listñ z poprzedniego podrozdziaäu:
# W Pythonie 2.6:
>>> type(L) # Typy: L jest obiektem typu lista
<type 'list'>
>>> type(type(L)) # Typy teĔ sñ obiektami
<type 'type'>
# W Pythonie 3.0:
>>> type(L) # 3.0: typy sñ klasami i odwrotnie
<class 'list'>
>>> type(type(L)) # Wiöcej na temat typów klas w rozdziale 31.
<class 'type'>
Poza umoĔliwieniem interaktywnego zbadania obiektów w praktyce pozwala to kodowi
sprawdzaè typy przetwarzanych obiektów. W skryptach Pythona moĔna to zrobiè na przynajm-
niej trzy sposoby.
>>> if type(L) == type([]): # Sprawdzanie typów, skoro juĔ musimy…
print('tak')
tak
>>> if type(L) == list: # UĔycie nazwy typu
144
_
Rozdziaĥ 4. Wprowadzenie do typów obiektów Pythona
print('tak')
tak
>>> if isinstance(L, list): # Sprawdzanie zorientowane obiektowo
print('tak')
tak
Pokazaäem wszystkie te sposoby sprawdzania typów, jednak moim obowiñzkiem jest dodaè,
Ĕe korzystanie z nich jest prawie zawsze zäym pomysäem w programie napisanym w Pytho-
nie (i czösto jest teĔ znakiem rozpoznawczym byäego programisty jözyka C, który zaczyna
przygodö z Pythonem). Przyczyna takiego stanu rzeczy stanie siö caäkowicie zrozumiaäa dopiero
póĒniej, kiedy zaczniemy pisaè wiöksze jednostki kodu, takie jak funkcje, jednak jest to kon-
cepcja kluczowa dla Pythona (byè moĔe wröcz najwaĔniejsza ze wszystkich). Sprawdzajñc okre-
Ĉlone typy w kodzie, efektywnie niszczymy jego elastycznoĈè, ograniczajñc go do tylko jednego
typu danych. Bez takiego sprawdzania kod moĔe dziaäaè na szerokiej gamie typów danych.
Jest to powiñzane ze wspomnianñ wczeĈniej koncepcjñ polimorfizmu i ma swoje Ēródäo w braku
deklaracji typu w Pythonie. W Pythonie, czego nauczymy siö juĔ niedäugo, koduje siö pod
kñtem interfejsów obiektów (obsäugiwanych operacji), a nie typów. Nieprzejmowanie siö kon-
kretnymi typami sprawia, Ĕe kod automatycznie moĔna zastosowaè do wielu typów danych.
KaĔdy obiekt ze zgodnym interfejsem bödzie dziaäaä bez wzglödu na typ. Choè sprawdzanie
typów jest obsäugiwane — a nawet w niektórych przypadkach wymagane — to nie jest to
„pythonowy” sposób myĈlenia. Jak siö okaĔe, sam polimorfizm jest jednñ z kluczowych kon-
cepcji stojñcych za Pythonem.
Klasy zdefiniowane przez uŜytkownika
W dalszej czöĈci ksiñĔki bödziemy bardziej szczegóäowo omawiali programowanie zorientowane
obiektowo w Pythonie — opcjonalnñ, lecz majñcñ duĔe moĔliwoĈci wäaĈciwoĈè tego jözyka pozwa-
lajñcñ na skrócenie czasu programowania dziöki dostosowaniu obiektów do wäasnych potrzeb.
Z abstrakcyjnego punktu widzenia klasy definiujñ nowe typy obiektów, które rozszerzajñ
zbiór typów podstawowych, dlatego zasäugujñ na kilka säów w tym miejscu. Powiedzmy na
przykäad, Ĕe potrzebny jest nam typ obiektu bödñcy modelem pracownika. Choè taki wäaĈnie
typ nie istnieje w Pythonie, poniĔsza zdefiniowana przez uĔytkownika klasa powinna siö
przydaè.
>>> class Worker:
def __init__(self, name, pay): # Inicjalizacja przy utworzeniu
self.name = name # self jest nowym obiektem; name to nazwisko, a pay — päaca
self.pay = pay
def lastName(self):
return self.name.split()[-1] # Podziaä äaþcucha znaków na znakach pustych
def giveRaise(self, percent):
self.pay *= (1.0 + percent) # Uaktualnienie päacy w miejscu
PowyĔsza klasa definiuje nowy rodzaj obiektu, który bödzie miaä atrybuty
name
(nazwisko)
i
pay
(päaca) — czasami nazywane informacjami o stanie (ang. state information) — a takĔe dwa
rodzaje zachowania zakodowane w postaci funkcji (normalnie nazywanych metodami). Wywo-
äanie klasy w sposób podobny do funkcji generuje obiekty naszego nowego typu, a metody
klasy automatycznie otrzymujñ obiekt przetwarzany przez dane wywoäanie metody (w argu-
mencie
self
).
Podsumowanie rozdziaĥu
_
145
>>> bob = Worker('Robert Zielony', 50000) # Utworzenie dwóch obiektów
>>> anna = Worker('Anna Czerwona', 60000) # KaĔdy ma atrybut imienia i nazwiska oraz päacy
>>> bob.lastName() # Wywoäanie metody — self to bob
'Zielony'
>>> anna.lastName() # Teraz self to anna
'Czerwona'
>>> anna.giveRaise(.10) # Uaktualnienie päacy Anny
>>> anna.pay
66000.0
Domniemany obiekt
self
jest przyczynñ nazwania tego modelu zorientowanym obiektowo —
w funkcjach klasy zawsze istnieje domniemany podmiot. W pewnym sensie typ oparty na klasie
po prostu tworzy coĈ na bazie typów podstawowych. Zdefiniowany wyĔej obiekt
Worker
jest
na przykäad zbiorem äaþcucha znaków oraz liczby (odpowiednio
name
i
pay
) wraz z funkcjami
odpowiedzialnymi za przetwarzanie tych wbudowanych obiektów.
Bardziej rozbudowane wyjaĈnienie kwestii klas mówi, Ĕe to ich mechanizm dziedziczenia obsäu-
guje hierarchiö oprogramowania, która pozwala na dostosowywanie programów do wäasnych
potrzeb poprzez rozszerzanie ich. Programy rozszerza siö poprzez pisanie nowych klas, a nie
modyfikowanie tego, co juĔ dziaäa. Warto równieĔ wiedzieè, Ĕe klasy sñ w Pythonie opcjo-
nalne i w wielu przypadkach proste obiekty wbudowane, takie jak listy i säowniki, sñ czösto
lepszymi narzödziami od klas zakodowanych przez uĔytkowników. Wszystko to jednak wy-
kracza poza zakres wstöpnego omówienia typów, dlatego naleĔy uznaè to tylko za zapowiedĒ
tego, co znajduje siö dalej. Peäne informacje na temat typów zdefiniowanych przez uĔytkow-
nika i tworzonych za pomocñ klas bödzie moĔna znaleĒè w szóstej czöĈci ksiñĔki.
I wszystko inne
Jak wspomniano wczeĈniej, wszystko, co moĔemy przetworzyè w skrypcie Pythona, jest typem
obiektu, przez co nasze omówienie nie moĔe byè kompletne. Jednak mimo Ĕe wszystko
w Pythonie jest obiektem, jedynie obiekty omówione wyĔej stanowiñ zbiór obiektów podsta-
wowych tego jözyka. Pozostaäe typy sñ albo obiektami powiñzanymi z omówionym póĒniej
wykonywaniem programu (jak funkcje, moduäy, klasy i skompilowany kod), albo sñ implemen-
towane przez funkcje importowanych moduäów, a nie skäadniö jözyka. Ta druga kategoria
peäni zwykle role specyficzne dla okreĈlonego zastosowania — wzorców tekstowych, interfej-
sów do baz danych czy poäñczeþ sieciowych.
NaleĔy równieĔ pamiötaè, Ĕe obiekty omówione wyĔej sñ obiektami, ale niekoniecznie sñ zorien-
towane obiektowo. Zorientowanie obiektowe zazwyczaj wymaga w Pythonie dziedziczenia
i instrukcji
class
, z którñ spotkamy siö w dalszej czöĈci ksiñĔki. Obiekty podstawowe Pythona
sñ siäñ napödowñ prawie kaĔdego skryptu napisanego w tym jözyku, z jakim moĔna siö spotkaè,
i zazwyczaj sñ teĔ podstawñ wiökszych typów niemieszczñcych siö w tej kategorii.
Podsumowanie rozdziaĥu
I to by byäo na tyle, jeĈli chodzi o naszñ krótkñ wycieczkö po typach danych. W niniejszym
rozdziale zawaräem zwiözäe wprowadzenie do podstawowych typów obiektów w Pythonie
wraz z omówieniem rodzajów operacji, jakie moĔna do nich zastosowaè. PrzyjrzeliĈmy siö
uniwersalnym operacjom, które dziaäajñ na wielu typach obiektów (na przykäad operacjom
na sekwencjach, takim jak indeksowanie czy wycinki), a takĔe operacjom specyficznym dla