PYTHON DOBRE PRAKTYKI PROFESJONALISTÓW

ISBN: 978-83-283-6869-9

240 stron
format: B5
oprawa: miękka
Rok wydania: 2020

Python wydaje się językiem idealnym: ma intuicyjną składnię, jest przyjemny w używaniu, umożliwia tworzenie wydajnego, elastycznego kodu. Przy tym jest wyjątkowo wszechstronny, a stosowanie go w przeróżnych celach ułatwiają liczne biblioteki tworzone przez pasjonatów. To jednak nie zmienia faktu, że aby stać się profesjonalnym programistą Pythona, trzeba nauczyć się tworzyć kod godny profesjonalisty: działający bez błędów, czysty, czytelny i łatwy w utrzymaniu. W tym celu trzeba korzystać z branżowych standardów, które określają styl kodowania, projektowania aplikacji i prowadzenie całego procesu programowania. Należy wiedzieć, kiedy i w jaki sposób modularyzować kod, jak poprawić jakość przez zmniejszenie złożoności i stosować kilka innych, koniecznych praktyk.

Ta książka okaże się szczególnie cenna dla każdego, kto zamierza profesjonalnie tworzyć kod w Pythonie. Stanowi jasny i zrozumiały zbiór zasad wytwarzania oprogramowania o najwyższej jakości, praktyk stosowanych przez zawodowych wyjadaczy projektowania i kodowania. Poza teoretycznym omówieniem poszczególnych zagadnień znalazło się tu mnóstwo przykładów i przydatnych ćwiczeń, utrwalających prezentowany materiał. Nie zabrakło krótkiego wprowadzenia do Pythona, przedstawiono też sporo informacji o strukturach danych i różnych podejściach w kontekście osiągania dobrej wydajności kodu.

Pokazano, w jaki sposób zapobiegać nadmiernemu przyrostowi kodu podczas rozwijania aplikacji i jak redukować niepożądane powiązania w aplikacji. Dodatkową wartością publikacji jest bogactwo informacji o ogólnej architekturze oprogramowania, przydatnych każdemu zawodowemu programiście.

SPIS TREŚCI

Przedmowa

Podziękowania

O książce

O autorze

CZĘŚĆ I. DLACZEGO TO WSZYSTKO MA ZNACZENIE

Rozdział 1. Szersze spojrzenie
1.1. Python jest językiem dla przedsiębiorstw
1.1.1. Czasy się zmieniają
1.1.2. Co lubię w Pythonie
1.2. Python jest językiem przyjaznym do nauczania
1.3. Projektowanie jest procesem
1.3.1. Doświadczenie użytkownika
1.3.2. Już to widziałeś
1.4. Projektowanie umożliwia tworzenie lepszego oprogramowania
1.4.1. Rozważania przy projektowaniu oprogramowania
1.4.2. Oprogramowanie organiczne
1.5. Kiedy inwestować w projektowanie
1.6. Nowe początki
1.7. Projekt jest demokratyczny
1.7.1. Obecność umysłu
1.8. Jak korzystać z tej książki
Podsumowanie

CZĘŚĆ II. PODSTAWY PROJEKTOWANIA

Rozdział 2. Rozdzielanie zagadnień
2.1. Przestrzenie nazw
2.1.1. Przestrzenie nazw oraz polecenie import
2.1.2. Wiele twarzy importowania
2.1.3. Przestrzenie nazw zapobiegają kolizjom nazw
2.2. Hierarchia rozdzielania w Pythonie
2.2.1. Funkcje
2.2.2. Klasy
2.2.3. Moduły
2.2.4. Pakiety
Podsumowanie

Rozdział 3. Abstrakcja i hermetyzacja
3.1. Co to jest abstrakcja?
3.1.1. "Czarna skrzynka"
3.1.2. Abstrakcja jest jak cebula
3.1.3. Abstrakcja to uproszczenie
3.1.4. Dekompozycja umożliwia zastosowanie abstrakcji
3.2. Hermetyzacja
3.2.1. Konstrukty hermetyzacji w Pythonie
3.2.2. Prywatność w Pythonie
3.3. Wypróbuj
3.3.1. Refaktoryzacja
3.4. Style programowania to też abstrakcja
3.4.1. Programowanie proceduralne
3.4.2. Programowanie funkcyjne
3.4.3. Programowanie deklaratywne
3.5. Typowanie, dziedziczenie i polimorfizm
3.6. Rozpoznanie nieprawidłowej abstrakcji
3.6.1. Kwadratowe kołki i okrągłe otwory
3.6.2. Buty szyte na miarę
Podsumowanie

Rozdział 4. Projektowanie pod kątem wysokiej wydajności
4.1. Pędząc przez czas i przestrzeń
4.1.1. Złożoność jest trochę... złożona
4.1.2. Złożoność czasowa
4.1.3. Złożoność przestrzeni
4.2. Wydajność i typy danych
4.2.1. Typy danych dla stałego czasu
4.2.2. Typy danych w czasie liniowym
4.2.3. Złożoność przestrzeni w operacjach na typach danych
4.3. Zrób to, zrób to dobrze, spraw, żeby było szybkie
4.3.1. Zrób to
4.3.2. Zrób to dobrze
4.3.3. Spraw, żeby było szybkie
4.4. Narzędzia
4.4.1. timeit
4.4.2. Profilowanie CPU
4.5. Wypróbuj
Podsumowanie

Rozdział 5. Testowanie oprogramowania
5.1. Czym jest testowanie oprogramowania
5.1.1. Czy robi to, co napisano w instrukcji
5.1.2. Anatomia testu funkcjonalnego
5.2. Podejścia do testowania funkcjonalnego
5.2.1. Testy manualne
5.2.2. Testy automatyczne
5.2.3. Testy akceptacyjne
5.2.4. Testy jednostkowe
5.2.5. Testy integracyjne
5.2.6. Piramida testów
5.2.7. Testy regresji
5.3. Stwierdzenie faktów
5.4. Testy jednostkowe z unittest
5.4.1. Organizacja testów z unittest
5.4.2. Uruchamianie testów z unittest
5.4.3. Pisanie pierwszego testu w unittest
5.4.4. Pierwszy test integracyjny w unittest
5.4.5. Zamienniki testowe
5.4.6. Wypróbuj
5.4.7. Pisanie ciekawych testów
5.5. Testowanie z pytest
5.5.1. Organizowanie testów w pytest
5.5.2. Konwersja testów w unittest na pytest
5.6. Poza testowaniem funkcjonalnym
5.6.1. Testy wydajności
5.6.2. Testowanie obciążenia
5.7. Rozwój oparty na testach: podstawy
5.7.1. To sposób myślenia
5.7.2. To filozofia
Podsumowanie

CZĘŚĆ III. ARANŻACJA DUŻYCH SYSTEMÓW

Rozdział 6. Rozdzielanie aspektów w praktyce
6.1. Aplikacja do tworzenia zakładek z wiersza poleceń
6.2. Wycieczka po Bark
6.2.1. Korzyści wynikające z rozdzielenia: powtórzenie
6.3. Początkowa struktura kodu, według aspektów
6.3.1. Warstwa przechowywania danych
6.3.2. Warstwa logiki biznesowej
6.3.3. Warstwa prezentacji
Podsumowanie

Rozdział 7. Rozszerzalność i elastyczność
7.1. Co to jest kod rozszerzalny?
7.1.1. Dodawanie nowych zachowań
7.1.2. Modyfikacja istniejących zachowań
7.1.3. Luźne wiązanie
7.2. Rozwiązania dla sztywności
7.2.1. Oddawanie: odwrócenie sterowania
7.2.2. Diabeł tkwi w szczegółach: poleganie na interfejsach
7.2.3. Zwalczanie entropii: zasada odporności
7.3. Ćwiczenie rozszerzalności
Podsumowanie

Rozdział 8. Zasady (i wyjątki) dziedziczenia
8.1. Historia dziedziczenia w programowaniu
8.1.1. Panaceum
8.1.2. Wyzwania hierarchii
8.2. Dziedziczenie obecnie
8.2.1. Do czego służy dziedziczenie
8.2.2. Zastępowalność
8.2.3. Idealny przypadek użycia dziedziczenia
8.3. Dziedziczenie w Pythonie
8.3.1. Inspekcja typu
8.3.2. Dostęp do klasy bazowej
8.3.3. Wielokrotne dziedziczenie i kolejność rozwiązywania metod
8.3.4. Abstrakcyjne klasy bazowe
8.4. Dziedziczenie i kompozycja w programie Bark
8.4.1. Refaktoryzacja w celu użycia abstrakcyjnej klasy bazowej
8.4.2. Ostateczne spojrzenie na wykonane dziedziczenie
Podsumowanie

Rozdział 9. Zapewnianie lekkości
9.1. Jak duża powinna być klasa/funkcja/moduł
9.1.1. Fizyczny rozmiar
9.1.2. Pojedyncza odpowiedzialność
9.1.3. Złożoność kodu
9.2. Rozkładanie złożoności
9.2.1. Wyodrębnianie konfiguracji
9.2.2. Wyodrębnianie funkcji
9.3. Dekompozycja klas
9.3.1. Złożoność inicjacji
9.3.2. Wyodrębnianie klas i przekazywanie wywołań
Podsumowanie

Rozdział 10. Luźne wiązania w praktyce
10.1. Definicja wiązania
10.1.1. Tkanka łączna
10.1.2. Ścisłe wiązania
10.1.3. Luźne wiązania
10.2. Rozpoznawanie wiązania
10.2.1. Zazdrość o funkcje
10.2.2. Chirurgia przy użyciu strzelby
10.2.3. Nieszczelne abstrakcje
10.3. Wiązania w programie Bark
10.4. Radzenie sobie z wiązaniami
10.4.1. Powiadamianie użytkownika
10.4.2. Przechowywanie zakładek
10.4.3. Wypróbuj
Podsumowanie

CZĘŚĆ IV. CO DALEJ?

Rozdział 11. Dalej i wyżej
11.1. Co teraz
11.1.1. Opracuj plan
11.1.2. Wykonaj plan
11.1.3. Śledź swoje postępy
11.2. Wzorce projektowe
11.2.1. Mocne i słabe strony wzorców projektowych w Pythonie
11.2.2. Tematy, od których zacząć
11.3. Systemy rozproszone
11.3.1. Tryby awarii w systemach rozproszonych
11.3.2. Adresowanie stanu aplikacji
11.3.3. Tematy, od których zacząć
11.4. Zanurz się głęboko w Pythonie
11.4.1. Styl kodu w języku Python
11.4.2. Funkcje językowe są wzorcami
11.4.3. Tematy, od których zacząć
11.5. Gdzie byłeś
11.5.1. Tam i z powrotem: opowieść programisty
11.5.2. Zakończenie
Podsumowanie

Załącznik A. Instalacja Pythona
A.1. Jakiej wersji Pythona powinienem użyć
A.2. Python "systemowy"
A.3. Instalowanie innych wersji Pythona
A.3.1. Pobierz oficjalną dystrybucję Pythona
A.3.2. Pobierz za pomocą Anacondy
A.4. Weryfikacja instalacji