Twórcy Pythona niemal od początku starali się opracować wieloparadygmatowy język zorientowany na czytelność kodu i produktywność programisty. Dziś język ten jest uważany za wszechstronny i potężny, a do tego cechuje się prostotą i elastycznością. Nadaje się zarówno do pisania niedużych skryptów, jak i wielkich systemów, a także do wysoce specjalistycznych zadań, jak choćby analiza danych w celach naukowych. Mimo to pisanie kodu, który jest wydajny, prosty w utrzymaniu oraz łatwy w użyciu, wciąż sprawia problemy nawet zaawansowanym programistom Pythona.

Niniejsza książka jest zbiorem praktyk stosowanych przez najlepszych programistów pracujących z Pythonem. Jest przeznaczona dla osób zawodowo zajmujących się rozwojem oprogramowania oraz dla ambitnych pasjonatów w tej dziedzinie. Poza opisem zaawansowanych technik programowania w Pythonie znalazły się tu również informacje o narzędziach i technikach stosowanych obecnie przez profesjonalnych programistów. Opisano metody zarządzania kodem, tworzenia, dokumentowania i testowania kodu oraz zasady optymalizacji oprogramowania. Przedstawiono również wzorce projektowe, które szczególnie docenią programiści Pythona.

Najważniejsze zagadnienia przedstawione w książce:

• metodologie pracy w Pythonie i najlepsze praktyki skÅ‚adniowe
• rozszerzenia Pythona napisane w innych jÄ™zykach programowania
• techniki profilowania aplikacji
• przetwarzanie współbieżne i równolegÅ‚e
• najprzydatniejsze wzorce projektowe

Python — niezawodne narzÄ™dzie dla profesjonalisty!

MichaÅ‚ Jaworski — od blisko 10 lat programuje w Pythonie. NapisaÅ‚ Graceful - framework REST oparty na bibliotece Falcon. Obecnie jest architektem oprogramowania w firmie Opera Software. Poza tym projektuje wysoce wydajne rozproszone usÅ‚ugi sieciowe i angażuje siÄ™ w liczne projekty open source.

Tarek Ziadé — jest kierownikiem ds. technicznych w firmie Mozilla. Zajmuje siÄ™ usÅ‚ugami sieciowymi o wielkiej skali w Pythonie na potrzeby przeglÄ…darki Firefox. Jest także zaÅ‚ożycielem Afpy, Francuskiej Grupy Użytkowników Pythona. Wielokrotnie byÅ‚ prelegentem podczas konferencji Solutions Linux, PyCon, OSCON, EuroPython i innych.

Osoby które kupowały "Profesjonalne programowanie w Pythonie. Poziom ekspert. Wydanie II", wybierały także:

• GraphQL. Kurs video. Buduj nowoczesne API w Pythonie 169,00 zÅ‚, (50,70 zÅ‚ -70%)
• Receptura na Python. Kurs Video. 54 praktyczne porady dla programist 199,00 zÅ‚, (59,70 zÅ‚ -70%)
• Podstawy Pythona z Minecraftem. Kurs video. Piszemy pierwsze skrypty 149,00 zÅ‚, (44,70 zÅ‚ -70%)
• Twórz gry w Pythonie. Kurs video. Poznaj bibliotekÄ™ PyGame 249,00 zÅ‚, (74,70 zÅ‚ -70%)
• Data Science w Pythonie. Kurs video. Algorytmy uczenia maszynowego 199,00 zÅ‚, (59,70 zÅ‚ -70%)

Spis treści

Profesjonalne programowanie w Pythonie. Poziom ekspert. Wydanie II -- spis treści

O autorach (11)

O recenzencie (12)

Przedmowa (13)

Rozdział 1. Obecny status Pythona (19)

• Gdzie jesteÅ›my i dokÄ…d zmierzamy? (20)
• Dlaczego i jak zmienia siÄ™ Python (20)
• BÄ…dź na bieżąco ze zmianami jÄ™zyka - dokumenty PEP (21)
• Popularność Pythona 3 w chwili pisania tej książki (22)
• GÅ‚ówne różnice pomiÄ™dzy Pythonem 3 a Pythonem 2 (23)
  • KorzyÅ›ci pÅ‚ynÄ…ce ze znajomoÅ›ci starej wersji Pythona (23)
  • GÅ‚ówne różnice skÅ‚adni i czÄ™ste puÅ‚apki (24)
  • Popularne narzÄ™dzia i techniki używane w celu utrzymania kompatybilnoÅ›ci (26)
• Nie tylko CPython (30)
  • Dlaczego powinieneÅ› siÄ™ przejmować? (30)
  • Stackless Python (31)
  • Jython (31)
  • IronPython (32)
  • PyPy (33)
• Nowoczesne podejÅ›cia do programowania w Pythonie (34)
  • Izolacja Å›rodowisk Pythona na poziomie aplikacji (34)
  • Zalety stosowania izolacji (36)
  • Popularne rozwiÄ…zania (37)
  • Które rozwiÄ…zanie wybrać? (41)
• Izolacja Å›rodowisk Pythona na poziomie systemu operacyjnego (42)
  • Wirtualne Å›rodowiska robocze z wykorzystaniem narzÄ™dzia Vagrant (43)
  • Konteneryzacja czy wirtualizacja? (45)
• Popularne narzÄ™dzia pracy ukierunkowane na produktywność (45)
  • Alternatywne powÅ‚oki Pythona - IPython, bpython, ptpython (46)
  • Interaktywne debuggery (48)
• Przydatne materiaÅ‚y (49)
• Podsumowanie (50)

Rozdział 2. Najlepsze praktyki składniowe - poniżej poziomu klas (51)

• Typy wbudowane Pythona (52)
  • CiÄ…gi znaków i bajtów (52)
  • Kolekcje (56)
• Zaawansowane elementy skÅ‚adni (67)
  • Iteratory (67)
  • Instrukcja yield (69)
  • Dekoratory (72)
  • ZarzÄ…dcy kontekstu - instrukcja with (83)
• Inne elementy skÅ‚adni, o których możesz jeszcze nie wiedzieć (87)
  • Konstrukcja for ... else ... (87)
  • Adnotacje funkcji (88)
• Podsumowanie (89)

Rozdział 3. Najlepsze praktyki składniowe - powyżej poziomu klas (91)

• Dziedziczenie po typach wbudowanych (92)
• Uzyskiwanie dostÄ™pu do metod klas nadrzÄ™dnych (94)
  • Klasy w starym stylu oraz funkcja super() w Pythonie 2 (96)
  • PorzÄ…dek rozpatrywania metod w Pythonie (97)
  • PuÅ‚apki zwiÄ…zane z funkcjÄ… super() (101)
  • Najlepsze praktyki (104)
• Zaawansowane wzorce dostÄ™pu do atrybutów (104)
  • Deskryptory (105)
  • WÅ‚aÅ›ciwoÅ›ci (111)
  • Sloty (114)
• Metaprogramowanie (114)
  • Dekoratory jako metoda metaprogramowania (115)
  • Dekoratory klas (116)
  • Wykorzystanie metody __new__() w celu nadpisania procesu tworzenia instancji klas (118)
  • Metaklasy (120)
  • Rady dotyczÄ…ce automatycznego generowania kodu (127)
• Podsumowanie (134)

RozdziaÅ‚ 4. WÅ‚aÅ›ciwy dobór nazw (135)

• PEP 8 i najlepsze praktyki nazewnicze (135)
  • Kiedy i dlaczego przestrzegać zasad PEP 8? (136)
  • Poza PEP 8 - wytyczne stylu w zespoÅ‚ach (136)
• Notacje nazewnicze (137)
  • Zmienne (138)
  • Zmienne publiczne i prywatne (140)
  • Funkcje i metody (142)
  • WÅ‚aÅ›ciwoÅ›ci (145)
  • Klasy (145)
  • ModuÅ‚y i pakiety (146)
• Dobre praktyki nazewnicze (146)
  • Użycie prefiksów is oraz has przy elementach logicznych (146)
  • Użycie liczby mnogiej przy zmiennych przechowujÄ…cych kolekcje (146)
  • Precyzyjne opisywanie sÅ‚owników (147)
  • Unikanie zbyt ogólnych okreÅ›leÅ„ (147)
  • Unikanie istniejÄ…cych nazw (148)
• Najlepsze praktyki dla argumentów funkcji i metod (149)
  • Projektowanie argumentów metodÄ… przyrostowÄ… (150)
  • Ufaj argumentom i testom (150)
  • Ostrożne wykorzystanie magicznych argumentów *args oraz **kwargs (152)
• Nazwy klas (154)
• Nazwy moduÅ‚ów i pakietów (154)
• Przydatne narzÄ™dzia (155)
  • Pylint (155)
  • pep8 i flake8 (157)
• Podsumowanie (158)

RozdziaÅ‚ 5. Tworzenie i dystrybucja pakietów (159)

• Tworzenie pakietów (160)
  • Zamieszanie wokóÅ‚ narzÄ™dzi do tworzenia i dystrybuowania pakietów (160)
  • Konfiguracja projektu (162)
  • WÅ‚asne polecenia skryptu setup.py (172)
  • Praca z pakietami podczas ich rozwoju (172)
• Pakiety przestrzeni nazw (174)
  • Zastosowanie pakietów przestrzeni nazw (174)
  • PEP 420 - domyÅ›lne pakiety przestrzeni nazw (176)
  • Pakiety przestrzeni nazw w starszych wersjach Pythona (177)
• Praca z repozytorium pakietów (178)
  • Python Package Index - repozytorium pakietów Pythona (179)
  • Dystrybucje źródÅ‚owe a dystrybucje budowane (181)
• Samodzielne pliki wykonywalne (184)
  • Kiedy samodzielne pliki wykonywalne sÄ… użyteczne? (186)
  • Popularne narzÄ™dzia (186)
  • BezpieczeÅ„stwo kodu Pythona w samodzielnych plikach wykonywalnych (193)
• Podsumowanie (195)

Rozdział 6. Zdalne wdrożenia kodu (197)

• Manifest Twelve-Factor App (198)
• Automatyzacja wdrożeÅ„ z wykorzystaniem narzÄ™dzia Fabric (200)
• WÅ‚asne repozytorium pakietów lub kopie lustrzane PyPI (205)
  • Utrzymywanie kopii lustrzanych PyPI (206)
  • Wdrożenia z wykorzystaniem dystrybucji pakietów (207)
• Popularne konwencje i dobre praktyki (215)
  • Hierarchia systemu plików (215)
  • Izolacja (216)
  • Wykorzystanie narzÄ™dzi nadzoru nad procesami (216)
  • Kod aplikacji powinien być uruchomiony w przestrzeni użytkownika (218)
  • Korzystanie ze wstecznych serwerów proxy protokoÅ‚u HTTP (219)
  • PrzeÅ‚adowywanie procesów bez zastojów (219)
• Instrumentacja i monitorowanie kodu (221)
  • Logowanie bÅ‚Ä™dów (Sentry oraz raven) (221)
  • Monitorowanie metryk systemowych i aplikacji (224)
  • ObsÅ‚uga logów (226)
• Podsumowanie (230)

Rozdział 7. Rozszerzenia Pythona w innych językach programowania (231)

• Inne jÄ™zyki, czyli C lub C++ (232)
  • Jak dziaÅ‚ajÄ… rozszerzenia w C i C++ (232)
• Dlaczego warto tworzyć rozszerzenia (234)
  • ZwiÄ™kszanie wydajnoÅ›ci w krytycznych sekcjach kodu (235)
  • Integracja kodu napisanego w innych jÄ™zykach programowania (236)
  • Integracja zewnÄ™trznych bibliotek dynamicznych (236)
  • Tworzenie wÅ‚asnych wbudowanych typów danych (236)
• Pisanie rozszerzeÅ„ (237)
  • Zwyczajne rozszerzenia w C (238)
  • Cython (253)
• Wyzwania zwiÄ…zane z rozszerzeniami (257)
  • Dodatkowa zÅ‚ożoność (258)
  • Debugowanie (258)
• Korzystanie z dynamicznych bibliotek bez pisania rozszerzeÅ„ (259)
  • ctypes (259)
  • CFFI (265)
• Podsumowanie (266)

Rozdział 8. Zarządzanie kodem (267)

• Systemy kontroli wersji (268)
  • Scentralizowane systemy kontroli wersji (268)
  • Rozproszone systemy kontroli wersji (271)
  • Systemy scentralizowane czy rozproszone? (274)
  • Korzystaj z systemu Git, jeÅ›li tylko możesz (274)
  • Git flow oraz GitHub flow (275)
• CiÄ…gÅ‚e procesy programistyczne (279)
  • CiÄ…gÅ‚a integracja oprogramowania (280)
  • CiÄ…gÅ‚e dostarczanie oprogramowania (284)
  • CiÄ…gÅ‚e wdrażanie oprogramowania (285)
  • Popularne narzÄ™dzia do ciÄ…gÅ‚ej integracji (285)
  • Wybór odpowiednich narzÄ™dzi i czÄ™ste puÅ‚apki (294)
• Podsumowanie (297)

Rozdział 9. Dokumentowanie projektu (299)

• Siedem zasad technicznego pisania (300)
  • Pisz w dwóch krokach (300)
  • Skieruj przekaz do konkretnej grupy czytelników (301)
  • Korzystaj z prostego stylu (302)
  • Ogranicz zakres informacji (303)
  • Korzystaj z realistycznych przykÅ‚adów (303)
  • Dokumentuj lekko, ale jednoczeÅ›nie wystarczajÄ…co (304)
  • Korzystaj z szablonów (305)
• Poradnik reStructuredText (305)
  • Struktura sekcji (307)
  • Listy numerowane i wypunktowania (309)
  • Formatowanie znakowe (310)
  • Bloki dosÅ‚owne (310)
  • OdnoÅ›niki (311)
• Budowanie dokumentacji (312)
  • Budowanie portfolio dokumentacji (312)
• Tworzenie wÅ‚asnego portfolio (319)
  • Projektowanie krajobrazu dokumentacji (319)
  • Budowanie dokumentacji a systemy ciÄ…gÅ‚ej integracji (324)
• Podsumowanie (325)

Rozdział 10. Programowanie sterowane testami (327)

• Nie testujÄ™ (327)
  • Zasady programowania sterowanego testami (328)
  • Możliwe rodzaje testów (332)
  • NarzÄ™dzia testowe standardowej biblioteki Pythona (335)
• TestujÄ™ (340)
  • PuÅ‚apki moduÅ‚u unittest (340)
  • Alternatywy dla moduÅ‚u unittest (341)
  • Mierzenie pokrycia kodu testami (349)
  • FaÅ‚szywe obiekty zastÄ™pcze i atrapy (351)
  • Testowanie kompatybilnoÅ›ci Å›rodowisk i zależnoÅ›ci (358)
  • Programowanie sterowane dokumentami (361)
• Podsumowanie (363)

RozdziaÅ‚ 11. Optymalizacja - ogólne zasady i techniki profilowania (365)

• Trzy zasady optymalizacji (365)
  • Przede wszystkim spraw, aby kod dziaÅ‚aÅ‚ poprawnie (366)
  • Pracuj z perspektywy użytkownika (367)
  • Utrzymuj kod czytelnym (367)
• Strategia optymalizacyjna (368)
  • Poszukaj innego winowajcy (368)
  • Skaluj sprzÄ™t (369)
  • Napisz test wydajnoÅ›ciowy (370)
• Identyfikowanie wÄ…skich gardeÅ‚ wydajnoÅ›ci (370)
  • Profilowanie czasu użycia procesora (370)
  • Profilowanie zużycia pamiÄ™ci (379)
  • Profilowanie poÅ‚Ä…czeÅ„ sieciowych (389)
• Podsumowanie (390)

Rozdział 12. Optymalizacja - wybrane skuteczne techniki (391)

• Redukcja zÅ‚ożonoÅ›ci (392)
  • ZÅ‚ożoność cyklomatyczna (394)
  • Notacja dużego O (394)
• Upraszczanie (397)
  • Przeszukiwanie list (397)
  • Korzystanie ze zbiorów w miejscu list (398)
  • Ukróć zewnÄ™trzne wywoÅ‚ania, zredukuj nakÅ‚ad pracy (398)
  • Korzystanie z moduÅ‚u collections (399)
• Stosowanie kompromisów architektonicznych (403)
  • Stosowanie heurystyk i algorytmów aproksymacyjnych (403)
  • Stosowanie kolejek zadaÅ„ i opóźnionego przetwarzania (404)
  • Stosowanie probabilistycznych struktur danych (408)
• Buforowanie (409)
  • Buforowanie deterministyczne (410)
  • Buforowanie niedeterministyczne (412)
  • UsÅ‚ugi buforujÄ…ce (413)
• Podsumowanie (416)

RozdziaÅ‚ 13. Przetwarzanie wspóÅ‚bieżne i równolegÅ‚e (419)

• Dlaczego wspóÅ‚bieżność? (420)
• WielowÄ…tkowość (421)
  • Czym jest wielowÄ…tkowość? (422)
  • Jak Python radzi sobie z wÄ…tkami (423)
  • Kiedy należy korzystać z wielowÄ…tkowoÅ›ci? (424)
• Przetwarzanie wieloprocesowe (439)
  • Wbudowany moduÅ‚ multiprocessing (442)
• Programowanie asynchroniczne (447)
  • Kooperacyjna wielozadaniowość i asynchroniczne operacje wejÅ›cia/wyjÅ›cia (448)
  • SÅ‚owa kluczowe async i await (449)
  • asyncio w starszych wersjach Pythona (453)
  • Praktyczny przykÅ‚ad programu asynchronicznego (454)
  • Integracja nieasynchronicznego kodu z async za pomocÄ… moduÅ‚u futures (456)
• Podsumowanie (459)

Rozdział 14. Przydatne wzorce projektowe (461)

• Wzorce kreacyjne (462)
  • Singleton (462)
• Wzorce strukturalne (465)
  • Adapter (466)
  • PeÅ‚nomocnik (481)
  • Fasada (482)
• Wzorce czynnoÅ›ciowe (483)
  • Obserwator (483)
  • OdwiedzajÄ…cy (485)
  • Szablon (488)
• Podsumowanie (491)

Skorowidz (492)