Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie \ Python

Profesjonalne programowanie w Pythonie. Poziom ekspert. Wydanie II Język: 1

978-83-283-3033-7

Cena Brutto: 79.00

Cena netto: 75.24

Ilość:
Wersja: Drukowana
Autor Michal Jaworski, Tarek Ziade
Liczba_stron 508
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2017-08-06

Profesjonalne programowanie w

Pythonie

Poziom ekspert. Wydanie II


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

    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)

powrót
 
Produkty Podobne
Profesjonalne programowanie w Pythonie. Poziom ekspert. Wydanie II
The Python 3 Standard Library by Example
Python. Podstawy nauki o danych. Wydanie II
Automatyzacja nudnych zadań z Pythonem. Nauka programowania
Python in a Nutshell, 3rd Edition
Python na start! Programowanie dla nastolatków
Hello World! Przygoda z programowaniem dla dzieci i absolutnie początkujących. Wydanie II
Myśl w języku Python! Nauka programowania. Wydanie II
Thoughtful Machine Learning with Python
Python Data Science Handbook
Więcej produktów