Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00435 007327 10472196 na godz. na dobę w sumie
Python. Wprowadzenie. Wydanie III - książka
Python. Wprowadzenie. Wydanie III - książka
Autor: Liczba stron: 736
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-1648-0 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> python - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj i wykorzystaj w praktyce aktualne możliwości Pythona

Python to popularny język programowania, wykorzystywany w wielu różnych dziedzinach. Używa się go zarówno w samodzielnych programach, jak i skryptach. Jest wyposażony w dynamiczny system typów oraz automatyczne zarządzanie pamięcią. Ponadto -- co istotne -- jest on darmowy, łatwo przenośny i bardzo prosty w użyciu. Podobnie jak inne języki, również Python ciągle się rozwija. W tej książce przedstawiono właśnie wszystkie potrzebne i aktualne wiadomości, dotyczące wykorzystania tego języka programowania w praktyce.

Książka 'Python. Wprowadzenie. Wydanie III' stanowi kompletny i szczegółowy przewodnik po podstawach języka Python. Wiedza w niej zawarta umożliwia pełne zrozumienie tego języka, co pozwoli Ci pojąć dowolne przykłady kodu na poziomie aplikacji. Zwięźle i jasno przedstawione przykłady świetnie ilustrują poszczególne kwestie i problemy, co daje solidny fundament do praktycznego zastosowania świeżo nabytych umiejętności. W niniejszym -- trzecim już -- wydaniu znajdziesz nowy zestaw praktycznych wskazówek i porad, dobranych w taki sposób, aby obejmowały aktualne zalecenia i najlepsze praktyki programowania. Krótko mówiąc, ta książka ma wszystko, czego potrzebujesz, aby nie tylko dokładnie poznać język Python, ale także efektywnie z niego korzystać!

Zdobądź solidne podstawy języka Python i poznaj
najlepsze rozwiązania w programowaniu!

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

Darmowy fragment publikacji:

Python. Wprowadzenie. Wydanie III Autor: Mark Lutz T‡umaczenie: Anna Trojan ISBN: 978-83-246-1648-0 Tytu‡ orygina‡u: Learning Python, 3rd Edition Format: 168x237, stron: 736 Poznaj i wykorzystaj w praktyce aktualne mo¿liwo(cid:156)ci Pythona (cid:149) Jak Python wykonuje programy? (cid:149) Jak korzysta(cid:230) ze standardowej biblioteki tego jŒzyka? (cid:149) Jak programowa(cid:230) skrypty internetowe i grafikŒ za jego pomoc„? Python to popularny jŒzyk programowania, wykorzystywany w wielu r(cid:243)¿nych dziedzinach. U¿ywa siŒ go zar(cid:243)wno w samodzielnych programach, jak i skryptach. Jest wyposa¿ony w dynamiczny system typ(cid:243)w oraz automatyczne zarz„dzanie pamiŒci„. Ponadto (cid:151) co istotne (cid:151) jest on darmowy, ‡atwo przeno(cid:156)ny i bardzo prosty w u¿yciu. Podobnie jak inne jŒzyki, r(cid:243)wnie¿ Python ci„gle siŒ rozwija. W tej ksi„¿ce przedstawiono w‡a(cid:156)nie wszystkie potrzebne i aktualne wiadomo(cid:156)ci, dotycz„ce wykorzystania tego jŒzyka programowania w praktyce. Ksi„¿ka (cid:132)Python. Wprowadzenie. Wydanie III(cid:148) stanowi kompletny i szczeg(cid:243)‡owy przewodnik po podstawach jŒzyka Python. Wiedza w niej zawarta umo¿liwia pe‡ne zrozumienie tego jŒzyka, co pozwoli Ci poj„(cid:230) dowolne przyk‡ady kodu na poziomie aplikacji. ZwiŒ(cid:159)le i jasno przedstawione przyk‡ady (cid:156)wietnie ilustruj„ poszczeg(cid:243)lne kwestie i problemy, co daje solidny fundament do praktycznego zastosowania (cid:156)wie¿o nabytych umiejŒtno(cid:156)ci. W niniejszym (cid:151) trzecim ju¿ (cid:151) wydaniu znajdziesz nowy zestaw praktycznych wskaz(cid:243)wek i porad, dobranych w taki spos(cid:243)b, aby obejmowa‡y aktualne zalecenia i najlepsze praktyki programowania. Kr(cid:243)tko m(cid:243)wi„c, ta ksi„¿ka ma wszystko, czego potrzebujesz, aby nie tylko dok‡adnie pozna(cid:230) jŒzyk Python, ale tak¿e efektywnie z niego korzysta(cid:230)! (cid:149) Wprowadzenie do interpretera Pythona (cid:149) Interaktywne wpisywanie kodu (cid:149) Systemowe wiersze poleceæ i pliki (cid:149) Typy liczbowe Pythona (cid:149) Referencje wsp(cid:243)‡dzielone (cid:149) £aæcuchy znak(cid:243)w (cid:149) Instrukcje przypisania i instrukcje wyra¿eæ (cid:149) Źr(cid:243)d‡a dokumentacji (cid:149) Funkcje i modu‡y (cid:149) Zakres i argumenty (cid:149) Programowanie zorientowane obiektowo (cid:149) Projektowanie z udzia‡em klas Zdob„d(cid:159) solidne podstawy jŒzyka Python i poznaj najlepsze rozwi„zania w programowaniu! Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Spis treści Przedmowa .............................................................................................................................25 I Wprowadzenie .......................................................................................41 Dlaczego ludzie używają Pythona? Jakość oprogramowania Wydajność programistów Czy Python jest językiem skryptowym? Jakie są zatem wady Pythona? Kto dzisiaj używa Pythona? Co mogę zrobić za pomocą Pythona? Programowanie systemowe Graficzne interfejsy użytkownika Skrypty internetowe Integracja komponentów Programowanie bazodanowe Szybkie prototypowanie Programowanie numeryczne i naukowe Gry, grafika, AI, XML, roboty i tym podobne 1. Pytania i odpowiedzi dotyczące Pythona ..................................................................43 43 44 45 45 47 48 49 49 49 50 50 51 51 51 51 52 52 52 53 54 55 55 57 57 Jest zorientowany obiektowo Jest darmowy Jest przenośny Ma duże możliwości Można go łączyć z innymi językami Jest łatwy w użyciu Jest łatwy do nauczenia się Zawdzięcza swoją nazwę Monty Pythonowi Jakie są techniczne mocne strony Pythona? 5 Jak Python wygląda na tle innych języków? Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 58 59 60 60 60 Warianty modeli wykonywania Alternatywne implementacje Pythona Z punktu widzenia programisty Z punktu widzenia Pythona Wprowadzenie do interpretera Pythona Wykonywanie programu Kompilacja kodu bajtowego Maszyna wirtualna Pythona Wpływ na wydajność Wpływ na proces programowania 2. Jak Python wykonuje programy? ................................................................................63 63 65 65 66 66 67 67 68 68 69 69 69 70 70 70 71 72 73 73 74 74 74 Zamrożone pliki binarne Przyszłe możliwości? Podsumowanie rozdziału Łamigłówka Kompilator JIT Psyco Translator Shedskin C++ Narzędzia do optymalizacji wykonywania CPython Jython IronPython Quiz Odpowiedzi Interaktywne wpisywanie kodu Systemowe wiersze poleceń i pliki Wykorzystywanie sesji interaktywnej 3. Jak wykonuje się programy? .......................................................................................75 75 77 78 80 81 83 83 84 86 Kliknięcie ikony w systemie Windows Sztuczka z raw_input Inne ograniczenia klikania ikon Wykorzystywanie wierszy poleceń i plików Skrypty wykonywalne Uniksa (#!) Kliknięcie ikony pliku 6 | Spis treści Importowanie i przeładowywanie modułów Więcej o modułach — atrybuty Moduły i przestrzenie nazw Uwagi na temat używania instrukcji import i reload Interfejs użytkownika IDLE Podstawy IDLE Korzystanie z IDLE Zaawansowane opcje IDLE Inne IDE Osadzanie wywołań Zamrożone binarne pliki wykonywalne Uruchamianie kodu w edytorze tekstowym Inne możliwości uruchamiania Przyszłe możliwości Jaką opcję wybrać? Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Łamigłówka Ćwiczenia do części pierwszej 86 88 90 90 91 91 93 95 95 96 97 97 98 98 98 99 100 100 100 102 102 II Typy i operacje ......................................................................................105 Po co korzysta się z typów wbudowanych? Najważniejsze typy danych w Pythonie 4. Wprowadzenie do typów obiektów Pythona .......................................................... 107 108 109 110 111 111 113 114 115 116 116 117 117 117 118 119 119 Operacje na sekwencjach Niezmienność Metody specyficzne dla typu Otrzymanie pomocy Inne sposoby kodowania łańcuchów znaków Dopasowywanie wzorców Liczby Łańcuchy znaków Listy Operacje na sekwencjach Operacje specyficzne dla typu Sprawdzanie granic Zagnieżdżanie Listy składane Spis treści | 7 Słowniki Operacje na odwzorowaniach Zagnieżdżanie raz jeszcze Sortowanie kluczy — pętle for Iteracja i optymalizacja Brakujące klucze — testowanie za pomocą if Krotki Czemu służą krotki? Pliki Inne narzędzia podobne do plików Inne typy podstawowe Jak zepsuć elastyczność kodu Klasy zdefiniowane przez użytkownika I wszystko inne Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 120 120 121 123 124 125 126 126 126 127 128 128 129 130 131 132 132 132 Typy liczbowe Pythona Literały liczbowe Wbudowane narzędzia liczbowe oraz rozszerzenia Operatory wyrażeń Pythona Liczby w akcji Połączone operatory stosują się do priorytetów Podwyrażenia grupowane są w nawiasach Pomieszane typy poddawane są konwersji Przeciążanie operatorów — przegląd 5. Liczby ......................................................................................................................... 135 135 136 137 138 139 139 139 140 141 141 143 144 145 145 146 146 147 149 149 150 Zmienne i podstawowe wyrażenia Formaty wyświetlania liczb Dzielenie — klasyczne, bez reszty i prawdziwe Operacje poziomu bitowego Długie liczby całkowite Liczby zespolone Notacja szesnastkowa i ósemkowa Inne wbudowane narzędzia liczbowe Inne typy liczbowe Liczby dziesiętne Zbiory 8 | Spis treści Wartości Boolean Dodatkowe rozszerzenia Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 151 152 152 153 153 153 Sprawa brakujących deklaracji typu Zmienne, obiekty i referencje Typy powiązane są z obiektami, a nie ze zmiennymi Obiekty są uwalniane Referencje współdzielone 6. Wprowadzenie do typów dynamicznych ................................................................. 155 155 155 157 158 159 161 162 163 164 165 165 165 Referencje współdzielone a modyfikacje w miejscu Referencje współdzielone a równość Typy dynamiczne są wszędzie Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Literały łańcuchów znaków 7. Łańcuchy znaków ...................................................................................................... 167 168 169 169 171 Łańcuchy znaków w apostrofach i cudzysłowach są tym samym Sekwencje ucieczki reprezentują bajty specjalne Surowe łańcuchy znaków blokują sekwencje ucieczki Potrójne cudzysłowy i apostrofy kodują łańcuchy znaków będące wielowierszowymi blokami Łańcuchy znaków Unicode pozwalają na zakodowanie większych zbiorów znaków kodowych Łańcuchy znaków w akcji Podstawowe operacje Indeksowanie i wycinki Rozszerzone wycinki — trzeci limit Narzędzia do konwersji łańcuchów znaków Konwersje kodu znaków Modyfikowanie łańcuchów znaków Formatowanie łańcuchów znaków Zaawansowane formatowanie łańcuchów znaków Formatowanie łańcuchów znaków w oparciu o słownik 172 174 176 176 177 179 180 182 183 184 185 186 Spis treści | 9 Metody łańcuchów znaków Przykłady metod łańcuchów znaków — modyfikowanie łańcuchów znaków Przykłady metod łańcuchów znaków — analiza składniowa tekstu Inne znane metody łańcuchów znaków w akcji Oryginalny moduł string Generalne kategorie typów Typy z jednej kategorii współdzielą zbiory operacji Typy zmienne można modyfikować w miejscu Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 187 188 190 191 192 193 193 194 194 195 195 195 Podstawowe operacje na listach Indeksowanie, wycinki i macierze Modyfikacja list w miejscu Przypisywanie do indeksu i wycinków Wywołania metod list Inne popularne operacje na listach Słowniki Słowniki w akcji Listy Listy w akcji 8. Listy oraz słowniki ..................................................................................................... 197 197 199 199 200 201 201 202 204 204 206 206 207 208 209 210 210 211 211 212 213 214 215 215 215 Wykorzystywanie słowników do symulowania elastycznych list Wykorzystywanie słowników z rzadkimi strukturami danych Unikanie błędów z brakującymi kluczami Wykorzystywanie słowników w postaci „rekordów” Inne sposoby tworzenia słowników Podstawowe operacje na słownikach Modyfikacja słowników w miejscu Inne metody słowników Przykład z tabelą języków programowania Uwagi na temat korzystania ze słowników Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 10 | Spis treści Pliki Inne narzędzia powiązane z plikami Krotki Krotki w akcji Otwieranie plików Wykorzystywanie plików Pliki w akcji Właściwości składni krotek — przecinki i nawiasy Konwersje i niezmienność Dlaczego istnieją listy i krotki? Przechowywanie obiektów Pythona w plikach i przetwarzanie ich Przechowywanie obiektów Pythona za pomocą pickle Przechowywanie i przetwarzanie spakowanych danych binarnych w plikach 9. Krotki, pliki i pozostałe ...............................................................................................217 217 218 219 219 220 221 221 222 223 223 225 226 227 227 228 229 231 233 234 235 236 236 236 237 237 238 239 239 239 240 240 Przypisanie tworzy referencje, nie kopie Powtórzenie dodaje jeden poziom zagłębienia Uwaga na cykliczne struktury danych Typów niezmiennych nie można modyfikować w miejscu Raz jeszcze o kategoriach typów Elastyczność obiektów Referencje a kopie Porównania, równość i prawda Hierarchie typów Pythona Inne typy w Pythonie Pułapki typów wbudowanych Znaczenie True i False w Pythonie Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Łamigłówka Ćwiczenia do części drugiej III Instrukcje i składnia ............................................................................. 243 Raz jeszcze o strukturze programu Pythona 10. Wprowadzenie do instrukcji Pythona ......................................................................245 245 246 246 248 Instrukcje Pythona Co dodaje Python Historia dwóch if Spis treści | 11 Co usuwa Python Nawiasy są opcjonalne Koniec wiersza jest końcem instrukcji Koniec wcięcia to koniec bloku Skąd bierze się składnia indentacji? Kilka przypadków specjalnych Przypadki specjalne dla reguły o końcu wiersza Przypadki specjalne dla reguły o indentacji bloków Szybki przykład — interaktywne pętle Prosta pętla interaktywna Wykonywanie obliczeń na danych użytkownika Obsługa błędów za pomocą sprawdzania danych wejściowych Obsługa błędów za pomocą instrukcji try Kod zagnieżdżony na trzy poziomy głębokości Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 248 248 248 249 249 252 252 253 253 254 255 256 257 257 258 259 259 259 Instrukcje przypisania Zaawansowane wzorce przypisywania sekwencji Przypisanie z wieloma celami Przypisanie z wieloma celami a współdzielone referencje Przypisania rozszerzone Przypisania rozszerzone a współdzielone referencje Formy instrukcji przypisania Przypisanie sekwencji 11. Przypisanie, wyrażenia i print .................................................................................. 261 261 262 263 264 265 265 266 268 268 270 270 271 272 272 273 274 274 277 278 278 278 Program „Witaj, świecie!” w Pythonie Przekierowanie strumienia wyjścia Rozszerzenie print file Reguły dotyczące nazw zmiennych Konwencje dotyczące nazewnictwa Nazwy nie mają typu, typ mają obiekty Instrukcje wyrażeń Instrukcje print Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Instrukcje wyrażeń i modyfikacje w miejscu 12 | Spis treści Instrukcje if Ogólny format Proste przykłady Rozgałęzienia kodu Reguły składni Pythona Ograniczniki bloków Ograniczniki instrukcji Kilka przypadków specjalnych 12. Testy if ........................................................................................................................279 279 279 280 280 282 283 284 285 285 287 289 290 290 290 Podsumowanie rozdziału Łamigłówka Wyrażenie trójargumentowe if/else Quiz Odpowiedzi Testy prawdziwości Pętle while Ogólny format Przykłady Pętle for Ogólny format pętli Przykłady Instrukcje break, continue, pass oraz else w pętli Instrukcja pass Instrukcja continue Instrukcja break Instrukcja else Więcej o części pętli else 13. Pętle while i for .......................................................................................................... 291 291 291 292 293 293 293 293 294 295 295 296 297 297 298 298 299 299 299 302 302 304 305 306 Iteratory plików Inne iteratory typów wbudowanych Inne konteksty iteracyjne Iteratory definiowane przez użytkownika Podstawowe zastosowanie Inne typy danych Przypisanie krotek w pętli for Zagnieżdżone pętle for Ogólny format Przykłady Pierwsze spojrzenie na iteratory Spis treści | 13 Techniki tworzenia pętli Pętle liczników — while i range Przechodzenie niewyczerpujące — range Modyfikacja list — range Przechodzenie równoległe — zip oraz map Tworzenie słowników za pomocą funkcji zip Generowanie wartości przesunięcia i elementów — enumerate Listy składane — wprowadzenie Podstawy list składanych Wykorzystywanie list składanych w plikach Rozszerzona składnia list składanych Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 306 307 308 309 310 311 312 313 313 314 315 316 317 317 317 Źródła dokumentacji Pythona Komentarze ze znakami # Funkcja dir Łańcuchy znaków dokumentacji — __doc__ Łańcuchy znaków dokumentacji zdefiniowane przez użytkownika Standardy dotyczące łańcuchów znaków dokumentacji Wbudowane łańcuchy znaków dokumentacji 14. Wprowadzenie do dokumentacji .............................................................................. 319 319 320 320 321 321 323 323 324 326 329 330 330 330 332 333 333 333 334 334 PyDoc — funkcja help PyDoc — raporty HTML Zbiór standardowej dokumentacji Zasoby internetowe Publikowane książki Często spotykane problemy programistyczne Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Łamigłówka Ćwiczenia do części trzeciej 14 | Spis treści IV Funkcje ..................................................................................................337 Pierwszy przykład — definicje i wywoływanie Definicja Wywołanie Polimorfizm w Pythonie Po co używa się funkcji? Tworzenie funkcji Instrukcje def Instrukcja def uruchamiana jest w czasie wykonania 15. Podstawy funkcji .......................................................................................................339 340 340 342 342 343 343 343 344 345 345 346 346 347 348 349 349 349 Definicja Wywołania Raz jeszcze o polimorfizmie Zmienne lokalne Podsumowanie rozdziału Łamigłówka Drugi przykład — przecinające się sekwencje Quiz Odpowiedzi Instrukcja global Reguły dotyczące zakresu Podstawy zakresów Pythona Rozwiązywanie konfliktów w zakresie nazw — reguła LEGB Przykład zakresu Zakres wbudowany 16. Zakres i argumenty .................................................................................................... 351 351 352 353 355 355 357 358 359 360 361 361 361 362 Minimalizowanie stosowania zmiennych globalnych Minimalizacja modyfikacji dokonywanych pomiędzy plikami Inne metody dostępu do zmiennych globalnych Szczegóły dotyczące zakresów zagnieżdżonych Przykład zakresu zagnieżdżonego Zakresy a funkcje zagnieżdżone Funkcje fabryczne Zachowywanie stanu zakresu zawierającego za pomocą argumentów domyślnych Zakresy zagnieżdżone a lambda Zakresy a domyślne wartości argumentów w zmiennych pętli Dowolne zagnieżdżanie zakresów 363 364 365 366 Spis treści | 15 Przekazywanie argumentów Argumenty a współdzielone referencje Unikanie modyfikacji zmiennych argumentów Symulowanie parametrów wyjścia Specjalne tryby dopasowania argumentów Przykłady ze słowami kluczowymi i wartościami domyślnymi Słowa kluczowe Wartości domyślne Przykład dowolnych argumentów Zbieranie argumentów Rozpakowywanie argumentów Łączenie słów kluczowych i wartości domyślnych Przykład z funkcją obliczającą minimum Pełne rozwiązanie Dodatkowy bonus Puenta Bardziej przydatny przykład — uniwersalne funkcje działające na zbiorach Dopasowywanie argumentów — szczegóły Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 367 368 369 370 371 372 373 373 374 374 375 376 376 376 378 378 379 380 381 382 382 383 Zastosowanie funkcji do argumentów Wbudowana funkcja apply Przekazywanie argumentów ze słowami kluczowymi Składnia wywołania podobna do stosowania funkcji apply Funkcje anonimowe — lambda Wyrażenia lambda Po co używa się wyrażenia lambda? Jak łatwo zaciemnić kod napisany w Pythonie Zagnieżdżone wyrażenia lambda a zakresy 17. Zaawansowane zagadnienia związane z funkcjami ...............................................385 385 385 387 388 389 390 391 391 392 392 394 395 395 396 398 399 Odwzorowywanie funkcji na sekwencje — map Narzędzia programowania funkcyjnego — filter i reduce Jeszcze raz listy składane — odwzorowania Podstawy list składanych Dodawanie testów i zagnieżdżonych pętli Listy składane i macierze Zrozumienie list składanych 16 | Spis treści Jeszcze o iteratorach — generatory Przykład funkcji generatora Rozszerzony protokół generatora funkcji — metoda send a next Iteratory a typy wbudowane Wyrażenia generatora — iteratory spotykają listy składane Pomiar alternatywnych sposobów iteracji Koncepcje związane z projektowaniem funkcji Funkcje są obiektami — wywołania pośrednie Pułapki związane z funkcjami Zmienne lokalne wykrywane są w sposób statyczny Wartości domyślne i obiekty zmienne Funkcje bez instrukcji return Zmienne pętli zakresu zawierającego Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Łamigłówka Ćwiczenia do części czwartej 401 402 403 404 404 406 408 410 410 411 412 413 414 414 415 415 415 417 417 V Moduły ..................................................................................................421 Jak działa importowanie 1. Odnalezienie modułu Po co używa się modułów? Architektura programu w Pythonie Struktura programu Importowanie i atrybuty Moduły biblioteki standardowej 18. Moduły — wprowadzenie ........................................................................................423 423 424 424 425 427 427 428 428 430 430 431 432 432 433 435 435 435 Ścieżka wyszukiwania modułów Lista sys.path Wybór pliku modułu Zaawansowane koncepcje związane z wyborem modułów 2. (Ewentualne) Kompilowanie 3. Wykonanie Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Spis treści | 17 Tworzenie modułów Użycie modułów Instrukcja import Instrukcja from Instrukcja from * Operacja importowania odbywa się tylko raz Instrukcje import oraz from są przypisaniami Modyfikacja zmiennych pomiędzy plikami Równoważność instrukcji import oraz from Potencjalne pułapki związane z użyciem instrukcji from 19. Podstawy tworzenia modułów .................................................................................437 437 438 438 439 439 439 440 441 441 442 443 443 443 445 446 447 448 449 450 451 452 452 452 Pliki generują przestrzenie nazw Kwalifikowanie nazw atrybutów Importowanie a zakresy Zagnieżdżanie przestrzeni nazw Podstawy przeładowywania modułów Przykład przeładowywania z użyciem reload Podsumowanie rozdziału Łamigłówka Kiedy wymagane jest stosowanie instrukcji import Przestrzenie nazw modułów Przeładowywanie modułów Quiz Odpowiedzi Przykład importowania pakietu Podstawy importowania pakietów Pakiety a ustawienia ścieżki wyszukiwania Pliki pakietów __init__.py 20. Pakiety modułów .......................................................................................................453 453 454 454 456 457 458 458 461 462 462 462 Podsumowanie rozdziału Łamigłówka Instrukcja from a instrukcja import w importowaniu pakietów Do czego służy importowanie pakietów? Quiz Odpowiedzi Historia trzech systemów 18 | Spis treści Do czego służy importowanie względne? Projektowanie modułów Moduły są obiektami — metaprogramy Pułapki związane z modułami Ukrywanie danych w modułach Minimalizacja niebezpieczeństw użycia from * — _X oraz __all__ Modyfikacja ścieżki wyszukiwania modułów Rozszerzenie import as Składnia importowania względnego Włączanie opcji z przyszłych wersji Pythona Mieszane tryby użycia — __name__ oraz __main__ Testy jednostkowe z wykorzystaniem __name__ 21. Zaawansowane zagadnienia związane z modułami ..............................................463 463 464 464 465 466 467 468 468 469 471 472 474 474 475 476 476 477 478 478 480 481 482 482 482 483 483 W kodzie najwyższego poziomu kolejność instrukcji ma znaczenie Importowanie modułów za pomocą łańcucha znaków nazwy Instrukcja from kopiuje nazwy, jednak łącza już nie Instrukcja from * może zaciemnić znaczenie zmiennych Funkcja reload może nie mieć wpływu na obiekty importowane za pomocą from Funkcja reload i instrukcja from a testowanie interaktywne Instrukcja reload nie jest stosowana rekurencyjnie Rekurencyjne importowanie za pomocą from może nie działać Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Łamigłówka Ćwiczenia do części piątej VI Klasy i programowanie zorientowane obiektowo ............................485 Po co używa się klas? Programowanie zorientowane obiektowo z dystansu 22. Programowanie zorientowane obiektowo ..............................................................487 488 489 489 492 492 493 Wyszukiwanie dziedziczenia atrybutów Klasy a instancje Wywołania metod klasy Tworzenie drzew klas Programowanie zorientowane obiektowo oparte jest na ponownym wykorzystaniu kodu 495 Spis treści | 19 Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 498 499 499 499 Klasy generują większą liczbę obiektów instancji Klasy dostosowuje się do własnych potrzeb przez dziedziczenie Drugi przykład Klasy są atrybutami w modułach Obiekty klas udostępniają zachowania domyślne Obiekty instancji są rzeczywistymi elementami Pierwszy przykład 23. Podstawy tworzenia klas .......................................................................................... 501 501 502 502 503 505 506 507 508 509 511 512 514 515 515 515 Najprostsza klasa Pythona na świecie Podsumowanie rozdziału Łamigłówka Trzeci przykład Po co przeciąża się operatory? Klasy mogą przechwytywać operatory Pythona Quiz Odpowiedzi Metody Instrukcja class Ogólna forma Przykład Przykład Wywoływanie konstruktorów klas nadrzędnych Inne możliwości wywoływania metod 24. Szczegóły kodu klas ....................................................................................................517 517 517 518 520 521 521 522 522 523 524 524 526 527 527 528 529 Często spotykane metody przeciążania operatorów Metoda __getitem__ przechwytuje referencje do indeksów Metody __getitem__ oraz __iter__ implementują iterację Tworzenie drzewa atrybutów Specjalizacja odziedziczonych metod Techniki interfejsów klas Abstrakcyjne klasy nadrzędne Przeciążanie operatorów Dziedziczenie 20 | Spis treści Iteratory zdefiniowane przez użytkownika Wiele iteracji po jednym obiekcie Metody __getattr__ oraz __setattr__ przechwytują referencje do atrybutów Emulowanie prywatności w atrybutach instancji Metody __repr__ oraz __str__ zwracają reprezentacje łańcuchów znaków Metoda __radd__ obsługuje dodawanie prawostronne Metoda __call__ przechwytuje wywołania Interfejsy funkcji i kod oparty na wywołaniach zwrotnych Metoda __del__ jest destruktorem Przestrzenie nazw — cała historia Pojedyncze nazwy — globalne, o ile nie przypisane Nazwy atrybutów — przestrzenie nazw obiektów Zen przestrzeni nazw Pythona — przypisania klasyfikują zmienne Słowniki przestrzeni nazw Łącza przestrzeni nazw Bardziej realistyczny przykład Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 530 532 534 535 536 537 538 538 540 541 541 541 542 544 546 547 550 551 551 551 Raz jeszcze procesor strumienia danych Programowanie zorientowane obiektowo a delegacja Dziedziczenie wielokrotne Klasy są obiektami — uniwersalne fabryki obiektów Do czego służą fabryki? Python a programowanie zorientowane obiektowo Przeciążanie za pomocą sygnatur wywołań (lub nie) Klasy jako rekordy Programowanie zorientowane obiektowo i dziedziczenie — związek „jest” Programowanie zorientowane obiektowo i kompozycja — związki „ma” 25. Projektowanie z udziałem klas .................................................................................553 553 554 554 556 558 559 562 563 566 567 568 570 571 572 573 573 573 Metody są obiektami — z wiązaniem i bez wiązania Raz jeszcze o łańcuchach znaków dokumentacji Klasy a moduły Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Spis treści | 21 Rozszerzanie typów wbudowanych Pseudoprywatne atrybuty klas Klasy w nowym stylu Inne rozszerzenia klas w nowym stylu Przegląd zniekształcania nazw zmiennych Po co używa się atrybutów pseudoprywatnych? Rozszerzanie typów za pomocą osadzania Rozszerzanie typów za pomocą klas podrzędnych Modyfikacja wielokrotnego dziedziczenia po jednej klasie Przykład wielokrotnego dziedziczenia po jednej klasie Jawne rozwiązywanie konfliktów Metody statyczne oraz metody klasy Miejsca na atrybuty instancji Właściwości klas Nowa metoda przeciążania __getattribute__ 26. Zaawansowane zagadnienia związane z klasami ..................................................575 575 576 576 579 579 580 581 582 583 583 585 585 585 586 588 588 590 592 593 594 594 595 596 598 598 599 599 599 600 600 Modyfikacja atrybutów klas może mieć efekty uboczne Dziedziczenie wielokrotne — kolejność ma znaczenie Metody, klasy oraz zakresy zagnieżdżone Przesadne opakowywanie Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Łamigłówka Dekoratory funkcji Przykład dekoratora Pułapki związane z klasami Metody statyczne oraz metody klasy Wykorzystywanie metod statycznych oraz metod klasy Ćwiczenia do części szóstej VII Wyjątki oraz narzędzia ....................................................................... 607 Role wyjątków Po co używa się wyjątków? 27. Podstawy wyjątków ..................................................................................................609 610 610 611 615 616 618 Obsługa wyjątków w skrócie Instrukcja try/except/else Części instrukcji try Część try/else 22 | Spis treści Przykład — zachowanie domyślne Przykład — przechwytywanie wbudowanych wyjątków Instrukcja try/finally Przykład — działania kończące kod z użyciem try/finally Połączona instrukcja try/except/finally Łączenie finally oraz except za pomocą zagnieżdżania Przykład połączonego try Instrukcja raise Przykład — zgłaszanie i przechwytywanie wyjątków zdefiniowanych przez użytkownika Przykład — przekazywanie dodatkowych danych w raise Przykład — przekazywanie wyjątków za pomocą raise Instrukcja assert Przykład — wyłapywanie ograniczeń (ale nie błędów) Menedżery kontekstu with/as Podstawowe zastosowanie Protokół zarządzania kontekstem Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi 619 620 620 621 622 623 624 625 626 626 627 628 628 629 629 632 633 634 634 634 Wyjątki oparte na łańcuchach znaków Wyjątki oparte na łańcuchach znaków znikają Wyjątki oparte na klasach Przykład wyjątku opartego na klasach Po co istnieją wyjątki oparte na klasach? Wbudowane klasy wyjątków Określanie tekstu wyjątku Przesyłanie danych oraz zachowania w instancjach 28. Obiekty wyjątków .....................................................................................................635 636 636 637 637 639 641 643 644 644 646 647 648 648 648 Ogólne formy instrukcji raise Podsumowanie rozdziału Łamigłówka Przykład — dodatkowe dane w klasach i łańcuchach znaków Quiz Odpowiedzi Spis treści | 23 Wskazówki dotyczące projektowania wyjątków Zagnieżdżanie programów obsługi wyjątków Przykład — zagnieżdżanie przebiegu sterowania Przykład — zagnieżdżanie składniowe Zastosowanie wyjątków Co powinniśmy opakować w try Jak nie przechwytywać zbyt wiele — unikanie pustych except Jak nie przechwytywać zbyt mało — korzystanie z kategorii opartych na klasach Wyjątki nie zawsze są błędami Funkcje sygnalizują warunki za pomocą raise Debugowanie z wykorzystaniem zewnętrznych instrukcji try Testowanie kodu wewnątrz tego samego procesu Więcej informacji na temat funkcji sys.exc_info 29. Projektowanie z wykorzystaniem klas .....................................................................649 649 651 651 653 653 653 654 655 656 656 656 657 659 659 659 661 661 661 663 666 667 667 667 668 668 Zbiór narzędzi Pythona Narzędzia programistyczne przeznaczone do większych projektów Wyjątki znaków dopasowywane są po tożsamości, a nie wartości Przechwytywanie niewłaściwej rzeczy Podsumowanie rozdziału Łamigłówka Quiz Odpowiedzi Łamigłówka Ćwiczenia do części siódmej Pułapki związane z wyjątkami Podsumowanie jądra języka Python Dodatki ................................................................................................. 669 A Instalacja i konfiguracja ............................................................................................ 671 B Rozwiązania ćwiczeń podsumowujących poszczególne części książki .................679 Skorowidz ..............................................................................................................................711 24 | Spis treści ROZDZIAŁ 10. Wprowadzenie do instrukcji Pythona Ponieważ znamy już podstawowe wbudowane typy obiektów Pythona, niniejszy rozdział rozpoczniemy od omówienia podstawowych form instrukcji tego języka. Tak jak w poprzed- niej części, zaczniemy od ogólnego wprowadzenia do składni instrukcji. W kolejnych roz- działach znajdą się bardziej szczegółowe informacje dotyczące poszczególnych instrukcji. Mówiąc ogólnie, instrukcje (ang. statement) to coś, co piszemy w celu przekazania Pythonowi tego, co mają robić nasze programy. Jeśli program „coś robi”, to instrukcje pozwalają określić, co to konkretnie jest. Python jest językiem proceduralnym, opartym na instrukcjach. Łącząc instrukcje, określamy procedurę wykonywaną przez Pythona w celu spełnienia celów pro- gramu. Raz jeszcze o strukturze programu Pythona Innym sposobem zrozumienia roli instrukcji jest powrócenie do hierarchii wprowadzonej w rozdziale 4., który omawiał obiekty wbudowane wraz z wyrażeniami służącymi do ich przetwarzania. Niniejszy rozdział stanowi przejście o jeden poziom w górę hierarchii. 1. Programy składają się z modułów. 2. Moduły zawierają instrukcje. 3. Instrukcje zawierają wyrażenia. 4. Wyrażenia tworzą i przetwarzają obiekty. Składnia Pythona składa się z instrukcji i wyrażeń. Wyrażenia przetwarzają obiekty i są osa- dzone w instrukcjach. Instrukcje kodują większą logikę operacji programu — wykorzystują i kierują wyrażenia do przetwarzania obiektów omawianych w poprzednich rozdziałach. Ponadto to właśnie w instrukcjach obiekty zaczynają istnieć (na przykład w wyrażeniach wewnątrz instrukcji przypisania), a niektóre instrukcje tworzą zupełnie nowe rodzaje obiek- tów (na przykład funkcje i klasy). Instrukcje zawsze istnieją w modułach, które z kolei same są zarządzane za pomocą instrukcji. Raz jeszcze o strukturze programu Pythona | 245 Instrukcje Pythona W tabeli 10.1 zaprezentowano zbiór instrukcji Pythona1. Niniejsza część książki omawia wpi- sy z tabeli od góry aż do break i continue. Niektóre z instrukcji z tej tabeli zostały już nie- formalnie wprowadzone wcześniej. W tej części książki uzupełnimy pominięte szczegóły, wprowadzimy pozostałą część zbioru instrukcji proceduralnych Pythona i omówimy ogólny model składni. Instrukcje z dolnej części tabeli 10.1, dotyczące większych części programów — funkcji, klas, modułów oraz wyjątków — prowadzą do zadań programistycznych, dlatego zasługują na poświęcenie im osobnych części. Instrukcje bardziej egzotyczne, jak exec (kom- pilująca i wykonująca kod skonstruowany w postaci łańcuchów znaków), omówione są w dal- szej części książki lub w dokumentacji biblioteki standardowej Pythona. Historia dwóch if Zanim zagłębimy się w szczegóły którejś z instrukcji z tabeli 10.1, chciałbym zacząć nasze omawianie składni instrukcji od pokazania, czego nie będziemy wpisywać do kodu Pythona, tak by można było dokonać porównania tego języka z innymi modelami składni, z jakimi można się spotkać. Rozważmy poniższą instrukcję if zakodowaną w języku podobnym do C. if (x y) { x = 1; y = 2; } Może to być instrukcja w języku C, C++, Java, JavaScript lub Perl. Teraz przyjrzyjmy się odpowiadającej jej instrukcji z Pythona. if x y: x = 1 y = 2 Pierwszą rzeczą, jaką łatwo zauważyć, jest to, że instrukcja napisana w Pythonie jest mniej, nazwijmy to, zaśmiecona — to znaczy jest w niej mniej elementów składniowych. Jest to ce- lowe — Python jest językiem skryptowym, zatem jednym z jego celów jest ułatwienie życia programistom poprzez pisanie mniejszej ilości kodu. Co więcej, kiedy porównamy oba modele składni, okaże się, że Python dodaje jeden dodat- kowy element, a trzy elementy obecne w językach podobnych do C w Pythonie są nieobecne. 1 Z technicznego punktu widzenia w Pythonie 2.5 yield z instrukcji stało się wyrażeniem, a instrukcje try/except i try/finally zostały połączone (obie były kiedyś osobnymi instrukcjami, ale teraz możemy już użyć except i finally w jednej instrukcji try). W Pythonie 2.6 ma zostać dodana nowa instrukcja wi- th/as służąca do kodowania menedżerów kontekstu. Mówiąc ogólnie, jest to alternatywa dla operacji try/finally powiązanych z wyjątkami (w wersji 2.5 with/as jest rozszerzeniem dodatkowym i nie jest dostępne, jeśli nie włączymy go w jawny sposób, wykonując instrukcję from __future__ import with_statement). Więcej informacji na ten temat można znaleźć w dokumentacji Pythona. W przyszłości, w Pythonie 3.0, print i exec staną się wywołaniami funkcji, a nie instrukcjami, a nowa instrukcja nonlocal będzie spełniała rolę podobną do dzisiejszego global. 246 | Rozdział 10. Wprowadzenie do instrukcji Pythona Tabela 10.1. Instrukcje Pythona Instrukcja Przypisanie Wywołania print if/elif/else Rola Tworzenie referencji Wykonywanie funkcji Wyświetlanie obiektów Wybór działania for/else Iteracja po sekwencjach while/else Ogólne pętle pass Pusty pojemnik break, continue Przeskoki w pętli try/except/finally Przechwytywanie wyjątków raise import, from Wywoływanie wyjątków Dostęp do modułów def, return, yield Budowanie funkcji class global del exec assert with/as Budowanie obiektów Przestrzenie nazw Usuwanie referencji Wykonywanie łańcuchów znaków kodu Sprawdzanie w debugowaniu Menedżery kontekstu (Python 2.6) Przykład a, b, c = dobry , zły , paskudny log.write( mielonka, szynka\n ) print The Killer , joke if python in text: print text for x in mylist: print x while X Y: print witaj while True: pass while True: if not line: break try: action( ) except: print Błąd w akcji raise endSearch, location import sys from sys import stdin def f(a, b, c=1, *d): return a+b+c+d[0] def gen(n): for i in n, yield i*2 class subclass(Superclass): staticData = [] def function( ): global x, y x = nowy del dane[k] del dane[i:j] del obiekt.atrybut del zmienna exec import + modName exec code in gdict, ldict assert X Y with open( data ) as myfile: process(myfile) Historia dwóch if | 247 Co dodaje Python Tym jednym dodatkowym elementem składniowym jest w Pythonie znak dwukropka (:). Wszystkie instrukcje złożone w Pythonie (czyli instrukcje z zagnieżdżonymi kolejnymi instruk- cjami) pisze się zgodnie z jednym wzorcem — z nagłówkiem zakończonym dwukropkiem, po którym następuje zagnieżdżony blok kodu wcięty w stosunku do wiersza nagłówka. Wiersz nagłówka: Zagnieżdżony blok instrukcji Dwukropek jest wymagany i pominięcie go jest chyba najczęściej popełnianym przez począt- kujących programistów Pythona błędem — na swoich szkoleniach i kursach widziałem go tysiące razy. Każda osoba zaczynająca swoją przygodę z Pythonem szybko zapomina o zna- ku dwukropka. Większość edytorów do Pythona sprawia, że błąd ten jest łatwo zauważyć, a wpisywanie dwukropka w końcu staje się nieświadomym nawykiem (do tego stopnia, że można odruchowo zacząć wpisywać dwukropki do kodu napisanego w języku C++, gene- rując tym samym wiele zabawnych komunikatów o błędach ze strony kompilatora C++). Co usuwa Python Choć Python wymaga dodatkowego znaku dwukropka, istnieją trzy elementy, które muszą uwzględnić programiści języków podobnych do C, a których nie ma w Pythonie. Nawiasy są opcjonalne Pierwszym z nich są nawiasy wokół testów znajdujących się na górze instrukcji. if (x y) Nawiasy wymagane są przez składnię wielu języków podobnych do C. W Pythonie tak nie jest — nawiasy możemy pominąć, a instrukcja nadal będzie działać. if x y Z technicznego punktu widzenia, ponieważ każde wyrażenie można umieścić w nawiasach, wstawienie ich tutaj nie zaszkodzi i nie będą one potraktowane jako błąd. Nie należy tego jed- nak robić — to niepotrzebne nadużycie klawiatury, które na dodatek zdradza całemu światu, że jesteśmy byłymi programistami języka C, którzy nadal uczą się Pythona (sam takim kiedyś byłem). Sposób stosowany w Pythonie polega na całkowitym pomijaniu nawiasów w tego rodzaju instrukcjach. Koniec wiersza jest końcem instrukcji Drugim, bardziej znaczącym elementem składni, którego nie znajdziemy w Pythonie, jest znak średnika (;). W Pythonie nie trzeba kończyć instrukcji za pomocą średników, tak jak robi się to w językach podobnych do C. x = 1; W Pythonie istnieje ogólna reguła mówiąca, że koniec wiersza jest automatycznie końcem in- strukcji znajdującej się w tym wierszu. Innymi słowy, można opuścić średniki, a instrukcja będzie działała tak samo. x = 1 248 | Rozdział 10. Wprowadzenie do instrukcji Pythona Istnieje kilka obejść tej reguły, o czym przekonamy się za chwilę. Generalnie jednak w więk- szości kodu w Pythonie pisze się jedną instrukcję w wierszu i średniki nie są wymagane. Również tutaj osoby tęskniące za programowaniem w języku C (o ile to w ogóle możliwe…) mogą kontynuować używanie średników na końcu każdej instrukcji — sam język nam na to pozwala. Jednak ponownie nie należy tego robić (naprawdę!) — kolejny raz zdradza to, że nadal jesteśmy programistami języka C, którzy jeszcze nie przestawili się na kodowanie w Pythonie. Styl stosowany w Pythonie polega na całkowitym opuszczaniu średników. Koniec wcięcia to koniec bloku Trzecim i ostatnim komponentem składniowym nieobecnym w Pythonie, i chyba najbardziej niezwykłym dla byłych programistów języka C (dopóki nie poużywają go przez dziesięć minut i nie ucieszą się z jego braku), jest to, że w kodzie nie wpisuje się niczego, co jawnie oznaczałoby początek i koniec zagnieżdżonego bloku kodu. Nie musimy uwzględniać begin/end, then/endif czy umieszczać wokół kodu nawiasów klamrowych, tak jak robi się to w językach podobnych do C. if (x y) { x = 1; y = 2; } Zamiast tego w Pythonie w spójny sposób wcina się wszystkie instrukcje w danym bloku zagnieżdżonym o tę samą odległość w prawo. Python wykorzystuje fizyczne podobieństwo instrukcji do ustalenia, gdzie blok się zaczyna i gdzie się kończy. if x y: x = 1 y = 2 Przez indentację rozumiemy puste białe znaki znajdujące się po lewej stronie obu zagnież- dżonych instrukcji. Pythona nie interesuje sposób indentacji (można korzystać ze spacji lub tabulatorów) ani też jej ilość (można użyć dowolnej liczby spacji lub tabulatorów). Wcięcie jednego bloku zagnieżdżonego może tak naprawdę być zupełnie inne od wcięcia innego bloku. Reguła składni mówi jedynie, że w jednym bloku zagnieżdżonym wszystkie instrukcje muszą być zagnieżdżone na tę samą odległość w prawo. Jeśli tak nie jest, otrzymamy błąd składni i kod nie zostanie wykonany, dopóki nie naprawimy indentacji w spójny sposób. Skąd bierze się składnia indentacji? Reguła indentacji może programistom języków podobnych do C na pierwszy rzut oka wydać się niezwykła, jednak jest ona celową cechą Pythona oraz jednym ze sposobów, w jaki Python wymusza na programistach tworzenie jednolitego, regularnego i czytelnego kodu. Oznacza to, że kod musi być wyrównany w pionie, w kolumnach, zgodnie ze swoją strukturą logiczną. Rezultat jest taki, że kod staje się bardziej spójny i czytelny (w przeciwieństwie do kodu napisanego w językach podobnych do C). Mówiąc inaczej, wyrównanie kodu zgodnie z jego strukturą logiczną jest podstawowym na- rzędziem uczynienia go czytelnym i tym samym łatwym w ponownym użyciu oraz później- szym utrzymywaniu — zarówno przez nas samych, jak i przez inne osoby. Nawet osoby, Historia dwóch if | 249 które po skończeniu lektury niniejszej książki nigdy nie będą używać Pythona, powinny nabrać nawyku wyrównywania kodu w celu zwiększenia jego czytelności w dowolnym języku o strukturze blokowej. Python wymusza to, gdyż jest to częścią jego składni, jednak ma to znaczenie w każdym języku programowania i ogromny wpływ na użyteczność na- szego kodu. Doświadczenia każdej osoby mogą być różne, jednak kiedy ja byłem pełnoetatowym pro- gramistą, byłem zatrudniony przede wszystkim przy pracy z dużymi, starymi programami w języku C++, tworzonymi przez długie lata przez wiele różnych osób. Co było nie do unik- nięcia, prawie każdy programista miał swój własny styl indentacji kodu. Często proszono mnie na przykład o zmianę pętli while zakodowanej w języku C, która rozpoczynała się w na- stępujący sposób: while (x 0) { Zanim jeszcze przejdziemy do samej indentacji, powiem, że istnieją trzy czy cztery sposoby układania nawiasów klamrowych w językach podobnych do C. Wiele organizacji prowadzi niemal polityczne debaty i tworzy podręczniki opisujące standardy, które powinny sobie z tym radzić (co wydaje się nieco przesadne, zważając na to, że trudno uznać to za problem programistyczny). Ignorując te spory, przejdźmy do scenariusza, z jakim często spotykałem się w kodzie napisanym w języku C++. Pierwsza osoba pracująca nad tym kodem wcinała pętlę o cztery spacje. while (x 0) { --------; --------; Ta osoba w końcu awansowała, zajęła się zarządzaniem, a jej miejsce zajął ktoś, kto wolał wcięcia jeszcze bardziej przesunięte w prawo. while (x 0) { --------; --------; --------; --------; I ta osoba w pewnym momencie zmieniła pracę, a jej zadania przejął ktoś, kto wolał mniejsze wcięcia. while (x 0) { --------; --------; --------; --------; --------; --------; } I tak w nieskończoność. Blok ten kończy się nawiasem klamrowym (}), co oczywiście spra- wia, że jest on kodem ustrukturyzowanym blokowo (przynajmniej teoretycznie). W każdym języku ustrukturyzowanym blokowo (w Pythonie i innych), jeśli zagnieżdżone bloki nie są wcięte w spójny sposób, stają się trudne do interpretacji, modyfikacji czy ponownego użycia. Czytelność ma duże znaczenie i indentacja jest jej istotnym komponentem. 250 | Rozdział 10. Wprowadzenie do instrukcji Pythona Poniżej znajduje się kolejny przykład, który mógł nas zaboleć w przeszłości, jeśli programo- waliśmy kiedyś w języku podobnym do C. Rozważmy poniższą instrukcję języka C: if (x) if (y) instrukcja1; else instrukcja2; Z którym if powiązane jest else? Co może być zaskoczeniem, else jest dopełnieniem za- gnieżdżonej instrukcji if (y), choć wizualnie wydaje się przynależeć do zewnętrznej in- strukcji if (x). To klasyczna pułapka języka C, która może prowadzić do całkowicie niepo- prawnej interpretacji kodu przez czytelnika i jego modyfikacji w niepoprawny sposób, co może nie zostać wykryte do momentu, gdy marsjański łazik rozbije się na wielkiej skale! Takie coś nie może się jednak zdarzyć w Pythonie. Ponieważ indentacja jest znacząca, to, jak wy- gląda kod, przedstawia to, jak działa. Rozważmy odpowiednik powyższego kodu w Pythonie: if x: if y: instrukcja1 else: instrukcja2 W tym przykładzie if, z którym else wyrównane jest w pionie, to if, z którym else jest powiązane logicznie (jest to zewnętrzne if x). W pewnym sensie Python jest językiem typu WYSIWYG — to, co widzimy, jest tym, co otrzymujemy, ponieważ kod wykonywany jest tak, jak wygląda, bez względu na jego autora. Jeśli te argumenty nie były w stanie przekonać kogoś o wyższości składni Pythona, podam jeszcze jedną anegdotę. Na początku mojej kariery zawodowej pracowałem w firmie rozwi- jającej oprogramowanie w języku C, w którym spójna indentacja nie jest wymagana. Mimo to, kiedy pod koniec dnia przesyłaliśmy kod do systemu kontroli wersji, wykorzystywano zautomatyzowany skrypt analizujący indentację w kodzie. Jeśli skrypt zauważył, że nie wci- namy kodu w sposób spójny, następnego dnia czekał na nas e-mail w tej sprawie, który trafiał również do naszych szefów. Dlaczego o tym piszę? Nawet jeśli język programowania tego nie wymaga, dobrzy programiści wiedzą, że spójna indentacja kodu ma ogromny wpływ na jego czytelność i jakość. To, że Python przenosi tę kwestię na poziom składni, przez większość osób uznawane jest za wielką zaletę. Wreszcie należy pamiętać, że prawie każdy używany obecnie edytor tekstu dla programi- stów ma wbudowaną obsługę modelu składni Pythona. W IDLE wiersze kodu są wcinane automatycznie, kiedy piszemy blok zagnieżdżony. Naciśnięcie przycisku Backspace powraca o jeden poziom wcięcia i można również ustawić, jak daleko do prawej strony IDLE wcina instrukcje zagnieżdżonego bloku. Nie ma bezwzględnego standardu określającego sposób wcinania kodu. Często stosuje się cztery spacje lub jeden tabulator na poziom, jednak to każdy z nas decyduje, w jaki sposób i na jaką odległość wcinać kod. Dla bloków bardziej zagnieżdżonych odległość ta może być większa, dla bloków bliższych zewnętrznemu — mniejsza. Co więcej, wstawianie tabulatorów zamiast nawiasów klamrowych nie jest w praktyce trudniejsze dla narzędzi zwracających kod w Pythonie. Generalnie wystarczy robić to samo co w językach podobnych do C — należy się tylko po- zbyć nawiasów klamrowych, a kod będzie spełniał reguły składni Pythona. Historia dwóch if | 251 Kilka przypadków specjalnych Jak wspomniano wcześniej, w modelu składni Pythona: • koniec wiersza kończy instrukcję znajdującą się w tym wierszu (bez konieczności użycia średników), • instrukcje zagnieżdżone są łączone w bloki i wiązane ze sobą za pomocą fizycznego wcięcia (bez konieczności użycia nawiasów klamrowych). Te reguły decydują o prawie całym kodzie napisanym w Pythonie, z jakim można się spotkać w praktyce. Python udostępnia również kilka reguł specjalnego przeznaczenia, które po- zwalają na dostosowanie instrukcji i zagnieżdżonych bloków instrukcji do własnych potrzeb. Przypadki specjalne dla reguły o końcu wiersza Choć instrukcje normalnie pojawiają się po jednej na wiersz, można również umieścić w wierszu kodu Pythona więcej niż jedną instrukcję, rozdzielając je od siebie średnikami. a = 1; b = 2; print a + b # Trzy instrukcje w wierszu To jedyne miejsce, w którym w Pythonie wymagane są średniki — jako separatory instrukcji. Działa to jednak tylko wtedy, gdy połączone w ten sposób instrukcje nie są instrukcjami zło- żonymi. Innymi słowy, można połączyć ze sobą jedynie proste instrukcje, takie jak przypi- sania, wyświetlanie za pomocą print czy wywołania funkcji. Instrukcje złożone nadal muszą pojawiać się w osobnych wierszach (w przeciwnym razie w jednym wierszu można by było umieścić cały program, co nie przysporzyłoby nam popularności wśród współ- pracowników). Druga reguła specjalna dla instrukcji jest odwrotna: jedna instrukcja może rozciągać się na kilka wierszy. By to zadziałało, wystarczy umieścić część instrukcji w parze nawiasów — zwykłych (()), kwadratowych ([]) lub klamrowych ({}). Kod umieszczony w tych konstruk- cjach może znajdować się w kilku wierszach. Instrukcja nie kończy się, dopóki Python nie dojdzie do wiersza zawierającego zamykającą część nawiasu. Przykładem może być rozcią- gający się na kilka wierszy literał listy. mlist = [111, 222, 333] Ponieważ kod umieszczony jest w parze nawiasów kwadratowych, Python po prostu prze- chodzi do kolejnego wiersza aż do momentu napotkania nawiasu zamykającego. W ten sposób na kilka wierszy mogą się rozciągać również słowniki, a zwykłe nawiasy mogą mieścić krotki, wywołania funkcji i wyrażenia. Indentacja wiersza z kontynuacją nie ma znaczenia, choć zdrowy rozsądek nakazuje jakoś wyrównać ze sobą kolejne wiersze dla celów czytelności. Nawiasy są wszechstronnym narzędziem. Ponieważ można w nich umieścić dowolne wyra- żenie, samo wstawienie lewego nawiasu pozwala na przejście do kolejnego wiersza i konty- nuowanie instrukcji tam. X = (A + B + C + D) 252 | Rozdział 10. Wprowadzenie do instrukcji Pythona Ta technika działa zresztą również w przypadku instrukcji złożonych. Kiedy tylko potrzebu- jemy zakodować duże wyrażenie, wystarczy opakować je w nawiasy, by móc je kontynu- ować w kolejnym wierszu. if (A == 1 and B == 2 and C == 3): print mielonka * 3 Starsza reguła pozwala również na kontynuację w następnym wierszu, kiedy poprzedni koń- czy się ukośnikiem lewym. X = A + B + \ C + D Ta technika alternatywna jest przestarzała i raczej już nielubiana, ponieważ trudno jest za- uważyć i utrzymywać ukośniki lewe, a do tego dość bezwzględna (po ukośniku nie może być spacji). Jest to również kolejny powrót do języka C, gdzie jest ona często wykorzystywa- na w makrach „#define”. W świecie Pythona należy zachowywać się jak programista Pythona, a nie języka C. Przypadki specjalne dla reguły o indentacji bloków Jak wspomniano wcześniej, instrukcje w zagnieżdżonym bloku kodu są zazwyczaj wiązane ze sobą dzięki wcinaniu na tę samą odległość w prawą stronę. W specjalnym przypadku ciało instrukcji złożonej może pojawić się w tym samym wierszu co jej nagłówek, po znaku dwukropka. if x y: print x Pozwala to na kodowanie jednowierszowych instrukcji if czy pętli. Tutaj jednak zadziała to tylko wtedy, gdy ciało instrukcji złożonej nie zawiera żadnych instrukcji złożonych. Mogą się tam znajdować jedynie proste instrukcje — przypisania, instrukcje print, wywołania funkcji i tym podobne. Większe instrukcje nadal muszą być umieszczane w osobnych wierszach. Dodatkowe części instrukcji złożonych (na przykład część else z if, z którą spotkamy się później) również muszą znajdować się w osobnych wierszach. Ciało instrukcji może składać się z kilku prostych instrukcji rozdzielonych średnikami, jednak zazwyczaj nie jest to pochwalane. Ogólnie rzecz biorąc, nawet jeśli nie zawsze jest to wymagane, jeśli będziemy umieszczać każdą instrukcję w osobnym wierszu i zawsze wcinać zagnieżdżone bloki, nasz kod będzie łatwiejszy do odczytania i późniejszej modyfikacji. By zobaczyć najważniejszy i najczęściej spotykany wyjątek od jednej z tych reguł (użycie jednowierszowej instrukcji if w celu wyjścia z pętli), przejdźmy do kolejnego podrozdziału i zajmijmy się pisaniem prawdziwego kodu. Szybki przykład — interaktywne pętle Wszystkie te reguły składni zobaczymy w działaniu, kiedy w kolejnych rozdziałach będzie- my omawiać określone instrukcje złożone Pythona. Działają one w ten sam sposób w całym języku. Na początek zajmiemy się krótkim, realistycznym przykładem demonstrującym sposób łączenia składni i zagnieżdżania instrukcji, a także wprowadzającym przy okazji kilka instrukcji. Szybki przykład — interaktywne pętle | 253 Prosta pętla interaktywna Przypuśćmy, że poproszono nas o napisanie w Pythonie programu wchodzącego w interak- cję z użytkownikiem w oknie konsoli. Być może będziemy przyjmować dane wejściowe w celu przesłania ich do bazy danych bądź odczytywać liczby wykorzystane w obliczeniach. Bez względu na cel potrzebna nam będzie pętla odczytująca dane wejściowe wpisywane przez użytkownika na klawiaturze i wyświetlająca dla nich wynik. Innymi słowy, musimy utwo- rzyć klasyczną pętlę odczytaj-oblicz-wyświetl. W Pythonie typowy kod takiej pętli interaktywnej może wyglądać jak poniższy przykład. while True: reply = raw_input( Wpisz tekst: ) if reply == stop : break print reply.upper( ) Kod ten wykorzystuje kilka nowych koncepcji. • W kodzie użyto pętli while — najbardziej ogólnej instrukcji pętli Pythona. Instrukcję while omówimy bardziej szczegółowo później. Mówiąc w skrócie, zaczyna się ona od słowa while, a po nim następuje wyrażenie, którego wynik interpretowany jest jako prawda lub fałsz. Później znajduje się zagnieżdżony blok kodu powtarzany, dopóki test znajdujący się na górze jest prawdą (słowo True z przykładu jest zawsze prawdą). • Wbudowana funkcja raw_input, z którą spotkaliśmy się już wcześniej, wykorzystana zo- stała tutaj do wygenerowania danych wejściowych z konsoli. Wyświetla ona w charakte- rze zachęty łańcuch znaków będący opcjonalnym argumentem i zwraca odpowiedź wpi- saną przez użytkownika w postaci łańcucha znaków. • W kodzie pojawia się również jednowierszowa instrukcja if wykorzystująca regułę spe- cjalną dotyczącą zagnieżdżonych bloków. Ciało instrukcji if pojawia się po dwukropku w jej nagłówku, zamiast znajdować się w kolejnym, wciętym wierszu. Oba alternatywne sposoby zadziałają, jednak dzięki metodzie zastosowanej powyżej zaoszczędziliśmy jeden wiersz. • Instrukcja break Pythona wykorzystywana jest do natychmiastowego wyjścia z pętli. Powoduje ona całkowite wyskoczenie z instrukcji pętli i program kontynuowany jest po pętli. Bez takiej instrukcji wyjścia pętla byłaby nieskończona, ponieważ wynik jej testu będzie zawsze prawdziwy. W rezultacie takie połączenie instrukcji oznacza: „Wczytuj wiersze wpisane przez użytkow- nika i wyświetl je zapisane wielkimi literami, dopóki nie wpisze on słowa stop”. Istnieją inne sposoby zakodowania takiej pętli, jednak metoda zastosowana powyżej jest w Pythonie często spotykana. Warto zauważyć, że wszystkie trzy wiersze zagnieżdżone pod wierszem nagłówka instrukcji while są wcinane na tę samą odległość. Ponieważ są one wyrównane w pionie jak jedna ko- lumna, są blokiem kodu powiązanego z testem while i powtarzanego. Blok ciała pętli zostaje zakończony albo przez koniec pliku źródłowego, albo przez umieszczenie mniej wciętej instrukcji. 254 | Rozdział 10. Wprowadzenie do instrukcji Pythona Po wykonaniu kodu możemy otrzymać interakcję podobną do poniższej. Wpisz tekst:mielonka MIELONKA Wpisz tekst:42 42 Wpisz tekst:stop Wykonywanie obliczeń na danych użytkownika Nasz skrypt działa, jednak teraz załóżmy, że zamiast zmiany tekstowego łańcucha znaków na zapisany wielkimi literami wolelibyśmy wykonać jakieś obliczenia na danych liczbowych — na przykład podnosząc je do kwadratu. By osiągnąć zamierzony efekt, możemy spróbo- wać z poniższymi instrukcjami. reply = 20 reply ** 2 ...pominięto tekst błędu... TypeError: unsupported operand type(s) for ** or pow( ): str and int Takie coś nie zadziała w naszym skrypcie, ponieważ Python nie przekształci typów obiektów w wyrażeniach, jeśli wszystkie one nie są typami liczbowymi — a tak nie jest, ponieważ dane wpisywane przez użytkownika są zawsze w skrypcie zwracane jako łańcuchy znaków. Nie możemy podnieść łańcucha cyfr do potęgi, dopóki ręcznie nie przekształcimy go na liczbę całkowitą. int(reply) ** 2 400 Mając takie informacje, możemy teraz poprawić naszą pętlę w taki sposób, by wykonywała ona niezbędne obliczenia. while True: reply = raw_input( Wpisz tekst: ) if reply == stop : break print int(reply) ** 2 print Koniec Ten skrypt wykorzystuje jednowierszową instrukcję if do wyjścia z pętli w momencie wpi- sania słowa „stop”, jednak przy okazji konwertuje również dane wejściowe na postać liczbo- wą w celu umożliwienia obliczeń. Wersja ta dodaje także komunikat końcowy umieszczony na dole. Ponieważ instrukcja print z ostatniego wiersza nie jest wcięta na tę samą odległość co zagnieżdżony blok kodu, nie jest ona uważana za część ciała pętli i zostanie wykonana tylko raz — po wyjściu z pętli. Wpisz tekst:2 4 Wpisz tekst:40 1600 Wpisz tekst:stop Koniec Szybki przykład — interaktywne pętle | 255 Obsługa błędów za pomocą sprawdzania danych wejściowych Jak na razie wszystko działa, ale co się stanie, kiedy dane wejściowe będą niepoprawne? Wpisz tekst:xxx ...pominięto tekst błędu... ValueError: invalid literal for int( ) with base 10: xxx Wbudowana funkcja int w momencie wystąpienia błędu zwraca tutaj wyjątek. Jeśli chcemy, by nasz skrypt miał większe możliwości, możemy z wyprzedzeniem sprawdzić zawartość łańcucha znaków za pomocą metody obiektu łańcucha znaków o nazwie isdigit. S = 123 T = xxx S.isdigit( ), T.isdigit( ) (True, False) Daje nam to również pretekst do dalszego zagnieżdżenia instrukcji w naszym przykładzie. Poniższa nowa wersja naszego interaktywnego skryptu wykorzystuje pełną instrukcję if do obejścia problemu wyjątków pojawiających się w momencie wystąpienia błędu. while True: reply = raw_input( Wpisz tekst: ) if reply == stop : break elif not reply.isdigit( ): print Niepoprawnie! * 5 else: print int(reply) ** 2 print Koniec Instrukcję if przestudiujemy szczegółowo w rozdziale 12. Jest ona dość łatwym narzędziem służącym do kodowania logiki w skryptach. W pełnej formie składa się ze słowa if, po któ- rym następuje test, powiązany blok kodu, jeden lub większa liczba opcjonalnych testów elif (od „else if”) i bloków kodu, a na dole opcjonalna część else z powiązanym blokiem kodu, który służy za wynik domyślny. Kiedy pierwszy test zwraca wynik będący prawdą, Python wykonuje blok kodu z nim powiązany — od góry do dołu. Jeśli wszystkie testy będą zwra- cały wyniki będące fałszem, wykonywany jest kod z części else. Części if, elif i else w powyższym przykładzie są powiązanymi częściami tej samej in- strukcji, ponieważ wszystkie są ze sobą wyrównane w pionie (to znaczy mają ten sam po- ziom wcięcia). Instrukcja if rozciąga się od słowa if do początku instrukcji print w ostat- nim wierszu skryptu. Z kolei cały blok if jest częścią pętli while, ponieważ w całości wcięty jest pod wierszem nagłówka tej pętli. Zagnieżdżanie instrukcji z czasem stanie się dla każde- go naturalne. Kiedy wykonamy nasz nowy skrypt, jego kod przechwyci błąd przed jego wystąpieniem i wyświetli (dość głupi) komunikat w celu podkreślenia tego. Wpisz tekst:5 25 Wpisz tekst:xyz Niepoprawnie!Niepoprawnie!Niepoprawnie!Niepoprawnie!Niepoprawnie! Wpisz tekst:10 100 Wpisz tekst:stop 256 | Rozdział 10. Wprowadzenie do instrukcji Pythona Obsługa błędów za pomocą instrukcji try Powyższe rozwiązanie działa, jednak, jak zobaczymy w dalszej części książki, najbardziej uniwersalnym sposobem obsługi wyjątków w Pythonie jest przechwytywanie ich i poradzenie sobie z błędem za pomocą instrukcji try. Instrukcję tę omówimy bardziej dogłębnie w ostat- niej części książki, jednak już teraz możemy pokazać, że użycie tutaj try może sprawić, iż kod niektórym osobom wyda się prostszy od poprzedniej wersji. while True: reply = raw_input( Wpisz tekst: ) if reply == stop : break try: num = int(reply) except: print Niepoprawnie! * 5 else: print int(reply) ** 2 print Koniec Ta wersja działa dokładnie tak samo jak poprzednia, jednak zastąpiliśmy dosłowne sprawdzanie błędu kodem zak
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Python. Wprowadzenie. Wydanie III
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ą: