• 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

Osoby które kupowały "Python. Wprowadzenie. Wydanie III ", wybierały także:

• Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
• Zen Steve'a Jobsa 29,67 zł, (8,90 zł -70%)
• ASP.NET MVC. Kompletny przewodnik dla programistów interaktywnych aplikacji internetowych w Visual Studio 86,77 zł, (26,90 zł -69%)
• TDD. Sztuka tworzenia dobrego kodu 48,54 zł, (19,90 zł -59%)
• GitHub. Przyjazny przewodnik 32,90 zł, (16,45 zł -50%)

Spis treści

Python. Wprowadzenie. Wydanie III -- spis treści

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)