Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00334 006189 14087277 na godz. na dobę w sumie
Python. Wprowadzenie. Wydanie IV - książka
Python. Wprowadzenie. Wydanie IV - książka
Autor: Liczba stron: 1184
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-2694-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> python - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj język, który wykorzystuje Google i YouTube!

Czy wiesz, dlaczego ponad milion programistów na całym świecie używa właśnie tego języka skryptowego? Jego atuty to niezwykła czytelność, spójność i wydajność - pewnie dlatego także i Ty chcesz opanować słynnego Pythona. Kod napisany w tym języku można z łatwością utrzymywać, przenosić i używać go ponownie. Pozostaje on zrozumiały nawet wówczas, jeśli analizuje go ktoś, kto nie jest jego autorem. Co więcej, taki kod ma rozmiary średnio o dwie trzecie do czterech piątych mniejsze od kodu w językach C++ czy Java, co wielokrotnie zwiększa wydajność pracy używających go programistów. Python obsługuje także zaawansowane mechanizmy pozwalające na ponowne wykorzystanie kodu, takie jak programowanie zorientowane obiektowo, a programy w nim napisane działają natychmiast, bez konieczności przeprowadzania długiej kompilacji, niezależnie od wykorzystywanej platformy. Jeśli jesteś gotowy na opanowanie tego potężnego języka, mamy doskonały podręcznik dla Ciebie.

Mark Lutz, autor tego podręcznika, jest kultową postacią w środowisku Pythona i znanym na całym świecie instruktorem tego języka, a struktura jego książki powstała w oparciu o słynny, prowadzony przez niego kurs. Naukę rozpoczniesz od najważniejszych wbudowanych typów danych - liczb, list czy słowników. Przyjrzysz się również typom dynamicznym oraz ich interfejsom. Później poznasz instrukcje oraz ogólny model składni Pythona. Poszerzysz wiedzę na temat powiązanych z nim narzędzi, takich jak system PyDoc, a także alternatywnych możliwości tworzenia kodu. Dowiesz się wszystkiego na temat modułów: jak się je tworzy, przeładowuje i jak się ich używa. W końcu poznasz klasy oraz zagadnienia związane z programowaniem zorientowanym obiektowo i nauczysz się obsługiwać wyjątki. Czwarte wydanie tej książki zostało wzbogacone o wiele nowych, ciekawych i bardzo zaawansowanych zagadnień, dzięki czemu stanowi doskonałą lekturę także dla zawodowców, na co dzień piszących kod w tym języku.

Dzięki tej książce:

Opanuj Pythona z Markiem Lutzem
- najbardziej znanym ekspertem w tej dziedzinie!

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

Darmowy fragment publikacji:

Idź do • Spis treści • Przykładowy rozdział Katalog książek • Katalog online • Zamów drukowany katalog Twój koszyk • Dodaj do koszyka Cennik i informacje • Zamów informacje o nowościach • Zamów cennik Czytelnia • Fragmenty książek online Kontakt Helion SA ul. Kościuszki 1c 44-100 Gliwice tel. 32 230 98 63 e-mail: helion@helion.pl © Helion 1991–2010 Python. Wprowadzenie. Wydanie IV Autor: Mark Lutz Tłumaczenie: Anna Trojan, Marek Pętlicki ISBN: 978-83-246-2694-6 Tytuł oryginału: Learning Python, 4th edition Format: 172×245, stron: 1184 Poznaj język, który wykorzystuje Google i YouTube! • Jak tworzyć i przetwarzać obiekty za pomocą instrukcji Pythona? • Jak stworzyć strukturę kodu i wykorzystać go ponownie? • Jak programować obiektowo w Pythonie? Czy wiesz, dlaczego ponad milion programistów na całym świecie używa właśnie tego języka skryptowego? Jego atuty to niezwykła czytelność, spójność i wydajność – pewnie dlatego także i Ty chcesz opanować słynnego Pythona. Kod napisany w tym języku można z łatwością utrzymywać, przenosić i używać go ponownie. Pozostaje on zrozumiały nawet wówczas, jeśli analizuje go ktoś, kto nie jest jego autorem. Co więcej, taki kod ma rozmiary średnio o dwie trzecie do czterech piątych mniejsze od kodu w językach C++ czy Java, co wielokrotnie zwiększa wydajność pracy używających go programistów. Python obsługuje także zaawansowane mechanizmy pozwalające na ponowne wykorzystanie kodu, takie jak programowanie zorientowane obiektowo, a programy w nim napisane działają natychmiast, bez konieczności przeprowadzania długiej kompilacji, niezależnie od wykorzystywanej platformy. Naukę rozpoczniesz od najważniejszych wbudowanych typów danych – liczb, list czy słowników. Przyjrzysz się również typom dynamicznym oraz ich interfejsom. Później poznasz instrukcje oraz ogólny model składni Pythona. Poszerzysz wiedzę na temat powiązanych z nim narzędzi, takich jak system PyDoc, a także alternatywnych możliwości tworzenia kodu. Dowiesz się wszystkiego na temat modułów: jak się je tworzy, przeładowuje i jak się ich używa. W końcu poznasz klasy oraz zagadnienia związane z programowaniem zorientowanym obiektowo i nauczysz się obsługiwać wyjątki. Czwarte wydanie tej książki zostało wzbogacone o wiele nowych, ciekawych i bardzo zaawansowanych zagadnień, dzięki czemu stanowi doskonałą lekturę także dla zawodowców, na co dzień piszących kod w tym języku. Dzięki tej książce: • zapoznasz się z podstawowymi typami wbudowanymi Pythona, • nauczysz się tworzyć i przetwarzać obiekty za pomocą instrukcji Pythona, a także opanujesz ogólny model składni tego języka • stworzysz strukturę kodu i wykorzystasz kod ponownie dzięki podstawowym narzędziom proceduralnym Pythona • dowiesz się wszystkiego o modułach Pythona – pakietach instrukcji i funkcji oraz innych narzędziach zorganizowanych w większe komponenty • odkryjesz narzędzie programowania zorientowanego obiektowo, umożliwiające strukturyzację kodu • opanujesz model obsługi wyjątków i narzędzia programistyczne służące do pisania większych programów • zapoznasz się z zaawansowanymi narzędziami Pythona, w tym dekoratorami, deskryptorami, metaklasami i przetwarzaniem tekstu Unicode Opanuj Pythona z Markiem Lutzem – najbardziej znanym ekspertem w tej dziedzinie! Spis treści Przedmowa .............................................................................................................................29 Część I Wprowadzenie .................................................................................. 47 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? Jakie wsparcie techniczne ma Python? Jakie są techniczne mocne strony Pythona? Programowanie systemowe Graficzne interfejsy użytkownika Skrypty internetowe Integracja komponentów Programowanie bazodanowe Szybkie prototypowanie Programowanie numeryczne i naukowe Gry, grafika, porty szeregowe, XML, roboty i tym podobne 1. Pytania i odpowiedzi dotyczące Pythona ..................................................................49 49 50 51 51 53 53 55 55 55 56 56 57 57 57 58 58 59 59 59 60 61 62 62 62 63 63 64 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 Jak Python wygląda na tle innych języków? Podsumowanie rozdziału 5 Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 65 65 Wprowadzenie do interpretera Pythona Wykonywanie programu Z punktu widzenia programisty Z punktu widzenia Pythona Warianty modeli wykonywania 2. Jak Python wykonuje programy? ................................................................................69 69 71 71 72 74 75 76 78 78 79 80 80 80 Alternatywne implementacje Pythona Narzędzia do optymalizacji wykonywania Zamrożone pliki binarne Inne opcje wykonywania Przyszłe możliwości? Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Interaktywny wiersz poleceń Interaktywne wykonywanie kodu Do czego służy sesja interaktywna? Wykorzystywanie sesji interaktywnej Systemowe wiersze poleceń i pliki Kliknięcie ikony w systemie Windows Sztuczka z funkcją input Inne ograniczenia klikania ikon Pierwszy skrypt Wykonywanie plików za pomocą wiersza poleceń Wykorzystywanie wierszy poleceń i plików Skrypty wykonywalne Uniksa (#!) 3. Jak wykonuje się programy? ....................................................................................... 81 81 82 83 85 87 87 88 90 91 92 93 94 95 96 98 100 101 102 103 105 106 107 108 108 109 110 Osadzanie wywołań Zamrożone binarne pliki wykonywalne Uruchamianie kodu w edytorze tekstowym Wykorzystywanie exec do wykonywania plików modułów Interfejs użytkownika IDLE Podstawy IDLE Korzystanie z IDLE Zaawansowane opcje IDLE Inne IDE Inne opcje wykonywania kodu Kliknięcie ikony pliku Importowanie i przeładowywanie modułów Więcej o modułach — atrybuty Uwagi na temat używania instrukcji import i reload 6 | Spis treści Jeszcze inne możliwości uruchamiania Przyszłe możliwości Jaką opcję wybrać? Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Sprawdź swoją wiedzę — ćwiczenia do części pierwszej 110 110 111 112 113 113 114 Część II Typy i operacje ..................................................................................117 Liczby Łańcuchy znaków Listy Słowniki Po co korzysta się z typów wbudowanych? Najważniejsze typy danych w Pythonie Operacje na sekwencjach Operacje specyficzne dla typu Sprawdzanie granic Zagnieżdżanie Listy składane Operacje na sekwencjach Niezmienność Metody specyficzne dla typu Otrzymanie pomocy Inne sposoby kodowania łańcuchów znaków Dopasowywanie wzorców 4. Wprowadzenie do typów obiektów Pythona ...........................................................119 120 121 122 124 124 126 126 127 128 129 130 130 130 131 131 132 133 134 134 136 137 138 139 140 140 142 142 143 144 145 145 146 146 Operacje na odwzorowaniach Zagnieżdżanie raz jeszcze Sortowanie kluczy — pętle for Iteracja i optymalizacja Brakujące klucze — testowanie za pomocą if Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Inne narzędzia podobne do plików Inne typy podstawowe Jak zepsuć elastyczność kodu Klasy zdefiniowane przez użytkownika I wszystko inne Krotki Pliki Czemu służą krotki? Spis treści | 7 Podstawy typów liczbowych Pythona Literały liczbowe Wbudowane narzędzia liczbowe Operatory wyrażeń Pythona Zmienne i podstawowe wyrażenia Formaty wyświetlania liczb Porównania — zwykłe i łączone Dzielenie — klasyczne, bez reszty i prawdziwe Precyzja liczb całkowitych Liczby zespolone Notacja szesnastkowa, ósemkowa i dwójkowa Operacje poziomu bitowego Inne wbudowane narzędzia liczbowe 5. Typy liczbowe ............................................................................................................ 149 149 150 151 152 156 157 158 160 161 164 165 165 167 168 170 170 172 176 181 182 183 183 184 Dodatkowe rozszerzenia numeryczne Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Liczby w akcji Inne typy liczbowe Typ liczby dziesiętnej Typ liczby ułamkowej Zbiory Wartości Boolean 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 ................................................................. 185 185 186 187 188 190 191 193 194 194 195 195 Typy dynamiczne są wszędzie Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Referencje współdzielone a modyfikacje w miejscu Referencje współdzielone a równość Literały łańcuchów znaków 7. Łańcuchy znaków ...................................................................................................... 197 199 200 200 203 Ł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 204 8 | Spis treści Łańcuchy znaków w akcji Podstawowe operacje Indeksowanie i wycinki Narzędzia do konwersji łańcuchów znaków Modyfikowanie łańcuchów znaków Metody łańcuchów znaków Przykłady metod łańcuchów znaków — modyfikowanie 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 (usunięty w 3.0) Wyrażenia formatujące łańcuchy znaków Zaawansowane wyrażenia formatujące Wyrażenia formatujące z użyciem słownika Metoda format Podstawy Użycie kluczy, atrybutów i przesunięć Formatowanie specjalizowane Porównanie z wyrażeniami formatującymi Po co nam kolejny mechanizm formatujący? Generalne kategorie typów Typy z jednej kategorii współdzielą zbiory operacji Typy zmienne można modyfikować w miejscu Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 205 206 207 210 213 214 215 218 219 220 221 222 224 225 225 226 227 229 232 235 235 236 236 236 237 Listy Listy w akcji Podstawowe operacje na listach Iteracje po listach i składanie list Indeksowanie, wycinki i macierze Modyfikacja list w miejscu Słowniki Słowniki w akcji 8. Listy oraz słowniki .....................................................................................................239 239 241 241 242 243 244 248 249 250 251 252 253 254 257 258 264 264 264 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 Inne sposoby tworzenia słowników Zmiany dotyczące słowników w 3.0 Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Spis treści | 9 Krotki Pliki Hierarchie typów Pythona Obiekty typów Krotki w akcji Dlaczego istnieją listy i krotki? Otwieranie plików Wykorzystywanie plików Pliki w akcji Inne narzędzia powiązane z plikami Raz jeszcze o kategoriach typów Elastyczność obiektów Referencje a kopie Porównania, równość i prawda 9. Krotki, pliki i pozostałe ..............................................................................................267 267 268 271 271 272 273 274 280 281 282 283 285 287 288 290 291 291 292 292 293 293 294 294 294 295 295 Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Sprawdź swoją wiedzę — ćwiczenia do części drugiej 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 Porównywanie słowników w Pythonie 3.0 Znaczenie True i False w Pythonie Inne typy w Pythonie Pułapki typów wbudowanych Część III Instrukcje i składnia ........................................................................ 299 Historia dwóch if Instrukcje Pythona Raz jeszcze o strukturze programu Pythona Co dodaje Python Co usuwa Python Skąd bierze się składnia indentacji? Kilka przypadków specjalnych 10. Wprowadzenie do instrukcji Pythona ...................................................................... 301 301 301 303 304 304 306 308 310 310 311 312 313 314 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 Szybki przykład — interaktywne pętle 10 | Spis treści Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 315 315 315 Instrukcje wyrażeń Instrukcje przypisania Formy instrukcji przypisania Przypisanie sekwencji Rozszerzona składnia rozpakowania sekwencji w 3.0 Przypisanie z wieloma celami Przypisania rozszerzone Reguły dotyczące nazw zmiennych 11. Przypisania, wyrażenia i wyświetlanie .....................................................................317 317 318 319 322 325 326 329 332 333 334 334 337 338 341 343 344 344 Funkcja print Pythona 3.0 Instrukcja print w Pythonie 2.6 Przekierowanie strumienia wyjściowego Wyświetlanie niezależne od wersji Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Instrukcje wyrażeń i modyfikacje w miejscu Polecenia print Instrukcje if Ogólny format Proste przykłady Rozgałęzienia kodu Reguły składni Pythona 12. Testy if i reguły składni .............................................................................................345 345 345 346 346 348 349 351 352 353 355 356 357 358 Testy prawdziwości Wyrażenie trójargumentowe if/else Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Ograniczniki bloków — reguły indentacji Ograniczniki instrukcji — wiersze i kontynuacje Kilka przypadków specjalnych Pętle while 13. Pętle while i for ..........................................................................................................359 359 360 360 361 361 361 Instrukcje break, continue, pass oraz else w pętli Ogólny format pętli Instrukcja pass Ogólny format Przykłady Spis treści | 11 14. Instrukcja continue Instrukcja break Instrukcja else Pętle for Ogólny format Przykłady Techniki tworzenia pętli Pętle liczników — while i range Przechodzenie niewyczerpujące — range i wycinki Modyfikacja list — range Przechodzenie równoległe — zip oraz map Generowanie wartości przesunięcia i elementów — enumerate Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 363 363 364 365 365 367 372 373 374 375 376 379 380 380 380 Podstawy list składanych Wykorzystywanie list składanych w plikach Rozszerzona składnia list składanych Inne konteksty iteracyjne Nowe obiekty iterowane w Pythonie 3.0 Protokół iteracyjny, iteratory plików Kontrola iteracji — iter i next Inne iteratory typów wbudowanych Listy składane — wprowadzenie Iteracje i składanie list — część 1. .............................................................................383 Pierwsze spojrzenie na iteratory 383 384 386 388 390 390 391 392 393 397 397 398 399 400 402 402 402 403 Inne zagadnienia związane z iteratorami Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Iterator range() Iteratory map(), zip() i filter() Kilka iteratorów na tym samym obiekcie Iteratory widoku słownika 15. Wprowadzenie do dokumentacji ..............................................................................405 405 406 406 407 410 412 415 415 416 Źródła dokumentacji Pythona Komentarze ze znakami # Funkcja dir Łańcuchy znaków dokumentacji — __doc__ PyDoc — funkcja help PyDoc — raporty HTML Zbiór standardowej dokumentacji Zasoby internetowe Publikowane książki 12 | Spis treści Często spotykane problemy programistyczne Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Ćwiczenia do części trzeciej 417 419 419 419 420 Część IV Funkcje ............................................................................................ 423 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 16. Podstawy funkcji .......................................................................................................425 426 426 428 428 429 429 430 430 431 432 432 433 433 434 434 434 Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Definicja Wywołania Raz jeszcze o polimorfizmie Zmienne lokalne Drugi przykład — przecinające się sekwencje Podstawy zakresów w Pythonie Reguły dotyczące zakresów Rozwiązywanie konfliktów w zakresie nazw — reguła LEGB Przykład zakresu Zakres wbudowany 17. Zakresy .......................................................................................................................437 437 438 440 441 442 443 445 446 447 448 449 449 455 455 456 458 462 Minimalizowanie stosowania zmiennych globalnych Minimalizacja modyfikacji dokonywanych pomiędzy plikami Inne metody dostępu do zmiennych globalnych Podstawy instrukcji nonlocal Instrukcja nonlocal w akcji Czemu służą zmienne nielokalne? Szczegóły dotyczące zakresów zagnieżdżonych Przykład zakresu zagnieżdżonego Zakresy a funkcje zagnieżdżone Podsumowanie rozdziału Instrukcja global Instrukcja nonlocal Spis treści | 13 Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 462 463 Podstawy przekazywania argumentów Specjalne tryby dopasowania argumentów Argumenty a współdzielone referencje Unikanie modyfikacji zmiennych argumentów Symulowanie parametrów wyjścia Podstawy Składnia dopasowania Dopasowywanie argumentów — szczegóły Przykłady ze słowami kluczowymi i wartościami domyślnymi Przykład dowolnych argumentów Argumenty mogące być tylko słowami kluczowymi z Pythona 3.0 18. Argumenty .................................................................................................................465 465 466 468 469 470 470 471 472 473 475 479 482 483 484 485 485 486 487 488 489 490 Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Uogólnione funkcje działające na zbiorach Emulacja funkcji print z Pythona 3.0 Wykorzystywanie argumentów mogących być tylko słowami kluczowymi Pełne rozwiązanie Dodatkowy bonus Puenta Przykład z funkcją obliczającą minimum Obiekty funkcji — atrybuty i adnotacje Koncepcje projektowania funkcji Funkcje rekurencyjne Sumowanie z użyciem rekurencji Implementacje alternatywne Pętle a rekurencja Obsługa dowolnych struktur 19. Zaawansowane zagadnienia dotyczące funkcji ...................................................... 491 491 493 493 494 495 496 497 497 498 499 499 501 501 503 504 505 507 508 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 Odwzorowywanie funkcji na sekwencje — map Narzędzia programowania funkcyjnego — filter i reduce Pośrednie wywołania funkcji Introspekcja funkcji Atrybuty funkcji Adnotacje funkcji w Pythonie 3.0 Funkcje anonimowe — lambda 14 | Spis treści Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 510 510 510 20. Iteratorów ciąg dalszy — generatory Podsumowanie obiektów składanych w 3.0 Zrozumieć zbiory i słowniki składane Rozszerzona składnia zbiorów i słowników składanych Listy składane kontra map Dodajemy warunki i pętle zagnieżdżone — filter Listy składane i macierze Zrozumieć listy składane Funkcje generatorów — yield kontra return Wyrażenia generatorów — iteratory spotykają złożenia Funkcje generatorów kontra wyrażenia generatorów Generatory są jednorazowymi iteratorami Emulacja funkcji zip i map za pomocą narzędzi iteracyjnych Generowanie wyników we wbudowanych typach i klasach Iteracje i składanie list — część 2. ............................................................................. 513 Listy składane, podejście drugie — narzędzia funkcyjne 513 514 515 517 518 520 520 524 525 526 527 531 533 534 534 535 536 536 537 539 543 544 544 546 548 548 548 549 549 550 Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Sprawdź swoją wiedzę — ćwiczenia do części czwartej Lokalne nazwy są wykrywane w sposób statyczny Wartości domyślne i obiekty mutowalne Funkcje niezwracające wyników Funkcje zagnieżdżone a zmienne modyfikowane w pętli Pomiary wydajności implementacji iteratorów Moduł mytimer Skrypt mierzący wydajność Pomiary czasu Alternatywne moduły mierzące wydajność Inne sugestie Pułapki związane z funkcjami Część V Moduły ............................................................................................. 553 Po co używa się modułów? Architektura programu w Pythonie 21. Moduły — wprowadzenie ........................................................................................555 555 556 556 557 558 Struktura programu Importowanie i atrybuty Moduły biblioteki standardowej Spis treści | 15 Jak działa importowanie 1. Odnalezienie modułu 2. (Ewentualne) Kompilowanie 3. Wykonanie Ścieżka wyszukiwania modułów Konfiguracja ścieżki wyszukiwania Wariacje ścieżki wyszukiwania modułów Lista sys.path Wybór pliku modułu Zaawansowane zagadnienia związane z wyborem modułów Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 559 560 560 561 561 563 564 564 565 566 566 567 568 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 22. Podstawy tworzenia modułów .................................................................................569 569 570 570 571 571 571 572 573 573 574 575 576 577 578 579 580 581 581 582 583 584 Pliki generują przestrzenie nazw Kwalifikowanie nazw atrybutów Importowanie a zakresy Zagnieżdżanie przestrzeni nazw Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Podstawy przeładowywania modułów Przykład przeładowywania z użyciem reload Przestrzenie nazw modułów Przeładowywanie modułów Podstawy importowania pakietów Pakiety a ustawienia ścieżki wyszukiwania Pliki pakietów __init__.py 23. Pakiety modułów .......................................................................................................585 585 586 586 588 589 590 590 Instrukcja from a instrukcja import w importowaniu pakietów Do czego służy importowanie pakietów? Przykład importowania pakietu Historia trzech systemów 16 | Spis treści Względne importowanie pakietów Zmiany w Pythonie 3.0 Podstawy importów względnych Do czego służą importy względne? Zakres importów względnych Podsumowanie reguł wyszukiwania modułów Importy względne w działaniu Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 593 593 594 595 597 598 598 603 604 604 Ukrywanie danych w modułach Minimalizacja niebezpieczeństw użycia from * — _X oraz __all__ Włączanie opcji z przyszłych wersji Pythona Mieszane tryby użycia — __name__ oraz __main__ Testy jednostkowe z wykorzystaniem __name__ Użycie argumentów wiersza poleceń z __name__ 24. Zaawansowane zagadnienia związane z modułami ..............................................607 607 608 608 609 610 611 613 614 615 617 618 621 622 622 623 624 Modyfikacja ścieżki wyszukiwania modułów Rozszerzenie as dla instrukcji import oraz from Moduły są obiektami — metaprogramy Importowanie modułów za pomocą łańcucha znaków nazwy Przechodnie przeładowywanie modułów Projektowanie modułów Pułapki związane z modułami W kodzie najwyższego poziomu kolejność instrukcji ma znaczenie 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 Rekurencyjne importowanie za pomocą from może nie działać Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Sprawdź swoją wiedzę — ćwiczenia do części piątej 624 625 626 627 627 628 628 Część VI Klasy i programowanie zorientowane obiektowo ........................631 Po co używa się klas? Programowanie zorientowane obiektowo z dystansu 25. Programowanie zorientowane obiektowo ..............................................................633 634 635 635 637 Wyszukiwanie dziedziczenia atrybutów Klasy a instancje Spis treści | 17 Wywołania metod klasy Tworzenie drzew klas Programowanie zorientowane obiektowo oparte jest na ponownym wykorzystaniu kodu Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 638 638 641 643 644 644 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 26. Podstawy tworzenia klas ..........................................................................................647 647 648 648 649 651 652 653 654 655 657 658 660 662 662 663 Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Klasy mogą przechwytywać operatory Pythona Trzeci przykład Po co przeciąża się operatory? Najprostsza klasa Pythona na świecie Klasy a słowniki Krok 1. — tworzenie instancji Tworzenie konstruktorów Testowanie w miarę pracy Wykorzystywanie kodu na dwa sposoby 27. Bardziej realistyczny przykład ..................................................................................665 666 666 667 668 669 671 673 674 Krok 3. — przeciążanie operatorów Krok 2. — dodawanie metod Udostępnienie wyświetlania Tworzenie kodu metod Krok 4. — dostosowanie zachowania do własnych potrzeb za pomocą klas podrzędnych Tworzenie klas podrzędnych Rozszerzanie metod — niewłaściwy sposób Rozszerzanie metod — właściwy sposób Polimorfizm w akcji Dziedziczenie, dostosowanie do własnych potrzeb i rozszerzenie Programowanie zorientowane obiektowo — idea Krok 5. — dostosowanie do własnych potrzeb także konstruktorów Programowanie zorientowane obiektowo jest prostsze, niż się wydaje Inne sposoby łączenia klas 675 675 676 676 678 679 680 680 682 683 18 | Spis treści Krok 6. — wykorzystywanie narzędzi do introspekcji Specjalne atrybuty klas Uniwersalne narzędzie do wyświetlania Atrybuty instancji a atrybuty klas Rozważania na temat nazw w klasach narzędzi Ostateczna postać naszych klas Krok 7. i ostatni — przechowanie obiektów w bazie danych Obiekty pickle i shelve Przechowywanie obiektów w bazie danych za pomocą shelve Interaktywne badanie obiektów shelve Uaktualnianie obiektów w pliku shelve Przyszłe kierunki rozwoju Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 684 686 687 688 689 690 691 691 692 694 695 697 699 699 700 Przykład metody Wywoływanie konstruktorów klas nadrzędnych Inne możliwości wywoływania metod Dziedziczenie Przestrzenie nazw — cała historia Instrukcja class Ogólna forma Przykład Metody Tworzenie drzewa atrybutów Specjalizacja odziedziczonych metod Techniki interfejsów klas Abstrakcyjne klasy nadrzędne Abstrakcyjne klasy nadrzędne z Pythona 2.6 oraz 3.0 28. Szczegóły kodu klas ...................................................................................................703 703 703 704 706 707 708 708 708 709 710 711 712 713 714 715 715 715 718 720 722 723 724 724 724 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 Raz jeszcze o łańcuchach znaków dokumentacji Klasy a moduły Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Spis treści | 19 Podstawy Wycinki Iteratory zdefiniowane przez użytkownika Wiele iteracji po jednym obiekcie Iteracja po indeksie — __getitem__ Obiekty iteratorów — __iter__ i __next__ Test przynależności — __contains__, __iter__ i __getitem__ Metody __getattr__ oraz __setattr__ przechwytują referencje do atrybutów Konstruktory i wyrażenia — __init__ i __sub__ Często spotykane metody przeciążania operatorów Indeksowanie i wycinanie — __getitem__ i __setitem__ 29. Przeciążanie operatorów .......................................................................................... 727 727 728 728 730 730 731 733 734 735 737 740 741 741 742 745 746 747 748 750 750 751 752 754 755 755 Testy logiczne — __bool__ i __len__ Destrukcja obiektu — __del__ Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Metody __repr__ oraz __str__ zwracają reprezentacje łańcuchów znaków Metoda __radd__ obsługuje dodawanie prawostronne i modyfikację w miejscu Inne narzędzia do zarządzania atrybutami Emulowanie prywatności w atrybutach instancji Interfejsy funkcji i kod oparty na wywołaniach zwrotnych Metoda __call_ przechwytuje wywołania Metoda __cmp__ w 2.6 (usunięta w 3.0) Porównania — __lt__, __gt__ i inne Dodawanie w miejscu Raz jeszcze procesor strumienia danych Python a programowanie zorientowane obiektowo Przeciążanie za pomocą sygnatur wywołań (lub bez nich) Programowanie zorientowane obiektowo i dziedziczenie — związek „jest” Programowanie zorientowane obiektowo i kompozycja — związki typu „ma” Programowanie zorientowane obiektowo a delegacja — obiekty „opakowujące” Pseudoprywatne atrybuty klas 30. Projektowanie z użyciem klas ................................................................................... 757 757 758 759 760 762 765 767 767 768 770 772 773 775 776 785 787 Przegląd zniekształcania nazw zmiennych Po co używa się atrybutów pseudoprywatnych? Metody są obiektami — z wiązaniem i bez wiązania Metody niezwiązane w 3.0 Metody związane i inne obiekty wywoływane Klasy są obiektami — uniwersalne fabryki obiektów Dziedziczenie wielokrotne — klasy mieszane Tworzenie klas mieszanych Do czego służą fabryki? 20 | Spis treści Inne zagadnienia związane z projektowaniem Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 788 788 789 789 Rozszerzanie typów wbudowanych Rozszerzanie typów za pomocą osadzania Rozszerzanie typów za pomocą klas podrzędnych Klasy w nowym stylu Nowości w klasach w nowym stylu Zmiany w modelu typów Zmiany w dziedziczeniu diamentowym Nowości w klasach w nowym stylu Sloty Właściwości klas Przeciążanie nazw — __getattribute__ i deskryptory Metaklasy 31. Zaawansowane zagadnienia związane z klasami .................................................. 791 791 792 793 795 796 797 801 805 805 809 811 811 811 812 812 814 815 817 818 820 820 821 822 823 824 824 Do czego potrzebujemy metod specjalnych? Metody statyczne w 2.6 i 3.0 Alternatywy dla metod statycznych Używanie metod statycznych i metod klas Zliczanie instancji z użyciem metod statycznych Zliczanie instancji z metodami klas Podstawowe informacje o dekoratorach funkcji Przykład dekoratora Dekoratory klas i metaklasy Dalsza lektura Metody statyczne oraz metody klasy Dekoratory i metaklasy — część 1. Pułapki związane z klasami Modyfikacja atrybutów klas może mieć efekty uboczne Modyfikowanie mutowalnych atrybutów klas również może mieć efekty uboczne Dziedziczenie wielokrotne — kolejność ma znaczenie Metody, klasy oraz zakresy zagnieżdżone Klasy wykorzystujące delegację w 3.0 — __getattr__ i funkcje wbudowane Przesadne opakowywanie Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Sprawdź swoją wiedzę — ćwiczenia do części szóstej 825 826 827 829 829 830 830 830 831 Spis treści | 21 Część VII Wyjątki oraz narzędzia ................................................................. 839 Po co używa się wyjątków? Role wyjątków Wyjątki w skrócie 32. Podstawy wyjątków ..................................................................................................841 841 842 843 843 844 845 845 846 847 849 849 Domyślny program obsługi wyjątków Przechwytywanie wyjątków Zgłaszanie wyjątków Wyjątki zdefiniowane przez użytkownika Działania końcowe Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Instrukcja try/except/else Instrukcja try/finally Przykład — działania kończące kod z użyciem try/finally Połączona instrukcja try/except/finally Składnia połączonej instrukcji try Łączenie finally oraz except za pomocą zagnieżdżania Przykład połączonego try Części instrukcji try Część try/else Przykład — zachowanie domyślne Przykład — przechwytywanie wbudowanych wyjątków 33. Szczegółowe informacje dotyczące wyjątków ........................................................ 851 851 853 855 856 857 857 858 859 860 861 862 863 864 865 865 866 867 867 868 870 871 871 Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Menedżery kontekstu with/as Podstawowe zastosowanie Protokół zarządzania kontekstem Przekazywanie wyjątków za pomocą raise Łańcuchy wyjątków w Pythonie 3.0 — raise from Przykład — wyłapywanie ograniczeń (ale nie błędów!) Instrukcja raise Instrukcja assert Wyjątki — powrót do przyszłości 34. Obiekty wyjątków .....................................................................................................873 874 874 875 875 Wyjątki oparte na łańcuchach znaków znikają Wyjątki oparte na klasach Tworzenie klas wyjątków 22 | Spis treści Do czego służą hierarchie wyjątków? Wbudowane klasy wyjątków Kategorie wbudowanych wyjątków Domyślne wyświetlanie oraz stan Własne sposoby wyświetlania Własne dane oraz zachowania Udostępnianie szczegółów wyjątku Udostępnianie metod wyjątków Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 877 880 881 882 883 884 884 885 886 886 886 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 35. Projektowanie z wykorzystaniem wyjątków ...........................................................889 889 891 891 893 893 893 894 895 895 896 897 897 898 Wyjątki nie zawsze są błędami Funkcje mogą sygnalizować warunki za pomocą raise Zamykanie plików oraz połączeń z serwerem Debugowanie z wykorzystaniem zewnętrznych instrukcji try Testowanie kodu wewnątrz tego samego procesu Więcej informacji na temat funkcji sys.exc_info Co powinniśmy opakować w try Jak nie przechwytywać zbyt wiele — unikanie pustych except i wyjątków Jak nie przechwytywać zbyt mało — korzystanie z kategorii Wskazówki i pułapki dotyczące projektowania wyjątków opartych na klasach Podsumowanie jądra języka Python Zbiór narzędzi Pythona Narzędzia programistyczne przeznaczone do większych projektów Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi Sprawdź swoją wiedzę — ćwiczenia do części siódmej 900 901 901 902 906 906 906 907 Część VIII Zagadnienia zaawansowane ...................................................... 909 Zmiany w łańcuchach znaków w Pythonie 3.0 Podstawy łańcuchów znaków 36. Łańcuchy znaków Unicode oraz łańcuchy bajtowe ..................................................911 912 913 913 915 916 Kodowanie znaków Typy łańcuchów znaków Pythona Pliki binarne i tekstowe Spis treści | 23 Łańcuchy znaków Pythona 3.0 w akcji Literały i podstawowe właściwości Konwersje Kod łańcuchów znaków Unicode Kod tekstu z zakresu ASCII Kod tekstu spoza zakresu ASCII Kodowanie i dekodowanie tekstu spoza zakresu ASCII Inne techniki kodowania łańcuchów Unicode Konwersja kodowania Łańcuchy znaków Unicode w Pythonie 2.6 Deklaracje typu kodowania znaków pliku źródłowego Wykorzystywanie obiektów bytes z Pythona 3.0 Wywołania metod Operacje na sekwencjach Inne sposoby tworzenia obiektów bytes Mieszanie typów łańcuchów znaków Wykorzystywanie obiektów bytearray z Pythona 3.0 (i 2.6) Wykorzystywanie plików tekstowych i binarnych Podstawy plików tekstowych Tryby tekstowy i binarny w Pythonie 3.0 Brak dopasowania typu i zawartości Wykorzystywanie plików Unicode Odczyt i zapis Unicode w Pythonie 3.0 Obsługa BOM w Pythonie 3.0 Pliki Unicode w Pythonie 2.6 Inne zmiany narzędzi łańcuchów znaków w Pythonie 3.0 Moduł dopasowywania wzorców re Moduł danych binarnych struct Moduł serializacji obiektów pickle Narzędzia do analizy składniowej XML Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 918 918 919 920 921 921 922 923 925 925 928 929 929 930 931 931 932 935 935 936 938 939 939 941 943 944 944 945 947 948 951 952 952 Po co zarządza się atrybutami? Wstawianie kodu wykonywanego w momencie dostępu do atrybutów Właściwości Podstawy Pierwszy przykład Obliczanie atrybutów Zapisywanie właściwości w kodzie za pomocą dekoratorów 37. Zarządzane atrybuty .................................................................................................955 955 956 957 957 958 959 960 961 962 964 966 Deskryptory Podstawy Pierwszy przykład Obliczone atrybuty 24 | Spis treści Wykorzystywanie informacji o stanie w deskryptorach Powiązania pomiędzy właściwościami a deskryptorami Metody __getattr__ oraz __getattribute__ Podstawy Pierwszy przykład Obliczanie atrybutów Porównanie metod __getattr__ oraz __getattribute__ Porównanie technik zarządzania atrybutami Przechwytywanie atrybutów wbudowanych operacji Powrót do menedżerów opartych na delegacji Przykład — sprawdzanie poprawności atrybutów Wykorzystywanie właściwości do sprawdzania poprawności Wykorzystywanie deskryptorów do sprawdzania poprawności Wykorzystywanie metody __getattr__ do sprawdzania poprawności Wykorzystywanie metody __getattribute__ do sprawdzania poprawności Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 967 968 970 971 973 974 975 976 979 983 986 986 988 990 991 992 992 993 Czym jest dekorator? Zarządzanie wywołaniami oraz instancjami Zarządzanie funkcjami oraz klasami Wykorzystywanie i definiowanie dekoratorów Do czego służą dekoratory? Podstawy Dekoratory funkcji Dekoratory klas Zagnieżdżanie dekoratorów Argumenty dekoratorów Dekoratory zarządzają także funkcjami oraz klasami 38. Dekoratory .................................................................................................................995 995 996 996 997 997 998 998 1002 1004 1006 1006 1007 1007 1009 1012 1017 1019 1021 1021 1023 1027 1028 1029 1031 1033 1033 Klasy singletona Śledzenie interfejsów obiektów Uwagi na temat klas II — zachowanie większej liczby instancji Dekoratory a funkcje zarządzające Do czego służą dekoratory? (raz jeszcze) Śledzenie wywołań Możliwości w zakresie zachowania informacji o stanie Uwagi na temat klas I — dekorowanie metod klas Mierzenie czasu wywołania Dodawanie argumentów dekoratora Bezpośrednie zarządzanie funkcjami oraz klasami Przykład — atrybuty „prywatne” i „publiczne” Implementacja atrybutów prywatnych Kod dekoratorów funkcji Kod dekoratorów klas Spis treści | 25 Szczegóły implementacji I Uogólnienie kodu pod kątem deklaracji atrybutów jako publicznych Szczegóły implementacji II Znane problemy W Pythonie nie chodzi o kontrolę Przykład: Sprawdzanie poprawności argumentów funkcji Cel Prosty dekorator sprawdzający przedziały dla argumentów pozycyjnych Uogólnienie kodu pod kątem słów kluczowych i wartości domyślnych Szczegóły implementacji Znane problemy Argumenty dekoratora a adnotacje funkcji Inne zastosowania — sprawdzanie typów (skoro nalegamy!) Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 1035 1036 1038 1039 1043 1044 1044 1045 1047 1050 1052 1053 1054 1055 1056 1056 Model metaklasy Klasy są instancjami obiektu type Metaklasy są klasami podrzędnymi klasy type Protokół instrukcji class Tworzyć metaklasy czy tego nie robić? Zwiększające się poziomy magii Wady funkcji pomocniczych Metaklasy a dekoratory klas — runda 1. Deklarowanie metaklas Tworzenie metaklas Prosta metaklasa Dostosowywanie tworzenia do własnych potrzeb oraz inicjalizacja Pozostałe sposoby tworzenia metaklas Instancje a dziedziczenie 39. Metaklasy ..................................................................................................................1061 1061 1062 1064 1066 1068 1068 1070 1071 1071 1073 1073 1074 1074 1077 1078 1078 1080 1081 1084 1084 1085 1086 1088 1091 1092 1092 Ręczne śledzenie za pomocą dekoracji Śledzenie metaklas oraz dekoratorów Zastosowanie dowolnego dekoratora do metod Metaklasy a dekoratory klas — runda 3. Przykład — dodawanie metod do klas Ręczne rozszerzanie Rozszerzanie oparte na metaklasie Metaklasy a dekoratory klas — runda 2. Przykład — zastosowanie dekoratorów do metod Podsumowanie rozdziału Sprawdź swoją wiedzę — quiz Sprawdź swoją wiedzę — odpowiedzi 26 | Spis treści Dodatki .........................................................................................................1093 Instalowanie interpretera Pythona Czy Python jest już zainstalowany? Skąd pobrać Pythona Instalacja Pythona Konfiguracja Pythona Dodatek A Instalacja i konfiguracja ................................................................................... 1095 1095 1095 1096 1097 1098 1098 1100 1103 1104 Zmienne środowiskowe Pythona Jak ustawić opcje konfiguracyjne? Opcje wiersza poleceń Pythona Uzyskanie pomocy Dodatek B Rozwiązania ćwiczeń podsumowujących poszczególne części książki .........1105 1105 1107 1112 1114 1121 1125 1132 Część I Wprowadzenie Część II Typy i operacje Część III Instrukcja i składnia Część IV Funkcje Część V Moduły Część VI Klasy i programowanie zorientowane obiektowo Część VII Wyjątki oraz narzędzia Skorowidz ............................................................................................................................1139 Spis treści | 27 ROZDZIAŁ 4. Wprowadzenie do typów obiektów Pythona Niniejszy rozdział rozpoczyna naszą wycieczkę po języku Python. W pewnym sensie w Pytho- nie „robi się coś z różnymi rzeczami”. To „coś” ma postać operacji (działań), takich jak doda- wanie czy konkatenacja, natomiast „różne rzeczy” to obiekty, na których wykonuje się owe operacje. W tej części książki skupimy się właśnie na owych „różnych rzeczach”, jak również na tym, co mogą z nimi robić nasze programy. Mówiąc bardziej formalnym językiem, w Pythonie dane przybierają postać obiektów — albo wbudowanych obiektów udostępnianych przez Pythona, albo obiektów tworzonych za pomocą Pythona lub innych narzędzi zewnętrznych, takich jak biblioteki rozszerzeń języka C. Choć definicję tę nieco później rozbudujemy, obiekty są generalnie fragmentami pamięci z warto- ściami i zbiorami powiązanych operacji. Ponieważ obiekty są najbardziej podstawowym elementem Pythona, ten rozdział rozpoczniemy od przeglądu obiektów wbudowanych w sam język. Tytułem wstępu warto jednak najpierw ustalić, jak niniejszy rozdział wpisuje się w całość Pythona. Programy napisane w Pythonie można rozbić na moduły, instrukcje, wyrażenia i obiekty — w następujący sposób: 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. Omówienie modułów zamieszczone w rozdziale 3. uwzględnia najwyższy poziom w tej hie- rarchii. Rozdziały tej części książki odwołują się do najniższego jej poziomu, czyli wbudowanych obiektów oraz wyrażeń, które tworzy się w celu korzystania z tych obiektów. 119 Po co korzysta się z typów wbudowanych? Osoby używające języków niższego poziomu, takich jak C czy C++, wiedzą, że większość ich pracy polega na implementowaniu obiektów — znanych również jako struktury danych — tak by reprezentowały one komponenty w dziedzinie naszej aplikacji. Konieczne jest rozplano- wanie struktur pamięci, zarządzanie przydzielaniem pamięci czy zaimplementowanie procedur wyszukiwania i dostępu. Te zadania są tak żmudne (i podatne na błędy), na jakie wyglądają, i zazwyczaj odciągają programistę od prawdziwych celów programu. W typowych programach napisanych w Pythonie większość tej przyziemnej pracy nie jest konieczna. Ponieważ Python udostępnia typy obiektów jako nieodłączną część samego języka, zazwyczaj nie istnieje konieczność kodowania implementacji obiektów przed rozpoczęciem rozwiązywania prawdziwych problemów. Tak naprawdę, o ile oczywiście nie mamy potrzeby korzystania ze specjalnych metod przetwarzania, które nie są dostępne w obiektach wbudo- wanych, prawie zawsze lepiej będzie skorzystać z gotowego typu obiektu, zamiast tworzyć własny. Poniżej znajduje się kilka przyczyn takiego stanu rzeczy. • Obiekty wbudowane sprawiają, że programy łatwo się pisze. W przypadku prostych zadań obiekty wbudowane często wystarczą nam do stworzenia struktur właściwych dla okre- ślonych problemów. Od ręki dostępne są narzędzia o sporych możliwościach, jak zbiory (listy) i tabele, które można przeszukiwać (słowniki). Wiele zadań można wykonać, korzy- stając z samych obiektów wbudowanych. • Obiekty wbudowane są komponentami rozszerzeń. W przypadku bardziej zaawanso- wanych zadań być może nadal konieczne będzie udostępnianie własnych obiektów, wyko- rzystywanie klas Pythona czy interfejsów języka C. Jednak jak okaże się w dalszej części książki, obiekty implementowane ręcznie są często zbudowane na bazie typów wbudo- wanych, takich jak listy czy słowniki. Strukturę danych stosu można na przykład zaim- plementować jako klasę zarządzającą wbudowaną listą lub dostosowującą tę listę do własnych potrzeb. • Obiekty wbudowane często są bardziej wydajne od własnych struktur danych. Wbu- dowane obiekty Pythona wykorzystują już zoptymalizowane algorytmy struktur danych, które zostały zaimplementowane w języku C w celu zwiększenia szybkości ich działania. Choć możemy samodzielnie napisać podobne typy obiektów, zazwyczaj trudno nam będzie osiągnąć ten sam poziom wydajności, jaki udostępniają obiekty wbudowane. • Obiekty wbudowane są standardową częścią języka. W pewien sposób Python zapożycza zarówno od języków opierających się na obiektach wbudowanych (jak na przykład LISP), jak i języków, w których to programista udostępnia implementacje narzędzi czy własnych platform (jak C++). Choć można w Pythonie implementować własne, unikalne typy obiektów, nie trzeba tego robić, by zacząć programować w tym języku. Co więcej, ponie- waż obiekty wbudowane są standardem, zawsze pozostaną one takie same. Rozwiązania własnościowe zazwyczaj mają tendencję do zmian ze strony na stronę. Innymi słowy, obiekty wbudowane nie tylko ułatwiają programowanie, ale mają także większe możliwości i są bardziej wydajne od większości tego, co tworzy się od podstaw. Bez względu na to, czy zdecydujemy się implementować nowe typy obiektów, obiekty wbudowane sta- nowią podstawę każdego programu napisanego w Pythonie. 120 | Rozdział 4. Wprowadzenie do typów obiektów Pythona Najważniejsze typy danych w Pythonie W tabeli 4.1 zaprezentowano przegląd wbudowanych obiektów Pythona wraz ze składnią wykorzystywaną do kodowania ich literałów — czyli wyrażeń generujących te obiekty.1 Nie- które z typów powinny dla osób znających inne języki programowania wyglądać znajomo. Liczby i łańcuchy znaków reprezentują, odpowiednio, wartości liczbowe i tekstowe. Pliki udostępniają natomiast interfejsy służące do przetwarzania plików przechowywanych na komputerze. Tabela 4.1. Przegląd obiektów wbudowanych Pythona Typ obiektu Liczby Łańcuchy znaków Listy Słowniki Krotki Pliki Zbiory Inne typy podstawowe Typy jednostek programu Typy powiązane z implementacją Przykładowy literał (tworzenie) 1234, 3.1415, 3+4j, Decimal, Fraction mielonka , Brian , b ax01c [1, [2, trzy ], 4] { jedzenie : mielonka , smak : mniam } (1, mielonka , 4, U ) myfile = open( jajka , r ) set( abc ), { a , b , c } Wartości Boolean, typy, None Funkcje, moduły, klasy (część IV, V i VI książki) Kod skompilowany, ślady stosu (część IV i VII książki) Tabela 4.1 nie jest kompletna, ponieważ wszystko, co przetwarzamy w programie napisanym w Pythonie, jest tak naprawdę rodzajem obiektu. Kiedy na przykład wykonujemy w Pytho- nie dopasowanie tekstu do wzorca, tworzymy obiekty wzorców, natomiast kiedy tworzymy skrypty sieciowe, wykorzystujemy obiekty gniazd. Te pozostałe typy obiektów tworzy się przede wszystkim za pomocą importowania i wykorzystywania modułów; każdy z nich wiąże się z pewnym typem zachowania. Jak zobaczymy w dalszych częściach książki, jednostki programów, takie jak funkcje, moduły i klasy, także są w Pythonie obiektami — są one tworzone za pomocą instrukcji oraz wyrażeń, takich jak def, class, import czy lambda, i można je swobodnie przekazywać w skryptach bądź przechowywać w innych obiektach. Python udostępnia również zbiór typów powiąza- nych z implementacją, takich jak obiekty skompilowanego kodu, które są zazwyczaj bardziej przedmiotem zainteresowania osób tworzących narzędzia niż twórców aplikacji. Zostaną one omówione w późniejszych częściach książki. Pozostałe typy obiektów z tabeli 4.1 nazywane są zazwyczaj typami podstawowymi, ponieważ są one tak naprawdę wbudowane w sam język. Oznacza to, że istnieje określona składnia wyra- żeń służąca do generowania większości z nich. Na przykład kiedy wykonamy poniższy kod: mielonka 1 W niniejszej książce pojęcie literał oznacza po prostu wyrażenie, którego składnia generuje obiekt — czasami nazywane również stałą. Warto zauważyć, że „stała” nie oznacza wcale obiektów czy zmiennych, które nigdy nie mogą być zmienione (czyli pojęcie to nie ma związku z const z języka C++ czy określeniem „niezmienny” [ang. immutable] z Pythona — zagadnienie to omówione zostanie w dalszej części rozdziału). Po co korzysta się z typów wbudowanych? | 121 z technicznego punktu widzenia wykonujemy właśnie wyrażenie z literałem, które generuje i zwraca nowy obiekt łańcucha znaków. Istnieje specyficzna składnia Pythona, która tworzy ten obiekt. Podobnie wyrażenie umieszczone w nawiasach kwadratowych tworzy listę, a w nawia- sach klamrowych — słownik. Choć — jak się niedługo okaże — w Pythonie nie istnieje dekla- rowanie typu, składnia wykonywanego wyrażenia określa typy tworzonych i wykorzystywa- nych obiektów. Wyrażenia generujące obiekty, jak te z tabeli 4.1, to właśnie miejsca, z których pochodzą typy obiektów. Co równie ważne: kiedy tworzymy jakiś obiekt, wiążemy go z określonym zbiorem operacji. Na łańcuchach znaków można wykonywać tylko operacje dostępne dla łańcuchów znaków, natomiast na listach — tylko te dla list. Jak się za chwilę okaże, Python jest językiem z typami dynamicznymi (to znaczy automatycznie przechowuje za nas informacje o typach, zamiast wyma- gać kodu z deklaracją), jednak jego typy są silne (to znaczy na obiekcie można wykonać tylko te operacje, które są poprawne dla określonego typu). Z funkcjonalnego punktu widzenia typy obiektów z tabeli 4.1 są bardziej ogólne i mają więk- sze możliwości, niż bywa to w innych językach. Jak się okaże, już same listy i słowniki mają wystarczająco duże możliwości, by zlikwidować większość pracy związanej z obsługą zbio- rów i wyszukiwania w językach niższego poziomu. Listy udostępniają uporządkowane zbio- ry innych obiektów, natomiast słowniki przechowują obiekty i ich klucze. Oba typy danych mogą być zagnieżdżane, mogą rosnąć i kurczyć się na życzenie oraz mogą zawierać obiekty dowolnego typu. W kolejnych rozdziałach szczegółowo omówimy poszczególne typy obiektów zaprezentowane w tabeli 4.1. Zanim jednak zagłębimy się w szczegóły, najpierw przyjrzyjmy się podstawo- wym obiektom Pythona w działaniu. Pozostała część rozdziału zawiera przegląd operacji, które bardziej dokładnie omówimy w kolejnych rozdziałach. Nie należy oczekiwać, że zosta- nie tutaj zaprezentowane wszystko — celem niniejszego rozdziału jest tylko zaostrzenie ape- tytu i wprowadzenie pewnych kluczowych koncepcji. Najlepszym sposobem na rozpoczęcie czegoś jest… samo rozpoczęcie, zatem czas zabrać się za prawdziwy kod. Liczby Dla osób, które zajmowały się już programowaniem czy tworzeniem skryptów, niektóre typy danych z tabeli 4.1 będą wyglądały znajomo. Nawet dla osób niemających nic wspólnego z pro- gramowaniem liczby wyglądają dość prosto. Zbiór podstawowych obiektów Pythona obejmuje typowe rodzaje liczb: całkowite (liczby bez części ułamkowej), zmiennoprzecinkowe (w przy- bliżeniu liczby z przecinkiem), a także bardziej egzotyczne typy liczbowe (liczby zespolone z liczbami urojonymi, liczby stałoprzecinkowe, liczby wymierne z mianownikiem i licznikiem, a także pełne zbiory). Choć oferują kilka bardziej zaawansowanych opcji, podstawowe typy liczbowe Pythona są… właśnie podstawowe. Liczby w Pythonie obsługują normalne działania matematyczne. Znak + wykonuje dodawanie, znak * mnożenie, natomiast ** potęgowanie. 123 + 222 # Dodawanie liczb całkowitych 345 1.5 * 4 # Mnożenie liczb zmiennoprzecinkowych 6.0 2 ** 100 # 2 do potęgi 100 1267650600228229401496703205376 122 | Rozdział 4. Wprowadzenie do typów obiektów Pythona Warto zwrócić uwagę na wynik ostatniego działania. Typ liczby całkowitej Pythona 3.0 auto- matycznie udostępnia dodatkową precyzję dla tak dużych liczb, kiedy jest to potrzebne (w Pytho- nie 2.6 osobny typ długiej liczby całkowitej w podobny sposób obsługiwał liczby zbyt duże dla zwykłego typu liczby całkowitej). Można na przykład w Pythonie obliczyć 2 do potęgi 1000000 jako liczbę całkowitą (choć pewnie lepiej byłoby nie wyświetlać wyniku tego działa- nia — z ponad trzystoma tysiącami cyfr będziemy musieli trochę poczekać!). len(str(2 ** 1000000)) # Ile cyfr będzie w naprawdę DUŻEJ liczbie? 301030 Kiedy zaczniemy eksperymentować z liczbami zmiennoprzecinkowymi, z pewnością natkniemy się na coś, co na pierwszy rzut oka może wyglądać nieco dziwnie: 3.1415 * 2 # repr: jako kod 6.2830000000000004 print(3.1415 * 2) # str: w postaci przyjaznej dla użytkownika 6.283 Pierwszy wynik nie jest błędem — to kwestia sposobu wyświetlania. Okazuje się, że każdy obiekt można wyświetlić na dwa sposoby — z pełną precyzją (jak w pierwszym wyniku powy- żej) oraz w formie przyjaznej dla użytkownika (jak w drugim wyniku). Pierwsza postać znana jest jako repr obiektu (jak w kodzie), natomiast druga jest przyjazną dla użytkownika str. Róż- nica ta zacznie mieć znaczenie, kiedy przejdziemy do używania klas. Na razie, kiedy coś będzie dziwnie wyglądało, należy wyświetlić to za pomocą wywołania wbudowanej instrukcji print. Poza wyrażeniami w Pythonie znajduje się kilka przydatnych modułów liczbowych. Moduły są po prostu pakietami dodatkowych narzędzi, które musimy zaimportować, by móc z nich skorzystać. import math math.pi 3.1415926535897931 math.sqrt(85) 9.2195444572928871 Moduł math zawiera bardziej zaawansowane narzędzia liczbowe w postaci funkcji, natomiast moduł random wykonuje generowanie liczb losowych, a także losowe wybieranie (tutaj z listy Pythona omówionej w dalszej części rozdziału): import random random.random() 0.59268735266273953 random.choice([1, 2, 3, 4]) 1 Python zawiera również bardziej egzotyczne obiekty liczb, takie jak liczby zespolone, liczby stałoprzecinkowe, liczby wymierne, a także zbiory i wartości Boolean (logiczne). Można rów- nież znaleźć różne dodatkowe rozszerzenia na licencji open source (na przykład dla matryc czy wektorów). Szczegółowe omówienie tych typów zostawimy sobie na później. Jak na razie omawialiśmy Pythona w funkcji prostego kalkulatora. Żeby jednak oddać sprawie- dliwość jego typom wbudowanym, warto przejść do omówienia łańcuchów znaków. Liczby | 123 Łańcuchy znaków Łańcuchy znaków (ang. strings) wykorzystywane są do przechowywania informacji teksto- wych, a także dowolnych zbiorów bajtów. Są pierwszym przykładem tego, co w Pythonie znane jest pod nazwą sekwencji — czyli uporządkowanych zbiorów innych obiektów. Sekwen- cje zachowują porządek zawieranych elementów od lewej do prawej strony. Elementy te są przechowywane i pobierane zgodnie z ich pozycją względną. Mówiąc dokładnie, łańcuchy zna- ków to sekwencje łańcuchów składających się z pojedynczych znaków. Pozostałe typy sekwencji to omówione później listy oraz krotki. Operacje na sekwencjach Jako sekwencje łańcuchy znaków obsługują operacje zakładające pozycyjne uporządkowanie elementów. Jeśli na przykład mamy łańcuch czteroznakowy, możemy zweryfikować jego dłu- gość za pomocą wbudowanej funkcji len i pobrać jego elementy za pomocą wyrażeń indek- sujących: S = Mielonka len(S) # Długość 8 S[0] # Pierwszy element w S, indeksowanie rozpoczyna się od zera M S[1] # Drugi element od lewej i W Pythonie indeksy zakodowane są jako wartość przesunięcia od początku łańcucha, dlatego rozpoczynają się od zera. Pierwszy element znajduje się pod indeksem 0, kolejny pod indek- sem 1 i tak dalej. Warto tutaj zwrócić uwagę na przypisanie łańcucha znaków do zmiennej o nazwie S. Szcze- gółowe omówienie tego, jak to działa, odłożymy na później (zwłaszcza do rozdziału 6.), nato- miast warto wiedzieć, że zmiennych Pythona nigdy nie trzeba deklarować z wyprzedzeniem. Zmienna tworzona jest, kiedy przypisujemy do niej wartość; można do niej przypisać dowolny typ obiektu i zostanie zastąpiona swoją wartością, kiedy pojawi się w wyrażeniu. Przed uży- ciem jej wartości musi najpierw zostać przypisana. Na cele niniejszego rozdziału wystarczy nam wiedza, że by móc zapisać obiekt w celu późniejszego użycia, musimy przypisać ten obiekt do zmiennej. W Pythonie można również indeksować od końca — indeksy dodatnie odliczane są od lewej strony do prawej, natomiast ujemne od prawej do lewej: S[-1] # Pierwszy element od końca S a S[-2] # Drugi element od końca S k Z formalnego punktu widzenia indeks ujemny jest po prostu dodawany do rozmiaru łańcu- cha znaków, dzięki czemu dwie poniższe operacje są równoważne (choć pierwszą łatwiej jest zapisać, a trudniej się w niej pomylić): S[-1] # Ostatni element w S a S[len(S)-1] # Indeks ujemny zapisany w trudniejszy sposób a 124 | Rozdział 4. Wprowadzenie do typów obiektów Pythona Warto zauważyć, że w nawiasach kwadratowych możemy wykorzystać dowolne wyrażenie, a nie tylko zakodowany na stałe literał liczbowy. W każdym miejscu, w którym Python ocze- kuje wartości, można użyć literału, zmiennej lub dowolnego wyrażenia. Składnia Pythona jest w tym zakresie bardzo ogólna. Poza prostym indeksowaniem zgodnie z pozycją sekwencje obsługują również bardziej ogólną formę indeksowania znaną jako wycinki (ang. slice). Polega ona na ekstrakcji całej części (wycinka) za jednym razem, jak na przykład: S # Łańcuch z ośmioma znakami Mielonka S[1:3] # Wycinek z S z indeksami od 1 do 2 (bez 3) ie Wycinki najłatwiej jest sobie wyobrazić jako sposób pozwalający na ekstrakcję całej kolumny z łańcucha znaków za jednym razem. Ich ogólna forma, X[I:J], oznacza: „Zwróć wszystko z X od przesunięcia I aż do przesunięcia J, ale bez niego”. Wynik zwracany jest w nowym obiekcie. Druga operacja z listingu wyżej zwraca na przykład wszystkie znaki w łańcuchu znaków S od przesunięcia 1 do przesunięcia 2 (czyli 3–1) jako nowy łańcuch znaków. Wynikiem jest wycinek składający się z dwóch znaków znajdujących się w środku łańcucha S. W wycinku lewą granicą jest domyślnie zero, natomiast prawą — długość sekwencji, z której coś wycinamy. Dzięki temu można spotkać różne warianty użycia wycinków: S[1:] # Wszystko poza pierwszym znakiem (1:len(S)) ielonka S # Łańcuch S się nie zmienił Mielonka S[0:7] # Wszystkie elementy bez ostatniego Mielonk S[:7] # To samo co S[0:7] Mielonk S[:-1] # Wszystkie elementy bez ostatniego w łatwiejszej postaci Mielonk S[:] # Całość S jako kopia najwyższego poziomu (0:len(S)) Mielonka Warto zwrócić uwagę na to, że do ustalenia granic wycinków mogą również zostać wykorzy- stane ujemne wartości przesunięcia. Widać również, że ostatnia operacja w rezultacie kopiuje cały łańcuch znaków. Jak się okaże później, kopiowanie łańcucha znaków nie ma sensu, jednak to polecenie może
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

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