Efektywny Python 90 sposobow na lepszy kod Wydanie II.pdf

(2252 KB) Pobierz
Tytuł oryginału: Effective Python: 90 Specific Ways to Write Better Python (2nd Edition)
Tłumaczenie: Robert Górczyński
ISBN: 978-83-283-6732-6
Authorized translation from the English language edition, entitled: EFFECTIVE PYTHON: 90 SPECIFIC
WAYS TO WRITE BETTER PYTHON, 2nd Edition by SLATKIN, BRETT, published by Pearson Education,
Inc, publishing as Addison-Wesley Professional.
Copyright © 2020 by Pearson Education, Inc.
All rights reserved. No part of this book may by reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording or by any information storage retrieval system,
without permission from Pearson Education, Inc.
Polish language edition published by Helion SA, Copyright © 2020.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich
właścicieli.
Autor oraz Helion SA dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne
i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym
ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Helion SA nie ponoszą również
żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.
Helion SA
ul. Kościuszki 1c, 44-100 Gliwice
tel. 32 231 22 19, 32 230 98 63
e-mail:
helion@helion.pl
WWW:
http://helion.pl
(księgarnia internetowa, katalog książek)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/efpyt2
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
•
Kup książkę
•
Poleć książkę
•
Oceń książkę
•
Księgarnia internetowa
•
Lubię to! » Nasza społeczność
Spis treści
Wprowadzenie ...............................................................................................................11
Podziękowania ...............................................................................................................15
O autorze ........................................................................................................................17
Rozdział 1. Programowanie zgodne z duchem Pythona ..............................................19
Sposób 1.
Sposób 2.
Sposób 3.
Sposób 4.
Sposób 5.
Sposób 6.
Sposób 7.
Sposób 8.
Sposób 9.
Sposób 10.
Ustalenie używanej wersji Pythona ............................................................................19
Stosuj styl PEP 8 ............................................................................................................21
Różnice między typami bytes i str ..............................................................................23
Wybieraj interpolowane ciągi tekstowe f zamiast ciągów tekstowych
formatowania w stylu C i funkcji str.format() ..........................................................28
Decyduj się na funkcje pomocnicze zamiast na skomplikowane wyrażenia .......38
Zamiast indeksowania wybieraj rozpakowanie wielu operacji przypisania .........41
Preferuj użycie funkcji enumerate() zamiast range() ..............................................44
Używaj funkcji zip() do równoczesnego przetwarzania iteratorów ......................46
Unikaj bloków else po pętlach for i while .................................................................48
Unikaj powtórzeń w wyrażeniach przypisania .........................................................50
Rozdział 2. Lista i słownik .............................................................................................57
Sposób 11. Umiejętnie podziel sekwencje .....................................................................................57
Sposób 12. Unikaj użycia indeksów początek, koniec i wartości kroku
w pojedynczej operacji podziału .................................................................................60
Sposób 13. Wybieraj rozpakowanie typu catch-all zamiast tworzenia wycinków ..................62
Sposób 14. Używaj parametru key podczas sortowania
według skomplikowanych kryteriów .........................................................................66
Sposób 15. Zachowaj ostrożność, gdy polegasz na kolejności wstawiania elementów
do obiektu typu dict .....................................................................................................71
Kup książkę
Poleć książkę
8
Spis treści
Sposób 16. Podczas obsługi brakujących kluczy słownika wybieraj funkcję get()
zamiast operatora in i wyjątku KeyError ...................................................................78
Sposób 17. Podczas obsługi brakujących elementów w wewnętrznym stanie
wybieraj typ defaultdict zamiast metody setdefault() ..............................................82
Sposób 18. Wykorzystaj metodę __missing__() do tworzenia wartości domyślnych
w zależności od klucza ..................................................................................................84
Rozdział 3. Funkcje ....................................................................................................... 89
Sposób 19. Gdy funkcja zwraca wiele wartości, nie rozpakowuj więcej
niż trzech zmiennych ...................................................................................................89
Sposób 20. Preferuj wyjątki zamiast zwrotu wartości None .......................................................92
Sposób 21. Zobacz, jak domknięcia współdziałają z zakresem zmiennej .................................95
Sposób 22. Zmniejszenie wizualnego zagmatwania za pomocą zmiennej liczby
argumentów pozycyjnych ............................................................................................98
Sposób 23. Zdefiniowanie zachowania opcjonalnego za pomocą argumentów
w postaci słów kluczowych ....................................................................................... 101
Sposób 24. Użycie None i docstring w celu dynamicznego określenia
argumentów domyślnych ......................................................................................... 105
Sposób 25. Wymuszaj czytelność kodu, stosując jedynie argumenty
w postaci słów kluczowych ....................................................................................... 108
Sposób 26. Dekoratory funkcji definiuj za pomocą functools.wraps ..................................... 112
Rozdział 4. Konstrukcje składane i generatory ......................................................... 117
Sposób 27. Używaj list składanych zamiast funkcji map() i filter() ........................................ 117
Sposób 28. Unikaj więcej niż dwóch wyrażeń na liście składanej ........................................... 119
Sposób 29. Stosuj wyrażenia przypisania, aby unikać powielania zadań
w konstrukcjach składanych .................................................................................... 121
Sposób 30. Rozważ użycie generatorów, zamiast zwracać listy ............................................... 124
Sposób 31. Podczas iteracji przez argumenty zachowuj postawę defensywną ..................... 126
Sposób 32. Rozważ użycie generatora wyrażeń dla dużych list składanych .......................... 131
Sposób 33. Twórz wiele generatorów za pomocą wyrażenia yield from ................................ 132
Sposób 34. Unikaj wstrzykiwania danych do generatorów za pomocą metody send() ........ 135
Sposób 35. Unikaj w generatorach przejścia między stanami za pomocą metody throw() ........140
Sposób 36. Rozważ stosowanie modułu itertools w pracy z iteratorami i generatorami .... 144
Rozdział 5. Klasy i interfejsy ...................................................................................... 151
Sposób 37.
Sposób 38.
Sposób 39.
Sposób 40.
Twórz klasy, zamiast zagnieżdżać wiele poziomów typów wbudowanych ....... 151
Dla prostych interfejsów akceptuj funkcje zamiast klas ....................................... 157
Użycie polimorfizmu @classmethod w celu ogólnego tworzenia obiektów ..... 160
Inicjalizacja klasy nadrzędnej za pomocą wywołania super() ............................. 165
Kup książkę
Poleć książkę
Spis treści
9
Sposób 41. Rozważ łączenie funkcjonalności za pomocą klas domieszek ..............................169
Sposób 42. Preferuj atrybuty publiczne zamiast prywatnych ...................................................173
Sposób 43. Stosuj dziedziczenie po collections.abc w kontenerach
typów niestandardowych ...........................................................................................178
Rozdział 6. Metaklasy i atrybuty .................................................................................183
Sposób 44. Używaj zwykłych atrybutów zamiast metod typu getter i setter ..........................183
Sposób 45. Rozważ użycie @property zamiast refaktoryzacji atrybutów ...............................187
Sposób 46. Stosuj deskryptory, aby wielokrotnie wykorzystywać metody
udekorowane przez @property .................................................................................191
Sposób 47. Używaj metod __getattr__(), __getattribute__() i __setattr__()
dla opóźnionych atrybutów .......................................................................................196
Sposób 48. Sprawdzaj podklasy za pomocą __init_subclass__ ................................................201
Sposób 49. Rejestruj istniejące klasy za pomocą __init_subclass__() .....................................208
Sposób 50. Adnotacje atrybutów klas dodawaj za pomocą metody __set_name__() ..........212
Sposób 51. Dla złożonych rozszerzeń klas wybieraj dekoratory klas zamiast metaklas .......216
Rozdział 7. Współbieżność i równoległość .................................................................223
Sposób 52. Używaj modułu subprocess do zarządzania procesami potomnymi ..................224
Sposób 53. Użycie wątków dla operacji blokujących wejście- yjście,
unikanie równoległości ..............................................................................................228
Sposób 54. Używaj klasy Lock, aby unikać stanu wyścigu w wątkach ....................................232
Sposób 55. Używaj klasy Queue do koordynacji pracy między wątkami ...............................236
Sposób 56. Naucz się rozpoznawać, kiedy współbieżność jest niezbędna ..............................244
Sposób 57. Unikaj tworzenia nowych egzemplarzy Thread na żądanie fan-out ...................248
Sposób 58. Pamiętaj, że stosowanie Queue do obsługi współbieżności
wymaga refaktoringu .................................................................................................252
Sposób 59. Rozważ użycie klasy ThreadPoolExecutor, gdy wątki są potrzebne
do zapewnienia współbieżności ................................................................................258
Sposób 60. Zapewnij wysoką współbieżność operacji wejścia-wyjścia
dzięki użyciu współprogramów ................................................................................260
Sposób 61. Naucz się przekazywać do asyncio wątkowane operacje wejścia-wyjścia ..........264
Sposób 62. Połączenie wątków i współprogramów w celu ułatwienia konwersji
na wersję stosującą asyncio .......................................................................................274
Sposób 63. Maksymalizuj responsywność przez unikanie
blokującej pętli zdarzeń asyncio ...............................................................................280
Sposób 64. Rozważ użycie concurrent.futures(), aby otrzymać prawdziwą równoległość ....283
Kup książkę
Poleć książkę

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin