.:$$:.

• Jak Python wykonuje programy?
• Jak korzystać ze standardowej biblioteki tego języka?
• Jak programować obiektowo w Pythonie?

Python to popularny język programowania, wykorzystywany w wielu różnych dziedzinach. Używa się go zarówno w samodzielnych programach, jak i skryptach. Jest wyposażony w dynamiczny system typów oraz automatyczne zarządzanie pamięcią. Ponadto -- co istotne -- jest on darmowy, łatwo przenośny i bardzo prosty w użyciu. Podobnie jak inne języki, również Python ciągle się rozwija. W tej książce przedstawiono właśnie wszystkie potrzebne i aktualne wiadomości, dotyczące wykorzystania tego języka programowania w praktyce.

Książka "Python. Wprowadzenie. Wydanie III" stanowi kompletny i szczegółowy przewodnik po podstawach języka Python. Wiedza w niej zawarta umożliwia pełne zrozumienie tego języka, co pozwoli Ci pojąć dowolne przykłady kodu na poziomie aplikacji. Zwięźle i jasno przedstawione przykłady świetnie ilustrują poszczególne kwestie i problemy, co daje solidny fundament do praktycznego zastosowania świeżo nabytych umiejętności. W niniejszym -- trzecim już -- wydaniu znajdziesz nowy zestaw praktycznych wskazówek i porad, dobranych w taki sposób, aby obejmowały aktualne zalecenia i najlepsze praktyki programowania. Krótko mówiąc, ta książka ma wszystko, czego potrzebujesz, aby nie tylko dokładnie poznać język Python, ale także efektywnie z niego korzystać!

• Wprowadzenie do interpretera Pythona
• Interaktywne wpisywanie kodu
• Systemowe wiersze poleceń i pliki
• Typy liczbowe Pythona
• Referencje współdzielone
• Łańcuchy znaków
• Instrukcje przypisania i instrukcje wyrażeń
• Źródła dokumentacji
• Funkcje i moduły
• Zakres i argumenty
• Programowanie zorientowane obiektowo
• Projektowanie z udziałem klas

Przedmowa (25)
I: Wprowadzenie (41)
1. Pytania i odpowiedzi dotyczące Pythona (43)

• Dlaczego ludzie używają Pythona? (43)
• Jakość oprogramowania (44)
• Wydajność programistów (45)
• Czy Python jest językiem skryptowym? (45)
• Jakie są zatem wady Pythona? (47)
• Kto dzisiaj używa Pythona? (48)
• Co mogę zrobić za pomocą Pythona? (49)
• Programowanie systemowe (49)
• Graficzne interfejsy użytkownika (49)
• Skrypty internetowe (50)
• Integracja komponentów (50)
• Programowanie bazodanowe (51)
• Szybkie prototypowanie (51)
• Programowanie numeryczne i naukowe (51)
• Gry, grafika, AI, XML, roboty i tym podobne (51)
• Jakie są techniczne mocne strony Pythona? (52)
• Jest zorientowany obiektowo (52)
• Jest darmowy (52)
• Jest przenośny (53)
• Ma duże możliwości (54)
• Można go łączyć z innymi językami (55)
• Jest łatwy w użyciu (55)
• Jest łatwy do nauczenia się (57)
• Zawdzięcza swoją nazwę Monty Pythonowi (57)
• Jak Python wygląda na tle innych języków? (58)
• Podsumowanie rozdziału (59)
• Łamigłówka (60)
• Quiz (60)
• Odpowiedzi (60)

2. Jak Python wykonuje programy? (63)

• Wprowadzenie do interpretera Pythona (63)
• Wykonywanie programu (65)
• Z punktu widzenia programisty (65)
• Z punktu widzenia Pythona (66)
• Warianty modeli wykonywania (68)
• Alternatywne implementacje Pythona (69)
• Narzędzia do optymalizacji wykonywania (70)
• Zamrożone pliki binarne (72)
• Przyszłe możliwości? (73)
• Podsumowanie rozdziału (73)
• Łamigłówka (74)
• Quiz (74)
• Odpowiedzi (74)

3. Jak wykonuje się programy? (75)

• Interaktywne wpisywanie kodu (75)
• Wykorzystywanie sesji interaktywnej (77)
• Systemowe wiersze poleceń i pliki (78)
• Wykorzystywanie wierszy poleceń i plików (80)
• Skrypty wykonywalne Uniksa (#!) (81)
• Kliknięcie ikony pliku (83)
• Kliknięcie ikony w systemie Windows (83)
• Sztuczka z raw_input (84)
• Inne ograniczenia klikania ikon (86)
• Importowanie i przeładowywanie modułów (86)
• Więcej o modułach - atrybuty (88)
• Uwagi na temat używania instrukcji import i reload (90)
• Interfejs użytkownika IDLE (91)
• Podstawy IDLE (91)
• Korzystanie z IDLE (93)
• Zaawansowane opcje IDLE (95)
• Inne IDE (95)
• Osadzanie wywołań (96)
• Zamrożone binarne pliki wykonywalne (97)
• Uruchamianie kodu w edytorze tekstowym (97)
• Inne możliwości uruchamiania (98)
• Przyszłe możliwości (98)
• Jaką opcję wybrać? (98)
• Podsumowanie rozdziału (99)
• Łamigłówka (100)
• Quiz (100)
• Odpowiedzi (100)
• Łamigłówka (102)
• Ćwiczenia do części pierwszej (102)

II: Typy i operacje (105)
4. Wprowadzenie do typów obiektów Pythona (107)

• Po co korzysta się z typów wbudowanych? (108)
• Najważniejsze typy danych w Pythonie (109)
• Liczby (110)
• Łańcuchy znaków (111)
• Operacje na sekwencjach (111)
• Niezmienność (113)
• Metody specyficzne dla typu (114)
• Otrzymanie pomocy (115)
• Inne sposoby kodowania łańcuchów znaków (116)
• Dopasowywanie wzorców (116)
• Listy (117)
• Operacje na sekwencjach (117)
• Operacje specyficzne dla typu (117)
• Sprawdzanie granic (118)
• Zagnieżdżanie (119)
• Listy składane (119)
• Słowniki (120)
• Operacje na odwzorowaniach (120)
• Zagnieżdżanie raz jeszcze (121)
• Sortowanie kluczy - pętle for (123)
• Iteracja i optymalizacja (124)
• Brakujące klucze - testowanie za pomocą if (125)
• Krotki (126)
• Czemu służą krotki? (126)
• Pliki (126)
• Inne narzędzia podobne do plików (127)
• Inne typy podstawowe (128)
• Jak zepsuć elastyczność kodu (128)
• Klasy zdefiniowane przez użytkownika (129)
• I wszystko inne (130)
• Podsumowanie rozdziału (131)
• Łamigłówka (132)
• Quiz (132)
• Odpowiedzi (132)

5. Liczby (135)

• Typy liczbowe Pythona (135)
• Literały liczbowe (136)
• Wbudowane narzędzia liczbowe oraz rozszerzenia (137)
• Operatory wyrażeń Pythona (138)
• Połączone operatory stosują się do priorytetów (139)
• Podwyrażenia grupowane są w nawiasach (139)
• Pomieszane typy poddawane są konwersji (139)
• Przeciążanie operatorów - przegląd (140)
• Liczby w akcji (141)
• Zmienne i podstawowe wyrażenia (141)
• Formaty wyświetlania liczb (143)
• Dzielenie - klasyczne, bez reszty i prawdziwe (144)
• Operacje poziomu bitowego (145)
• Długie liczby całkowite (145)
• Liczby zespolone (146)
• Notacja szesnastkowa i ósemkowa (146)
• Inne wbudowane narzędzia liczbowe (147)
• Inne typy liczbowe (149)
• Liczby dziesiętne (149)
• Zbiory (150)
• Wartości Boolean (151)
• Dodatkowe rozszerzenia (152)
• Podsumowanie rozdziału (152)
• Łamigłówka (153)
• Quiz (153)
• Odpowiedzi (153)

6. Wprowadzenie do typów dynamicznych (155)

• Sprawa brakujących deklaracji typu (155)
• Zmienne, obiekty i referencje (155)
• Typy powiązane są z obiektami, a nie ze zmiennymi (157)
• Obiekty są uwalniane (158)
• Referencje współdzielone (159)
• Referencje współdzielone a modyfikacje w miejscu (161)
• Referencje współdzielone a równość (162)
• Typy dynamiczne są wszędzie (163)
• Podsumowanie rozdziału (164)
• Łamigłówka (165)
• Quiz (165)
• Odpowiedzi (165)

7. Łańcuchy znaków (167)

• Literały łańcuchów znaków (168)
• Łańcuchy znaków w apostrofach i cudzysłowach są tym samym (169)
• Sekwencje ucieczki reprezentują bajty specjalne (169)
• Surowe łańcuchy znaków blokują sekwencje ucieczki (171)
• Potrójne cudzysłowy i apostrofy kodują łańcuchy znaków będące wielowierszowymi blokami (172)
• Łańcuchy znaków Unicode pozwalają na zakodowanie większych zbiorów znaków kodowych (174)
• Łańcuchy znaków w akcji (176)
• Podstawowe operacje (176)
• Indeksowanie i wycinki (177)
• Narzędzia do konwersji łańcuchów znaków (180)
• Modyfikowanie łańcuchów znaków (183)
• Formatowanie łańcuchów znaków (184)
• Zaawansowane formatowanie łańcuchów znaków (185)
• Formatowanie łańcuchów znaków w oparciu o słownik (186)
• Metody łańcuchów znaków (187)
• Przykłady metod łańcuchów znaków - modyfikowanie łańcuchów znaków (188)
• Przykłady metod łańcuchów znaków - analiza składniowa tekstu (190)
• Inne znane metody łańcuchów znaków w akcji (191)
• Oryginalny moduł string (192)
• Generalne kategorie typów (193)
• Typy z jednej kategorii współdzielą zbiory operacji (193)
• Typy zmienne można modyfikować w miejscu (194)
• Podsumowanie rozdziału (194)
• Łamigłówka (195)
• Quiz (195)
• Odpowiedzi (195)

8. Listy oraz słowniki (197)

• Listy (197)
• Listy w akcji (199)
• Podstawowe operacje na listach (199)
• Indeksowanie, wycinki i macierze (200)
• Modyfikacja list w miejscu (201)
• Słowniki (204)
• Słowniki w akcji (206)
• Podstawowe operacje na słownikach (206)
• Modyfikacja słowników w miejscu (207)
• Inne metody słowników (208)
• Przykład z tabelą języków programowania (209)
• Uwagi na temat korzystania ze słowników (210)
• Podsumowanie rozdziału (214)
• Łamigłówka (215)
• Quiz (215)
• Odpowiedzi (215)

9. Krotki, pliki i pozostałe (217)

• Krotki (217)
• Krotki w akcji (218)
• Dlaczego istnieją listy i krotki? (220)
• Pliki (221)
• Otwieranie plików (221)
• Wykorzystywanie plików (222)
• Pliki w akcji (223)
• Inne narzędzia powiązane z plikami (227)
• Raz jeszcze o kategoriach typów (227)
• Elastyczność obiektów (228)
• Referencje a kopie (229)
• Porównania, równość i prawda (231)
• Znaczenie True i False w Pythonie (233)
• Hierarchie typów Pythona (234)
• Inne typy w Pythonie (235)
• Pułapki typów wbudowanych (236)
• Przypisanie tworzy referencje, nie kopie (236)
• Powtórzenie dodaje jeden poziom zagłębienia (236)
• Uwaga na cykliczne struktury danych (237)
• Typów niezmiennych nie można modyfikować w miejscu (237)
• Podsumowanie rozdziału (238)
• Łamigłówka (239)
• Quiz (239)
• Odpowiedzi (239)
• Łamigłówka (240)
• Ćwiczenia do części drugiej (240)

III: Instrukcje i składnia (243)
10. Wprowadzenie do instrukcji Pythona (245)

• Raz jeszcze o strukturze programu Pythona (245)
• Instrukcje Pythona (246)
• Historia dwóch if (246)
• Co dodaje Python (248)
• Co usuwa Python (248)
• Skąd bierze się składnia indentacji? (249)
• Kilka przypadków specjalnych (252)
• Szybki przykład - interaktywne pętle (253)
• Prosta pętla interaktywna (254)
• Wykonywanie obliczeń na danych użytkownika (255)
• Obsługa błędów za pomocą sprawdzania danych wejściowych (256)
• Obsługa błędów za pomocą instrukcji try (257)
• Kod zagnieżdżony na trzy poziomy głębokości (257)
• Podsumowanie rozdziału (258)
• Łamigłówka (259)
• Quiz (259)
• Odpowiedzi (259)

11. Przypisanie, wyrażenia i print (261)

• Instrukcje przypisania (261)
• Formy instrukcji przypisania (262)
• Przypisanie sekwencji (263)
• Przypisanie z wieloma celami (265)
• Przypisania rozszerzone (266)
• Reguły dotyczące nazw zmiennych (268)
• Instrukcje wyrażeń (271)
• Instrukcje wyrażeń i modyfikacje w miejscu (272)
• Instrukcje print (272)
• Program "Witaj, świecie!" w Pythonie (273)
• Przekierowanie strumienia wyjścia (274)
• Rozszerzenie print >> file (274)
• Podsumowanie rozdziału (277)
• Łamigłówka (278)
• Quiz (278)
• Odpowiedzi (278)

12. Testy if (279)

• Instrukcje if (279)
• Ogólny format (279)
• Proste przykłady (280)
• Rozgałęzienia kodu (280)
• Reguły składni Pythona (282)
• Ograniczniki bloków (283)
• Ograniczniki instrukcji (284)
• Kilka przypadków specjalnych (285)
• Testy prawdziwości (285)
• Wyrażenie trójargumentowe if/else (287)
• Podsumowanie rozdziału (289)
• Łamigłówka (290)
• Quiz (290)
• Odpowiedzi (290)

13. Pętle while i for (291)

• Pętle while (291)
• Ogólny format (291)
• Przykłady (292)
• Instrukcje break, continue, pass oraz else w pętli (293)
• Ogólny format pętli (293)
• Przykłady (293)
• Pętle for (297)
• Ogólny format (297)
• Przykłady (298)
• Pierwsze spojrzenie na iteratory (302)
• Iteratory plików (302)
• Inne iteratory typów wbudowanych (304)
• Inne konteksty iteracyjne (305)
• Iteratory definiowane przez użytkownika (306)
• Techniki tworzenia pętli (306)
• Pętle liczników - while i range (307)
• Przechodzenie niewyczerpujące - range (308)
• Modyfikacja list - range (309)
• Przechodzenie równoległe - zip oraz map (310)
• Generowanie wartości przesunięcia i elementów - enumerate (312)
• Listy składane - wprowadzenie (313)
• Podstawy list składanych (313)
• Wykorzystywanie list składanych w plikach (314)
• Rozszerzona składnia list składanych (315)
• Podsumowanie rozdziału (316)
• Łamigłówka (317)
• Quiz (317)
• Odpowiedzi (317)

14. Wprowadzenie do dokumentacji (319)

• Źródła dokumentacji Pythona (319)
• Komentarze ze znakami # (320)
• Funkcja dir (320)
• Łańcuchy znaków dokumentacji - __doc__ (321)
• PyDoc - funkcja help (324)
• PyDoc - raporty HTML (326)
• Zbiór standardowej dokumentacji (329)
• Zasoby internetowe (330)
• Publikowane książki (330)
• Często spotykane problemy programistyczne (330)
• Podsumowanie rozdziału (332)
• Łamigłówka (333)
• Quiz (333)
• Odpowiedzi (333)
• Łamigłówka (334)
• Ćwiczenia do części trzeciej (334)

IV: Funkcje (337)
15. Podstawy funkcji (339)

• Po co używa się funkcji? (340)
• Tworzenie funkcji (340)
• Instrukcje def (342)
• Instrukcja def uruchamiana jest w czasie wykonania (342)
• Pierwszy przykład - definicje i wywoływanie (343)
• Definicja (343)
• Wywołanie (343)
• Polimorfizm w Pythonie (344)
• Drugi przykład - przecinające się sekwencje (345)
• Definicja (345)
• Wywołania (346)
• Raz jeszcze o polimorfizmie (346)
• Zmienne lokalne (347)
• Podsumowanie rozdziału (348)
• Łamigłówka (349)
• Quiz (349)
• Odpowiedzi (349)

16. Zakres i argumenty (351)

• Reguły dotyczące zakresu (351)
• Podstawy zakresów Pythona (352)
• Rozwiązywanie konfliktów w zakresie nazw - reguła LEGB (353)
• Przykład zakresu (355)
• Zakres wbudowany (355)
• Instrukcja global (357)
• Minimalizowanie stosowania zmiennych globalnych (358)
• Minimalizacja modyfikacji dokonywanych pomiędzy plikami (359)
• Inne metody dostępu do zmiennych globalnych (360)
• Zakresy a funkcje zagnieżdżone (361)
• Szczegóły dotyczące zakresów zagnieżdżonych (361)
• Przykład zakresu zagnieżdżonego (361)
• Przekazywanie argumentów (367)
• Argumenty a współdzielone referencje (368)
• Unikanie modyfikacji zmiennych argumentów (369)
• Symulowanie parametrów wyjścia (370)
• Specjalne tryby dopasowania argumentów (371)
• Przykłady ze słowami kluczowymi i wartościami domyślnymi (372)
• Przykład dowolnych argumentów (374)
• Łączenie słów kluczowych i wartości domyślnych (376)
• Przykład z funkcją obliczającą minimum (376)
• Bardziej przydatny przykład - uniwersalne funkcje działające na zbiorach (379)
• Dopasowywanie argumentów - szczegóły (380)
• Podsumowanie rozdziału (381)
• Łamigłówka (382)
• Quiz (382)
• Odpowiedzi (383)

17. Zaawansowane zagadnienia związane z funkcjami (385)

• Funkcje anonimowe - lambda (385)
• Wyrażenia lambda (385)
• Po co używa się wyrażenia lambda? (387)
• Jak łatwo zaciemnić kod napisany w Pythonie (388)
• Zagnieżdżone wyrażenia lambda a zakresy (389)
• Zastosowanie funkcji do argumentów (390)
• Wbudowana funkcja apply (391)
• Składnia wywołania podobna do stosowania funkcji apply (392)
• Odwzorowywanie funkcji na sekwencje - map (392)
• Narzędzia programowania funkcyjnego - filter i reduce (394)
• Jeszcze raz listy składane - odwzorowania (395)
• Podstawy list składanych (395)
• Dodawanie testów i zagnieżdżonych pętli (396)
• Listy składane i macierze (398)
• Zrozumienie list składanych (399)
• Jeszcze o iteratorach - generatory (401)
• Przykład funkcji generatora (402)
• Rozszerzony protokół generatora funkcji - metoda send a next (403)
• Iteratory a typy wbudowane (404)
• Wyrażenia generatora - iteratory spotykają listy składane (404)
• Pomiar alternatywnych sposobów iteracji (406)
• Koncepcje związane z projektowaniem funkcji (408)
• Funkcje są obiektami - wywołania pośrednie (410)
• Pułapki związane z funkcjami (410)
• Zmienne lokalne wykrywane są w sposób statyczny (411)
• Wartości domyślne i obiekty zmienne (412)
• Funkcje bez instrukcji return (413)
• Zmienne pętli zakresu zawierającego (414)
• Podsumowanie rozdziału (414)
• Łamigłówka (415)
• Quiz (415)
• Odpowiedzi (415)
• Łamigłówka (417)
• Ćwiczenia do części czwartej (417)

V: Moduły (421)
18. Moduły - wprowadzenie (423)

• Po co używa się modułów? (423)
• Architektura programu w Pythonie (424)
• Struktura programu (424)
• Importowanie i atrybuty (425)
• Moduły biblioteki standardowej (427)
• Jak działa importowanie (427)
• 1. Odnalezienie modułu (428)
• 2. (Ewentualne) Kompilowanie (432)
• 3. Wykonanie (432)
• Podsumowanie rozdziału (433)
• Łamigłówka (435)
• Quiz (435)
• Odpowiedzi (435)

19. Podstawy tworzenia modułów (437)

• Tworzenie modułów (437)
• Użycie modułów (438)
• Instrukcja import (438)
• Instrukcja from (439)
• Instrukcja from * (439)
• Operacja importowania odbywa się tylko raz (439)
• Instrukcje import oraz from są przypisaniami (440)
• Modyfikacja zmiennych pomiędzy plikami (441)
• Równoważność instrukcji import oraz from (441)
• Potencjalne pułapki związane z użyciem instrukcji from (442)
• Przestrzenie nazw modułów (443)
• Pliki generują przestrzenie nazw (443)
• Kwalifikowanie nazw atrybutów (445)
• Importowanie a zakresy (446)
• Zagnieżdżanie przestrzeni nazw (447)
• Przeładowywanie modułów (448)
• Podstawy przeładowywania modułów (449)
• Przykład przeładowywania z użyciem reload (450)
• Podsumowanie rozdziału (451)
• Łamigłówka (452)
• Quiz (452)
• Odpowiedzi (452)

20. Pakiety modułów (453)

• Podstawy importowania pakietów (453)
• Pakiety a ustawienia ścieżki wyszukiwania (454)
• Pliki pakietów __init__.py (454)
• Przykład importowania pakietu (456)
• Instrukcja from a instrukcja import w importowaniu pakietów (457)
• Do czego służy importowanie pakietów? (458)
• Historia trzech systemów (458)
• Podsumowanie rozdziału (461)
• Łamigłówka (462)
• Quiz (462)
• Odpowiedzi (462)

21. Zaawansowane zagadnienia związane z modułami (463)

• Ukrywanie danych w modułach (463)
• Minimalizacja niebezpieczeństw użycia from * - _X oraz __all__ (464)
• Włączanie opcji z przyszłych wersji Pythona (464)
• Mieszane tryby użycia - __name__ oraz __main__ (465)
• Testy jednostkowe z wykorzystaniem __name__ (466)
• Modyfikacja ścieżki wyszukiwania modułów (467)
• Rozszerzenie import as (468)
• Składnia importowania względnego (468)
• Do czego służy importowanie względne? (469)
• Projektowanie modułów (471)
• Moduły są obiektami - metaprogramy (472)
• Pułapki związane z modułami (474)
• W kodzie najwyższego poziomu kolejność instrukcji ma znaczenie (474)
• Importowanie modułów za pomocą łańcucha znaków nazwy (475)
• Instrukcja from kopiuje nazwy, jednak łącza już nie (476)
• Instrukcja from * może zaciemnić znaczenie zmiennych (476)
• Funkcja reload może nie mieć wpływu na obiekty importowane za pomocą from (477)
• Funkcja reload i instrukcja from a testowanie interaktywne (478)
• Instrukcja reload nie jest stosowana rekurencyjnie (478)
• Rekurencyjne importowanie za pomocą from może nie działać (480)
• Podsumowanie rozdziału (481)
• Łamigłówka (482)
• Quiz (482)
• Odpowiedzi (482)
• Łamigłówka (483)
• Ćwiczenia do części piątej (483)

VI: Klasy i programowanie zorientowane obiektowo (485)
22. Programowanie zorientowane obiektowo (487)

• Po co używa się klas? (488)
• Programowanie zorientowane obiektowo z dystansu (489)
• Wyszukiwanie dziedziczenia atrybutów (489)
• Klasy a instancje (492)
• Wywołania metod klasy (492)
• Tworzenie drzew klas (493)
• Programowanie zorientowane obiektowo oparte jest na ponownym wykorzystaniu kodu (495)
• Podsumowanie rozdziału (498)
• Łamigłówka (499)
• Quiz (499)
• Odpowiedzi (499)

23. Podstawy tworzenia klas (501)

• Klasy generują większą liczbę obiektów instancji (501)
• Obiekty klas udostępniają zachowania domyślne (502)
• Obiekty instancji są rzeczywistymi elementami (502)
• Pierwszy przykład (503)
• Klasy dostosowuje się do własnych potrzeb przez dziedziczenie (505)
• Drugi przykład (506)
• Klasy są atrybutami w modułach (507)
• Klasy mogą przechwytywać operatory Pythona (508)
• Trzeci przykład (509)
• Po co przeciąża się operatory? (511)
• Najprostsza klasa Pythona na świecie (512)
• Podsumowanie rozdziału (514)
• Łamigłówka (515)
• Quiz (515)
• Odpowiedzi (515)

24. Szczegóły kodu klas (517)

• Instrukcja class (517)
• Ogólna forma (517)
• Przykład (518)
• Metody (520)
• Przykład (521)
• Wywoływanie konstruktorów klas nadrzędnych (521)
• Inne możliwości wywoływania metod (522)
• Dziedziczenie (522)
• Tworzenie drzewa atrybutów (523)
• Specjalizacja odziedziczonych metod (524)
• Techniki interfejsów klas (524)
• Abstrakcyjne klasy nadrzędne (526)
• Przeciążanie operatorów (527)
• Często spotykane metody przeciążania operatorów (527)
• Metoda __getitem__ przechwytuje referencje do indeksów (528)
• Metody __getitem__ oraz __iter__ implementują iterację (529)
• Iteratory zdefiniowane przez użytkownika (530)
• Metody __getattr__ oraz __setattr__ przechwytują referencje do atrybutów (534)
• Emulowanie prywatności w atrybutach instancji (535)
• Metody __repr__ oraz __str__ zwracają reprezentacje łańcuchów znaków (536)
• Metoda __radd__ obsługuje dodawanie prawostronne (537)
• Metoda __call__ przechwytuje wywołania (538)
• Interfejsy funkcji i kod oparty na wywołaniach zwrotnych (538)
• Metoda __del__ jest destruktorem (540)
• Przestrzenie nazw - cała historia (541)
• Pojedyncze nazwy - globalne, o ile nie przypisane (541)
• Nazwy atrybutów - przestrzenie nazw obiektów (541)
• Zen przestrzeni nazw Pythona - przypisania klasyfikują zmienne (542)
• Słowniki przestrzeni nazw (544)
• Łącza przestrzeni nazw (546)
• Bardziej realistyczny przykład (547)
• Podsumowanie rozdziału (550)
• Łamigłówka (551)
• Quiz (551)
• Odpowiedzi (551)

25. Projektowanie z udziałem klas (553)

• Python a programowanie zorientowane obiektowo (553)
• Przeciążanie za pomocą sygnatur wywołań (lub nie) (554)
• Klasy jako rekordy (554)
• Programowanie zorientowane obiektowo i dziedziczenie - związek "jest" (556)
• Programowanie zorientowane obiektowo i kompozycja - związki "ma" (558)
• Raz jeszcze procesor strumienia danych (559)
• Programowanie zorientowane obiektowo a delegacja (562)
• Dziedziczenie wielokrotne (563)
• Klasy są obiektami - uniwersalne fabryki obiektów (566)
• Do czego służą fabryki? (567)
• Metody są obiektami - z wiązaniem i bez wiązania (568)
• Raz jeszcze o łańcuchach znaków dokumentacji (570)
• Klasy a moduły (571)
• Podsumowanie rozdziału (572)
• Łamigłówka (573)
• Quiz (573)
• Odpowiedzi (573)

26. Zaawansowane zagadnienia związane z klasami (575)

• Rozszerzanie typów wbudowanych (575)
• Rozszerzanie typów za pomocą osadzania (576)
• Rozszerzanie typów za pomocą klas podrzędnych (576)
• Pseudoprywatne atrybuty klas (579)
• Przegląd zniekształcania nazw zmiennych (579)
• Po co używa się atrybutów pseudoprywatnych? (580)
• Klasy w nowym stylu (581)
• Modyfikacja wielokrotnego dziedziczenia po jednej klasie (582)
• Inne rozszerzenia klas w nowym stylu (585)
• Metody statyczne oraz metody klasy (588)
• Wykorzystywanie metod statycznych oraz metod klasy (590)
• Dekoratory funkcji (592)
• Przykład dekoratora (593)
• Pułapki związane z klasami (594)
• Modyfikacja atrybutów klas może mieć efekty uboczne (594)
• Dziedziczenie wielokrotne - kolejność ma znaczenie (595)
• Metody, klasy oraz zakresy zagnieżdżone (596)
• Przesadne opakowywanie (598)
• Podsumowanie rozdziału (598)
• Łamigłówka (599)
• Quiz (599)
• Odpowiedzi (599)
• Łamigłówka (600)
• Ćwiczenia do części szóstej (600)

VII: Wyjątki oraz narzędzia (607)
27. Podstawy wyjątków (609)

• Po co używa się wyjątków? (610)
• Role wyjątków (610)
• Obsługa wyjątków w skrócie (611)
• Instrukcja try/except/else (615)
• Części instrukcji try (616)
• Część try/else (618)
• Przykład - zachowanie domyślne (619)
• Przykład - przechwytywanie wbudowanych wyjątków (620)
• Instrukcja try/finally (620)
• Przykład - działania kończące kod z użyciem try/finally (621)
• Połączona instrukcja try/except/finally (622)
• Łączenie finally oraz except za pomocą zagnieżdżania (623)
• Przykład połączonego try (624)
• Instrukcja raise (625)
• Przykład - zgłaszanie i przechwytywanie wyjątków zdefiniowanych przez użytkownika (626)
• Przykład - przekazywanie dodatkowych danych w raise (626)
• Przykład - przekazywanie wyjątków za pomocą raise (627)
• Instrukcja assert (628)
• Przykład - wyłapywanie ograniczeń (ale nie błędów) (628)
• Menedżery kontekstu with/as (629)
• Podstawowe zastosowanie (629)
• Protokół zarządzania kontekstem (632)
• Podsumowanie rozdziału (633)
• Łamigłówka (634)
• Quiz (634)
• Odpowiedzi (634)

28. Obiekty wyjątków (635)

• Wyjątki oparte na łańcuchach znaków (636)
• Wyjątki oparte na łańcuchach znaków znikają (636)
• Wyjątki oparte na klasach (637)
• Przykład wyjątku opartego na klasach (637)
• Po co istnieją wyjątki oparte na klasach? (639)
• Wbudowane klasy wyjątków (641)
• Określanie tekstu wyjątku (643)
• Przesyłanie danych oraz zachowania w instancjach (644)
• Ogólne formy instrukcji raise (646)
• Podsumowanie rozdziału (647)
• Łamigłówka (648)
• Quiz (648)
• Odpowiedzi (648)

29. Projektowanie z wykorzystaniem klas (649)

• Zagnieżdżanie programów obsługi wyjątków (649)
• Przykład - zagnieżdżanie przebiegu sterowania (651)
• Przykład - zagnieżdżanie składniowe (651)
• Zastosowanie wyjątków (653)
• Wyjątki nie zawsze są błędami (653)
• Funkcje sygnalizują warunki za pomocą raise (653)
• Debugowanie z wykorzystaniem zewnętrznych instrukcji try (654)
• Testowanie kodu wewnątrz tego samego procesu (655)
• Więcej informacji na temat funkcji sys.exc_info (656)
• Wskazówki dotyczące projektowania wyjątków (656)
• Co powinniśmy opakować w try (656)
• Jak nie przechwytywać zbyt wiele - unikanie pustych except (657)
• Jak nie przechwytywać zbyt mało - korzystanie z kategorii opartych na klasach (659)
• Pułapki związane z wyjątkami (659)
• Wyjątki znaków dopasowywane są po tożsamości, a nie wartości (659)
• Przechwytywanie niewłaściwej rzeczy (661)
• Podsumowanie jądra języka Python (661)
• Zbiór narzędzi Pythona (661)
• Narzędzia programistyczne przeznaczone do większych projektów (663)
• Podsumowanie rozdziału (666)
• Łamigłówka (667)
• Quiz (667)
• Odpowiedzi (667)
• Łamigłówka (668)
• Ćwiczenia do części siódmej (668)

Dodatki (669)
A: Instalacja i konfiguracja (671)
B: Rozwiązania ćwiczeń podsumowujących poszczególne części książki (679)
Skorowidz (711)