Darmowy fragment publikacji:
Python 3. Kompletne
wprowadzenie do
programowania. Wydanie II
Autor: Mark Summerfield
T³umaczenie: Robert Górczyñski
ISBN: 978-83-246-2642-7
Tytu³ orygina³u: Programming in Python 3: A Complete
Introduction to the Python Language (2nd Edition)
Format: 170×230, stron: 640
Poznaj wspania³e mo¿liwoœci jêzyka Python 3 i twórz dowolne programy
Python 3 uznany zosta³ za najlepsz¹ dotychczasow¹ wersjê tego jêzyka, poniewa¿
jego mo¿liwoœci s¹ dziœ znacznie wiêksze ni¿ dawniej. Python 3 jest wygodny, spójny
i ekspresyjny, a tak¿e niezale¿ny od platformy sprzêtowej i – co najwa¿niejsze –
dostarczany z pe³n¹ bibliotek¹ standardow¹. Mo¿na go wykorzystaæ do programowania
proceduralnego, zorientowanego obiektowo oraz (w mniejszym stopniu) do programowania
w stylu funkcjonalnym. Autor ksi¹¿ki, Mark Summerfield, ekspert w dziedzinie programowania,
przedstawia szczegó³owe informacje dotycz¹ce tego jêzyka w bardzo przyjazny sposób,
co sprawia, ¿e czytelnik szybko i sprawnie mo¿e napisaæ dowolny program.
Ksi¹¿ka „Python 3. Kompletne wprowadzenie do programowania. Wydanie II” zosta³a
zaprojektowana tak, aby móg³ z niej korzystaæ zarówno ktoœ o niewielkim doœwiadczeniu
w programowaniu, jak i profesjonaliœci, naukowcy, in¿ynierowie oraz studenci. Dziêki
niej szybko nauczysz siê m.in. wykorzystywaæ zaawansowane rodzaje danych, kolekcje
oraz struktury kontrolne. Poznasz techniki analizy sk³adniowej, obejmuj¹ce u¿ywanie
modu³ów PyParsing i PLY. Dowiesz siê, na czym polega rozk³adanie obci¹¿enia programu
miêdzy wiele procesów i w¹tków, a tak¿e zaczniesz u¿ywaæ techniki Test Driven
Development, aby unikn¹æ pope³niania b³êdów. Znajdziesz tu wszelkie niezbêdne
informacje, dziêki którym bêdziesz móg³ stworzyæ solidne i wydajne programy.
(cid:129) Tworzenie i uruchamianie programów Pythona
(cid:129) Polecenia kontroli przep³ywu
(cid:129) Rodzaje danych
(cid:129) Funkcje i struktury kontrolne
(cid:129) Modu³y i pakiety
(cid:129) Programowanie zorientowane obiektowo
(cid:129) Obs³uga plików
(cid:129) Zaawansowane techniki programowania
(cid:129) Kontrola dostêpu do atrybutów
(cid:129) Usuwanie b³êdów, testowanie i profilowanie
(cid:129) Wyra¿enia regularne
Ten podrêcznik jest jak Python 3 – spójny, praktyczny i wygodny
Mark Summerfield jest informatykiem z wieloletnim doœwiadczeniem w dziedzinie
programowania. Jest tak¿e wspó³autorem ksi¹¿ki „C++ GUI Programming with Qt 4”
oraz autorem ksi¹¿ki „Rapid GUI Programming with Python and Qt: The Definitive Guide
to PyQt Programming”. Mark za³o¿y³ firmê Qtrac Ltd., http://www.qtrac.eu, w której
pracuje jako niezale¿ny publicysta, redaktor, trener i konsultant specjalizuj¹cy siê
w C++, Qt, Pythonie i PyQt.
Spis treści
O autorze ...........................................................................13
Wprowadzenie ...................................................................15
Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego ......23
Tworzenie i uruchamianie programów Pythona .................................24
„Piökne serce” Pythona .................................................................29
Koncepcja 1. — rodzaje danych ................................................29
Koncepcja 2. — odniesienia do obiektów ..................................31
Koncepcja 3. — kolekcje rodzajów danych .................................33
Koncepcja 4. — operatory logiczne ...........................................36
Koncepcja 5. — polecenia kontroli przepäywu programu ..............40
Koncepcja 6. — operatory arytmetyczne ....................................45
Koncepcja 7. — operacje wejĈcia-wyjĈcia ...................................48
Koncepcja 8. — tworzenie i wywoäywanie funkcji ........................51
Przykäady ......................................................................................53
bigdigits.py ..............................................................................53
generate_grid.py ......................................................................56
Podsumowanie .............................................................................58
çwiczenia .....................................................................................61
Rozdziaä 2. Rodzaje danych ..................................................................65
Identyfikatory i säowa kluczowe .......................................................65
Caäkowite rodzaje danych ...............................................................69
Liczby caäkowite .......................................................................69
WartoĈci boolowskie ................................................................72
Zmiennoprzecinkowe rodzaje danych ..............................................73
Liczby zmiennoprzecinkowe (Float) ............................................74
Liczby zespolone (Complex) ......................................................77
Liczby Decimal .........................................................................78
8
Python 3. Kompletne wprowadzenie do programowania
Ciñgi tekstowe ..............................................................................80
Porównywanie ciñgów tekstowych ..............................................83
Segmentowanie i poruszanie siö krokami
w ciñgu tekstowym .................................................................84
Operatory i metody dotyczñce ciñgu tekstowego .........................87
Formatowanie ciñgu tekstowego
za pomocñ metody str.format() ...............................................95
Kodowanie znaków ................................................................107
Przykäady ....................................................................................111
quadratic.py ..........................................................................111
csv2html.py ...........................................................................114
Podsumowanie ...........................................................................118
çwiczenia ...................................................................................120
Rozdziaä 3. Kolekcje rodzajów danych ................................................123
Rodzaje sekwencji .......................................................................124
Krotki ....................................................................................124
Nazwane krotki ......................................................................127
Listy .....................................................................................129
Rodzaje danych set .....................................................................137
Set (zbiór) .............................................................................138
Rodzaj danych frozenset .........................................................142
Rodzaje mapowania ....................................................................143
Säowniki ................................................................................143
Säowniki domyĈlne .................................................................152
Säowniki uporzñdkowane ........................................................153
Iteracja i kopiowanie kolekcji ........................................................155
Iteratory i operacje oraz funkcje iteracji ....................................155
Kopiowanie kolekcji ...............................................................164
Przykäady ....................................................................................166
generate_usernames.py .........................................................166
statistics.py ..........................................................................169
Podsumowanie ...........................................................................173
çwiczenia ...................................................................................175
Rozdziaä 4. Funkcje i struktury kontrolne ...........................................177
Struktury kontrolne ......................................................................177
Konstrukcje rozgaäöziajñce ......................................................178
Pötle .....................................................................................179
Obsäuga wyjñtków ........................................................................181
Przechwytywanie i obsäuga wyjñtków ........................................181
Wäasne wyjñtki .......................................................................186
Spis treĈci
9
Wäasne funkcje ...........................................................................189
Nazwy i dokumentujñce ciñgi tekstowe ....................................193
Rozpakowywanie argumentu i parametru .................................195
Uzyskiwanie dostöpu do zmiennych w zasiögu globalnym ..........197
Funkcja lambda .....................................................................199
Asercje .................................................................................201
Przykäad: make_html_skeleton.py .................................................202
Podsumowanie ...........................................................................208
çwiczenie ...................................................................................209
Rozdziaä 5. Moduäy ............................................................................213
Moduäy i pakiety ..........................................................................214
Pakiety ..................................................................................217
Wäasne moduäy ......................................................................220
Ogólny opis biblioteki standardowej Pythona .................................230
Obsäuga ciñgów tekstowych ....................................................230
Programowanie wiersza polecenia ...........................................232
Matematyka i liczby ................................................................233
Data i godzina .......................................................................234
Algorytmy i kolekcje rodzajów danych .......................................235
Formaty plików, kodowania znaków i przechowywanie danych ....236
Plik, katalog i obsäuga przetwarzania .......................................240
Praca w sieci i programowanie internetowe ..............................242
XML ......................................................................................244
Inne moduäy ..........................................................................246
Podsumowanie ...........................................................................247
çwiczenie ...................................................................................249
Rozdziaä 6. Programowanie zorientowane obiektowo ...........................251
PodejĈcie zorientowane obiektowo ...............................................252
Koncepcje i terminologia programowania
zorientowanego obiektowo ....................................................253
Wäasne klasy ..............................................................................256
Atrybuty i metody ...................................................................257
Dziedziczenie i polimorfizm .....................................................262
UĔywanie wäaĈciwoĈci w celu kontrolowania
dostöpu do atrybutów ..........................................................264
Tworzenie w peäni zintegrowanych rodzajów danych ...................266
Wäasne klasy kolekcji ..................................................................279
Tworzenie klas agregujñcych kolekcje ......................................279
Tworzenie klas kolekcji za pomocñ agregacji ............................286
Tworzenie klas kolekcji za pomocñ dziedziczenia ......................292
Podsumowanie ...........................................................................299
çwiczenia ...................................................................................301
10
Python 3. Kompletne wprowadzenie do programowania
Rozdziaä 7. Obsäuga plików ................................................................303
Zapis i odczyt danych binarnych ...................................................308
Peklowanie wraz z opcjonalnñ konwersjñ .................................308
Zwykäe dane binarne wraz z opcjonalnñ kompresjñ ....................312
Zapis i przetwarzanie plików tekstowych ........................................321
Zapis tekstu ..........................................................................321
Przetwarzanie tekstu ..............................................................322
Przetwarzanie tekstu za pomocñ wyraĔeþ regularnych ...............325
Zapis i przetwarzanie plików XML .................................................328
Drzewa elementów .................................................................329
Model DOM (Document Object Model) .....................................332
Röczny zapis XML ..................................................................335
Przetwarzanie XML za pomocñ SAX (Simple API dla XML) ..........336
Swobodny dostöp do plików binarnych ..........................................339
Ogólna klasa BinaryRecordFile ................................................339
Przykäad: klasy moduäu BikeStock ...........................................347
Podsumowanie ...........................................................................351
çwiczenia ...................................................................................352
Rozdziaä 8. Zaawansowane techniki programowania ...........................355
Dalsze techniki programowania proceduralnego .............................356
Rozgaäözianie za pomocñ säowników ........................................356
Funkcje i wyraĔenia generatora ...............................................358
Dynamiczne wykonywanie kodu
oraz dynamiczne polecenia import .........................................360
Funkcje lokalne i rekurencyjne ................................................368
Dekoratory funkcji i metod ......................................................372
Adnotacje funkcji ...................................................................376
Dalsze techniki programowania zorientowanego obiektowo .............378
Kontrola dostöpu do atrybutów ...............................................379
Funktor .................................................................................382
MenedĔery kontekstu .............................................................384
Deskryptory ...........................................................................388
Dekoratory klas .....................................................................392
Abstrakcyjne klasy bazowe .....................................................395
Dziedziczenie wielokrotne .......................................................402
Metaklasy .............................................................................404
Programowanie funkcjonalne ........................................................408
Funkcje czöĈciowe aplikacji ....................................................411
Wspóäprogramy ......................................................................412
Przykäad: valid.py .........................................................................421
Podsumowanie ...........................................................................423
çwiczenia ...................................................................................424
Spis treĈci
11
Rozdziaä 9. Usuwanie bäödów, testowanie i profilowanie .....................427
Usuwanie bäödów ........................................................................428
Obsäuga bäödów skäadni ..........................................................429
Obsäuga bäödów w trakcie dziaäania programu ..........................430
Naukowy sposób usuwania bäödów ..........................................434
Testy jednostkowe ......................................................................440
Profilowanie ................................................................................446
Podsumowanie ...........................................................................451
Rozdziaä 10. Procesy i wñtkowanie ......................................................453
UĔywanie moduäu Multiprocessing ................................................454
UĔywanie moduäu Threading .........................................................458
Przykäad: program wyszukiwania uĔywajñcy wñtków ...................460
Przykäad: program wyszukujñcy powielone pliki
uĔywajñcy wñtkowania ..........................................................463
Podsumowanie ...........................................................................468
çwiczenia ...................................................................................469
Rozdziaä 11. Praca w sieci ..................................................................471
Tworzenie klienta TCP ..................................................................473
Tworzenie serwera TCP ................................................................478
Podsumowanie ...........................................................................485
çwiczenia ...................................................................................485
Rozdziaä 12. Programowanie bazy danych ............................................489
Bazy danych DBM .......................................................................490
Bazy danych SQL ........................................................................494
Podsumowanie ...........................................................................501
çwiczenie ...................................................................................502
Rozdziaä 13. WyraĔenia regularne ........................................................503
Jözyk wyraĔeþ regularnych Pythona ...............................................504
Znaki i klasy znaków ..............................................................505
Kwantyfikatory .......................................................................506
Grupowanie i przechwytywanie ................................................508
Asercje i opcje .......................................................................511
Moduä wyraĔeþ regularnych ..........................................................515
Podsumowanie ...........................................................................526
çwiczenia ...................................................................................526
Rozdziaä 14. Wprowadzenie do analizy skäadniowej ...............................529
Skäadnia BNF i terminologia zwiñzana z analizñ skäadniowñ ............531
Tworzenie wäasnych analizatorów skäadni ......................................535
Prosta analiza skäadniowa danych klucz – wartoĈè ....................536
Analiza skäadniowa listy odtwarzania .......................................539
Analiza skäadniowa bloków jözyka specjalizowanego .................541
12
Python 3. Kompletne wprowadzenie do programowania
Analiza skäadniowa za pomocñ moduäu PyParsing ..........................550
Krótkie wprowadzenie do moduäu PyParsing .............................551
Prosta analiza skäadniowa danych klucz – wartoĈè ....................555
Analiza skäadniowa danych listy odtwarzania ............................557
Analiza skäadniowa bloków jözyka specjalizowanego .................559
Analiza skäadni logiki pierwszego rzödu ....................................564
Analiza skäadniowa Lex/Yacc za pomocñ moduäu PLY ....................569
Prosta analiza skäadniowa danych klucz – wartoĈè ....................571
Analiza skäadniowa danych listy odtwarzania ............................573
Analiza skäadniowa bloków jözyka specjalizowanego .................575
Analizator skäadni logiki pierwszego rzödu ................................577
Podsumowanie ...........................................................................582
çwiczenie ...................................................................................583
Rozdziaä 15. Wprowadzenie do programowania GUI ..............................585
Programy w stylu okna dialogowego ..............................................588
Programy w stylu okna gäównego ..................................................594
Tworzenie okna gäównego .......................................................595
Tworzenie wäasnego okna dialogowego ....................................605
Podsumowanie ...........................................................................608
çwiczenia ...................................................................................609
Epilog ..............................................................................611
Wybrana bibliografia ........................................................613
Skorowidz ........................................................................615
1
Szybkie wprowadzenie
do programowania
proceduralnego
W rozdziale:
Tworzenie i uruchamianie programów Pythona
„Piękne serce” Pythona
W
tym rozdziale zostanie omówiona taka ilość materiału, że jej lektura pozwoli czytelnikowi
na rozpoczęcie tworzenia programów w języku Python. Jeżeli czytelnik jeszcze nie
zainstalował Pythona, gorąco zachęcamy do przeprowadzenia instalacji. Pozwoli to na
zdobywanie doświadczenia i utrwalanie poznawanego materiału. (Instalacja Pythona na
głównych platformach sprzętowych została omówiona we wcześniejszym rozdziale
„Wprowadzenie”, g 19).
Pierwszy podrozdział zaprezentuje sposób tworzenia i uruchamiania programów
Pythona. Kod Pythona można tworzyć w dowolnym edytorze tekstowym. Omówione
w rozdziale środowisko programistyczne IDLE oferuje nie tylko sam edytor kodu
źródłowego, ale także funkcje dodatkowe pozwalające na między innymi eksperymentowanie
z kodem Pythona oraz usuwanie błędów z kodu.
Drugi podrozdział został poświęcony ośmiu kluczowym koncepcjom Pythona,
których poznanie wystarczy do tworzenia użytecznych programów. Wszystkie wymienione
tutaj konstrukcje będą dokładnie omówione w dalszych rozdziałach książki. W miarę
przedstawiania kolejnego materiału koncepcje te zostaną uzupełnione informacjami
obejmującymi szerszy zakres języka Python. W ten sposób po przeczytaniu książki czytelnik
będzie znał cały język i podczas pracy nad własnymi programami będzie w stanie
wykorzystywać wszystkie możliwości języka.
24
Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego
Ostatni podrozdział zawiera dwa krótkie programy, w których użyto niektórych funkcji
Pythona omówionych w podrozdziale drugim. Dzięki temu czytelnik natychmiast będzie
mógł „wypróbować” Pythona.
Kodowanie
znaków
h 107.
Tworzenie i uruchamianie programów Pythona
Kod Pythona można tworzyć w dowolnym edytorze tekstowym, który umożliwia zapis
i odczyt plików tekstowych stosujących kodowanie znaków ASCII lub UTF-8 Unicode.
Domyślnie pliki Pythona stosują kodowanie znaków UTF-8 obejmujące większy zbiór
znaków niż ASCII. Za pomocą kodowania UTF-8 można przedstawiać każdy znak w każdym
języku. Pliki Pythona zwykle mają rozszerzenie .py, chociaż w niektórych systemach z rodziny
Unix (na przykład Linux i Mac OS X) pewne aplikacje Pythona nie mają rozszerzenia pliku.
Programy Pythona z graficznym interfejsem użytkownika (GUI, czyli Graphical User
Interface) zazwyczaj mają rozszerzenie .pyw, zwłaszcza w systemach Windows oraz Mac
OS X. W niniejszej książce moduły Pythona oraz programy Pythona działające w konsoli
zawsze mają rozszerzenie .py, natomiast programy GUI są oznaczone rozszerzeniem .pyw.
Wszystkie przykłady zaprezentowane w książce można w niezmienionej postaci uruchomić
na każdej platformie sprzętowej z zainstalowanym Pythonem 3.
Aby upewnić się, że wszystko zostało skonfigurowane prawidłowo, oraz przedstawić
klasyczny pierwszy przykład, należy w edytorze tekstowym (w systemie Windows można
użyć programu Notatnik — wkrótce zaczniemy korzystać z lepszego edytora) utworzyć
plik o nazwie hello.py zawierający następujące wiersze:
#!/usr/bin/env python3
print( Witaj , Ăwiecie! )
Pierwszy wiersz to komentarz. W Pythonie komentarz rozpoczyna się od znaku #
i ciągnie się aż do końca wiersza. (Znaczenie powyższego komentarza wyjaśnimy za chwilę).
Drugi wiersz jest pusty — poza ciągami tekstowymi ujętymi w cudzysłów, Python ignoruje
puste wiersze. Jednak mają one istotne znaczenie dla programistów, gdyż oddzielają duże
bloki kodu, co ułatwia ich odczyt. Wiersz trzeci zawiera kod Pythona. W tym wierszu
następuje wywołanie funkcji printf() wraz z dwoma argumentami, z których każdy jest
typu str (string — ciąg tekstowy, czyli sekwencja znaków).
Każde polecenie napotkane w pliku .py zostaje kolejno wykonane, począwszy od
pierwszego i dalej wiersz po wierszu. To zupełnie odmienne podejście niż w innych językach,
takich jak C++ bądź Java, gdzie mamy określoną funkcję lub metodę posiadającą nazwę
specjalną, która stanowi punkt początkowy programu. Oczywiście, istnieje możliwość
sterowania przepływem programu, co zostanie zaprezentowane w kolejnym podrozdziale
podczas omawiania struktur kontrolnych Pythona.
Przyjmujemy założenie, że użytkownik systemu Windows zapisuje kod Pythona
w katalogu C:py3eg, natomiast użytkownik systemu z rodziny Unix (na przykład Unix,
Linux lub Mac OS X) przechowuje kod w katalogu $HOME/py3eg. Plik hello.py
należy więc zapisać w katalogu py3eg i zamknąć edytor tekstowy.
Tworzenie i uruchamianie programów Pythona
25
Mamy więc program, który można uruchomić. Programy w języku Python są wykonywane
przez interpreter Pythona, zazwyczaj w oknie konsoli. W systemie Windows konsola nosi
nazwę „konsola”, „wiersz polecenia DOS”, „wiersz polecenia MS-DOS” lub podobnie i zwykle
znajduje się w menu Start/Wszystkie programy/Akcesoria. W systemie Mac OS X konsola
jest dostarczana przez narzędzie Terminal.app (domyślnie znajduje się w katalogu
Programy/Narzędzia) dostępne poprzez Findera. W pozostałych systemach Unix można
użyć xterm bądź konsoli oferowanej przez menedżera okien, na przykład konsole bądź
gnome-terminal.
Uruchom konsolę, następnie w systemie Windows wprowadź poniższe polecenia
(przyjmujemy założenie, że Python został zainstalowany w lokalizacji domyślnej). Dane
wyjściowe konsoli są przedstawione czcionkÈ o staïej szerokoĂci, natomiast wprowadzane
polecenia zostały pogrubione:
C: cd c:py3eg
C:py3eg c:python31python.exe hello.py
Ponieważ polecenie cd (change directory, czyli zmień katalog) używa bezwzględnej ścieżki
dostępu, katalog, z poziomu którego zostanie uruchomiony program, nie ma żadnego
znaczenia.
Użytkownicy systemu Unix wydają polecenia pokazane poniżej (przyjmujemy założenie,
że odniesienie do Pythona 3 znajduje się w systemowej ścieżce PATH)1:
$ cd $HOME/py3eg
$ python3 hello.py
W obu przypadkach dane wyjściowe prezentują się tak samo:
Witaj Ăwiecie!
Warto pamiętać, że jeśli nie napisano inaczej, zachowanie języka Python w systemie
Mac OS X jest takie samo, jak w każdym innym systemie z rodziny Unix. Możemy więc
przyjąć, że kiedy używamy określenia „Unix”, oznacza to system Linux, BSD, Mac OS X
oraz większość pozostałych systemów Unix i wywodzących się z rodziny Unix.
Chociaż pierwszy program składa się tylko z jednego polecenia wykonywalnego, po
jego uruchomieniu możemy wyciągnąć pewne wnioski dotyczące funkcji print(). Przede
wszystkim funkcja print() jest elementem wbudowanym w język Python — w celu jej użycia
nie musimy jej „importować” ani „dołączać” z biblioteki. Ponadto każdy element wyświetlany
przez funkcję jest oddzielony pojedynczą spacją, a po wyświetleniu ostatniego wstawiany jest
znak nowego wiersza. To jest zachowanie domyślne funkcji i jak przekonamy się nieco później,
możemy je zmienić. Inną ważną informacją dotyczącą funkcji print() jest to, że może
pobierać dowolną ilość argumentów.
Wprowadzanie przedstawionych powyżej poleceń w celu uruchamiania tworzonych
programów w Pythonie bardzo szybko może okazać się uciążliwe. Na szczęście w systemach
zarówno Windows, jak i Unix można zastosować znacznie wygodniejsze podejście.
1
Znak zachęty systemu Unix może być odmienny niż przedstawiony w powyższym przykładzie znak
dolara ($), to nie ma żadnego znaczenia.
Funkcja
print()
h 198
26
Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego
Zakładamy, że znajdujemy się w katalogu py3eg. W systemie Windows można więc
po prostu wydać polecenie:
C:py3eg hello.py
Windows używa rejestru przypisań plików w celu automatycznego wywołania
interpretera Pythona za każdym razem, gdy w konsoli zostanie wprowadzona nazwa pliku
z rozszerzeniem .py.
Niestety, takie wygodne podejście nie zawsze działa, ponieważ pewne wersje systemu
Windows mają błąd, który czasami negatywnie wpływa na wykonywanie programów
interpretowanych wywoływanych jako wynik odczytania zdefiniowanego przypisania pliku.
To nie jest błąd w Pythonie — inne interpretery, a także niektóre pliki .bat także padają
ofiarą tego błędu. Jeżeli czytelnik spotka się z tego rodzaju błędem, wówczas należy
bezpośrednio wywołać Pythona, zamiast polegać na mechanizmie rozpoznawania
przypisań plików.
Jeśli w systemie Windows dane wyjściowe mają postać:
( Witaj , Ăwiecie! )
oznacza to, że w systemie znajduje się Python 2 i został wywołany zamiast Pythona 3.
Jednym z rozwiązań będzie zmiana przypisania pliku .py z Pythona 2 na Python 3. Inne
rozwiązanie (mniej wygodne, lecz bezpieczniejsze) do dodanie Pythona 3 do systemowej
ścieżki dostępu (przyjmujemy założenie, że został zainstalowany w lokalizacji domyślnej)
i wyraźne wywoływanie Pythona za każdym razem. (Ten sposób powoduje także rozwiązanie
wspomnianego wcześniej błędu w Windows, dotyczącego przypisań plików). Przykładowo:
C:py3eg path=c:python31; path
C:py3eg python hello.py
Znacznie wygodniejszym rozwiązaniem może być utworzenie pliku py3.bat zawierającego
pojedynczy wiersz kodu path=c:python31; path i zapisanie tego pliku w katalogu
C:Windows. Następnie, po każdym włączeniu konsoli w celu uruchamiania programów
napisanych w Pythonie, pracę trzeba rozpocząć od wykonania pliku py3.bat. Ewentualnie
można skonfigurować system tak, aby plik py3.bat był wykonywany automatycznie.
W tym celu należy zmodyfikować właściwości konsoli (odszukaj konsolę w menu Start,
a następnie kliknij konsolę prawym przyciskiem myszy i wybierz opcję Właściwości).
W wyświetlonym oknie dialogowym przejdź na kartę Skrót, w polu Element docelowy
dodaj ciąg tekstowy „ /u /k c:windowspy3.bat” (zwróć uwagę na spację przed, między
i po opcjach „/u” oraz „/k” i upewnij się, że ciąg tekstowy znajduje się po poleceniu cmd.exe).
W systemie Unix plikowi trzeba w pierwszej kolejności nadać uprawnienia do
wykonywania, a dopiero potem można go uruchomić:
$ chmod +x hello.py
$ ./hello.py
Oczywiście polecenie chmod należy wykonać tylko jednokrotnie, później wystarczy po
prostu wydać polecenie ./hello.py i program zostanie uruchomiony.
Tworzenie i uruchamianie programów Pythona
27
W systemie Unix podczas wywoływania programu w konsoli następuje odczyt dwóch
pierwszych bajtów pliku2. Jeżeli odczytane bajty są znakami #! zbioru znaków ASCII, wówczas
powłoka przyjmuje założenie, że plik powinien być wykonany przez interpreter, który
zresztą jest wskazany w pierwszym wierszu pliku. Ten wiersz nosi nazwę shebang (shell
execute, czyli plik wykonywalny powłoki) i jeśli zostaje umieszczony w pliku, to musi być
pierwszym wierszem pliku.
Wiersz shebang jest zazwyczaj zapisywany w jednej z dwóch możliwych postaci:
#!/usr/bin/python3
lub
#!/usr/bin/env python3
Jeżeli będzie zapisany w pierwszej formie, użyty zostanie wymieniony interpreter.
Użycie tej formy może okazać się konieczne w przypadku programów Pythona uruchamianych
przez serwer WWW, choć sama ścieżka dostępu może być odmienna niż przedstawiona
w powyższym przykładzie. Jeśli zostanie użyta druga forma, użyty zostanie pierwszy
interpreter python3 znaleziony w bieżącym środowisku powłoki. Druga forma jest znacznie
elastyczniejsza, ponieważ dopuszcza możliwość, że interpreter Python 3 nie został umieszczony
w katalogu /usr/bin (na przykład może być zainstalowany w katalogu /usr/local/bin bądź
w $HOME). W systemie Windows wiersz shebang nie jest wymagany (choć równocześnie
pozostaje nieszkodliwy). Wszystkie przykłady zaprezentowane w książce zawierają
wiersz shebang w drugiej formie, choć nie umieszczono go w listingach.
Warto zwrócić uwagę, że dla systemów Unix przyjmujemy założenie, iż nazwa pliku
wykonywalnego Pythona 3 (lub dowiązanie symboliczne do niego) w zmiennej systemowej
PATH to python3. Jeżeli tak nie jest, w przykładach należy zmodyfikować wiersz shebang
i podać odpowiednią nazwę (prawidłową nazwę i ścieżkę dostępu w przypadku używania
pierwszej formy wiersza shebang). Ewentualnie trzeba utworzyć dowiązanie symboliczne
z pliku wykonywalnego Python 3 do nazwy python3 w zmiennej PATH.
Wiele edytorów tekstowych o potężnych możliwościach, na przykład Vim i Ecmacs,
jest dostarczanych wraz z wbudowaną obsługą edycji programów w języku Python.
Wspominania obsługa zazwyczaj obejmuje kolorowanie składni oraz prawidłowe stosowanie
wcięć wierszy. Alternatywnym rozwiązaniem jest używanie środowiska programistycznego
dla Pythona, którym jest IDLE. W systemach Windows i Mac OS X środowisko IDLE jest
instalowane domyślnie. Z kolei w systemie Unix środowisko IDLE zostaje zbudowane
wraz z interpreterem Pythona, o ile jest on budowany z archiwum tarball. W przypadku
użycia menedżera pakietów środowisko IDLE zwykle jest dostarczane jako oddzielny pakiet,
jak to przedstawiono we wcześniejszym rozdziale „Wprowadzenie”.
Na rysunku 1.1 pokazano środowisko IDLE. Jak widać, IDLE charakteryzuje się
przestarzałym interfejsem graficznym, który przypomina czasy motywu Motif w systemach
Unix bądź systemu Windows 95. Wynika to z faktu używania biblioteki GUI Tkinter
2
Interakcja między użytkownikiem i konsolą jest obsługiwana przez program „powłoka”. Rozróżnienie między
programami konsoli i powłoki nie ma tutaj najmniejszego znaczenia, więc oba pojęcia są tu używane zamiennie.
Pobieranie
i instalacja
Pythona
19 g
28
Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego
Rysunek 1.1. Konsola Pythona w Ĉrodowisku IDLE
bazującej na Tk (omówiona w rozdziale 15.), a nie jednej z nowoczesnych i oferujących
potężniejsze możliwości bibliotek takich jak PyGtk, PyQt lub wxPython. Powód stosowania
biblioteki Tkinter to połączenie historii, liberalnych warunków licencji oraz faktu, że biblioteka
Tkinter jest znacznie mniejsza niż inne biblioteki GUI. Na plus można zaliczyć to, że środowisko
IDLE jest dostarczane domyślnie wraz z Pythonem i bardzo łatwo je poznać oraz go używać.
Środowisko IDLE zapewnia trzy istotne funkcje: możliwość wprowadzania wyrażeń
języka Python oraz kodu źródłowego i obserwowania wyników bezpośrednio w powłoce
Pythona, edytor kodu oferujący kolorowanie składni kodu Pythona oraz prawidłowe
stosowanie wcięć wierszy, a także moduł usuwania błędów pozwalający na przejście przez
kod wiersz po wierszu, znajdywanie i usuwanie błędów. Powłoka Pythona jest szczególnie
użyteczna w trakcie wypróbowywania przykładowych algorytmów, fragmentów kodu oraz
wyrażeń regularnych. Może być także używana jako oferujący potężne możliwości i bardzo
elastyczny kalkulator.
Dostępnych jest kilka innych środowisk programistycznych Pythona, ale zalecamy
stosowanie środowiska IDLE, przynajmniej na początku. Alternatywą jest tworzenie
programów w zwykłym edytorze tekstowym, a następnie usuwanie błędów poprzez
stosowanie wywołań funkcji print().
Możliwe jest wywołanie interpretera Pythona bez wskazywania programu w języku
Python. W takim przypadku interpreter zostaje uruchomiony w trybie interaktywnym.
Podczas pracy w tym trybie można wprowadzać polecenia Pythona i obserwować wyniki
dokładnie w taki sam sposób, jak w trakcie używania okna powłoki Pythona środowiska IDLE
— wraz z tymi samymi znakami zachęty w postaci . Jednak środowisko IDLE pozostaje
znacznie łatwiejsze w użyciu, więc zalecamy stosowanie IDLE podczas eksperymentowania
„Piökne serce” Pythona
29
z fragmentami kodu. Gdy prezentujemy krótkie przykłady interaktywne, przyjmujemy
wówczas założenie, że są one wprowadzane w interaktywnym interpreterze Python bądź
oknie powłoki Pythona środowiska IDLE.
Wiemy już, w jaki sposób tworzyć i uruchamiać programy Pythona, ale przecież
czytelnicy nie znają jeszcze języka — posiadają jedynie ogólną wiedzę o pojedynczej funkcji.
Dzięki lekturze kolejnego rozdziału wyraźnie zwiększy się ich wiedza o języku Python.
Przedstawione tu informacje pozwolą na tworzenie krótkich, choć użytecznych programów
w Pythonie, co zaprezentujemy w ostatnim podrozdziale niniejszego rozdziału.
„Piökne serce” Pythona
W tym podrozdziale zostanie omówionych osiem kluczowych koncepcji języka Python,
natomiast w kolejnym podrozdziale przedstawimy użycie tych koncepcji podczas tworzenia
kilku małych, a jednak użytecznych programów. Na temat zagadnień poruszonych w tym
podrozdziale można powiedzieć znacznie więcej. Dlatego też jeśli czytelnik poczuje, że czegoś
brakuje w Pythonie bądź że pewne zadania są wykonywane w zbyt długi sposób, wtedy
może przejść do znajdującego się w dalszej części książki materiału dotyczącego danego
zagadnienia. Wystarczy kierować się podanym w tekście odniesieniem lub skorzystać ze
spisu treści bądź skorowidza. W ten sposób łatwo przekonać się, że Python jednak ma
funkcję poszukiwaną przez czytelnika. Ponadto bardzo często okaże się, że dana funkcja
będzie miała nie tylko znacznie czytelniejsze formy wyrażenia niż zastosowane tutaj,
ale także i większe możliwości.
Koncepcja 1. — typy danych
Podstawową funkcją każdego języka programowania jest możliwość przedstawienia
danych. Python oferuje kilka wbudowanych typów danych, ale w chwili obecnej
skoncentrujemy się jedynie na dwóch. Liczby całkowite (dodatnie i ujemne) są przedstawiane
w Pythonie za pomocą typu int, natomiast ciągi tekstowe (sekwencje znaków Unicode)
— za pomocą typu str. Poniżej przedstawiono kilka przykładów liczb całkowitych oraz
dosłownych ciągów tekstowych:
-973
210624583337114373395836055367340864637790190801098222508621955072
0
Nieskoñczenie wymagajÈcy
Szymon Kowalski
pozytywne
€÷©
Nawiasem mówiąc, druga liczba to 2217 — wielkość liczb całkowitych w Pythonie jest
ograniczona jedynie przez ilość pamięci zainstalowanej w komputerze, a nie przez odgórnie
ustaloną liczbę bajtów. Ciągi tekstowe mogą być ujęte w cudzysłów bądź apostrofy, o ile
na obu końcach ciągu tekstowego znajduje się ten sam ogranicznik (znak cudzysłowu lub
30
Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego
apostrof). Ponieważ Python używa kodowania znaków Unicode, ciągi tekstowe nie są
ograniczone jedynie do zbioru znaków ASCII, co widać wyraźnie w przedostatnim ciągu
tekstowym. Pusty ciąg tekstowy składa się po prostu z ograniczników ciągu tekstowego.
W celu uzyskania dostępu do elementu w sekwencji, na przykład w ciągu tekstowym,
w Pythonie używa się nawiasów kwadratowych ([]). Przykładowo: pracując w powłoce
Pythona (albo w interpreterze interaktywnym lub środowisku IDLE), możemy wprowadzić
poniższe polecenia. Dane wyjściowe powłoki Pythona są przedstawione czcionkÈ o staïej
szerokoĂci, natomiast wprowadzane polecenia zostały pogrubione:
Trudne Czasy [7]
C
ĝyrafa [0]
ĝ
Tradycyjnie powłoka Pythona jako znaku zachęty używa , choć można to zmienić.
Składnia wykorzystująca nawiasy kwadratowe może być stosowana z elementami danych
będącymi dowolnego typu sekwencjami, czyli na przykład z ciągami tekstowymi bądź
listami. Konsekwencja w składni to jeden z powodów, dla których język Python jest tak piękny.
Warto zwrócić uwagę, że wszystkie pozycje indeksu w Pythonie rozpoczynają się od zera.
W Pythonie zarówno str, jak i podstawowe typy liczbowe, na przykład int,
są niemodyfikowalne — to znaczy, że raz ustalona wartość nie może być zmieniona.
W pierwszej chwili wydaje się, że to dziwne ograniczenie, ale składnia Pythona powoduje,
że w praktyce nie stanowi ono żadnego problemu. Jedynym powodem, dla którego
wspominamy o nim tutaj, jest to, że chociaż składni nawiasów kwadratowych można użyć
do pobrania znaku z pozycji o wskazanym indeksie w ciągu tekstowym, to nie można jej
wykorzystać do ustawienia nowego znaku. (Warto zwrócić uwagę, że w Pythonie znak
jest po prostu ciągiem tekstowym o długości 1).
Aby przekonwertować element danych z jednego typu na inny, można użyć składni
w postaci typ_danych(element), na przykład:
int( 45 )
45
str(912)
912
Typ konwersji int() jest tolerancyjny, jeśli chodzi o znaki odstępu umieszczone
przed lub po elemencie, tak więc polecenie int( 45 ) również działa doskonale. Typ
konwersji str() może być zastosowany wobec niemal dowolnego elementu danych. Jak się
przekonamy w rozdziale 6., bardzo łatwo możemy utworzyć własny typ danych obsługujący
konwersję str(), jak również konwersję int() i każdą inną, o ile ma to sens. Jeżeli konwersja
zakończy się niepowodzeniem, wtedy zostanie zgłoszony wyjątek — obsługa błędów będzie
pokrótce omówiona w koncepcji 5. Pełne omówienie wyjątków znajduje się w rozdziale 4.
Ciągi tekstowe i liczby całkowite zostały szczegółowo omówione w rozdziale 2.
wraz z innymi wbudowanymi typami danych oraz wybranymi typami danych
dostępnymi w bibliotece standardowej Pythona. W rozdziale 2. przedstawiono także operacje,
które można wykonać względem niemodyfikowalnych sekwencji, takich jak ciągi tekstowe.
„Piökne serce” Pythona
31
Koncepcja 2. — odniesienia do obiektów
Kiedy posiadamy już pewne typy danych, kolejnym potrzebnym elementem są zmienne
pozwalające na przechowywanie danych. Python nie posiada zmiennych jako takich, ale
ma odniesienia do obiektów. W przypadku niezmiennych obiektów, na przykład typu str
lub int, nie ma żadnej widocznej różnicy między zmienną i odniesieniem do obiektu.
Natomiast w przypadku obiektów zmiennych taka różnica występuje, choć w praktyce rzadko
ma znaczenie. Pojęć zmienna i odniesienie do obiektu będziemy więc używać zamiennie.
Spójrzmy na kilka prostych przykładów, które następnie będą dokładnie omówione:
x = niebieski
y = zielony
z = x
Składnia to po prostu odniesienie_do_obiektu = wartoĂÊ. Nie ma konieczności
podawania wcześniej jakichkolwiek deklaracji bądź określania rodzaju wartości. Kiedy
Python wykonuje pierwsze polecenie, tworzy obiekt str wraz z tekstem „niebieski” oraz
tworzy odniesienie do obiektu, nazwane x, które po prostu odnosi się do obiektu str.
Ze względów praktycznych możemy powiedzieć: „zmiennej x został przypisany ciąg
tekstowy niebieski ”. Drugie polecenie jest podobne. Trzecie polecenie tworzy nowe
odniesienie do obiektu, nazwane z, i określa, że będzie odnosiło się do tego samego obiektu,
do którego odnosi się odniesienie x. W omawianym przykładzie będzie to obiekt str
zawierający tekst „niebieski”.
Operator = nie ma takiej samej funkcji jak spotykany w niektórych językach operator
przypisania funkcji. Operator = łączy w pamięci odniesienie do obiektu wraz z obiektem.
Jeżeli odniesienie do obiektu już istnieje, wtedy po prostu nastąpi ponowne dołączenie
w celu utworzenia odniesienia do obiektu znajdującego się po prawej stronie operatora =.
Natomiast jeśli dane odniesienie jeszcze nie istnieje, zostanie utworzone przez operator =.
Kontynuujemy pracę z przykładem x, y, z i dokonujemy ponownych dołączeń. Jak już
wcześniej wspomniano, komentarz rozpoczyna się znakiem # i trwa aż do końca wiersza:
print(x, y, z) # dane wyjĻciowe: niebieski zielony niebieski
z = y
print(x, y, z) # dane wyjĻciowe: niebieski zielony zielony
x = z
print(x, y, z) # dane wyjĻciowe: zielony zielony zielony
Po czwartym poleceniu (x = z) wszystkie trzy odniesienia do obiektów odwołują się do
tego samego obiektu str. Ponieważ nie ma więcej odniesień do ciągu tekstowego „niebieski”,
Python może go usunąć (użyć mechanizmu garbage collection, czyli zbierania nieużytków).
Na rysunku 1.2 pokazano schematycznie związki zachodzące między obiektami
i odniesieniami do obiektów.
Nazwy używane dla odniesień do obiektów (nazywane identyfikatorami) mają kilka
ograniczeń. W szczególności nie mogą być takie same jak słowa kluczowe języka Python
oraz muszą rozpoczynać się literą bądź znakiem podkreślenia, po którym znajduje się
zero lub więcej znaków innych niż znaki odstępu (dozwolone się litery, znaki podkreślenia
lub cyfry). Nie ma ograniczenia w długości nazwy, a litery i cyfry to te, które są zdefiniowane
Kopiowanie
płytkie
i głębokie
h 164
Identyfika-
tory i słowa
kluczowe
h 65
32
Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego
Rysunek 1.2. Odniesienia do obiektów oraz obiekty
przez Unicode. Zawierają więc zestaw ASCII, choć nie muszą być ograniczone jedynie
do liter i cyfr ASCII („a”, „b”, …, „z”, „A”, „B”, …, „Z”, „0”, „1”, …, „9”). Identyfikatory
Pythona rozróżniają wielkość liter, więc LIMIT, Limit i limit to trzy różne identyfikatory.
Szczegółowe omówienie identyfikatorów oraz pewne nieco egzotyczne przykłady zostały
przedstawione w rozdziale 2.
Python stosuje dynamiczną kontrolę typu, co oznacza, że w dowolnej chwili
odniesienie do obiektu może być dołączone do innego obiektu, który z kolei może być
obiektem innego typu danych. Języki stosujące ścisłą kontrolę typu (na przykład C++
i Java) pozwalają na wykonanie jedynie tych operacji, które zostały zdefiniowane
w używanym typie danych. Python także stosuje wymienione ograniczenie, ale w przypadku
Pythona nie nazywamy tego ścisłą kontrolą typu, ponieważ dopuszczalne operacje mogą
ulegać zmianie — na przykład jeśli odniesienie do obiektu zostanie ponownie utworzone
i dołączone do obiektu innego typu danych. Przykładowo:
droga = 866
print(droga, type(droga)) # dane wyjĻciowe: 866 class int
droga = Póïnoc
print(droga, type(droga)) # dane wyjĻciowe: Pó§noc class str
W powyższym przykładzie tworzymy nowe odniesienie do obiektu nazwane droga
i przypisujemy mu nową wartość 866 typu int. Na tym etapie względem odniesienia
droga można użyć operatora /, ponieważ dzielenie jest dopuszczalną i poprawną operacją
przeprowadzaną na liczbach całkowitych. Następnie ponownie używamy odniesienia droga
w celu utworzenia odniesienia do nowej wartości „Północ” typu str. Obiekt int zostaje
skierowany do mechanizmu zbierania nieużytków, ponieważ w chwili obecnej nie ma
do niego żadnego odniesienia. Na tym etapie użycie operatora / względem odniesienia
droga spowoduje zgłoszenie wyjątku TypeError, ponieważ dzielenie (/) nie jest operacją
dopuszczalną do przeprowadzenia względem ciągu tekstowego.
Wartością zwrotną funkcji type() jest typ danych (znany także jako „klasa”)
wskazanego elementu danych. Funkcja ta może być więc bardzo użyteczna podczas
testowania i usuwania błędów w kodzie, ale zazwyczaj nie będzie stosowana w kodzie
produkcyjnym — jak się okaże w rozdziale 6., są tutaj inne, lepsze możliwości.
Jeżeli czytelnik eksperymentuje z kodem Pythona w interpreterze interaktywnym lub
powłoce Pythona, na przykład oferowanej przez środowisko IDLE, wystarczy po prostu
podać nazwę odniesienia do obiektu, a Python wyświetli jego wartość. Przykładowo:
Funkcja
insin
´stance()
h 260
„Piökne serce” Pythona
33
x = niebieski
y = zielony
z = x
x
niebieski
x, y, z
( niebieski , zielony , niebieski )
To znacznie wygodniejsze rozwiązanie niż ciągłe wywoływanie funkcji print(), ale działa
jedynie wtedy, gdy Python funkcjonuje w trybie interaktywnym. W celu wyświetlenia danych
wyjściowych wszystkie tworzone programy i moduły nadal muszą stosować funkcję print()
lub podobną. Warto zwrócić uwagę, że ostatnie dane wyjściowe zostały wyświetlone
w nawiasach i rozdzielone przecinkami. Oznacza to typ danych tuple, czyli krotkę —
uporządkowaną, niezmienną sekwencję obiektów. Krotki zostaną przedstawione
w kolejnej koncepcji.
Koncepcja 3. — kolekcje typów danych
Bardzo często wygodnym rozwiązaniem jest przechowywanie całej kolekcji elementów
danych. Python oferuje kilka kolekcji typów danych, które mogą przechowywać elementy —
są to między innymi tablice asocjacyjne i zbiory. W tym miejscu omówimy jednak tylko
dwa typy: tuple (krotka) i list (lista). Krotki i listy Pythona mogą być stosowane w celu
przechowywania dowolnej liczby elementów danych dowolnego typu danych. Krotki
pozostają niezmienne, więc po ich utworzeniu nie ma możliwości wprowadzania zmian.
Natomiast listy są zmienne, można więc łatwo wstawiać i usuwać elementy listy według
własnego uznania.
Jak widać na poniższych przykładach, krotki są tworzone za pomocą przecinków (,).
Warto zwrócić uwagę, że poniżej i ogólnie od tej chwili wprowadzane przez użytkownika
polecenia nie będą przedstawiane pogrubioną czcionką:
Dania , Finlandia , Norwegia , Szwecja
( Dania , Finlandia , Norwegia , Szwecja )
jeden
( jeden ,)
Kiedy Python wyświetla krotkę, ujmuje ją w nawias. Wielu programistów naśladuje
to rozwiązanie i zawsze ujmują dosłowne krotki w nawiasy. W przypadku krotki
jednoelementowej i chęci użycia nawiasu nadal trzeba zastosować przecinek, na przykład
(1,). Pusta krotka jest tworzona za pomocą pustego nawiasu (). Przecinek jest
wykorzystywany także do rozdzielania argumentów w wywołaniach funkcji. Dlatego też,
jeżeli dosłowna krotka ma zostać przekazana jako argument, musi być ujęta w nawias,
aby uniknąć zamieszania.
Poniżej przedstawiono kilka przykładów list:
[1, 4, 9, 16, 25, 36, 49]
[ alpha , bravo , charlie , delta , echo ]
[ zebra , 49, -879, mrównik , 200]
[]
Typ
danych
tuple
h 124
Tworzenie
i wywoływa-
nie funkcji
h 51
34
Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego
Typ
danych list
h 129
Kopiowanie
płytkie
i głębokie
h 164
Klasa
Sized
h 397
Jednym ze sposobów utworzenia listy jest użycie nawiasów kwadratowych ([]) — jak
pokazano na powyższym przykładzie. W dalszej części książki zostaną przedstawione
inne sposoby. Wiersz czwarty pokazuje pustą listę.
Wewnętrznie listy i krotki w ogóle nie przechowują elementów danych, a raczej
odniesienia do obiektów. W trakcie tworzenia listy bądź krotki (oraz podczas wstawiania
elementów w przypadku listy) kopiują one odniesienia do podanych obiektów. W przypadku
dosłownych elementów, na przykład liczb całkowitych i ciągów tekstowych, w pamięci
tworzony jest obiekt odpowiedniego typu danych i później jest on inicjalizowany.
Następnie tworzone jest odniesienie do tego obiektu i to utworzone odniesienie zostaje
umieszczone w krotce bądź na liście.
Podobnie jak w przypadku pozostałych konstrukcji Pythona, również kolekcje typów
danych są obiektami. Istnieje więc możliwość zagnieżdżania jednej kolekcji typu danych w
innej, na przykład w celu utworzenia listy zawierającej inne listy. W pewnych sytuacjach fakt,
że listy, krotki i większość pozostałych kolekcji typów danych Pythona przechowuje
odniesienia do obiektów zamiast obiektów, powoduje różnicę — zostanie to omówione
w rozdziale 3.
W programowaniu proceduralnym wywołujemy funkcje i często przekazujemy elementy
danych jako argumenty. Przykładowo widzieliśmy już w działaniu funkcję print(). Inna
często używana funkcja Pythona to len(), która jako argument pobiera pojedynczy element
danych. Wartością zwrotną funkcji jest „długość” elementu podana jako obiekt int. Poniżej
przedstawiono kilka wywołań funkcji len():
len(( jeden ,))
1
len([3, 5, 1, 2, pauza , 5])
6
len( automatycznie )
13
Krotki, listy oraz ciągi tekstowe mają „ustaloną wielkość”, to znaczy są typami danych,
które muszą mieć podaną wielkość. Elementy takiego typu danych mogą być bez
problemów przekazane funkcji len(). (W przypadku przekazania funkcji len() elementu
danych bez ustalonej wielkości następuje zgłoszenie wyjątku).
Wszystkie elementy danych Pythona są obiektami (nazywane są również egzemplarzami)
określonego typu danych (nazywanego także klasą). Pojęć typ danych i klasa będziemy
używać zamiennie. Jedną z istotnych różnic między obiektem i zwykłym elementem danych
dostarczanym przez niektóre języki (na przykład C++ lub wbudowane typy liczbowe
Javy) pozostaje to, że obiekt może mieć metody. Ogólnie rzecz biorąc, metoda to po prostu
funkcja, która jest wywoływana dla określonego obiektu. Przykładowo typ list ma
metodę append(), która umożliwia dołączenie obiektu do listy w następujący sposób:
x = [ zebra , 49, -879, mrównik , 200]
x.append( wiÚcej )
x
[ zebra , 49, -879, mrównik , 200, wiÚcej ]
„Piökne serce” Pythona
35
Obiekt x „wie”, że jest typu list (w Pythonie wszystkie obiekty znają swój typ
danych), tak więc nie ma potrzeby wyraźnego wskazywania typu danych. W implementacji
metody append() pierwszym argumentem jest sam obiekt x — przekazanie tego obiektu
jest przeprowadzane automatycznie przez Pythona jako część syntaktycznej obsługi metod.
Metoda append() mutuje, czyli zmienia początkową listę. Jest to możliwe, ponieważ
listy są elementami zmiennymi. Zwłaszcza w przypadku bardzo długich list jest to także
potencjalnie znacznie efektywniejsze rozwiązanie niż tworzenie nowej listy zawierającej
początkowe elementy, dodanie nowych elementów, ponowne dołączenie nowej listy do
odniesienia do obiektu.
W języku proceduralnym ten sam efekt można uzyskać, stosując metodę append()
listy, jak przedstawiono poniżej (to zupełnie prawidłowa składnia Pythona):
list.append(x, ekstra )
x
[ zebra , 49, -879, mrównik , 200, wiÚcej , ekstra ]
Tutaj podajemy typ danych oraz metodę typu danych. Ponadto jako pierwszy
argument przekazujemy element danych tego typu danych, którego chcemy użyć w metodzie,
a następnie dowolną liczbę argumentów dodatkowych. (W przypadku dziedziczenia
istnieje subtelna różnica semantyczna między dwiema przedstawionymi składniami.
W praktyce najczęściej spotykana jest pierwsza forma. Dziedziczenie zostanie omówione
w rozdziale 6.).
Jeżeli czytelnik nie zna programowania zorientowanego obiektowo, w pierwszej chwili
powyższe informacje mogą mu wydawać się nieco dziwne. Na chwilę obecną należy
zaakceptować fakt, że Python ma funkcje konwencjonalne wywoływane w postaci
nazwa_funkcji(argumenty) oraz metody wywoływane w postaci nazwa_obiektu.nazwa_
´metody(argumenty). (Programowanie zorientowane obiektowo zostanie omówione
w rozdziale 6.).
Operator kropki („atrybut dostępu”) jest używany w celu uzyskania dostępu do
atrybutów obiektu. Wspomniany atrybut może być dowolnego typu obiektem, chociaż jak
dotąd widzieliśmy jedynie atrybuty metod. Ponieważ atrybut może być obiektem
posiadającym atrybuty, które z kolei mogą mieć swoje atrybuty itd., istnieje możliwość użycia
tylu operatorów kropki, ilu potrzeba w celu uzyskania dostępu do żądanego atrybutu.
Typ list posiada wiele innych metod, między innymi insert(), która jest używana
w celu wstawiania elementu we wskazanej pozycji indeksu. Z kolei metoda remove() usuwa
element znajdujący się we wskazanej pozycji indeksu. Jak już wcześniej wspomniano,
indeksy Pythona zawsze rozpoczynają się od zera.
Wcześniej widzieliśmy, że istnieje możliwość pobierania znaków z ciągu tekstowego
za pomocą operatora w postaci nawiasów kwadratowych. Wspomniano także, że wymieniony
operator może być używany w dowolnej sekwencji. Ponieważ listy są sekwencjami, więc
bez problemu możemy wykonać przedstawione poniżej polecenia:
x
[ zebra , 49, -879, mrównik , 200, wiÚcej , ekstra ]
x[0]
36
Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego
zebra
x[4]
200
Krotki również są sekwencjami, jeśli więc zmienna x byłaby krotką, moglibyśmy pobrać
jej elementy, używając składni nawiasów kwadratowych w dokładnie taki sam sposób,
jak w przypadku listy x. Jednak ponieważ listy można zmieniać (w przeciwieństwie
do niezmiennych ciągów tekstowych i krotek), w celu ustawienia elementów listy też
możemy użyć operatora nawiasów kwadratowych. Przykładowo:
x[1] = czterdzieĂci dziewiÚÊ
x
[ zebra , czterdzieĂci dziewiÚÊ, -879, mrównik , 200, wiÚcej , ekstra ]
W przypadku podania pozycji indeksu wykraczającej poza zakres nastąpi zgłoszenie
wyjątku. Obsługa błędów będzie pokrótce omówiona w koncepcji 5. Pełne omówienie
wyjątków znajduje się w rozdziale 4.
Jak dotąd kilkakrotnie użyto pojęcia sekwencja, polegając jedynie na nieoficjalnym
przedstawieniu jego znaczenia. Na tym nieformalnym znaczeniu będziemy polegać jeszcze
przez jakiś czas. Jednak język Python precyzyjnie definiuje wymagania, które muszą być
spełnione przez sekwencję. Podobnie są zdefiniowane funkcje, które muszą być spełnione
przez obiekt o ustalonym rozmiarze. Ponadto zdefiniowane jest także wiele innych kategorii,
do których może zaliczać się typ danych, o czym przekonamy się w rozdziale 8.
Listy, krotki i inne wbudowane kolekcje typów danych Pythona zostaną szczegółowo
omówione w rozdziale 3.
Koncepcja 4. — operatory logiczne
Jedną z podstawowych funkcji dowolnego języka programowania jest obsługa operacji
logicznych. Python oferuje cztery zestawy operacji logicznych, w kolejnych sekcjach
omówimy podstawy każdego z nich.
Operator toĔsamoĈci
Ponieważ wszystkie zmienne Pythona tak naprawdę są odniesieniami do obiektów,
czasami sensowne jest sprawdzenie, czy dwa bądź większa liczba odniesień odwołuje się
do tego samego obiektu. Operator is to operator dwuargumentowy zwracający wartość
True, jeśli odniesienie do obiektu znajdujące się po lewej stronie operatora odwołuje się
do tego samego obiektu, do którego odwołuje się odniesienie po prawej stronie operatora.
Poniżej przedstawiono kilka przykładów:
a = [ Retencja , 3, None]
b = [ Retencja , 3, None]
a is b
False
b = a
a is b
True
„Piökne serce” Pythona
37
Warto pamiętać, że zazwyczaj nie ma większego sensu używanie operatora is w celu
porównywania obiektów int, str oraz większości pozostałych typów danych, ponieważ
prawie zawsze chcemy porównywać ich wartości. W rzeczywistości stosowanie operatora
is w celu porównywania elementów danych może prowadzić do otrzymania niewiarygodnych
wyników, jak mogliśmy zobaczyć na powyższym przykładzie. Tutaj, chociaż a i b miały
początkowo ustawione te same wartości listy, same listy były przechowywane jako oddzielne
obiekty list. Podczas pierwszego użycia operator is zwrócił więc wartość False.
Zaletą operatorów tożsamości jest ich duża szybkość działania. Wynika to z faktu,
że obiekty podawane w operatorze nie muszą być analizowane. Operator is porównuje
jedynie adresy w pamięci wskazanych obiektów — ten sam adres oznacza ten sam obiekt.
Najczęściej spotykaną sytuacją, w której stosuje się operator is, jest porównywanie
elementu danych z wbudowanym w język obiektem null (None). Obiekt ten jest często
używany jako oznaczenie wartości „nieznany” bądź „nieistniejący”:
a = CoĂ
b = None
a is not None, b is None
(True, True)
W celu odwrócenia testu tożsamości używamy operatora is not.
Celem operatora tożsamości jest sprawdzenie, czy dwa odniesienia do obiektu odwołują
się do tego samego obiektu, bądź sprawdzenie, czy którykolwiek z obiektów jest typu None.
Jeżeli zachodzi potrzeba porównania wartości obiektu, wtedy należy zastosować operator
porównania.
Operatory porównania
Python oferuje standardowy zestaw binarnych operatorów porównania charakteryzujących
się oczekiwaną semantyką: mniejszy niż, = mniejszy niż lub równy, == równy, != nierówny,
= większy niż lub równy oraz większy niż. Wymienione operatory porównują wartości
obiektów, to znaczy obiektów, do których odniesienia zostały wskazane w operatorze.
Poniżej przedstawiono kilka przykładów wprowadzonych w powłoce Pythona:
a = 2
b = 6
a == b
False
a b
True
a = b, a != b, a = b, a b
(True, True, False, False)
Podczas pracy z liczbami całkowitymi wszystko przebiega zgodnie z oczekiwaniami.
Podobnie w przypadku pracy z ciągami tekstowymi wydaje się, że operatory porównania
również działają poprawnie:
a = wiele Ăcieĝek
b = wiele Ăcieĝek
a is b
38
Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego
False
a == b
True
Chociaż a i b to różne obiekty (mają odmienne tożsamości), to posiadają takie same wartości,
więc w trakcie porównywania są uznawane za takie same. Trzeba jednak zachować ostrożność,
ponieważ w celu przedstawienia ciągu tekstowego Python używa kodowania znaków Unicode.
Dlatego też porównywanie ciągów tekstowych zawierających znaki wykraczające poza
zbiór znaków ASCII może być nieco odmienne i bardziej skomplikowane, niż się wydaje
w pierwszej chwili — to zagadnienie zostanie dokładnie omówione w rozdziale 2.
W pewnych sytuacjach porównywanie tożsamości dwóch ciągów tekstowych bądź
liczb — na przykład użycie polecenia a is b — spowoduje wygenerowanie wartości zwrotnej
True, nawet jeśli każdy element został przypisany oddzielnie jak w omawianym przypadku.
Wynika to z faktu, że pewne implementacje Pythona będą ponownie używały tego samego
obiektu (ponieważ wartość pozostaje taka sama, a obiekt jest niezmienny) w celu zwiększenia
wydajności. Morał jest taki, aby podczas porównywania wartości stosować operatory == i !=.
Z kolei operatory is i is not stosować jedynie w trakcie porównywania z obiektem None,
ewentualnie jeśli naprawdę zachodzi potrzeba sprawdzenia, czy dwa odniesienia do
obiektów — a nie ich wartości — są takie same.
Jedną ze szczególnie użytecznych cech operatorów porównania w Pythonie jest możliwość
ich łączenia, na przykład:
Porówny-
wanie
ciągów
tekstowych
h 83
a = 9
0 = a = 10
True
To znacznie ładniejszy sposób sprawdzenia, czy podany element danych mieści się
w zakresie, niż stosowanie dwóch oddzielnych operacji porównania połączonych logicznym
operatorem and, jak ma to miejsce w większości innych języków programowania. Dodatkową
zaletą tego rozwiązania jest sprawdzanie elementu danych tylko jednokrotnie (ponieważ
w podanym wyrażeniu pojawia się tylko jednokrotnie). Może mieć to ogromne znaczenie
w sytuacji, gdy obliczenie wartości elementu danych jest bardzo kosztowne, bądź jeśli
uzyskanie dostępu do elementu danych powoduje powstanie efektu ubocznego.
Dzięki „mocnemu” aspektowi Pythona, jakim jest dynamiczna kontrola typu,
porównania, które nie mają sensu, będą powodowały zgłoszenie wyjątku. Przykładowo:
trzy 4
Traceback (most recent call last):
...
TypeError: unorderable types: str() int()
Kiedy następuje zgłoszenie wyjątku, który nie jest obsłużony, Python wyświetla
komunikaty dotyczące ostatnich wywołań (traceback) wraz z komunikatem błędu wyjątku.
W celu
Pobierz darmowy fragment (pdf)