Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00361 010347 11217060 na godz. na dobę w sumie
Zaawansowany Python - ebook/pdf
Zaawansowany Python - ebook/pdf
Autor: Liczba stron:
Wydawca: Promise Język publikacji: polski
ISBN: 978-83-7541-223-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie
Porównaj ceny (książka, ebook, audiobook).

Prostota języka Python pozwala szybko osiągnąć produktywność, ale oznacza to również, że często nie wykorzystujemy wszystkiego, co ma da zaoferowania. Dzięki temu praktycznemu poradnikowi Czytelnik nauczy się, jak pisać efektywny, idiomatyczny kod Pythona dzięki wykorzystaniu jego najlepszych i zapewne najbardziej lekceważonych cech. Autor, Luciano Ramalho, prowadzi Czytelnika poprzez podstawowe cechy języka i biblioteki i pokazuje, jak sprawić, aby kod był jednocześnie krótszy, szybszy i bardziej czytelny.
Wielu doświadczonych programistów próbuje nagiąć Pythona do wzorców, których nauczyli się z innych języków i nigdy nie odkrywa możliwości, które wykraczają poza ich doświadczenie. Dzięki tej książce ci programiści będą mogli się nauczyć, jak osiągnąć biegłość w języku Python 3.
Książka obejmuje:
Model danych Pythona: pozwala zrozumieć, że metody specjalne są kluczem do spójnego zachowania obiektów
Struktury danych: umożliwia w pełni wykorzystać wbudowane typy i zrozumieć dualizm tekstowo-bajtowy w erze Unicode
Funkcje jako obiekty: wgląd w funkcje Pythona jako obiekty pierwszej klasy i wyjaśnienie, jak wpływa to na popularne wzorce projektowania
Idiomy zorientowane obiektowo: budowanie klas poprzez poznawanie odwołań, zmienności, interfejsów, przeciążanie operatorów i wielokrotne dziedziczenie
Przepływ sterowania: wykorzystanie menedżerów kontekstu, generatorów, współprogramów i współbieżności przy użyciu pakietów concurrent.futures i asyncio
Metaprogramowanie: wykorzystanie właściwości, deskryptorów atrybutów, dekoratorów klas i metaklas
Luciano Ramalho, programista Pythona od roku 1998, jest członkiem Python Software Foundation, współwłaścicielem Python.pro.br brazylijskiej firmy szkoleniowej i współzałożycielem Garoa Hacker Clube, pierwszego w Brazyli klubu hackerskiego. Prowadzi zespoły projektowania oprogramowania i wykłada stosowanie Pythona dla sektora medialnego, bankowego i rządowego.

„Jestem dumny, że zostałem recenzentem technicznym tej książki nie tylko pomoże ona wielu średnio zaawanowanym programistom w ich drodze do mistrzostwa, ale ja sam nauczyłem się z niej kilku rzeczy!”
—Alex Martelli
Python Software Foundation
„Zaawansowany Python to skarbiec pełen użytecznych programistycznych trików, przydatnych tak średnio, jak i bardzo doświadczonym programistom, którzy chcą rozszerzyć granice swojej wiedzy.”
—Daniel i Audrey Roy Greenfeld
autorzy Two Scoops of Django

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Zaawansowany Python Luciano Ramalho przekład: Maria Chaniewska, Jakub Niedźwiedź APN Promise Warszawa 2015 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Zaawansowany Python © 2015 APN PROMISE SA Authorized translation of English edition of Fluent Python ISBN 978-1-491-94600-8 Copyright © 2015 Luciano Ramalho. All rights reserved. This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls of all rights to publish and sell the same. APN PROMISE SA, biuro: ul. Kryniczna 2, 03-934 Warszawa tel. +48 22 35 51 600, fax +48 22 35 51 699 e-mail: mspress@promise.pl Wszystkie prawa zastrzeżone. Żadna część niniejszej książki nie może być powielana ani rozpowszechniana w jakiejkolwiek formie i w jakikolwiek sposób (elektroniczny, mechaniczny), włącznie z fotokopiowaniem, nagrywaniem na taśmy lub przy użyciu innych systemów bez pisemnej zgody wydawcy. Logo O’Reilly jest zarejestrowanym znakiem towarowym O’Reilly Media, Inc. Fluent Python, ilustracja z okładki i powiązane elementy są znakami towarowymi O’Reilly Media, Inc. Wszystkie inne nazwy handlowe i towarowe występujące w niniejszej publikacji mogą być znakami towarowymi zastrzeżonymi lub nazwami zastrzeżonymi odpowiednich firm odnośnych właścicieli. Przykłady firm, produktów, osób i wydarzeń opisane w niniejszej książce są fikcyjne i nie odnoszą się do żadnych konkretnych firm, produktów, osób i wydarzeń. Ewentualne podobieństwo do jakiejkolwiek rzeczywistej firmy, organizacji, produktu, nazwy domeny, adresu poczty elektronicznej, logo, osoby, miejsca lub zdarzenia jest przypadkowe i niezamierzone. APN PROMISE SA dołożyła wszelkich starań, aby zapewnić najwyższą jakość tej publikacji. Jednakże nikomu nie udziela się rękojmi ani gwarancji. APN PROMISE SA nie jest w żadnym wypadku odpowiedzialna za jakiekolwiek szkody będące następstwem korzystania z informacji zawartych w niniejszej publikacji, nawet jeśli APN PROMISE została powiadomiona o możliwości wystąpienia szkód. ISBN: 978-83-7541-171-3 Projekt okładki: Ellie Volkhausen Ilustracje: Rebecca Demarest Przekład: Maria Chaniewska, Jakub Niedźwiedź Redakcja: Marek Włodarz Korekta: Ewa Swędrowska Skład i łamanie: MAWart Marek Włodarz ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Para Marta, com todo o meu amor. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści Przedmowa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xv Część I Prolog 1 Model danych Pythona . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Pythoniczna talia kart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4 Sposoby używania metod specjalnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8 Emulacja typów liczbowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 Reprezentacja tekstowa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11 Operatory arytmetyczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .12 Wartość Boolean typu niestandardowego . . . . . . . . . . . . . . . . . . . . . . . . . . .12 Przegląd metod specjalnych. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13 Dlaczego len nie jest metodą . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16 Część II Struktury danych 2 Sekwencje i tablice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Przegląd wbudowanych sekwencji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .22 Wyrażenia listowe i wyrażenia generatora. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23 Wyrażenia listowe a czytelność . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .23 Wyrażenia listowe a funkcje map i filter. . . . . . . . . . . . . . . . . . . . . . . . . . . . .25 Iloczyny kartezjańskie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26 Wyrażenia generatora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27 Krotki nie są jedynie niezmiennymi listami . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29 Krotki jako rekordy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29 Rozpakowywanie krotek. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .30 Rozpakowywanie zagnieżdżonych krotek . . . . . . . . . . . . . . . . . . . . . . . . . . .32 Krotki nazwane. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .33 Krotki jako niezmienne listy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .35 Wycinanie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36 Dlaczego wycinki i zakresy wykluczają ostatni element. . . . . . . . . . . . . . . .37 Obiekty wycinków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37 Wycinanie wielowymiarowe i wielokropki. . . . . . . . . . . . . . . . . . . . . . . . . . .39 Przypisywanie do wycinków. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== v Używanie + i * z sekwencjami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40 Budowanie listy list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41 Przypisanie złożone w przypadku sekwencji. . . . . . . . . . . . . . . . . . . . . . . . . . . . .43 Zagadkowe przypisywanie += . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44 Metoda list.sort oraz wbudowana funkcja sorted. . . . . . . . . . . . . . . . . . . . . . . . .46 Zarządzanie sekwencjami uporządkowanymi przy użyciu bisect . . . . . . . . . . .48 Wyszukiwanie za pomocą funkcji bisect . . . . . . . . . . . . . . . . . . . . . . . . . . . .48 Wstawianie za pomocą funkcji bisect.insort . . . . . . . . . . . . . . . . . . . . . . . . .51 Kiedy lista nie jest rozwiązaniem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .52 Tablice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .52 Widoki pamięci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56 NumPy i SciPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57 Deques i inne kolejki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .60 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65 3 Słowniki i zbiory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 Ogólne typy odwzorowujące . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .72 Wyrażenia słownikowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .74 Przegląd powszechnych metod odwzorowań . . . . . . . . . . . . . . . . . . . . . . . . . . . .75 Obsługa brakujących kluczy za pomocą setdefault. . . . . . . . . . . . . . . . . . . .77 Odwzorowania z elastycznym przeszukiwaniem kluczy . . . . . . . . . . . . . . . . . . .79 defaultdict: inne podejście do brakujących kluczy . . . . . . . . . . . . . . . . . . . .79 Metoda __missing__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .81 Odmiany dict . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .84 Tworzenie klas podrzędnych klasy UserDict. . . . . . . . . . . . . . . . . . . . . . . . . . . . .85 Niezmienne odwzorowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .87 Teoria zbiorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88 Literały zbiorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .90 Wyrażenia zbioru. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .91 Operacje na zbiorach. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92 Budowa wewnętrzna typów dict i set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .96 Eksperyment wydajnościowy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .96 Tablice mieszające w słownikach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .98 Praktyczne konsekwencje działania słownika dict . . . . . . . . . . . . . . . . . . .101 Jak działają zbiory – konsekwencje praktyczne . . . . . . . . . . . . . . . . . . . . . .104 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105 4 Tekst a bajty. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .109 Problemy ze znakami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .110 Podstawy bajtów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .111 Struktury i widoki pamięci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114 vi | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Podstawowe kodery/dekodery. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .115 Zrozumienie problemów kodowania/dekodowania. . . . . . . . . . . . . . . . . . . . . .117 Radzenie sobie z UnicodeEncodeError . . . . . . . . . . . . . . . . . . . . . . . . . . . .117 Radzenie sobie z UnicodeDecodeError . . . . . . . . . . . . . . . . . . . . . . . . . . . .119 Błąd SyntaxError podczas ładowania modułów z nieoczekiwanym kodowaniem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .120 Jak wykryć kodowanie sekwencji bajtów . . . . . . . . . . . . . . . . . . . . . . . . . . .122 BOM: przydatny gremlin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .122 Obsługa plików tekstowych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .124 Domyślne kodowanie: dom wariatów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .127 Normalizacje Unicode w celu rozsądniejszego porównywania . . . . . . . . . . . .130 Sprowadzanie do jednego rejestru. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .133 Funkcje narzędziowe do dopasowywania normalizowanego tekstu . . . .134 „Normalizcja ekstremalna”: usuwanie znaków diakrytycznych . . . . . . . .135 Sortowanie tekstu Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .138 Sortowanie przy użyciu algorytmu porządku alfabetycznego Unicode . .140 Baza danych Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .141 Dwutrybowe interfejsy API dla typów str i bytes . . . . . . . . . . . . . . . . . . . . . . . .143 str a bytes w wyrażeniach regularnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . .143 str a bytes w funkcjach modułu os. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .144 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .147 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .148 Część III Funkcje jako obiekty 5 Funkcje pierwszej klasy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .155 Traktowanie funkcji jako obiektu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .156 Funkcje wyższego rzędu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .157 Nowoczesne odpowiedniki funkcji map, filter i reduce . . . . . . . . . . . . . . .158 Funkcje anonimowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .160 Siedem odmian obiektów wywoływalnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . .161 Definiowane przez użytkownika typy wywoływalne . . . . . . . . . . . . . . . . . . . . .162 Introspekcja funkcji. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .163 Od parametrów pozycyjnych do parametrów tylko słów kluczowych . . . . . .165 Pozyskiwanie informacji o parametrach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .167 Adnotacje do funkcji. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .172 Pakiety do programowania funkcyjnego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .174 Moduł operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .174 Zamrażanie argumentów przy użyciu funkcji functools.partial . . . . . . . .178 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .180 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .181 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści | vii 6 Wzorce projektowe z funkcjami pierwszej klasy . . . . . . . . . . . . . . . . . . . . . . . . . . .185 Studium przypadku: refaktoryzacja wzorca Strategia . . . . . . . . . . . . . . . . . . . .186 Klasyczny wzorzec Strategia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .186 Strategia zorientowana funkcyjnie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .190 Wybieranie najlepszej strategii: proste podejście. . . . . . . . . . . . . . . . . . . . .193 Znajdowanie Strategii w module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .194 Polecenie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .196 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .197 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .198 7 Dekoratory funkcji i domknięcia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .201 Dekoratory 101 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .202 Kiedy Python wykonuje dekoratory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203 Wzorzec Strategia wzbogacony dekoratorem . . . . . . . . . . . . . . . . . . . . . . . . . . .205 Reguły zasięgów zmiennych. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .207 Domknięcia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .210 Deklaracja nonlocal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .213 Implementacja prostego dekoratora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .215 Sposób działania. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .216 Dekoratory w bibliotece standardowej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .218 Memoizacja dzięki functools.lru_cache . . . . . . . . . . . . . . . . . . . . . . . . . . . .219 Funkcje generyczne z pojedynczym rozsyłaniem . . . . . . . . . . . . . . . . . . . .221 Zagnieżdżanie dekoratorów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .224 Dekoratory parametryzowane. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .225 Parametryzowany dekorator rejestrujący . . . . . . . . . . . . . . . . . . . . . . . . . . .226 Parametryzowany dekorator Clock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .228 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .230 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231 Część IV Idiomy zorientowane obiektowo 8 Odwołania do obiektów, zmienność i odzyskiwanie pamięci. . . . . . . . . . . . . . .237 Zmienne nie są pudełkami. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .238 Tożsamość, równość i aliasy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .240 Wybór między == a is . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .241 Względna niezmienność krotek. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .242 Kopie są domyślnie płytkie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .243 Głębokie i płytkie kopie arbitralnych obiektów. . . . . . . . . . . . . . . . . . . . . .246 Parametry funkcji jako odwołania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .247 Typy zmienne jako domyślne parametry: zły pomysł. . . . . . . . . . . . . . . . .249 Programowanie obronne ze zmiennymi parametrami. . . . . . . . . . . . . . . .251 viii | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== del i odzyskiwanie pamięci. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253 Słabe odwołania. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255 Skecz WeakValueDictionary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .256 Ograniczenia słabych odwołań . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258 Trikowe gry Pythona z niezmiennymi obiektami. . . . . . . . . . . . . . . . . . . . . . . .259 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .261 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .262 9 Obiekt pythonowy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .267 Reprezentacje obiektów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .268 Przypomnienie klasy Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .268 Alternatywny konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .271 classmethod a staticmethod. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .272 Formatowane wyświetlanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .274 Haszowalny obiekt Vector2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .277 Prywatne i „chronione” atrybuty w Pythonie . . . . . . . . . . . . . . . . . . . . . . . . . . .283 Oszczędzanie miejsca dzięki atrybutowi klasy __slots__ . . . . . . . . . . . . . . . . .285 Problemy z atrybutem __slots__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288 Przesłanianie atrybutów klasy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .291 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292 10 Kodowanie, haszowanie i wycinanie sekwencji . . . . . . . . . . . . . . . . . . . . . . . . . . .297 Vector: definiowany przez użytkownika typ sekwencyjny . . . . . . . . . . . . . . . .298 Vector podejście nr 1: zgodność z Vector2d . . . . . . . . . . . . . . . . . . . . . . . . . . . .298 Protokoły i kacze typowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301 Vector podejście nr 2: sekwencja z możliwością wycinania . . . . . . . . . . . . . . .302 Działanie wycinania. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .303 Metoda __getitem__ świadoma wycinania . . . . . . . . . . . . . . . . . . . . . . . . .305 Vector podejście nr 3: dynamiczny dostęp do atrybutów . . . . . . . . . . . . . . . . .307 Vector podejście nr 4: haszowanie i szybsze == . . . . . . . . . . . . . . . . . . . . . . . . .311 Vector podejście nr 5: formatowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .316 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .325 11 Interfejsy: od protokołów do abstrakcyjnych klas bazowych . . . . . . . . . . . . . . .331 Interfejsy i protokoły w kulturze języka Python . . . . . . . . . . . . . . . . . . . . . . . . .332 Python lubi sekwencje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .334 Małpie łatanie w celu zaimplementowania protokołu w trakcie działania programu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .336 Wodne ptactwo Alexa Martelli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .338 Tworzenie podklasy z abstrakcyjnej klasy bazowej . . . . . . . . . . . . . . . . . . . . . .344 Abstrakcyjne klasy bazowe w bibliotece standardowej . . . . . . . . . . . . . . . . . . .346 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści | ix Abstrakcyjne klasy bazowe w collections.abc . . . . . . . . . . . . . . . . . . . . . . .346 Wieża liczbowa klas ABC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .348 Definiowanie i wykorzystywanie abstrakcyjnej klasy bazowej . . . . . . . . . . . . .349 Szczegóły składni abstrakcyjnych klas bazowych . . . . . . . . . . . . . . . . . . . .354 Tworzenie podklas dla abstrakcyjnej klasy bazowej Tombola. . . . . . . . . .355 Wirtualna podklasa klasy Tombola. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .357 Jak testowano podklasy klasy Tombola . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .360 Użycie metody register w praktyce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .363 Gęsi mogą zachowywać się jak kaczki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .364 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .365 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .368 12 Dziedziczenie: na dobre czy na złe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .375 Tworzenie klas podrzędnych z typów wbudowanych jest zawiłe . . . . . . . . . . .376 Wielokrotne dziedziczenie i kolejność ustalania metod . . . . . . . . . . . . . . . . . .379 Wielokrotne dziedziczenie w świecie rzeczywistym. . . . . . . . . . . . . . . . . . . . . .384 Radzenie sobie z wielokrotnym dziedziczeniem. . . . . . . . . . . . . . . . . . . . . . . . .387 1. Rozróżniać dziedziczenie interfejsów od dziedziczenia implementacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .387 2. Tworzyć jawne interfejsy przy pomocy klas ABC . . . . . . . . . . . . . . . . . .387 3. Korzystać z domieszek w celu ponownego wykorzystania kodu . . . . .387 4. Jawnie deklarować domieszki dzięki nazewnictwu. . . . . . . . . . . . . . . . .388 5. Klasa ABC może być też domieszką, ale nie na odwrót . . . . . . . . . . . . .388 6. Nie tworzyć podklasy dziedziczącej z więcej niż jednej klasy konkretnej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .388 7. Dostarczać użytkownikom klasy łączone . . . . . . . . . . . . . . . . . . . . . . . . .389 8. „Preferować komponowanie obiektów przed dziedziczeniem klas”. . .389 Tkinter: dobry, zły i brzydki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .390 Nowoczesny przykład: domieszki w ogólnych widokach Django . . . . . . . . . .391 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .394 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .395 13 Przeciążanie operatorów: rób to poprawnie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .399 Podstawy przeciążania operatorów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .400 Operatory unarne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .400 Przeciążanie operatora + w celu zaimplementowania dodawania wektorów 403 Przeciążanie operatora * dla mnożenia wektora przez wartość skalarną . . . .409 Bogate operatory porównania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .413 Operatory rozszerzonego przypisania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .418 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .423 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .424 x | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Część V Przepływ sterowania 14 Iterowalność, iteratory i generatory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .431 Klasa Sentence – podejście nr 1: sekwencja słów . . . . . . . . . . . . . . . . . . . . . . . .432 Dlaczego sekwencje są iterowalne: funkcja iter . . . . . . . . . . . . . . . . . . . . . .434 Obiekty iterowalne a iteratory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .436 Klasa Sentence – podejście nr 2: klasyczne wnętrze. . . . . . . . . . . . . . . . . . . . . .440 Klasa Sentence jako iterator: zły pomysł. . . . . . . . . . . . . . . . . . . . . . . . . . . .441 Klasa Sentence – podejście nr 3: funkcja generatora . . . . . . . . . . . . . . . . . . . . .442 Jak działa funkcja generatora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .443 Klasa Sentence – podejście nr 4: leniwa implementacja . . . . . . . . . . . . . . . . . .447 Klasa Sentence – podejście nr 5: wyrażenie generatora . . . . . . . . . . . . . . . . . . .448 Wyrażenia generatora: kiedy ich używać . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .450 Inny przykład: generator ciągu arytmetycznego. . . . . . . . . . . . . . . . . . . . . . . . .451 Ciąg arytmetyczny wykorzystujący itertools . . . . . . . . . . . . . . . . . . . . . . . .453 Funkcje generatora w bibliotece standardowej . . . . . . . . . . . . . . . . . . . . . . . . . .455 Nowa składnia w wersji Python 3.3: yield from . . . . . . . . . . . . . . . . . . . . . . . . .467 Funkcje redukujące obiekty iterowalne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .468 Bliższe przyjrzenie się funkcji iter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .470 Studium przypadku: generatory w narzędziu do konwersji baz danych . . . . .471 Generatory jako współprogramy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .473 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .474 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .474 15 Zarządzanie kontekstem i bloki else. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .481 Zrób to, potem tamto: bloki else poza instrukcją if . . . . . . . . . . . . . . . . . . . . . .482 Zarządzanie kontekstem i bloki with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .484 Narzędzia contextlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .489 Korzystanie z @contextmanager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .489 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .493 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .494 16 Współprogramy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .497 Jak współprogramy wyewoluowały z generatorów . . . . . . . . . . . . . . . . . . . . . . .498 Podstawowe zachowanie generatora zastosowane jako współprogram. . . . . .499 Przykład: współprogram obliczający średnią kroczącą . . . . . . . . . . . . . . . . . . .503 Dekoratory przygotowujące współprogram . . . . . . . . . . . . . . . . . . . . . . . . . . . .504 Kończenie współprogramów i obsługa wyjątków. . . . . . . . . . . . . . . . . . . . . . . .506 Zwracanie wartości ze współprogramu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .510 Korzystanie z yield from. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .512 Znaczenie konstrukcji yield from . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .519 Przypadek użycia: współprogramy dla dyskretnego symulowania zdarzeń . .525 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści | xi Symulacje zdarzeń dyskretnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .525 Symulacja floty taksówek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .526 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .535 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .536 17 Współbieżność z futures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .543 Przykład: pobieranie stron WWW na trzy sposoby . . . . . . . . . . . . . . . . . . . . . .544 Skrypt pobierania sekwencyjnego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .546 Pobieranie przy pomocy concurrent.futures . . . . . . . . . . . . . . . . . . . . . . . .548 Gdzie są obiekty future? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .549 Blokowanie wejścia/wyjścia a GIL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .553 Uruchamianie procesów przy pomocy concurrent.futures. . . . . . . . . . . . . . . .554 Eksperymentowanie z Executor.map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .556 Pobierania flag z wyświetlaniem postępów i obsługą błędów. . . . . . . . . . . . . .559 Obsługa błędów w przykładach flags2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .564 Korzystanie z futures.as_completed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .566 Alternatywy dla przetwarzania wielowątkowego . . . . . . . . . . . . . . . . . . . .569 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .570 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .571 18 Współbieżność z asyncio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .577 Wątek kontra współprogram: porównanie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .579 Klasa asyncio.Future: nieblokująca z założenia . . . . . . . . . . . . . . . . . . . . . .585 Instrukcja yield from a obiekty future, zadania i współprogramy . . . . . .586 Pobieranie obrazów przy pomocy asyncio i aiohttp . . . . . . . . . . . . . . . . . . . . . .588 Bieganie w kółko wokół wywołań blokujących . . . . . . . . . . . . . . . . . . . . . . . . . .593 Ulepszanie skryptu pobierającego obrazy wykorzystującego asyncio . . . . . . .595 Wykorzystanie asyncio.as_completed. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .596 Korzystanie z obiektu wykonawczego w celu uniknięcia zablokowania pętli zdarzeń . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .601 Od procedur zwrotnych do obiektów future i współprogramów . . . . . . . . . . .603 Wykonywanie wielu żądań dla każdego pobierania . . . . . . . . . . . . . . . . . .605 Pisanie serwerów wykorzystujących asyncio. . . . . . . . . . . . . . . . . . . . . . . . . . . .608 Serwer TCP wykorzystujący asyncio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .609 Serwer WWW wykorzystujący aiohttp. . . . . . . . . . . . . . . . . . . . . . . . . . . . .614 Inteligentniejsi klienci a lepsza współbieżność . . . . . . . . . . . . . . . . . . . . . .617 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .618 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .619 xii | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Część VI Metaprogramowanie 19 Atrybuty i właściwości dynamiczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .627 Przekształcanie danych przy pomocy atrybutów dynamicznych . . . . . . . . . . .628 Badanie danych przypominających JSON przy pomocy atrybutów dynamicznych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .631 Problem z nieprawidłowymi nazwami atrybutów. . . . . . . . . . . . . . . . . . . .634 Elastyczne tworzenie obiektów przy pomocy __new__ . . . . . . . . . . . . . . .635 Restrukturyzacja źródła danych OSCON przy pomocy shelve. . . . . . . . .637 Pobieranie połączonych rekordów przy pomocy właściwości. . . . . . . . . .641 Użycie właściwości do sprawdzania poprawności atrybutów . . . . . . . . . . . . . .647 LineItem – podejście nr 1: klasa dla elementu zamówienia. . . . . . . . . . . .647 LineItem – podejście nr 2: właściwość sprawdzająca swoją poprawność 648 Właściwe spojrzenie na właściwości. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .650 Właściwości przesłaniają atrybuty instancji. . . . . . . . . . . . . . . . . . . . . . . . .651 Dokumentacja właściwości. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .654 Kodowanie fabryki właściwości. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .655 Obsługiwanie usuwania atrybutów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .658 Podstawowe atrybuty i funkcje obsługujące atrybuty . . . . . . . . . . . . . . . . . . . .659 Atrybuty specjalne, które wpływają na obsługę atrybutów . . . . . . . . . . . .659 Funkcje wbudowane do obsługi atrybutów . . . . . . . . . . . . . . . . . . . . . . . . .660 Metody specjalne do obsługi atrybutów. . . . . . . . . . . . . . . . . . . . . . . . . . . .661 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .662 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .663 20 Deskryptory atrybutów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .669 Przykład deskryptora: sprawdzanie poprawności atrybutu. . . . . . . . . . . . . . . .669 LineItem podejście nr 3: prosty deskryptor . . . . . . . . . . . . . . . . . . . . . . . . .670 LineItem podejście nr 4: automatyczne nazwy atrybutów przechowywania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .675 LineItem podejście nr 5: nowy typ deskryptora . . . . . . . . . . . . . . . . . . . . .681 Deskryptory przesłaniające a nieprzesłaniające . . . . . . . . . . . . . . . . . . . . . . . . .684 Deskryptor przesłaniający . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .686 Deskryptor przesłaniający bez __get__ . . . . . . . . . . . . . . . . . . . . . . . . . . . .687 Deskryptor nieprzesłaniający. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .688 Nadpisywanie deskryptora w klasie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .689 Metody są deskryptorami. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .690 Wskazówki dotyczące użycia deskryptorów . . . . . . . . . . . . . . . . . . . . . . . . . . . .693 Dokumentacja docstring deskryptora i przesłanianie usuwania . . . . . . . . . . .694 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .695 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .696 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści | xiii 21 Metaprogramowanie klas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .699 Fabryka klas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .700 Dekorator klasy służący do dostosowywania dekryptorów. . . . . . . . . . . . . . . .703 Co dzieje się kiedy: czas importu a czas działania . . . . . . . . . . . . . . . . . . . . . . .706 Ćwiczenia dotyczące czasu przetwarzania . . . . . . . . . . . . . . . . . . . . . . . . . .707 Metaklasy 101. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .710 Ćwiczenie dotyczące czasu przetwarzania metaklasy. . . . . . . . . . . . . . . . .713 Metaklasa do dostosowywania deskryptorów. . . . . . . . . . . . . . . . . . . . . . . . . . .717 Metoda specjalna __prepare__ metaklasy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .719 Klasy jako obiekty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .721 Podsumowanie rozdziału . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .722 Lektura uzupełniająca. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .723 Posłowie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .727 Dodatek: Skrypty pomocnicze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .731 Żargon społeczności Pythona. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .759 Indeks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .769 O autorze. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .788 xiv | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Przedmowa Plan jest taki: gdy ktoś używa funkcjonalności, której nie rozumiesz, po prostu go zastrzel. Jest to łatwiejsze niż uczenie się czegoś nowego, a wkrótce jedyni ży- jący programiści będą pisali w łatwym do zrozumienia, wąskim podzbiorze języka Python 0.9.6 ;-) – Tim Peters Legendarny deweloper Pythona i autor Th e Zen of Python „Python jest łatwym do nauczenia, potężnym językiem programowania”. To są pierw- sze słowa w ofi cjalnym samouczku Python Tutorial (https://docs.python.org/3/tutorial/). To prawda, ale jest pewna pułapka: ponieważ ten język jest łatwy do nauczenia i zasto- sowania, wielu praktykujących programistów Pythona korzysta tylko z ułamka jego po- tężnych funkcjonalności. Doświadczony programista może zacząć pisać użyteczny kod Pythona w ciągu paru godzin. W miarę jak pierwsze produktywne godziny zmieniają się w tygodnie i miesiące, wielu deweloperów nadal programuje w Pythonie z silnymi naleciałościami z języków, które znali wcześniej. Nawet osoby, dla których jest to pierwszy język programowa- nia, często poznają go z materiałów szkoleniowych ostrożnie pomijających specyfi czne funkcjonalności. Jako nauczyciel przedstawiający Pythona programistom doświadczonym w innych językach dostrzegam inny problem, który ta książka próbuje rozwiązać: tęsknimy jedynie za tym, co już znamy. Kierując się doświadczeniem z innych języków, każdy może zgad- nąć, że Python obsługuje wyrażenia regularne, i poszukać dokumentacji na ten temat. Ale jeśli ktoś nigdy nie widział wcześniej deskryptorów ani rozpakowywania krotek, prawdo- podobnie nie będzie się zastanawiać nad ich użyciem. Zatem może pomijać korzystanie z tych funkcjonalności tylko dlatego, że są specyfi czne dla Pythona. Ta książka nie jest wyczerpującym kompendium od A do Z dotyczącym Pythona. Skupia się na funkcjonalnościach języka, które albo są unikalne dla Pythona, albo nie są obecne w wielu innych popularnych językach. Jej zakres obejmuje rdzeń języka i tylko ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== xv niektóre jego biblioteki. Rzadko będę pisać o pakietach, które nie są w bibliotece stan- dardowej, chociaż indeks pakietów Pythona obejmuje obecnie ponad 60 000 bibliotek, a wiele z nich jest niewiarygodnie przydatnych. Dla kogo jest ta książka Ta książka została napisana dla praktykujących programistów Pythona, który chcą osiąg- nąć biegłą znajomość wersji Python 3. Jeśli znasz wersję Python 2, ale chcesz przejść do wersji Python 3.4 lub nowszej, to doskonale. Gdy to piszę, większość profesjonalnych programistów Pythona używa wersji Python 2, więc zatroszczyłem się specjalnie, aby podkreślić funkcjonalności wersji Python 3, które mogą być nowe dla tych odbiorców. Jednak Zaawansowany Python dotyczy jak najlepszego wykorzystania wersji Python 3.4 i nie omawiałem poprawek koniecznych do zastosowania tego kodu w poprzednich wersjach. Większość przykładów powinna działać w wersji Python 2.7 z niewielkimi po- prawkami lub od razu, ale w niektórych przypadkach przeniesienie na starszą wersję wymagałoby znaczących zmian. Powiedziawszy to, wierzę, że ta książka może być przydatna, nawet jeśli musisz na- dal korzystać z wersji Python 2.7, ponieważ podstawowe koncepcje są nadal takie same. Python 3 nie jest nowym językiem, a większość różnic można poznać w jedno popołu- dnie. What’s New in Python 3.0 (https://docs.python.org/3.0/whatsnew/3.0.html) jest do- brym punktem wyjścia. Oczywiście było wiele zmian od czasu wydania wersji Python 3.0 w roku 2009, ale żadne z nich nie były tak ważne, jak te w wersji 3.0. Jeśli nie wiesz, czy znasz Pythona wystarczająco, aby skorzystać z tej książki, przejrzyj tematy ofi cjalnego samouczka Python Tutorial. Tematy opisane w samouczku nie zostaną tu wyjaśnione, poza pewnymi funkcjonalnościami, które są nowością w wersji Python 3. Dla kogo nie jest ta książka Jeśli po prostu uczysz się Pythona, ta książka będzie zbyt trudna. Powiem więcej, jeśli przeczytasz ją za wcześnie podczas swojej przygody z Pythonem, możesz mieć wrażenie, że każdy skrypt Pythona powinien wykorzystywać metody specjalne i triki metaprogra- mowania. Przedwczesna abstrakcja jest równie zła, jak przedwczesna optymalizacja. Organizacja książki Docelowi odbiorcy tej książki nie powinni mieć problemu z przeskoczeniem bezpośred- nio do dowolnego rozdziału w tej książce. Jednak każda z sześciu części tworzy samo- dzielną książkę w ramach tej książki. Założyłem, że rozdziały w każdej części będą czytane kolejno. xvi | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Próbowałem podkreślić używanie dostępnych rozwiązań przed omawianiem, jak zbudować własne. Na przykład w rozdział 3 w części II dotyczy typów sekwencji, które są gotowe do użycia, łącznie z tymi, którym nie poświęca się zbyt wiele uwagi, takim jak collections.deque. Budowanie defi niowanych przez użytkownika sekwencji jest opisane dopiero w części IV, gdzie widzimy także, jak wykorzystać abstrakcyjne klasy bazowe (ABC) z modułu collections.abc. Tworzenie własnych klas ABC jest omówione jeszcze dalej w części IV, ponieważ uważam, że jest ważne, aby swobodnie korzystać z klas ABC, zanim będzie się pisać własne. To podejście ma parę zalet. Po pierwsze znajomość tego, co jest gotowe do użycia po- zwala uchronić nas przed ponownym wynajdowaniem koła. Używamy istniejących klas kolekcji częściej niż implementujemy własne i możemy poświęcić więcej uwagi zaawanso- wanemu użyciu dostępnych narzędzi dzięki odroczeniu omawiania sposobów tworzenia własnych. Również jest bardziej prawdopodobne, że będziemy dziedziczyć z istniejących klas ABC, niż tworzyć własne od zera. W końcu uważam, że łatwiej jest zrozumieć abs- trakcje po zobaczeniu ich w akcji. Wadą tej strategii są dalsze odwołania rozsiane po rozdziałach. Mam nadzieję, że bę- dzie Ci łatwiej je tolerować teraz, gdy wiesz, dlaczego zdecydowałem się na taki układ książki. Oto parę głównych tematów w każdej części tej książki: Część I Pojedynczy rozdział na temat modelu danych Pythona wyjaśniający, że metody specjalne (np. __repr__) są kluczowe dla spójnego działania obiektów wszystkich typów – w języku, który jest ceniony za swoją spójność. Zrozumienie różnych aspek- tów modelu danych jest przeważającym tematem dalszej treści tej książki, ale roz- dział 1 zapewnia ogólny przegląd na wysokim poziomie. Część II Rozdziały w tej części dotyczą użycia typów kolekcji: sekwencji, odwzorowań i zbio- rów, a także rozdziału między str a bytes – przyczyny radości dla użytkowników wersji Python 3 i dużego cierpienia dla użytkowników wersji Python 2, którzy nie przenieśli jeszcze swoich baz kodu. Głównymi celami jest przypomnienie dostęp- nych rozwiązań i wyjaśnienie ich działania, które jest czasami zaskakujące, jak nie- spostrzegalna zmiana kolejności kluczy dict lub zastrzeżenia dotyczące zależności sortowania łańcuchów Unicode od ustawień lokalnych. Opisy są czasami rozległe i na wysokim poziomie (np. podczas prezentacji wielu odmian sekwencji i odwzo- rowań), a czasami głębokie (np. podczas rozważania tablic mieszających leżących u podstaw typów dict i set). Część III Zawiera omówienie funkcji jako obiektów pierwszej klasy w języku: co to ozna- cza, jak wpływa na niektóre popularne wzorce projektowe i jak implementować dekoratory funkcji przy wykorzystaniu domknięć. Opisana jest tutaj także ogólna ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Organizacja książki | xvii koncepcja obiektów wywoływalnych w Pythonie, atrybutów funkcji, introspekcji, adnotacji parametrów oraz nowa deklaracja nonlocal w wersji Python 3. Część IV Teraz skupimy się na budowaniu klas. W części II deklaracja class pojawiła się w kilku przykładach. Część IV prezentuje wiele klas. Podobnie jak dowolny język zorientowany obiektowo (OO), Python ma szczególny zestaw funkcjonalności, które mogą, ale nie muszą być obecne w języku, w którym uczyliśmy się programowania opartego na klasach. Kolejne rozdziały wyjaśniają, jak działają odwołania, co ozna- cza naprawdę zmienność, jaki jest cykl życia instancji, jak budować własne kolekcje i klasy ABC, jak radzić sobie z wielokrotnym dziedziczeniem i jak implementować przeciążanie operatorów – kiedy to ma sens. Część V W tej części opisane są konstrukcje językowe i biblioteki, które wykraczają poza sek- wencyjny przepływ sterowania za pomocą instrukcji warunków, pętli i podprogra- mów. Zaczynamy od generatorów, następnie zajmujemy się menedżerami kontekstu i współprogramami, w tym trudną, ale potężną nową składnią yield from. Część V kończy się wprowadzeniem na wysokim poziomie do nowoczesnej współbieżności w Pythonie przy użyciu collections.futures (z wewnętrznym wykorzystaniem wątków i procesów wspomaganych przez obiekty future) i wykonywanie zorien- towanych na zdarzenia operacji I/O za pomocą asyncio (wykorzystujące obiekty future na szczycie współprogramów i yield from). Część VI Ta część zaczyna się od przeglądu technik do budowania klas z atrybutami two- rzonymi dynamicznie do obsługi danych semistrukturalnych, takich jak zestawy danych JSON. Dalej zajęliśmy się znajomym mechanizmem właściwości, przed za- głębieniem się w to, jak działa dostęp do obiektów atrybutów na niższym poziomie w Pythonie przy użyciu deskryptorów. Wyjaśniam także związek między funkcjami, metodami i deskryptorami. W całej części VI implementacja krok po kroku biblio- teki walidacji pól odkrywa subtelne problemy, które prowadzą do użycia w ostatnim rozdziale zaawansowanych narzędzi: dekoratorów klas i metaklas. Podejście praktyczne Często będziemy używać interaktywnej konsoli Pythona do badania języka i bibliotek. Uważam, że jest ważne, aby podkreślić siłę tego narzędzia do nauki, szczególnie dla Czytelników, którzy mieli więcej doświadczenia ze statycznymi, kompilowanymi języka- mi, które nie dostarczają mechanizmu REPL (read-eval-print#loop). Jeden ze standardowych pakietów testowych Pythona, doctest, działa symulując sesje konsoli i weryfi kując, że wyrażenia są przetwarzane na pokazane odpowiedzi. Używałem modułu doctest do testowania większości kodu w tej książce, w tym listingów konsoli. xviii | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Nie musisz używać modułu doctest, ani nawet o nim wiedzieć, aby być na bieżąco: głów- ną funkcjonalnością testów doctest jest to, że wyglądają jak transkrypcje interaktywnych sesji konsoli, więc z łatwością możesz wypróbować demonstrację samodzielnie. Czasami będę wyjaśniać, co chcemy osiągnąć, pokazując test doctest przed kodem, któ- ry pozwala na jego działanie. Ustalenie z góry, co ma być zrobione, przed zastanowieniem się, jak to zrobić, pomaga skoncentrować się podczas kodowania. Zaczynanie od pisania testów jest podstawą techniki programowania opartego na testach, czyli TDD (test dri- ven development). Uważam to również za pomocne podczas nauczania. Jeśli nie znasz modułu doctest, spójrz na jego dokumentację (https://docs.python.org/3/library/doctest. html) oraz repozytorium kodu źródłowego tej książki (https://github.com/fl uentpython/ example-code). Zobaczysz, że możesz zweryfi kować poprawność większości kodu w tej książce, wpisując python3 -m doctest example_script.py w powłoce poleceń swojego systemu operacyjnego. Sprzęt używany do pomiarów czasu Ta książka zawiera parę prostych benchmarków i pomiarów czasu. Te testy zostały wy- konane na jednym z dwóch laptopów używanych do pisania tej książki: 2011 MacBook Pro 13” z procesorem 2.7 GHz Intel Core i7 CPU, 8GB pamięci RAM oraz tradycyjnym dyskiem twardym, a także 2014 MacBook Air 13” z procesorem 1.4 GHz Intel Core i5 CPU, 4GB pamięci RAM i dyskiem SSD. MacBook Air ma wolniejszy procesor i mniej pamięci RAM, ale jego pamięć RAM jest szybsza (1600 zamiast 1333 MHz), a dysk SSD jest znacznie szybszy niż dysk HD. W codziennym użyciu nie mogę stwierdzić, który komputer jest szybszy. Pogadanki: moja osobista perspektywa Używam i nauczam Pythona oraz dyskutuję na jego temat od roku 1998 i cieszy mnie ba- danie i porównywanie języków programowania, ich projektów i teorii, która za nimi stoi. Na końcu pewnych rozdziałów dodałem ramki „Pogadanka” z moimi własnymi spostrze- żeniami dotyczącymi Pythona i innych języków. Możesz swobodnie pominąć te ramki, jeśli Cię nie interesują. Ich zawartość jest całkowicie opcjonalna. Żargon społeczności Pythona Chciałem, aby była to książka nie tylko o Pythonie, ale także o kulturze wokół niego. Przez ponad 20 lat społeczność Pythona wytworzyła własny szczególny dialekt i akronimy. Zamieszony na końcu tej książki rozdział „Żargon społeczności Pythona” zawiera listę terminów, które mają specjalne znaczenie wśród Pythonistów. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Sprzęt używany do pomiarów czasu | xix Użyte wersje Pythona Testowałem cały kod w tej książce przy użyciu Python 3.4 – czyli CPython 3.4, najbar- dziej popularnej implementacji Pythona napisanej w języku C. Jest tylko jeden wyjątek: ramka „Nowy operator infi ksowy @ w wersji Python 3.5” przedstawia operator @, który jest obsługiwany tylko w wersji Python 3.5. Prawie cały kod w tej książce powinien działać z dowolnym interpreterem kompaty- bilnym z wersją Python 3.x, w tym PyPy3 2.4.0, który jest kompatybilny z wersją Python 3.2.5. Wartymi zauważenia wyjątkami są przykłady korzystające z yield from i asyncio, które są dostępne tylko w wersji Python 3.3 lub nowszych. Większość kodu powinna działać także w wersji Python 2.7 z ewentualnymi drobnymi zmianami. Nie będą działać w niej przykłady związane z Unicode zawarte w rozdziale 4. Ponadto wcześniej wymienione wyjątki nie będą działać w wersjach Python 3 wcześniej- szych niż 3.3. Konwencje użyte w tej książce W tej książce używane są następujące konwencje typografi czne: Kursywa Wskazuje nowe terminy, adresy URL, adresy e-mail, nazwy plików i rozszerzenia plików. Stała szerokość Służy do wydruków programów, a także wewnątrz akapitów do odwołań do elemen- tów programu, takich jak nazwy zmiennych lub funkcji, bazy danych, typy danych, zmienne środowiskowe, instrukcje i słowa kluczowe. Zauważ, że gdy podział wiersza występuje w terminie o stałej_szerokości nie jest dodawany dywiz – mógłby zostać źle zrozumiany jako część terminu. Stała szerokość i pogrubienie Pokazuje polecenia lub inny tekst, który powinien być wpisany dokładnie tak przez użytkownika. Stała szerokość i kursywa Pokazuje tekst, który powinien być zastąpiony wartościami podanymi przez użyt- kownika lub wyznaczonymi przez kontekst. Ten element oznacza wskazówkę lub sugestię. xx | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Ten element oznacza uwagę ogólną. Ten element wskazuje ostrzeżenie lub przestrogę. Korzystanie z przykładów kodu Wszystkie skrypty i większość fragmentów kodu, które występują w tej książce, są do- stępne w repozytorium kodu tej książki (https://github.com/fl uentpython/example-code) na GitHub. Cenimy sobie, ale nie wymagamy, umieszczenia następujących informacji: tytułu, autora, wydawcy i ISBN. Na przykład: „Fluent Python by Luciano Ramalho (O’Reilly). Copyright 2015 Luciano Ramalho, 978-1-491-94600-8.” Jak się z nami kontaktować Istnieje strona internetowa dotycząca tej książki, gdzie znajduje się errata, przykłady i inne dodatkowe informacje. Jej adres to http://bit.ly/fl uent-python. Komentarze i pytania techniczne dotyczące książki można wysyłać na adres bookqu- estions@oreilly.com. Więcej informacji o naszych książkach, kursach, konferencjach i wiadomościach, zo- bacz na naszej stronie pod adresem http://www.oreilly.com. Znajdź nas na Facebooku: http://facebook.com/oreilly Śledź nas na Twitterze: http://twitter.com/oreillymedia Oglądaj nas na YouTube: http://www.youtube.com/oreillymedia Podziękowania Josef Hartwig zaprojektował zestaw szachów Bauhaus, który jest przykładem wspaniałego projektu: piękny, prosty i czysty. Guido van Rossum, syn architekta i brat mistrza projek- towania czcionek, zaprojektował cudowny język. Uwielbiam uczyć Pythona, ponieważ jest piękny, prosty i czysty. Alex Martelli i Anna Ravenscroft byli pierwszymi osobami, które zobaczyły konspekt tej książki i zachęciły mnie do wysłania do wydawnictwa O’Reilly w celu publikacji. Ich książki nauczyły mnie idiomatycznego Pythona i są modelem przejrzystości, dokładności ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Korzystanie z przykładów kodu | xxi i głębokości w pisaniu technicznym. Ponad 5 000 wpisów Alexa na Stack Overfl ow (http:// stackoverfl ow.com/users/95810/alex-martelli) jest źródłem spojrzeń na język i jego właś- ciwe użycie. Martelli i Ravenscroft , a także Lennart Regebro i Leonardo Rochael byli ponadto recen- zentami technicznymi tej książki. Każdy z tego wyróżniającego się zespołu recenzentów technicznych ma przynajmniej 15 lat doświadczenia w Pythonie, z ogromnym wkładem w wiele ważnych projektów Pythona w bliskim kontakcie z innymi deweloperami ze spo- łeczności. Razem wysłali mi setki poprawek, sugestii, pytań i opinii, dodając dużo wartości do książki. Victor Stinner uprzejmie zrecenzował rozdział 18, wnosząc swoją wiedzę jako zarządcę asyncio do zespołu recenzentów technicznych. Był to duży przywilej i przyjem- ność współpracować z nimi przez te ostatnie miesiące. Redaktorka Meghan Blanchette była wyróżniającym się mentorem, pomagając mi po- prawić organizację i przepływ pracy nad książką, pokazując mi, co było nudne i powstrzy- mując mnie przed dalszymi opóźnieniami. Brian MacDonald edytował rozdziały w części III , gdy Meghan była niedostępna. Cieszyłem się pracą z nimi oraz ze wszystkimi, z któ- rymi kontaktowałem się w wydawnictwie O’Reilly, w tym z zespołem twórców i pomocy technicznej Atlas (Atlas to platforma do publikowania książek wydawnictwa O’Reilly, której używałem szczęśliwie do pisania tej książki). Mario Domenech Goulart dostarczył wielu szczegółowych sugestii zaczynając od pierwszego wydania Early Release. Otrzymałem także wartościowe opinie od nastę- pujących osób: Dave Pawson, Elias Dorneles, Leonardo Alexandre Ferreira Leite, Bruce Eckel, J. S. Bueno, Rafael Gonçalves, Alex Chiaranda, Guto Maia, Lucas Vido i Lucas Brunialti. Przez lata wiele osób nakłaniało mnie, abym został autorem, a najbardziej przekonują- cymi byli Rubens Prates, Aurelio Jargas, Rudá Moura i Rubens Altimari. Mauricio Bussab otworzył dla mnie wiele drzwi, umożliwiając moją pierwszą prawdziwą próbę pisania książki. Renzo Nuccitelli wspierał ten projekt pisarski przez cały czas, chociaż to oznaczało opóźnienie naszego partnerstwa w python.pro.br. Cudowna brazylijska społeczność Pythona jest pełna wiedzy, życzliwości i humoru. Grupa Python Brasil (https://groups.google.com/group/python-brasil) liczy tysiące osób, a nasze krajowe konferencje przyciągają ich setki, ale najbardziej wpływowymi Pythonistami na mojej drodze byli Leonardo Rochael, Adriano Petrich, Daniel Vainsencher, Rodrigo RBP Pimentel, Bruno Gola, Leonardo Santagada, Jean Ferri, Rodrigo Senra, J. S. Bueno, David Kwast, Luiz Irber, Osvaldo Santana, Fernando Masanori, Henrique Bastos, Gustavo Niemayer, Pedro Werneck, Gustavo Barbieri, Lalo Martins, Danilo Bellini i Pedro Kroger. Dorneles Tremea był wspaniałym przyjacielem (niewiarygodnie życzliwie dzielącym się czasem i wiedzą), niesamowitym hakerem oraz najbardziej inspirującym liderem sto- warzyszenia Brazilian Python Association. Odszedł zbyt wcześnie. Przez lata moi studenci nauczyli mnie wiele przez swoje pytania, spostrzeżenia, opi- nie i kreatywne rozwiązania problemów. Érico Andrei i Simples Consultoria sprawili, że po raz pierwszy mogłem skupić się na byciu nauczycielem Pythona. xxii | Przedmowa ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Martijn Faassen był moim mentorem grokowania i podzielił się ze mną bezcennymi spojrzeniami na temat Pythona i neandertalczyków. Jego praca oraz praca następujących osób: Paul Everitt, Chris McDonough, Tres Seaver, Jim Fulton, Shane Hathaway, Lennart Regebro, Alan Runyan, Alexander Limi, Martijn Pieters, Godefroid Chapelle, a także innych z planet Zope, Plone i Pyramid była decydująca dla mojej kariery. Dzięki Zope i surfowaniu na pierwszej fali webowej, byłem w stanie zacząć zarabiać na życie za po- mocą Pythona w roku 1998. José Octavio Castro Neves był moim partnerem w pierwszej skupionej na Pythonie fi rmie programistycznej w Brazylii. Mam zbyt wiele guru w szerokiej społeczności Pythona, aby wymienić ich wszyst- kich, ale poza tymi wcześniej wymienionymi, jestem wdzięczy następującym osobom: Steve Holden, Raymond Hettinger, A.M. Kuchling, David Beazley, Fredrik Lundh, Doug Hellmann, Nick Coghlan, Mark Pilgrim, Martijn Pieters, Bruce Eckel, Michele Simionato, Wesley Chun, Brandon Craig Rhodes, Philip Guo, Daniel Greenfeld, Audrey Roy i Brett Slatkin za nauczenie mnie nowych i lepszych sposobów uczenia Pythona. Większość z tych stron została napisana w moim biurze domowym i w dwóch labora- toriach: Coff eeLab i Garoa Hacker Clube. Coff eeLab (http://coff eelab.com.br/) to siedziba kawiarnianych geeków w Vila Madalena, São Paulo, Brazil. Garoa Hacker Clube (https:// garoa.net.br/) to klub hackerspace otwarty dla wszystkich: laboratorium społecznościowe, gdzie każdy może swobodnie wypróbować nowe pomysły. Społeczność Garoa dostarczyła inspiracji, infrastruktury i  luzu. Myślę, że Aleph cie- szyłby się z tej książki. Moja matka, Maria Lucia, i mój ojciec, Jairo, zawsze wspierali mnie na każdej drodze. Chciałbym, aby ojciec był tutaj i zobaczył tę książkę. Cieszę się, że mogę ją pokazać matce. Moja żona, Marta Mello, trwała przy mnie przez 15 miesięcy, kiedy nieustannie pra- cowałem, ale nadal wspierała i podtrzymywała mnie w tych krytycznych momentach projektu, gdy chciałem uciec z tego maratonu. Dziękuję Wam wszystkim za wszystko. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Podziękowania | xxiii ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Część I Prolog ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Rozdział 1 Model danych Pythona Poczucie estetyki Guido dotyczące projektu języka jest zdumiewające. Spotkałem wielu dobrych projektantów umiejących tworzyć teoretycznie piękne języki progra- mowania, z których jednak nikt nie chciał korzystać. Natomiast Guido jest jedną z tych rzadkich osób potrafi ących zbudować język może odrobinę mniej piękny teoretycznie, ale dzięki temu sprawiający radość osobom, które w nim programują.1 – Jim Hugunin, twórca Jython, współtwórca AspectJ, architekt .Net DLR Jedną z najlepszych zalet Pythona jest jego spójność. Po pewnym czasie programo- wania w  Pythonie możemy zacząć poprawnie zgadywać działanie nowych dla nas funkcjonalności. Jednak osoby, które wcześniej uczyły się innego języka zorientowanego obiektowo niż Python, mogą uważać za dziwne używanie funkcji len(collection) zamiast metody collection.len(). Ta pozorna niezwykłość je
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Zaawansowany Python
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: