Python 3. Kompletne Wprowadzenie Do Programowania. Wydanie II

Python 3.
Kompletne
wprowadzenie do
programowania. Wydanie II
Autor: Mark Summerfield
Tumaczenie: Robert Grczyski
ISBN: 978-83-246-2642-7
Tytu oryginau: Programming in Python 3: A Complete
Introduction to the Python Language (2nd Edition)
Format: 170230, stron: 640
Poznaj wspaniae moliwoci jzyka Python 3 i twrz dowolne programy
Python 3 uznany zosta za najlepsz dotychczasow wersj tego jzyka, poniewa
jego moliwoci s dzi znacznie wiksze ni dawniej. Python 3 jest wygodny, spjny
i ekspresyjny, a take niezaleny od platformy sprztowej i co najwaniejsze
dostarczany z pen bibliotek standardow. Mona go wykorzysta do programowania
proceduralnego, zorientowanego obiektowo oraz (w mniejszym stopniu) do programowania
w stylu funkcjonalnym. Autor ksiki, Mark Summerfield, ekspert w dziedzinie programowania,
przedstawia szczegowe informacje dotyczce tego jzyka w bardzo przyjazny sposb,
co sprawia, e czytelnik szybko i sprawnie moe napisa dowolny program.
Ksika Python 3. Kompletne wprowadzenie do programowania. Wydanie II zostaa
zaprojektowana tak, aby mg z niej korzysta zarwno kto o niewielkim dowiadczeniu
w programowaniu, jak i profesjonalici, naukowcy, inynierowie oraz studenci. Dziki
niej szybko nauczysz si m.in. wykorzystywa zaawansowane rodzaje danych, kolekcje
oraz struktury kontrolne. Poznasz techniki analizy skadniowej, obejmujce uywanie
moduw PyParsing i PLY. Dowiesz si, na czym polega rozkadanie obcienia programu
midzy wiele procesw i wtkw, a take zaczniesz uywa techniki Test Driven
Development, aby unikn popeniania bdw. Znajdziesz tu wszelkie niezbdne
informacje, dziki ktrym bdziesz mg stworzy solidne i wydajne programy.
Tworzenie i uruchamianie programw Pythona
Polecenia kontroli przepywu
Rodzaje danych
Funkcje i struktury kontrolne
Moduy i pakiety
Programowanie zorientowane obiektowo
Obsuga plikw
Zaawansowane techniki programowania
Kontrola dostpu do atrybutw
Usuwanie bdw, testowanie i profilowanie
Wyraenia regularne
Ten podrcznik jest jak Python 3 spjny, praktyczny i wygodny
Mark Summerfield jest informatykiem z wieloletnim dowiadczeniem w dziedzinie
programowania. Jest take wspautorem ksiki C++ GUI Programming with Qt 4
oraz autorem ksiki Rapid GUI Programming with Python and Qt: The Definitive Guide
to PyQt Programming. Mark zaoy firm Qtrac Ltd., http://www.qtrac.eu, w ktrej
pracuje jako niezaleny publicysta, redaktor, trener i konsultant specjalizujcy si
w C++, Qt, Pythonie i PyQt.
Spis treci
O autorze ...........................................................................13
Wprowadzenie ...................................................................15
Rozdzia 1. Szybkie wprowadzenie do programowania proceduralnego ......23
Tworzenie i uruchamianie programw Pythona .................................24
Pikne serce Pythona .................................................................29
Koncepcja 1. rodzaje danych ................................................29
Koncepcja 2. odniesienia do obiektw ..................................31
Koncepcja 3. kolekcje rodzajw danych .................................33
Koncepcja 4. operatory logiczne ...........................................36
Koncepcja 5. polecenia kontroli przepywu programu ..............40
Koncepcja 6. operatory arytmetyczne ....................................45
Koncepcja 7. operacje wejcia-wyjcia ...................................48
Koncepcja 8. tworzenie i wywoywanie funkcji ........................51
Przykady ......................................................................................53
bigdigits.py ..............................................................................53
generate_grid.py ......................................................................56
Podsumowanie .............................................................................58
wiczenia .....................................................................................61
Rozdzia 2. Rodzaje danych ..................................................................65

Identyfikatory i sowa kluczowe .......................................................65
Cakowite rodzaje danych ...............................................................69
Liczby cakowite .......................................................................69
Wartoci boolowskie ................................................................72
Zmiennoprzecinkowe rodzaje danych ..............................................73
Liczby zmiennoprzecinkowe (Float) ............................................74
Liczby zespolone (Complex) ......................................................77
Liczby Decimal .........................................................................78
Python 3. Kompletne wprowadzenie do programowania
Cigi tekstowe ..............................................................................80

Porwnywanie cigw tekstowych ..............................................83
Segmentowanie i poruszanie si krokami
w cigu tekstowym .................................................................84
Operatory i metody dotyczce cigu tekstowego .........................87
Formatowanie cigu tekstowego
za pomoc metody str.format() ...............................................95
Kodowanie znakw ................................................................107
Przykady ....................................................................................111
quadratic.py ..........................................................................111
csv2html.py ...........................................................................114
Podsumowanie ...........................................................................118
wiczenia ...................................................................................120
Rozdzia 3. Kolekcje rodzajw danych ................................................123

Rodzaje sekwencji .......................................................................124
Krotki ....................................................................................124
Nazwane krotki ......................................................................127
Listy .....................................................................................129
Rodzaje danych set .....................................................................137
Set (zbir) .............................................................................138
Rodzaj danych frozenset .........................................................142
Rodzaje mapowania ....................................................................143
Sowniki ................................................................................143
Sowniki domylne .................................................................152
Sowniki uporzdkowane ........................................................153
Iteracja i kopiowanie kolekcji ........................................................155
Iteratory i operacje oraz funkcje iteracji ....................................155
Kopiowanie kolekcji ...............................................................164
Przykady ....................................................................................166
generate_usernames.py .........................................................166
statistics.py ..........................................................................169
Podsumowanie ...........................................................................173
wiczenia ...................................................................................175
Rozdzia 4. Funkcje i struktury kontrolne ...........................................177

Struktury kontrolne ......................................................................177
Konstrukcje rozgaziajce ......................................................178
Ptle .....................................................................................179
Obsuga wyjtkw ........................................................................181
Przechwytywanie i obsuga wyjtkw ........................................181
Wasne wyjtki .......................................................................186
Spis treci
Wasne funkcje ...........................................................................189

Nazwy i dokumentujce cigi tekstowe ....................................193
Rozpakowywanie argumentu i parametru .................................195
Uzyskiwanie dostpu do zmiennych w zasigu globalnym ..........197
Funkcja lambda .....................................................................199
Asercje .................................................................................201
Przykad: make_html_skeleton.py .................................................202
Podsumowanie ...........................................................................208
wiczenie ...................................................................................209
Rozdzia 5. Moduy ............................................................................213

Moduy i pakiety ..........................................................................214
Pakiety ..................................................................................217
Wasne moduy ......................................................................220
Oglny opis biblioteki standardowej Pythona .................................230
Obsuga cigw tekstowych ....................................................230
Programowanie wiersza polecenia ...........................................232
Matematyka i liczby ................................................................233
Data i godzina .......................................................................234
Algorytmy i kolekcje rodzajw danych .......................................235
Formaty plikw, kodowania znakw i przechowywanie danych ....236
Plik, katalog i obsuga przetwarzania .......................................240
Praca w sieci i programowanie internetowe ..............................242
XML ......................................................................................244
Inne moduy ..........................................................................246
Podsumowanie ...........................................................................247
wiczenie ...................................................................................249
Rozdzia 6. Programowanie zorientowane obiektowo ...........................251

Podejcie zorientowane obiektowo ...............................................252
Koncepcje i terminologia programowania
zorientowanego obiektowo ....................................................253
Wasne klasy ..............................................................................256
Atrybuty i metody ...................................................................257
Dziedziczenie i polimorfizm .....................................................262
Uywanie waciwoci w celu kontrolowania
dostpu do atrybutw ..........................................................264
Tworzenie w peni zintegrowanych rodzajw danych ...................266
Wasne klasy kolekcji ..................................................................279
Tworzenie klas agregujcych kolekcje ......................................279
Tworzenie klas kolekcji za pomoc agregacji ............................286
Tworzenie klas kolekcji za pomoc dziedziczenia ......................292
Podsumowanie ...........................................................................299
wiczenia ...................................................................................301
10
Rozdzia 7. Obsuga plikw ................................................................303

Zapis i odczyt danych binarnych ...................................................308
Peklowanie wraz z opcjonaln konwersj .................................308
Zwyke dane binarne wraz z opcjonaln kompresj ....................312
Zapis i przetwarzanie plikw tekstowych ........................................321
Zapis tekstu ..........................................................................321
Przetwarzanie tekstu ..............................................................322
Przetwarzanie tekstu za pomoc wyrae regularnych ...............325
Zapis i przetwarzanie plikw XML .................................................328
Drzewa elementw .................................................................329
Model DOM (Document Object Model) .....................................332
Rczny zapis XML ..................................................................335
Przetwarzanie XML za pomoc SAX (Simple API dla XML) ..........336
Swobodny dostp do plikw binarnych ..........................................339
Oglna klasa BinaryRecordFile ................................................339
Przykad: klasy moduu BikeStock ...........................................347
Podsumowanie ...........................................................................351
wiczenia ...................................................................................352
Rozdzia 8. Zaawansowane techniki programowania ...........................355

Dalsze techniki programowania proceduralnego .............................356
Rozgazianie za pomoc sownikw ........................................356
Funkcje i wyraenia 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 dostpu do atrybutw ...............................................379
Funktor .................................................................................382
Menedery kontekstu .............................................................384
Deskryptory ...........................................................................388
Dekoratory klas .....................................................................392
Abstrakcyjne klasy bazowe .....................................................395
Dziedziczenie wielokrotne .......................................................402
Metaklasy .............................................................................404
Programowanie funkcjonalne ........................................................408
Funkcje czciowe aplikacji ....................................................411
Wspprogramy ......................................................................412
Przykad: valid.py .........................................................................421
Podsumowanie ...........................................................................423
wiczenia ...................................................................................424
Spis treci
Rozdzia 9. Usuwanie bdw, testowanie i profilowanie .....................427

Usuwanie bdw ........................................................................428
Obsuga bdw skadni ..........................................................429
Obsuga bdw w trakcie dziaania programu ..........................430
Naukowy sposb usuwania bdw ..........................................434
Testy jednostkowe ......................................................................440
Profilowanie ................................................................................446
Podsumowanie ...........................................................................451
Rozdzia 10. Procesy i wtkowanie ......................................................453

Uywanie moduu Multiprocessing ................................................454
Uywanie moduu Threading .........................................................458
Przykad: program wyszukiwania uywajcy wtkw ...................460
Przykad: program wyszukujcy powielone pliki
uywajcy wtkowania ..........................................................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. Wyraenia regularne ........................................................503

Jzyk wyrae regularnych Pythona ...............................................504
Znaki i klasy znakw ..............................................................505
Kwantyfikatory .......................................................................506
Grupowanie i przechwytywanie ................................................508
Asercje i opcje .......................................................................511
Modu wyrae regularnych ..........................................................515
Podsumowanie ...........................................................................526
wiczenia ...................................................................................526
Rozdzia 14. Wprowadzenie do analizy skadniowej ...............................529

Skadnia BNF i terminologia zwizana z analiz skadniow ............531
Tworzenie wasnych analizatorw skadni ......................................535
Prosta analiza skadniowa danych klucz warto ....................536
Analiza skadniowa listy odtwarzania .......................................539
Analiza skadniowa blokw jzyka specjalizowanego .................541
11
12
Analiza skadniowa za pomoc moduu PyParsing ..........................550

Krtkie wprowadzenie do moduu PyParsing .............................551
Analiza skadniowa danych listy odtwarzania ............................557
Analiza skadni logiki pierwszego rzdu ....................................564
Analiza skadniowa Lex/Yacc za pomoc moduu PLY ....................569
Analiza skadniowa danych listy odtwarzania ............................573
Analizator skadni logiki pierwszego rzdu ................................577
Podsumowanie ...........................................................................582
wiczenie ...................................................................................583
Rozdzia 15. Wprowadzenie do programowania GUI ..............................585

Programy w stylu okna dialogowego ..............................................588
Programy w stylu okna gwnego ..................................................594
Tworzenie okna gwnego .......................................................595
Tworzenie wasnego okna dialogowego ....................................605
Podsumowanie ...........................................................................608
wiczenia ...................................................................................609
Epilog ..............................................................................611
Wybrana bibliografia ........................................................613
Skorowidz ........................................................................615
1
Szybkie wprowadzenie
do programowania
proceduralnego
W rozdziale:
Pikne serce Pythona
tym rozdziale zostanie omwiona taka ilo materiau, e jej lektura pozwoli czytelnikowi
na rozpoczcie tworzenia programw w jzyku Python. Jeeli czytelnik jeszcze nie
zainstalowa Pythona, gorco zachcamy do przeprowadzenia instalacji. Pozwoli to na
zdobywanie dowiadczenia i utrwalanie poznawanego materiau. (Instalacja Pythona na
gwnych platformach sprztowych zostaa omwiona we wczeniejszym rozdziale
Wprowadzenie, g 19).
Pierwszy podrozdzia zaprezentuje sposb tworzenia i uruchamiania programw
Pythona. Kod Pythona mona tworzy w dowolnym edytorze tekstowym. Omwione
w rozdziale rodowisko programistyczne IDLE oferuje nie tylko sam edytor kodu
rdowego, ale take funkcje dodatkowe pozwalajce na midzy innymi eksperymentowanie
z kodem Pythona oraz usuwanie bdw z kodu.
Drugi podrozdzia zosta powicony omiu kluczowym koncepcjom Pythona,
ktrych poznanie wystarczy do tworzenia uytecznych programw. Wszystkie wymienione
tutaj konstrukcje bd dokadnie omwione w dalszych rozdziaach ksiki. W miar
przedstawiania kolejnego materiau koncepcje te zostan uzupenione informacjami
obejmujcymi szerszy zakres jzyka Python. W ten sposb po przeczytaniu ksiki czytelnik
bdzie zna cay jzyk i podczas pracy nad wasnymi programami bdzie w stanie
wykorzystywa wszystkie moliwoci jzyka.
24
Rozdzia 1. Szybkie wprowadzenie do programowania proceduralnego
Ostatni podrozdzia zawiera dwa krtkie programy, w ktrych uyto niektrych funkcji
Pythona omwionych w podrozdziale drugim. Dziki temu czytelnik natychmiast bdzie
mg wyprbowa Pythona.

Kod Pythona mona tworzy w dowolnym edytorze tekstowym, ktry umoliwia zapis
i odczyt plikw tekstowych stosujcych kodowanie znakw ASCII lub UTF-8 Unicode.
Domylnie pliki Pythona stosuj kodowanie znakw UTF-8 obejmujce wikszy zbir
znakw ni ASCII. Za pomoc kodowania UTF-8 mona przedstawia kady znak w kadym
jzyku. Pliki Pythona zwykle maj rozszerzenie .py, chocia w niektrych systemach z rodziny
Unix (na przykad Linux i Mac OS X) pewne aplikacje Pythona nie maj rozszerzenia pliku.
Programy Pythona z graficznym interfejsem uytkownika (GUI, czyli Graphical User
Interface) zazwyczaj maj rozszerzenie .pyw, zwaszcza w systemach Windows oraz Mac
OS X. W niniejszej ksice moduy Pythona oraz programy Pythona dziaajce w konsoli
zawsze maj rozszerzenie .py, natomiast programy GUI s oznaczone rozszerzeniem .pyw.
Wszystkie przykady zaprezentowane w ksice mona w niezmienionej postaci uruchomi
na kadej platformie sprztowej z zainstalowanym Pythonem 3.
Aby upewni si, e wszystko zostao skonfigurowane prawidowo, oraz przedstawi
klasyczny pierwszy przykad, naley w edytorze tekstowym (w systemie Windows mona
uy programu Notatnik wkrtce zaczniemy korzysta z lepszego edytora) utworzy
plik o nazwie hello.py zawierajcy nastpujce wiersze:
#!/usr/bin/env python3
print("Witaj", "wiecie!")
Pierwszy wiersz to komentarz. W Pythonie komentarz rozpoczyna si od znaku #

i cignie si a do koca wiersza. (Znaczenie powyszego komentarza wyjanimy za chwil).
Drugi wiersz jest pusty poza cigami tekstowymi ujtymi w cudzysw, Python ignoruje
puste wiersze. Jednak maj one istotne znaczenie dla programistw, gdy oddzielaj due
bloki kodu, co uatwia ich odczyt. Wiersz trzeci zawiera kod Pythona. W tym wierszu
nastpuje wywoanie funkcji printf() wraz z dwoma argumentami, z ktrych kady jest
typu str (string cig tekstowy, czyli sekwencja znakw).
Kade polecenie napotkane w pliku .py zostaje kolejno wykonane, poczwszy od
pierwszego i dalej wiersz po wierszu. To zupenie odmienne podejcie ni w innych jzykach,
takich jak C++ bd Java, gdzie mamy okrelon funkcj lub metod posiadajc nazw
specjaln, ktra stanowi punkt pocztkowy programu. Oczywicie, istnieje moliwo
sterowania przepywem programu, co zostanie zaprezentowane w kolejnym podrozdziale
podczas omawiania struktur kontrolnych Pythona.
Przyjmujemy zaoenie, e uytkownik systemu Windows zapisuje kod Pythona
w katalogu C:\py3eg, natomiast uytkownik systemu z rodziny Unix (na przykad Unix,
Linux lub Mac OS X) przechowuje kod w katalogu $HOME/py3eg. Plik hello.py
naley wic zapisa w katalogu py3eg i zamkn edytor tekstowy.
Kodowanie
znakw
h 107.
25
Mamy wic program, ktry mona uruchomi. Programy w jzyku 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 narzdzie Terminal.app (domylnie znajduje si w katalogu
Programy/Narzdzia) dostpne poprzez Findera. W pozostaych systemach Unix mona
uy xterm bd konsoli oferowanej przez menedera okien, na przykad konsole bd
gnome-terminal.
Uruchom konsol, nastpnie w systemie Windows wprowad ponisze polecenia
(przyjmujemy zaoenie, e Python zosta zainstalowany w lokalizacji domylnej). Dane
wyjciowe konsoli s przedstawione czcionk o staej szerokoci, natomiast wprowadzane
polecenia zostay pogrubione:
C:\>cd c:\py3eg
C:\py3eg\>c:\python31\python.exe hello.py
Poniewa polecenie cd (change directory, czyli zmie katalog) uywa bezwzgldnej cieki
dostpu, katalog, z poziomu ktrego zostanie uruchomiony program, nie ma adnego
znaczenia.
Uytkownicy systemu Unix wydaj polecenia pokazane poniej (przyjmujemy zaoenie,
e odniesienie do Pythona 3 znajduje si w systemowej ciece PATH)1:
$ cd $HOME/py3eg
$ python3 hello.py
W obu przypadkach dane wyjciowe prezentuj si tak samo:

Witaj wiecie!
Warto pamita, e jeli nie napisano inaczej, zachowanie jzyka Python w systemie
Mac OS X jest takie samo, jak w kadym innym systemie z rodziny Unix. Moemy wic
przyj, e kiedy uywamy okrelenia Unix, oznacza to system Linux, BSD, Mac OS X
oraz wikszo pozostaych systemw Unix i wywodzcych si z rodziny Unix.
Chocia pierwszy program skada si tylko z jednego polecenia wykonywalnego, po
jego uruchomieniu moemy wycign pewne wnioski dotyczce funkcji print(). Przede
wszystkim funkcja print() jest elementem wbudowanym w jzyk Python w celu jej uycia
nie musimy jej importowa ani docza z biblioteki. Ponadto kady element wywietlany
przez funkcj jest oddzielony pojedyncz spacj, a po wywietleniu ostatniego wstawiany jest
znak nowego wiersza. To jest zachowanie domylne funkcji i jak przekonamy si nieco pniej,
moemy je zmieni. Inn wan informacj dotyczc funkcji print() jest to, e moe
pobiera dowoln ilo argumentw.
Wprowadzanie przedstawionych powyej polece w celu uruchamiania tworzonych
programw w Pythonie bardzo szybko moe okaza si uciliwe. Na szczcie w systemach
zarwno Windows, jak i Unix mona zastosowa znacznie wygodniejsze podejcie.
1
Znak zachty systemu Unix moe by odmienny ni przedstawiony w powyszym przykadzie znak
dolara ($), to nie ma adnego znaczenia.
Funkcja
print()
h 198
26
Zakadamy, e znajdujemy si w katalogu py3eg. W systemie Windows mona wic

po prostu wyda polecenie:
C:\py3eg\>hello.py
Windows uywa rejestru przypisa plikw w celu automatycznego wywoania

interpretera Pythona za kadym razem, gdy w konsoli zostanie wprowadzona nazwa pliku
z rozszerzeniem .py.
Niestety, takie wygodne podejcie nie zawsze dziaa, poniewa pewne wersje systemu
Windows maj bd, ktry czasami negatywnie wpywa na wykonywanie programw
interpretowanych wywoywanych jako wynik odczytania zdefiniowanego przypisania pliku.
To nie jest bd w Pythonie inne interpretery, a take niektre pliki .bat take padaj
ofiar tego bdu. Jeeli czytelnik spotka si z tego rodzaju bdem, wwczas naley
bezporednio wywoa Pythona, zamiast polega na mechanizmie rozpoznawania
przypisa plikw.
Jeli w systemie Windows dane wyjciowe maj posta:
('Witaj', 'wiecie!')
oznacza to, e w systemie znajduje si Python 2 i zosta wywoany zamiast Pythona 3.

Jednym z rozwiza bdzie zmiana przypisania pliku .py z Pythona 2 na Python 3. Inne
rozwizanie (mniej wygodne, lecz bezpieczniejsze) do dodanie Pythona 3 do systemowej
cieki dostpu (przyjmujemy zaoenie, e zosta zainstalowany w lokalizacji domylnej)
i wyrane wywoywanie Pythona za kadym razem. (Ten sposb powoduje take rozwizanie
wspomnianego wczeniej bdu w Windows, dotyczcego przypisa plikw). Przykadowo:
C:\py3eg\>path=c:\python31;%path%
C:\py3eg\>python hello.py
Znacznie wygodniejszym rozwizaniem moe by utworzenie pliku py3.bat zawierajcego

pojedynczy wiersz kodu path=c:\python31;%path% i zapisanie tego pliku w katalogu
C:\Windows. Nastpnie, po kadym wczeniu konsoli w celu uruchamiania programw
napisanych w Pythonie, prac trzeba rozpocz od wykonania pliku py3.bat. Ewentualnie
mona skonfigurowa system tak, aby plik py3.bat by wykonywany automatycznie.
W tym celu naley zmodyfikowa waciwoci konsoli (odszukaj konsol w menu Start,
a nastpnie kliknij konsol prawym przyciskiem myszy i wybierz opcj Waciwoci).
W wywietlonym oknie dialogowym przejd na kart Skrt, w polu Element docelowy
dodaj cig tekstowy /u /k c:\windows\py3.bat (zwr uwag na spacj przed, midzy
i po opcjach /u oraz /k i upewnij si, e cig tekstowy znajduje si po poleceniu cmd.exe).
W systemie Unix plikowi trzeba w pierwszej kolejnoci nada uprawnienia do
wykonywania, a dopiero potem mona go uruchomi:
$ chmod +x hello.py
$ ./hello.py
Oczywicie polecenie chmod naley wykona tylko jednokrotnie, pniej wystarczy po

prostu wyda polecenie ./hello.py i program zostanie uruchomiony.
W systemie Unix podczas wywoywania programu w konsoli nastpuje odczyt dwch

pierwszych bajtw pliku2. Jeeli odczytane bajty s znakami #! zbioru znakw ASCII, wwczas
powoka przyjmuje zaoenie, e plik powinien by wykonany przez interpreter, ktry
zreszt jest wskazany w pierwszym wierszu pliku. Ten wiersz nosi nazw shebang (shell
execute, czyli plik wykonywalny powoki) i jeli zostaje umieszczony w pliku, to musi by
pierwszym wierszem pliku.
Wiersz shebang jest zazwyczaj zapisywany w jednej z dwch moliwych postaci:
#!/usr/bin/python3
lub
#!/usr/bin/env python3
Pobieranie
i instalacja
Pythona
19 g
Jeeli bdzie zapisany w pierwszej formie, uyty zostanie wymieniony interpreter.

Uycie tej formy moe okaza si konieczne w przypadku programw Pythona uruchamianych
przez serwer WWW, cho sama cieka dostpu moe by odmienna ni przedstawiona
w powyszym przykadzie. Jeli zostanie uyta druga forma, uyty zostanie pierwszy
interpreter python3 znaleziony w biecym rodowisku powoki. Druga forma jest znacznie
elastyczniejsza, poniewa dopuszcza moliwo, e interpreter Python 3 nie zosta umieszczony
w katalogu /usr/bin (na przykad moe by zainstalowany w katalogu /usr/local/bin bd
w $HOME). W systemie Windows wiersz shebang nie jest wymagany (cho rwnoczenie
pozostaje nieszkodliwy). Wszystkie przykady zaprezentowane w ksice zawieraj
wiersz shebang w drugiej formie, cho nie umieszczono go w listingach.
Warto zwrci uwag, e dla systemw Unix przyjmujemy zaoenie, i nazwa pliku
wykonywalnego Pythona 3 (lub dowizanie symboliczne do niego) w zmiennej systemowej
PATH to python3. Jeeli tak nie jest, w przykadach naley zmodyfikowa wiersz shebang
i poda odpowiedni nazw (prawidow nazw i ciek dostpu w przypadku uywania
pierwszej formy wiersza shebang). Ewentualnie trzeba utworzy dowizanie symboliczne
z pliku wykonywalnego Python 3 do nazwy python3 w zmiennej PATH.
Wiele edytorw tekstowych o potnych moliwociach, na przykad Vim i Ecmacs,
jest dostarczanych wraz z wbudowan obsug edycji programw w jzyku Python.
Wspominania obsuga zazwyczaj obejmuje kolorowanie skadni oraz prawidowe stosowanie
wci wierszy. Alternatywnym rozwizaniem jest uywanie rodowiska programistycznego
dla Pythona, ktrym jest IDLE. W systemach Windows i Mac OS X rodowisko IDLE jest
instalowane domylnie. Z kolei w systemie Unix rodowisko IDLE zostaje zbudowane
wraz z interpreterem Pythona, o ile jest on budowany z archiwum tarball. W przypadku
uycia menedera pakietw rodowisko IDLE zwykle jest dostarczane jako oddzielny pakiet,
jak to przedstawiono we wczeniejszym rozdziale Wprowadzenie.
Na rysunku 1.1 pokazano rodowisko IDLE. Jak wida, IDLE charakteryzuje si
przestarzaym interfejsem graficznym, ktry przypomina czasy motywu Motif w systemach
Unix bd systemu Windows 95. Wynika to z faktu uywania biblioteki GUI Tkinter
2
Interakcja midzy uytkownikiem i konsol jest obsugiwana przez program powoka. Rozrnienie midzy
programami konsoli i powoki nie ma tutaj najmniejszego znaczenia, wic oba pojcia s tu uywane zamiennie.
27
28
Rysunek 1.1. Konsola Pythona w rodowisku IDLE
bazujcej na Tk (omwiona w rozdziale 15.), a nie jednej z nowoczesnych i oferujcych

potniejsze moliwoci bibliotek takich jak PyGtk, PyQt lub wxPython. Powd stosowania
biblioteki Tkinter to poczenie historii, liberalnych warunkw licencji oraz faktu, e biblioteka
Tkinter jest znacznie mniejsza ni inne biblioteki GUI. Na plus mona zaliczy to, e rodowisko
IDLE jest dostarczane domylnie wraz z Pythonem i bardzo atwo je pozna oraz go uywa.
rodowisko IDLE zapewnia trzy istotne funkcje: moliwo wprowadzania wyrae
jzyka Python oraz kodu rdowego i obserwowania wynikw bezporednio w powoce
Pythona, edytor kodu oferujcy kolorowanie skadni kodu Pythona oraz prawidowe
stosowanie wci wierszy, a take modu usuwania bdw pozwalajcy na przejcie przez
kod wiersz po wierszu, znajdywanie i usuwanie bdw. Powoka Pythona jest szczeglnie
uyteczna w trakcie wyprbowywania przykadowych algorytmw, fragmentw kodu oraz
wyrae regularnych. Moe by take uywana jako oferujcy potne moliwoci i bardzo
elastyczny kalkulator.
Dostpnych jest kilka innych rodowisk programistycznych Pythona, ale zalecamy
stosowanie rodowiska IDLE, przynajmniej na pocztku. Alternatyw jest tworzenie
programw w zwykym edytorze tekstowym, a nastpnie usuwanie bdw poprzez
stosowanie wywoa funkcji print().
Moliwe jest wywoanie interpretera Pythona bez wskazywania programu w jzyku
Python. W takim przypadku interpreter zostaje uruchomiony w trybie interaktywnym.
Podczas pracy w tym trybie mona wprowadza polecenia Pythona i obserwowa wyniki
dokadnie w taki sam sposb, jak w trakcie uywania okna powoki Pythona rodowiska IDLE
wraz z tymi samymi znakami zachty w postaci >>>. Jednak rodowisko IDLE pozostaje
znacznie atwiejsze w uyciu, wic zalecamy stosowanie IDLE podczas eksperymentowania
Pikne serce Pythona
z fragmentami kodu. Gdy prezentujemy krtkie przykady interaktywne, przyjmujemy

wwczas zaoenie, e s one wprowadzane w interaktywnym interpreterze Python bd
oknie powoki Pythona rodowiska IDLE.
Wiemy ju, w jaki sposb tworzy i uruchamia programy Pythona, ale przecie
czytelnicy nie znaj jeszcze jzyka posiadaj jedynie ogln wiedz o pojedynczej funkcji.
Dziki lekturze kolejnego rozdziau wyranie zwikszy si ich wiedza o jzyku Python.
Przedstawione tu informacje pozwol na tworzenie krtkich, cho uytecznych programw
w Pythonie, co zaprezentujemy w ostatnim podrozdziale niniejszego rozdziau.
Pikne serce Pythona

W tym podrozdziale zostanie omwionych osiem kluczowych koncepcji jzyka Python,
natomiast w kolejnym podrozdziale przedstawimy uycie tych koncepcji podczas tworzenia
kilku maych, a jednak uytecznych programw. Na temat zagadnie poruszonych w tym
podrozdziale mona powiedzie znacznie wicej. Dlatego te jeli czytelnik poczuje, e czego
brakuje w Pythonie bd e pewne zadania s wykonywane w zbyt dugi sposb, wtedy
moe przej do znajdujcego si w dalszej czci ksiki materiau dotyczcego danego
zagadnienia. Wystarczy kierowa si podanym w tekcie odniesieniem lub skorzysta ze
spisu treci bd skorowidza. W ten sposb atwo przekona si, e Python jednak ma
funkcj poszukiwan przez czytelnika. Ponadto bardzo czsto okae si, e dana funkcja
bdzie miaa nie tylko znacznie czytelniejsze formy wyraenia ni zastosowane tutaj,
ale take i wiksze moliwoci.
Koncepcja 1. typy danych

Podstawow funkcj kadego jzyka programowania jest moliwo przedstawienia
danych. Python oferuje kilka wbudowanych typw danych, ale w chwili obecnej
skoncentrujemy si jedynie na dwch. Liczby cakowite (dodatnie i ujemne) s przedstawiane
w Pythonie za pomoc typu int, natomiast cigi tekstowe (sekwencje znakw Unicode)
za pomoc typu str. Poniej przedstawiono kilka przykadw liczb cakowitych oraz
dosownych cigw tekstowych:
-973
210624583337114373395836055367340864637790190801098222508621955072
0
"Nieskoczenie wymagajcy"
'Szymon Kowalski'
'pozytywne
'
''
Nawiasem mwic, druga liczba to 2217 wielko liczb cakowitych w Pythonie jest
ograniczona jedynie przez ilo pamici zainstalowanej w komputerze, a nie przez odgrnie
ustalon liczb bajtw. Cigi tekstowe mog by ujte w cudzysw bd apostrofy, o ile
na obu kocach cigu tekstowego znajduje si ten sam ogranicznik (znak cudzysowu lub
29
30
apostrof). Poniewa Python uywa kodowania znakw Unicode, cigi tekstowe nie s
ograniczone jedynie do zbioru znakw ASCII, co wida wyranie w przedostatnim cigu
tekstowym. Pusty cig tekstowy skada si po prostu z ogranicznikw cigu tekstowego.
W celu uzyskania dostpu do elementu w sekwencji, na przykad w cigu tekstowym,
w Pythonie uywa si nawiasw kwadratowych ([]). Przykadowo: pracujc w powoce
Pythona (albo w interpreterze interaktywnym lub rodowisku IDLE), moemy wprowadzi
ponisze polecenia. Dane wyjciowe powoki Pythona s przedstawione czcionk o staej
szerokoci, natomiast wprowadzane polecenia zostay pogrubione:
>>> "Trudne Czasy"[7]
'C'
>>> "yrafa"[0]
''
Tradycyjnie powoka Pythona jako znaku zachty uywa >>>, cho mona to zmieni.
Skadnia wykorzystujca nawiasy kwadratowe moe by stosowana z elementami danych
bdcymi dowolnego typu sekwencjami, czyli na przykad z cigami tekstowymi bd
listami. Konsekwencja w skadni to jeden z powodw, dla ktrych jzyk Python jest tak pikny.
Warto zwrci uwag, e wszystkie pozycje indeksu w Pythonie rozpoczynaj si od zera.
W Pythonie zarwno str, jak i podstawowe typy liczbowe, na przykad int,
s niemodyfikowalne to znaczy, e raz ustalona warto nie moe by zmieniona.
W pierwszej chwili wydaje si, e to dziwne ograniczenie, ale skadnia Pythona powoduje,
e w praktyce nie stanowi ono adnego problemu. Jedynym powodem, dla ktrego
wspominamy o nim tutaj, jest to, e chocia skadni nawiasw kwadratowych mona uy
do pobrania znaku z pozycji o wskazanym indeksie w cigu tekstowym, to nie mona jej
wykorzysta do ustawienia nowego znaku. (Warto zwrci uwag, e w Pythonie znak
jest po prostu cigiem tekstowym o dugoci 1).
Aby przekonwertowa element danych z jednego typu na inny, mona uy skadni
w postaci typ_danych(element), na przykad:
>>> int("45")
45
>>> str(912)
'912'
Typ konwersji int() jest tolerancyjny, jeli chodzi o znaki odstpu umieszczone
przed lub po elemencie, tak wic polecenie int(" 45 ") rwnie dziaa doskonale. Typ
konwersji str() moe by zastosowany wobec niemal dowolnego elementu danych. Jak si
przekonamy w rozdziale 6., bardzo atwo moemy utworzy wasny typ danych obsugujcy
konwersj str(), jak rwnie konwersj int() i kad inn, o ile ma to sens. Jeeli konwersja
zakoczy si niepowodzeniem, wtedy zostanie zgoszony wyjtek obsuga bdw bdzie
pokrtce omwiona w koncepcji 5. Pene omwienie wyjtkw znajduje si w rozdziale 4.
Cigi tekstowe i liczby cakowite zostay szczegowo omwione w rozdziale 2.
wraz z innymi wbudowanymi typami danych oraz wybranymi typami danych
dostpnymi w bibliotece standardowej Pythona. W rozdziale 2. przedstawiono take operacje,
ktre mona wykona wzgldem niemodyfikowalnych sekwencji, takich jak cigi tekstowe.
Pikne serce Pythona
31
Koncepcja 2. odniesienia do obiektw

Kiedy posiadamy ju pewne typy danych, kolejnym potrzebnym elementem s zmienne
pozwalajce na przechowywanie danych. Python nie posiada zmiennych jako takich, ale
ma odniesienia do obiektw. W przypadku niezmiennych obiektw, na przykad typu str
lub int, nie ma adnej widocznej rnicy midzy zmienn i odniesieniem do obiektu.
Natomiast w przypadku obiektw zmiennych taka rnica wystpuje, cho w praktyce rzadko
ma znaczenie. Poj zmienna i odniesienie do obiektu bdziemy wic uywa zamiennie.
Spjrzmy na kilka prostych przykadw, ktre nastpnie bd dokadnie omwione:
Kopiowanie
pytkie
i gbokie
h 164
x = "niebieski"
y = "zielony"
z = x
Skadnia to po prostu odniesienie_do_obiektu = warto. Nie ma koniecznoci

podawania wczeniej jakichkolwiek deklaracji bd okrelania rodzaju wartoci. Kiedy
Python wykonuje pierwsze polecenie, tworzy obiekt str wraz z tekstem niebieski oraz
tworzy odniesienie do obiektu, nazwane x, ktre po prostu odnosi si do obiektu str.
Ze wzgldw praktycznych moemy powiedzie: zmiennej x zosta przypisany cig
tekstowy 'niebieski'. Drugie polecenie jest podobne. Trzecie polecenie tworzy nowe
odniesienie do obiektu, nazwane z, i okrela, e bdzie odnosio si do tego samego obiektu,
do ktrego odnosi si odniesienie x. W omawianym przykadzie bdzie to obiekt str
zawierajcy tekst niebieski.
Operator = nie ma takiej samej funkcji jak spotykany w niektrych jzykach operator
przypisania funkcji. Operator = czy w pamici odniesienie do obiektu wraz z obiektem.
Jeeli odniesienie do obiektu ju istnieje, wtedy po prostu nastpi ponowne doczenie
w celu utworzenia odniesienia do obiektu znajdujcego si po prawej stronie operatora =.
Natomiast jeli dane odniesienie jeszcze nie istnieje, zostanie utworzone przez operator =.
Kontynuujemy prac z przykadem x, y, z i dokonujemy ponownych docze. Jak ju
wczeniej wspomniano, komentarz rozpoczyna si znakiem # i trwa a do koca wiersza:
print(x, y, z) # dane wyjciowe: niebieski zielony niebieski
z = y
print(x, y, z) # dane wyjciowe: niebieski zielony zielony
x = z
print(x, y, z) # dane wyjciowe: zielony zielony zielony
Po czwartym poleceniu (x = z) wszystkie trzy odniesienia do obiektw odwouj si do

tego samego obiektu str. Poniewa nie ma wicej odniesie do cigu tekstowego niebieski,
Python moe go usun (uy mechanizmu garbage collection, czyli zbierania nieuytkw).
Na rysunku 1.2 pokazano schematycznie zwizki zachodzce midzy obiektami
i odniesieniami do obiektw.
Nazwy uywane dla odniesie do obiektw (nazywane identyfikatorami) maj kilka
ogranicze. W szczeglnoci nie mog by takie same jak sowa kluczowe jzyka Python
oraz musz rozpoczyna si liter bd znakiem podkrelenia, po ktrym znajduje si
zero lub wicej znakw innych ni znaki odstpu (dozwolone si litery, znaki podkrelenia
lub cyfry). Nie ma ograniczenia w dugoci nazwy, a litery i cyfry to te, ktre s zdefiniowane
Identyfikatory i sowa
kluczowe
h 65
32
Rysunek 1.2. Odniesienia do obiektw oraz obiekty
przez Unicode. Zawieraj wic zestaw ASCII, cho nie musz by ograniczone jedynie
do liter i cyfr ASCII (a, b, , z, A, B, , Z, 0, 1, , 9). Identyfikatory
Pythona rozrniaj wielko liter, wic LIMIT, Limit i limit to trzy rne identyfikatory.
Szczegowe omwienie identyfikatorw oraz pewne nieco egzotyczne przykady zostay
przedstawione w rozdziale 2.
Python stosuje dynamiczn kontrol typu, co oznacza, e w dowolnej chwili
odniesienie do obiektu moe by doczone do innego obiektu, ktry z kolei moe by
obiektem innego typu danych. Jzyki stosujce cis kontrol typu (na przykad C++
i Java) pozwalaj na wykonanie jedynie tych operacji, ktre zostay zdefiniowane
w uywanym typie danych. Python take stosuje wymienione ograniczenie, ale w przypadku
Pythona nie nazywamy tego cis kontrol typu, poniewa dopuszczalne operacje mog
ulega zmianie na przykad jeli odniesienie do obiektu zostanie ponownie utworzone
i doczone do obiektu innego typu danych. Przykadowo:
droga = 866
print(droga, type(droga)) # dane wyjciowe: 866 <class 'int'>
droga = "Pnoc"
print(droga, type(droga)) # dane wyjciowe: Pnoc <class 'str'>
W powyszym przykadzie tworzymy nowe odniesienie do obiektu nazwane droga

i przypisujemy mu now warto 866 typu int. Na tym etapie wzgldem odniesienia
droga mona uy operatora /, poniewa dzielenie jest dopuszczaln i poprawn operacj
przeprowadzan na liczbach cakowitych. Nastpnie ponownie uywamy odniesienia droga
w celu utworzenia odniesienia do nowej wartoci Pnoc typu str. Obiekt int zostaje
skierowany do mechanizmu zbierania nieuytkw, poniewa w chwili obecnej nie ma
do niego adnego odniesienia. Na tym etapie uycie operatora / wzgldem odniesienia
droga spowoduje zgoszenie wyjtku TypeError, poniewa dzielenie (/) nie jest operacj
dopuszczaln do przeprowadzenia wzgldem cigu tekstowego.
Wartoci zwrotn funkcji type() jest typ danych (znany take jako klasa)
wskazanego elementu danych. Funkcja ta moe by wic bardzo uyteczna podczas
testowania i usuwania bdw w kodzie, ale zazwyczaj nie bdzie stosowana w kodzie
produkcyjnym jak si okae w rozdziale 6., s tutaj inne, lepsze moliwoci.
Jeeli czytelnik eksperymentuje z kodem Pythona w interpreterze interaktywnym lub
powoce Pythona, na przykad oferowanej przez rodowisko IDLE, wystarczy po prostu
poda nazw odniesienia do obiektu, a Python wywietli jego warto. Przykadowo:
Funkcja
insin
stance()
h 260
Pikne serce Pythona
33
>>> x = "niebieski"
>>> y = "zielony"
>>> z = x
>>> x
'niebieski'
>>> x, y, z
('niebieski', 'zielony', 'niebieski')
To znacznie wygodniejsze rozwizanie ni cige wywoywanie funkcji print(), ale dziaa

jedynie wtedy, gdy Python funkcjonuje w trybie interaktywnym. W celu wywietlenia danych
wyjciowych wszystkie tworzone programy i moduy nadal musz stosowa funkcj print()
lub podobn. Warto zwrci uwag, e ostatnie dane wyjciowe zostay wywietlone
w nawiasach i rozdzielone przecinkami. Oznacza to typ danych tuple, czyli krotk
uporzdkowan, niezmienn sekwencj obiektw. Krotki zostan przedstawione
w kolejnej koncepcji.
Koncepcja 3. kolekcje typw danych

Bardzo czsto wygodnym rozwizaniem jest przechowywanie caej kolekcji elementw
danych. Python oferuje kilka kolekcji typw danych, ktre mog przechowywa elementy
s to midzy innymi tablice asocjacyjne i zbiory. W tym miejscu omwimy jednak tylko
dwa typy: tuple (krotka) i list (lista). Krotki i listy Pythona mog by stosowane w celu
przechowywania dowolnej liczby elementw danych dowolnego typu danych. Krotki
pozostaj niezmienne, wic po ich utworzeniu nie ma moliwoci wprowadzania zmian.
Natomiast listy s zmienne, mona wic atwo wstawia i usuwa elementy listy wedug
wasnego uznania.
Jak wida na poniszych przykadach, krotki s tworzone za pomoc przecinkw (,).
Warto zwrci uwag, e poniej i oglnie od tej chwili wprowadzane przez uytkownika
polecenia nie bd przedstawiane pogrubion czcionk:
>>> "Dania", "Finlandia", "Norwegia", "Szwecja"
('Dania', 'Finlandia', 'Norwegia', 'Szwecja')
>>> "jeden"
('jeden',)
Kiedy Python wywietla krotk, ujmuje j w nawias. Wielu programistw naladuje

to rozwizanie i zawsze ujmuj dosowne krotki w nawiasy. W przypadku krotki
jednoelementowej i chci uycia nawiasu nadal trzeba zastosowa przecinek, na przykad
(1,). Pusta krotka jest tworzona za pomoc pustego nawiasu (). Przecinek jest
wykorzystywany take do rozdzielania argumentw w wywoaniach funkcji. Dlatego te,
jeeli dosowna krotka ma zosta przekazana jako argument, musi by ujta w nawias,
aby unikn zamieszania.
Poniej przedstawiono kilka przykadw list:
[1, 4, 9, 16, 25, 36, 49]
['alpha', 'bravo', 'charlie', 'delta', 'echo']
['zebra', 49, -879, 'mrwnik', 200]
[]
Typ
danych
tuple
h 124
Tworzenie
i wywoywanie funkcji
h 51
34
Jednym ze sposobw utworzenia listy jest uycie nawiasw kwadratowych ([]) jak
pokazano na powyszym przykadzie. W dalszej czci ksiki zostan przedstawione
inne sposoby. Wiersz czwarty pokazuje pust list.
Wewntrznie listy i krotki w ogle nie przechowuj elementw danych, a raczej
odniesienia do obiektw. W trakcie tworzenia listy bd krotki (oraz podczas wstawiania
elementw w przypadku listy) kopiuj one odniesienia do podanych obiektw. W przypadku
dosownych elementw, na przykad liczb cakowitych i cigw tekstowych, w pamici
tworzony jest obiekt odpowiedniego typu danych i pniej jest on inicjalizowany.
Nastpnie tworzone jest odniesienie do tego obiektu i to utworzone odniesienie zostaje
umieszczone w krotce bd na licie.
Podobnie jak w przypadku pozostaych konstrukcji Pythona, rwnie kolekcje typw
danych s obiektami. Istnieje wic moliwo zagniedania jednej kolekcji typu danych w
innej, na przykad w celu utworzenia listy zawierajcej inne listy. W pewnych sytuacjach fakt,
e listy, krotki i wikszo pozostaych kolekcji typw danych Pythona przechowuje
odniesienia do obiektw zamiast obiektw, powoduje rnic zostanie to omwione
w rozdziale 3.
W programowaniu proceduralnym wywoujemy funkcje i czsto przekazujemy elementy
danych jako argumenty. Przykadowo widzielimy ju w dziaaniu funkcj print(). Inna
czsto uywana funkcja Pythona to len(), ktra jako argument pobiera pojedynczy element
danych. Wartoci zwrotn funkcji jest dugo elementu podana jako obiekt int. Poniej
przedstawiono kilka wywoa funkcji len():
Typ
danych list
h 129
Kopiowanie
pytkie
i gbokie
h 164
>>> len(("jeden",))
1
>>> len([3, 5, 1, 2, "pauza", 5])
6
>>> len("automatycznie")
13
Krotki, listy oraz cigi tekstowe maj ustalon wielko, to znaczy s typami danych,
ktre musz mie podan wielko. Elementy takiego typu danych mog by bez
problemw przekazane funkcji len(). (W przypadku przekazania funkcji len() elementu
danych bez ustalonej wielkoci nastpuje zgoszenie wyjtku).
Wszystkie elementy danych Pythona s obiektami (nazywane s rwnie egzemplarzami)
okrelonego typu danych (nazywanego take klas). Poj typ danych i klasa bdziemy
uywa zamiennie. Jedn z istotnych rnic midzy obiektem i zwykym elementem danych
dostarczanym przez niektre jzyki (na przykad C++ lub wbudowane typy liczbowe
Javy) pozostaje to, e obiekt moe mie metody. Oglnie rzecz biorc, metoda to po prostu
funkcja, ktra jest wywoywana dla okrelonego obiektu. Przykadowo typ list ma
metod append(), ktra umoliwia doczenie obiektu do listy w nastpujcy sposb:
>>> x = ['zebra', 49, -879, 'mrwnik', 200]
>>> x.append("wicej")
>>> x
['zebra', 49, -879, 'mrwnik', 200, 'wicej']
Klasa
Sized
h 397
Pikne serce Pythona
Obiekt x wie, e jest typu list (w Pythonie wszystkie obiekty znaj swj typ
danych), tak wic nie ma potrzeby wyranego wskazywania typu danych. W implementacji
metody append() pierwszym argumentem jest sam obiekt x przekazanie tego obiektu
jest przeprowadzane automatycznie przez Pythona jako cz syntaktycznej obsugi metod.
Metoda append() mutuje, czyli zmienia pocztkow list. Jest to moliwe, poniewa
listy s elementami zmiennymi. Zwaszcza w przypadku bardzo dugich list jest to take
potencjalnie znacznie efektywniejsze rozwizanie ni tworzenie nowej listy zawierajcej
pocztkowe elementy, dodanie nowych elementw, ponowne doczenie nowej listy do
odniesienia do obiektu.
W jzyku proceduralnym ten sam efekt mona uzyska, stosujc metod append()
listy, jak przedstawiono poniej (to zupenie prawidowa skadnia Pythona):
>>> list.append(x, "ekstra")
>>> x
['zebra', 49, -879, 'mrwnik', 200, 'wicej', 'ekstra']
Tutaj podajemy typ danych oraz metod typu danych. Ponadto jako pierwszy
argument przekazujemy element danych tego typu danych, ktrego chcemy uy w metodzie,
a nastpnie dowoln liczb argumentw dodatkowych. (W przypadku dziedziczenia
istnieje subtelna rnica semantyczna midzy dwiema przedstawionymi skadniami.
W praktyce najczciej spotykana jest pierwsza forma. Dziedziczenie zostanie omwione
w rozdziale 6.).
Jeeli czytelnik nie zna programowania zorientowanego obiektowo, w pierwszej chwili
powysze informacje mog mu wydawa si nieco dziwne. Na chwil obecn naley
zaakceptowa fakt, e Python ma funkcje konwencjonalne wywoywane w postaci
nazwa_funkcji(argumenty) oraz metody wywoywane w postaci nazwa_obiektu.nazwa_
metody(argumenty). (Programowanie zorientowane obiektowo zostanie omwione
w rozdziale 6.).
Operator kropki (atrybut dostpu) jest uywany w celu uzyskania dostpu do
atrybutw obiektu. Wspomniany atrybut moe by dowolnego typu obiektem, chocia jak
dotd widzielimy jedynie atrybuty metod. Poniewa atrybut moe by obiektem
posiadajcym atrybuty, ktre z kolei mog mie swoje atrybuty itd., istnieje moliwo uycia
tylu operatorw kropki, ilu potrzeba w celu uzyskania dostpu do danego atrybutu.
Typ list posiada wiele innych metod, midzy innymi insert(), ktra jest uywana
w celu wstawiania elementu we wskazanej pozycji indeksu. Z kolei metoda remove() usuwa
element znajdujcy si we wskazanej pozycji indeksu. Jak ju wczeniej wspomniano,
indeksy Pythona zawsze rozpoczynaj si od zera.
Wczeniej widzielimy, e istnieje moliwo pobierania znakw z cigu tekstowego
za pomoc operatora w postaci nawiasw kwadratowych. Wspomniano take, e wymieniony
operator moe by uywany w dowolnej sekwencji. Poniewa listy s sekwencjami, wic
bez problemu moemy wykona przedstawione poniej polecenia:
>>> x
['zebra', 49, -879, 'mrwnik', 200, 'wicej', 'ekstra']
>>> x[0]
35
36
'zebra'
>>> x[4]
200
Krotki rwnie s sekwencjami, jeli wic zmienna x byaby krotk, moglibymy pobra
jej elementy, uywajc skadni nawiasw kwadratowych w dokadnie taki sam sposb,
jak w przypadku listy x. Jednak poniewa listy mona zmienia (w przeciwiestwie
do niezmiennych cigw tekstowych i krotek), w celu ustawienia elementw listy te
moemy uy operatora nawiasw kwadratowych. Przykadowo:
>>> x[1] = "czterdzieci dziewi"
>>> x
['zebra', czterdzieci dziewi, -879, 'mrwnik', 200, 'wicej', 'ekstra']
W przypadku podania pozycji indeksu wykraczajcej poza zakres nastpi zgoszenie

wyjtku. Obsuga bdw bdzie pokrtce omwiona w koncepcji 5. Pene omwienie
wyjtkw znajduje si w rozdziale 4.
Jak dotd kilkakrotnie uyto pojcia sekwencja, polegajc jedynie na nieoficjalnym
przedstawieniu jego znaczenia. Na tym nieformalnym znaczeniu bdziemy polega jeszcze
przez jaki czas. Jednak jzyk Python precyzyjnie definiuje wymagania, ktre musz by
spenione przez sekwencj. Podobnie s zdefiniowane funkcje, ktre musz by spenione
przez obiekt o ustalonym rozmiarze. Ponadto zdefiniowane jest take wiele innych kategorii,
do ktrych moe zalicza si typ danych, o czym przekonamy si w rozdziale 8.
Listy, krotki i inne wbudowane kolekcje typw danych Pythona zostan szczegowo
omwione w rozdziale 3.
Koncepcja 4. operatory logiczne

Jedn z podstawowych funkcji dowolnego jzyka programowania jest obsuga operacji
logicznych. Python oferuje cztery zestawy operacji logicznych, w kolejnych sekcjach
omwimy podstawy kadego z nich.
Operator tosamoci
Poniewa wszystkie zmienne Pythona tak naprawd s odniesieniami do obiektw,
czasami sensowne jest sprawdzenie, czy dwa bd wiksza liczba odniesie odwouje si
do tego samego obiektu. Operator is to operator dwuargumentowy zwracajcy warto
True, jeli odniesienie do obiektu znajdujce si po lewej stronie operatora odwouje si
do tego samego obiektu, do ktrego odwouje si odniesienie po prawej stronie operatora.
Poniej przedstawiono kilka przykadw:
>>> a
>>> b
>>> a
False
>>> b
>>> a
True
= ["Retencja", 3, None]
= ["Retencja", 3, None]
is b
= a
is b
Pikne serce Pythona
Warto pamita, e zazwyczaj nie ma wikszego sensu uywanie operatora is w celu

porwnywania obiektw int, str oraz wikszoci pozostaych typw danych, poniewa
prawie zawsze chcemy porwnywa ich wartoci. W rzeczywistoci stosowanie operatora
is w celu porwnywania elementw danych moe prowadzi do otrzymania niewiarygodnych
wynikw, jak moglimy zobaczy na powyszym przykadzie. Tutaj, chocia a i b miay
pocztkowo ustawione te same wartoci listy, same listy byy przechowywane jako oddzielne
obiekty list. Podczas pierwszego uycia operator is zwrci wic warto False.
Zalet operatorw tosamoci jest ich dua szybko dziaania. Wynika to z faktu,
e obiekty podawane w operatorze nie musz by analizowane. Operator is porwnuje
jedynie adresy w pamici wskazanych obiektw ten sam adres oznacza ten sam obiekt.
Najczciej spotykan sytuacj, w ktrej stosuje si operator is, jest porwnywanie
elementu danych z wbudowanym w jzyk obiektem null (None). Obiekt ten jest czsto
uywany jako oznaczenie wartoci nieznany bd nieistniejcy:
>>> a = "Co"
>>> b = None
>>> a is not None, b is None
(True, True)
W celu odwrcenia testu tosamoci uywamy operatora is not.

Celem operatora tosamoci jest sprawdzenie, czy dwa odniesienia do obiektu odwouj
si do tego samego obiektu, bd sprawdzenie, czy ktrykolwiek z obiektw jest typu None.
Jeeli zachodzi potrzeba porwnania wartoci obiektu, wtedy naley zastosowa operator
porwnania.
Operatory porwnania
Python oferuje standardowy zestaw binarnych operatorw porwnania charakteryzujcych
si oczekiwan semantyk: < mniejszy ni, <= mniejszy ni lub rwny, == rwny, != nierwny,
>= wikszy ni lub rwny oraz > wikszy ni. Wymienione operatory porwnuj wartoci
obiektw, to znaczy obiektw, do ktrych odniesienia zostay wskazane w operatorze.
Poniej przedstawiono kilka przykadw wprowadzonych w powoce 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 cakowitymi wszystko przebiega zgodnie z oczekiwaniami.

Podobnie w przypadku pracy z cigami tekstowymi wydaje si, e operatory porwnania
rwnie dziaaj poprawnie:
>>> a = "wiele cieek"
>>> b = "wiele cieek"
>>> a is b
37
38
False
>>> a == b
True
Chocia a i b to rne obiekty (maj odmienne tosamoci), to posiadaj takie same wartoci,
wic w trakcie porwnywania s uznawane za takie same. Trzeba jednak zachowa ostrono,
poniewa w celu przedstawienia cigu tekstowego Python uywa kodowania znakw Unicode.
Dlatego te porwnywanie cigw tekstowych zawierajcych znaki wykraczajce poza
zbir znakw ASCII moe by nieco odmienne i bardziej skomplikowane, ni si wydaje
w pierwszej chwili to zagadnienie zostanie dokadnie omwione w rozdziale 2.
W pewnych sytuacjach porwnywanie tosamoci dwch cigw tekstowych bd
liczb na przykad uycie polecenia a is b spowoduje wygenerowanie wartoci zwrotnej
True, nawet jeli kady element zosta przypisany oddzielnie jak w omawianym przypadku.
Wynika to z faktu, e pewne implementacje Pythona bd ponownie uyway tego samego
obiektu (poniewa warto pozostaje taka sama, a obiekt jest niezmienny) w celu zwikszenia
wydajnoci. Mora jest taki, aby podczas porwnywania wartoci stosowa operatory == i !=.
Z kolei operatory is i is not stosowa jedynie w trakcie porwnywania z obiektem None,
ewentualnie jeli naprawd zachodzi potrzeba sprawdzenia, czy dwa odniesienia do
obiektw a nie ich wartoci s takie same.
Jedn ze szczeglnie uytecznych cech operatorw porwnania w Pythonie jest moliwo
ich czenia, na przykad:
Porwnywanie
cigw
tekstowych
h 83
>>> a = 9
>>> 0 <= a <= 10
True
To znacznie adniejszy sposb sprawdzenia, czy podany element danych mieci si

w zakresie, ni stosowanie dwch oddzielnych operacji porwnania poczonych logicznym
operatorem and, jak ma to miejsce w wikszoci innych jzykw programowania. Dodatkow
zalet tego rozwizania jest sprawdzanie elementu danych tylko jednokrotnie (poniewa
w podanym wyraeniu pojawia si tylko jednokrotnie). Moe mie to ogromne znaczenie
w sytuacji, gdy obliczenie wartoci elementu danych jest bardzo kosztowne, bd jeli
uzyskanie dostpu do elementu danych powoduje powstanie efektu ubocznego.
Dziki mocnemu aspektowi Pythona, jakim jest dynamiczna kontrola typu,
porwnania, ktre nie maj sensu, bd powodoway zgoszenie wyjtku. Przykadowo:
>>> "trzy" < 4
Traceback (most recent call last):
...
TypeError: unorderable types: str() < int()
Kiedy nastpuje zgoszenie wyjtku, ktry nie jest obsuony, Python wywietla
komunikaty dotyczce ostatnich wywoa (traceback) wraz z komunikatem bdu wyjtku.
W celu zachowania przejrzystoci w powyszym przykadzie usunito komunikaty dotyczce
ostatnich wywoa, zastpujc je wielokropkiem3. Ten sam wyjtek TypeError wystpi,
3
Komunikat dotyczcy ostatnich wywoa traceback (czasem nazywany backtrace) to lista wszystkich
wywoa wykonanych od pocztku wywoania stosu a do chwili wystpienia nieobsuonego wyjtku.
Obsuga
bdw
powstaych
w trakcie
dziaania
programu
h 430
Pikne serce Pythona
jeli wydamy polecenie "3" < 4, gdy Python nie prbuje odgadn naszych intencji.
Odpowiednim podejciem jest albo przeprowadzenie wyraniej konwersji na przykad
int("3") < 4, albo uycie moliwych do porwnania typw danych, to znaczy dwch
liczb cakowitych lub dwch cigw tekstowych.
Jzyk Python znacznie uatwia tworzenie wasnych typw danych, ktre bd
doskonale si integroway z istniejcymi. Przykadowo: moemy utworzy wasny liczbowy
typ danych, ktry nastpnie bdzie mona stosowa w operacji porwnania z wbudowanym
typem int, a take innymi wbudowanymi bd utworzonymi liczbowymi typami
danych. Nie bdzie jednak moliwe porwnywanie go z cigami tekstowymi lub innymi
nieliczbowymi typami danych.
Operator przynalenoci
W przypadku typw danych bdcych sekwencjami bd kolekcjami, takimi jak cigi
tekstowe, listy i krotki, przynaleno elementu mona sprawdzi za pomoc operatora in,
natomiast brak przynalenoci za pomoc operatora not in. Przykadowo:
>>> p = (4, "aba", 9, -33, 9, 2)
>>> 2 in p
True
>>> "pies" not in p
True
W przypadku list i krotek operator in uywa wyszukiwania liniowego, ktre moe

by bardzo wolne podczas przeszukiwania ogromnych kolekcji (dziesitki tysicy elementw
bd wicej). Z drugiej strony, operator in jest bardzo szybki podczas stosowania go
w sowniku lub zbiorze. Obie wymienione kolekcje typw danych zostan omwione
w rozdziale 3. Poniej pokazano przykad uycia operatora in wraz z cigiem tekstowym:
>>> fraza = "Dzikie abdzie autorstwa Jung Chang"
>>> "J" in fraza
True
>>> "han" in fraza
True
Na szczcie w przypadku cigu tekstowego operator przynalenoci moe by stosowany

w celu wyszukania podcigu tekstowego o dowolnej dugoci. (Jak ju wczeniej wspomniano,
znak jest po prostu cigiem tekstowym o dugoci 1).
Operatory logiczne
Jzyk Python oferuje trzy operatory logiczne: and, or i not. Zarwno and, jak i or uywaj
logiki warunkowej i zwracaj w wyniku operand, ktry determinuje wynik nie zwracaj
wartoci boolowskiej (o ile operand faktycznie nie bdzie typu boolowskiego). Zobaczmy,
co to oznacza w praktyce:
>>>
>>>
>>>
>>>
pi = 5
dwa = 2
zero = 0
pi and dwa
39
Alternatywa
w postaci
typu
danych
FuzzyBool
h 268
40
2
>>> dwa and pi
5
>>> pi and zero
0
Jeeli wyraenie wystpuje w kontekcie boolowskim, to warto zwrotna bdzie typu

boolowskiego. Dlatego te, gdyby powysze przykady znajdoway si na przykad w konstrukcji
if, wartociami zwrotnymi mogyby by True, True i False.
>>>
>>>
5
>>>
2
>>>
5
>>>
0
nic = 0
pi or dwa
dwa or pi
zero or pi
zero or nic
Operator or dziaa podobnie. Tutaj wartociami zwrotnymi w kontekcie boolowskim

byyby True, True, True i False.
Jednoargumentowy operator not oblicza swj argument w kontekcie boolowskim
i zawsze zwraca wynik w postaci wartoci boolowskiej. Dlatego te kontynuujc
wczeniejszy przykad wartoci zwrotn polecenia not (zero or nic) bdzie True,
natomiast polecenia not dwa warto False.
Koncepcja 5.
polecenia kontroli przepywu programu
Wczeniej wspomniano, e polecenia napotkane w pliku .py zostaj wykonane po kolei,
poczwszy od pierwszego wiersza i dalej wiersz po wierszu. Kontrola nad przepywem
programu moe by zmieniona przez wywoanie funkcji bd metody lub struktur
kontroln, tak jak polecenie warunkowe lub ptla. Kontrola nad przepywem programu
jest zmieniana take po zgoszeniu wyjtku.
W tej sekcji skoncentrujemy si na poleceniu if Pythona, podczas gdy ptle while i for
oraz funkcje zostan omwione w koncepcji 8., natomiast metody w rozdziale 6. Przedstawimy
take bardzo prost obsug wyjtkw. Szczegowe omwienie tego zagadnienia znajduje
si w rozdziale 4. Jednak w pierwszej kolejnoci naley wyjani kilka poj.
Wyraenie boolowskie to dowolne wyraenie, ktrego obliczenie daje w wyniku
warto boolowsk (czyli True lub False). W jzyku Python takie wyraenie przyjmuje
warto False, jeli jest predefiniowan sta False, obiektem specjalnym None, pust
sekwencj bd kolekcj (na przykad pusty cig tekstowy, lista lub krotka) lub liczbowym
typem danych o wartoci 0. Wszystko pozostae jest uznawane za True. Kiedy tworzymy
wasny typ danych (na przykad jak w rozdziale 6.), istnieje moliwo samodzielnego
ustalenia, jaka ma by warto zwrotna danego typu w kontekcie boolowskim.
Pikne serce Pythona
W jzyku Python blok kodu, to znaczy sekwencja jednego bd wikszej liczby polece,
nosi nazw pakietu. Poniewa pewne elementy skadni Pythona wymagaj obecnoci
pakietu, Python dostarcza sowo kluczowe pass, ktre jest poleceniem niewykonujcym
adnego dziaania. Dlatego te moe by uyte wszdzie tam, gdzie wymagany bdzie pakiet
(ewentualnie jeli chcemy wskaza, e rozwaamy dany przypadek), ale nie zachodzi potrzeba
przeprowadzania jakiegokolwiek przetwarzania.
Polecenie if
Oglna skadnia polecenia if w Pythonie jest nastpujca4:
if wyraenie_boolean1:
pakiet1
elif wyraenie_boolean2:
pakiet2
...
elif wyraenie_booleanN:
pakietN
else:
pakiet_else
W bloku instrukcji if moe by zero lub wiksza liczba klauzul elif, natomiast ostatnia
klauzula else jest opcjonalna. Jeeli chcemy uwzgldni okrelon sytuacj, ale nie trzeba
wykonywa adnych dziaa w przypadku jej wystpienia, wtedy mona uy sowa
kluczowego pass jako pakietu dla tej sytuacji.
Pierwsz rzecz rzucajc si w oczy programistom C++ lub Javy jest brak nawiasw
okrgych i klamrowych. Kolejn jest obecno dwukropka (:). Na pocztku bardzo atwo
zapomnie o tej czci skadni. Dwukropki s uywane wraz z klauzulami else i elif oraz
w kadym innym miejscu, do ktrego przechodzi pakiet.
W przeciwiestwie do wikszoci innych jzykw programowania, do wskazania
struktury bloku Python stosuje wcicia. Niektrzy programici nie lubi takiego rozwizania,
zwaszcza jeli wczeniej nie prbowali go stosowa, i podchodz do sprawy do
emocjonalnie. Jednak przywyknicie do tego rozwizania zabiera kilka dni, a po upywie
kilku tygodni bd miesicy kod pozbawiony nawiasw klamrowych wydaje si
przyjemniejszy i atwiejszy w odczycie ni kod stosujcy takie nawiasy.
Poniewa pakiety s wskazywane za pomoc wci, oczywiste jest, e rodzi si pytanie
w stylu jakiego rodzaju wcicia?. Dokumentacja Pythona zaleca stosowanie czterech spacji
(tylko spacji, adnych tabulatorw) na kady poziom wcicia. Wikszo nowoczesnych
edytorw tekstowych pozwala na ustawienie automatycznej obsugi wci. (Edytor rodowiska
IDLE oczywicie posiada tak funkcj, podobnie jak wikszo innych edytorw przeznaczonych
do tworzenia kodu w jzyku Python). Python bdzie dziaa bez problemu z dowoln liczb
spacji, tabulatorw lub pocze obu, zakadajc, e uyte wcicia zachowaj spjno.
W niniejszej ksice stosujemy oficjalne zalecenie dla jzyka Python.
W niniejszej ksice wielokropek () oznacza wiersze, ktre pominito w listingu.
41
42
Poniej przedstawiono bardzo prosty przykad polecenia if:

if x:
print("x jest niezerowe")
W tym przypadku, jeeli warto wyraenia (x) bdzie wynosia True, nastpi wykonanie
pakietu (wywoanie funkcji print()).
if wiersze < 1000:
print("may")
elif wiersze < 10000:
print("redni")
else:
print("duy")
Powyej przedstawiono nieco bardziej zoone polecenie if, ktre wywietla sowo
opisujce warto zmiennej wiersze.
Polecenie while
Polecenie while jest uywane w celu wykonania pakietu dowoln liczb razy, cho moe
wystpi sytuacja, w ktrej pakiet w ogle nie zostanie wykonany. Ilo powtrze zaley
od stanu wyraenia boolowskiego w ptli while. Poniej przedstawiono skadni polecenia
while:
while wyraenie_boolean:
pakiet
W rzeczywistoci pena skadnia ptli while jest nieco bardziej skomplikowana, ni

przedstawiono powyej, poniewa obsugiwane s sowa kluczowe break i continue.
Ponadto w ptli moe znajdowa si opcjonalna klauzula else, ktra zostanie omwiona
w rozdziale 4. Polecenie break powoduje przekazanie kontroli nad programem do pierwszego
polecenia w zewntrznej ptli wzgldem tej, w ktrej wystpio polecenie break to znaczy
powoduje opuszczenie biecej ptli. Z kolei polecenie continue przekazuje kontrol nad
programem do pocztku ptli. Zarwno polecenie break, jak i continue s zwykle uywane
wewntrz polece if w celu warunkowej zmiany zachowania ptli.
while True:
element = pobierz_nastpny_element()
if not element:
break
przetwrz_element(element)
Powysza ptla while ma bardzo typow struktur i dziaa a do chwili przetworzenia

wszystkich elementw przeznaczonych do przetworzenia. (Przyjmujemy zaoenie, e zarwno
pobierz_nastpny_element(), jak i przetwrz_element() do wasne funkcje zdefiniowane
w innym miejscu kodu). W powyszym przykadzie pakiet polecenia while zawiera polecenie if,
ktre z kolei ma wasny pakiet w tym przypadku skadajcy si z pojedynczego
polecenia break.
Pikne serce Pythona
43
Polecenie for in
Ptla for w Pythonie ponownie uywa sowa kluczowego in (ktre w innym kontekcie
jest operatorem przynalenoci) i posiada nastpujc skadni:
for zmienna in iteracja:
pakiet
Ptla for podobnie jak ptla while obsuguje polecenia break i continue, a take
opcjonaln klauzul else. Czci zmienna zostaje po kolei przypisane odniesienie do kadego
obiektu w czci iteracja. Wymieniona iteracja to dowolny typ danych, przez ktry
mona przej obejmuje midzy innymi cigi tekstowe (tutaj iteracja nastpuje znak
po znaku), listy, krotki oraz inne kolekcje typw danych Pythona.
for kraj in ["Dania", "Finlandia", "Norwegia", "Szwecja"]:
print(kraj)
Powyej pokazano bardzo proste podejcie pozwalajce na wywietlenie listy krajw.

W praktyce znacznie czciej spotykane rozwizanie zakada uycie zmiennej:
kraje = ["Dania", "Finlandia", "Norwegia", "Szwecja"]
for kraj in kraje:
print(kraj)
W rzeczywistoci caa lista (lub krotka) moe by wywietlona bezporednio za pomoc

funkcji print(), na przykad print(kraje). Bardzo czsto do wywietlenia kolekcji stosuje si
ptl for (lub omwione w dalszej czci ksiki listy skadane z ang. list comprehension)
w celu zachowania penej kontroli nad formatowaniem.
for litera in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
if litera in "AEIOU":
print(litera, "jest samogosk")
else:
print(litera, "jest spgosk")
W powyszym fragmencie kodu w pierwszej kolejnoci uywamy sowa kluczowego in

jako czci polecenia for. Zmienna litera pobiera wartoci A, B i tak dalej, a do Z,
zmieniajc ptl podczas kadej iteracji. W drugim wierszu kodu ponownie uywamy sowa
kluczowego in, ale tym razem jako operatora przynalenoci. Warto zwrci uwag,
e powyszy przykad pokazuje zagniedone pakiety. Pakietem ptli for jest konstrukcja
if...else, a zarwno polecenie if, jak i else maj wasne pakiety.
Podstawowa obsuga wyjtkw

Wiele funkcji i metod Pythona wskazuje bdy lub inne wane zdarzenia poprzez zgoszenie
wyjtku. Wspomniany wyjtek jest obiektem, dokadnie takim samym jak dowolny obiekt
Pythona. Podczas konwersji na posta cigu tekstowego (na przykad w chwili wywietlania)
wyjtek generuje komunikat tekstowy. Poniej przedstawiono prost form skadni obsugi
wyjtku:
try:
pakiet_try
except wyjtek1 as zmienna1:
Listy
skadane
h 135
44
pakiet1_exception
...
except wyjtekN as zmiennaN:
pakiet_exceptionN
Warto zwrci uwag, e cz zmienna jest opcjonalna, moemy by zainteresowani

tylko faktem zgoszenia okrelonego wyjtku, a nie jego komunikatem tekstowym.
Pena skadnia jest nieco bardziej skomplikowana. Przykadowo klauzula except moe
zawiera obsug wielu wyjtkw, poza tym istnieje opcjonalna klauzula else. To wszystko
zostanie szczegowo omwione w rozdziale 4.
Logika wyjtku dziaa w nastpujcy sposb. Jeeli wszystkie polecenia w pakiecie bloku
try zostan wykonane bez zgoszenia wyjtku, bloki except bd pominite. W przypadku
zgoszenia wyjtku w bloku try kontrola nad programem jest natychmiast przekazywana
do pakietu odpowiadajcego pierwszemu dopasowanemu wyjtkowi. Oznacza to, e pozostae
polecenia w pakiecie znajdujce si za poleceniem, ktre spowodowao zgoszenie wyjtku,
nie zostan wykonane. Jeeli wystpi taka sytuacja i jeli zdefiniowano cz zmienna, wwczas
wewntrz pakietu obsugi wyjtku zmienna odnosi si do obiektu wyjtku.
Jeli wyjtek zostanie zgoszony w obsudze bloku except lub jeli zgoszony wyjtek
nie zostanie dopasowany do adnego bloku except, Python bdzie prbowa dopasowa
blok except w kolejnym, zewntrznym zasigu. Poszukiwanie odpowiedniej procedury
obsugi wyjtku bdzie prowadzone w kierunku na zewntrz a do chwili jej znalezienia
i obsuenia wyjtku lub zakoczy si w przypadku nieznalezienia jej. W tym drugim
przypadku nastpi przerwanie wykonywania programu wraz z nieobsuonym wyjtkiem.
Wwczas Python wywietli komunikat dotyczcy ostatnich wywoa oraz komunikat tekstowy
wygenerowany przez wyjtek.
Poniej przedstawiono przykad:
s = input("podaj liczb cakowit: ")
try:
i = int(s)
print("podano prawidow liczb cakowit:", i)
except ValueError as err:
print(err)
Jeeli uytkownik wprowadzi warto 3.5, wwczas zostan wywietlone

nastpujce dane wyjciowe:
invalid literal for int() with base 10: '3.5'
Natomiast po podaniu wartoci 13 bd wywietlone nastpujce dane wyjciowe:

podano prawidow liczb cakowit: 13
W wielu ksikach obsuga bdw jest uznawana za temat zaawansowany, ktrego

omwienie jest przekadane na sam koniec. Jednak zgaszanie i przede wszystkim obsuga
wyjtkw to bardzo wany sposb dziaania Pythona. Dlatego te powinnimy jak najwczeniej
nauczy si korzystania z tego mechanizmu. Jak si wkrtce bdzie mona przekona, uywanie
procedur obsugi wyjtkw moe spowodowa, e kod stanie si czytelniejszy. Wynika to
z faktu oddzielenia przetwarzania od wyjtkowych przypadkw, ktrymi jestemy
rzadko zainteresowani.
Obsuga
bdw
powstaych
w trakcie
dziaania
programu
h 430
Pikne serce Pythona
45
Koncepcja 6. operatory arytmetyczne

Jzyk Python zawiera peny zestaw operatorw arytmetycznych, midzy innymi operatory
dwuargumentowe dla czterech podstawowych operacji matematycznych: + dodawania,
- odejmowania, * mnoenia i / dzielenia. Oprcz tego wiele typw danych Pythona moe
by uywanych z rozszerzonymi operatorami przypisania, takimi jak += i *=. Operatory +, - i *
zachowuj si zgodnie z oczekiwaniami, kiedy oba operandy s liczbami cakowitymi:
>>> 5 + 6
11
>>> 3 - 7
-4
>>> 4 * 8
32
Warto zwrci uwag, e jak ma to miejsce w wikszoci jzykw programowania,

minus (-) moe by uywany zarwno jako operator jednoargumentowy (negacja),
jak rwnie operator dwuargumentowy (odejmowanie). Podczas przeprowadzania dzielenia
mona dostrzec rnice midzy Pythonem i innymi jzykami:
>>> 12 / 3
4.0
>>> 3 / 2
1.5
Wynikiem dziaania operatora dzielenia jest warto zmiennoprzecinkowa, a nie liczba

cakowita. Wiele innych jzykw programowania stosuje w tym miejscu liczb cakowit,
usuwajc cz po przecinku dziesitnym. Jeeli w wyniku chcemy otrzyma liczb cakowit,
zawsze mona zastosowa konwersj za pomoc funkcji int() lub uy operatora dzielenia
usuwajcego cz po przecinku dziesitnym (//), ktry zostanie omwiony w dalszej
czci ksiki.
>>>
>>>
5
>>>
>>>
13
a = 5
a
a += 8
a
W pierwszej chwili powysze polecenia nie s zaskakujce, zwaszcza dla programistw

znajcych jzyk pochodny od jzyka C. W wikszoci takich jzykw rozszerzone przypisanie
jest skrtem przypisania wyniku operacji na przykad polecenie a += 8 daje dokadnie
taki sam wynik, jak a = a + 8. Jednak istniej dwie subtelne rnice, jedna charakterystyczna
dla Pythona, natomiast druga oglnie dotyczy operatorw rozszerzonego przypisania
stosowanych w dowolnym jzyku programowania.
Przede wszystkim trzeba pamita, e typ danych int jest niezmienny, to znaczy raz
przypisanej wartoci int nie mona zmieni. Dlatego te podczas uywania operatora
przypisania wzgldem niezmiennego obiektu nastpuje wykonanie operacji, utworzenie
obiektu przechowujcego wynik, a nastpnie ponownie doczenie, ale tym razem do obiektu
przechowujcego wynik, a nie wczeniej doczonego. Std w poprzednim przykadzie
Operatory
liczbowe
oraz funkcje
h 70
46
po napotkaniu polecenia a += 8 Python przeprowadza obliczenie a + 8, umieszcza wynik

w nowym obiekcie int, a nastpnie ponownie docza a w taki sposb, aby wskazywa
na nowy obiekt int. (Jeeli pocztkowy obiekt, do ktrego odnosia si zmienna a, nie
ma wicej odniesie od innych obiektw, wtedy zostaje przeznaczony do usunicia
przez mechanizm zbierania nieuytkw). Zilustrowano to na rysunku 1.3.
Rysunek 1.3. Rozszerzone przypisanie stosowane wzgldem niezmiennego obiektu
Druga rnica polega na tym, e wykonanie polecenia a operator= b nie powoduje

takiego samego efektu jak wykonanie polecenia a = a operator b. Rozszerzona wersja
wyszukuje warto operandu a tylko jednokrotnie, aby dziaaa potencjalnie szybciej. Ponadto,
jeeli a bdzie skomplikowanym wyraeniem (takim jak element listy, dla ktrego nastpuje
obliczenie pozycji, na przykad elementy[przesunicie + pozycja]), wtedy uycie operatora
rozszerzonego moe si wiza z mniejszym ryzykiem powstawania bdw. Wynika to
z faktu, e jeli obliczenie bdzie wizao si z koniecznoci wprowadzenia zmiany, wwczas
zmiana ta bdzie musiaa by wprowadzona tylko w jednym wyraeniu zamiast w dwch.
Zarwno w przypadku cigw tekstowych, jak i list Python przecia operatory + i +=
(na przykad ponownie uywa ich z innymi typami danych). W pierwszej sytuacji oznacza
to czenie cigw tekstowych, natomiast w drugiej doczanie do cigw tekstowych
i rozszerzanie (doczanie innej listy) list:
>>> imi = "Jan"
>>> imi + "Kowalski"
'JanKowalski'
>>> imi += " Kowalski"
>>> imi
'Jan Kowalski'
Podobnie jak liczby cakowite, tak i cigi tekstowe s niezmienne, wic w trakcie
uywania operatora += nastpuje utworzenie nowego cigu tekstowego i ponownie doczenie
do niego obiektu znajdujcego si po lewej stronie operatora. Przebiega to dokadnie w taki
sam sposb, jaki wczeniej omwiono dla obiektw int. Listy s obsugiwane przez tak
sam skadni, ale w tle zachowuj si nieco inaczej:
>>> ziarna = ["sezam", "sonecznik"]
>>> ziarna += ["dynia"]
>>> ziarna
['sezam', 'sonecznik', 'dynia']
Poniewa listy mona zmienia, po uyciu operatora += nastpuje modyfikacja

pocztkowego obiektu listy. Nie wystpuje wic konieczno ponownego doczania
obiektu do zmiennej ziarna. Zilustrowano to na rysunku 1.4.
Pikne serce Pythona
47
Rysunek 1.4. Rozszerzone przypisanie stosowane wzgldem obiektu,

ktry mona modyfikowa
Poniewa skadnia Pythona zrcznie ukrywa rnice midzy zmiennymi i niezmiennymi

typami danych, rodzi si pytanie, dlaczego w ogle potrzebujemy obu typw? Powody s
gwnie zwizane z wydajnoci. Niezmienne typy danych s znacznie efektywniejsze
w implementacji (poniewa nigdy nie ulegaj zmianie) ni typy zmienne. Ponadto pewne
kolekcje typw danych na przykad zestawy mog dziaa jedynie z niezmiennymi
typami danych. Z drugiej strony, zmienne typy danych mog by znacznie wygodniejsze
w uyciu. Kiedy rozrnienie bdzie miao znaczenie, wtedy je omwimy na przykad
w rozdziale 4. podczas przedstawiania sposobu ustawiania argumentw domylnych we
wasnych funkcjach, w rozdziale 3. podczas omawiania list, zestaww i kilku innych typw
danych oraz w rozdziale 6. podczas prezentacji tworzenia wasnych typw danych.
Prawy operand w operatorze += listy musi umoliwia iteracj, gdy w przeciwnym
razie zostanie zgoszony wyjtek:
>>> ziarna += 5
Traceback (most recent call last):
...
TypeError: 'int' object is not iterable
Waciwym sposobem rozbudowy listy jest uycie obiektu pozwalajcego na

przeprowadzenie iteracji, czyli na przykad listy:
>>> ziarna += [5]
>>> ziarna
['sezam', 'sonecznik', 'dynia', 5]
Oczywicie umoliwiajcy iteracj obiekt uyty do rozbudowania listy sam moe

posiada wicej ni tylko jeden element:
>>> ziarna += [9, 1, 5, "mak"]
>>> ziarna
['sezam', 'sonecznik', 'dynia', 5, 9, 1, 5, 'mak']
Doczenie zwykego cigu tekstowego na przykad durian zamiast listy

zawierajcej cig tekstowy ["durian"] prowadzi do logicznego, cho prawdopodobnie
zadziwiajcego wyniku:
>>> ziarna = ["sezam", "sonecznik ", "dynia"]
>>> ziarna += "durian"
>>> ziarna
['sezam', 'sonecznik', 'dynia', 'd', 'u', 'r', 'i', 'a', 'n']
Obsuga
bdw
powstaych
w trakcie
dziaania
programu
h 430
48
Operator += listy rozbudowuje list poprzez doczenie kadego elementu pobranego

z dostarczonego mu obiektu pozwalajcego na iteracj. Poniewa cig tekstowy pozwala
na iteracj, wic kady znak cigu tekstowego zostaje doczony indywidualnie. Jeeli
uyjemy metody append(), jej argument zawsze bdzie dodany jako pojedynczy element.
Koncepcja 7. operacje wejcia-wyjcia

Aby mc tworzy naprawd uyteczne programy, musimy mie moliwo odczytu danych
wejciowych na przykad od uytkownika za porednictwem konsoli lub z plikw
oraz generowania danych wyjciowych w konsoli bd do pliku. Jak dotd uywalimy
ju wbudowanej funkcji Pythona o nazwie print(), cho bdzie ona dokadnie omwiona
dopiero w rozdziale 4. W tym miejscu skoncentrujemy si na operacjach wejcia-wyjcia
konsoli oraz na stosowaniu przekierowania konsoli podczas odczytu i zapisu plikw.
Python oferuje wbudowan funkcj input() przyjmujc dane wejciowe od uytkownika.
Funkcja pobiera opcjonalny argument w postaci cigu tekstowego, ktry zostanie wywietlony
w konsoli. Nastpnie odczekuje, a uytkownik wprowadzi dane wejciowe i nacinie
klawisz Enter (lub Return). Jeeli uytkownik nie wprowadzi adnego tekstu i ograniczy
si do nacinicia klawisza Enter, wartoci zwrotn funkcji input() bdzie pusty cig
tekstowy. W przeciwnym razie wartoci zwrotn bdzie cig tekstowy zawierajcy dane
wprowadzone przez uytkownika bez adnego znaku przejcia do nowego wiersza.
Poniej przedstawiono pierwszy uyteczny program wykorzystuje on wiele
z wymienionych dotd koncepcji, a jedyn nowoci jest uycie funkcji input():
print("Podaj liczby cakowite, po kadej nacinij klawisz Enter lub po prostu nacinij
klawisz Enter, aby zakoczy dziaanie programu.")
total = 0
count = 0
while True:
line = input("liczba cakowita: ")
if line:
try:
number = int(line)
print(err)
continue
total += number
count += 1
else:
break
if count:
print("ilo =", count, "suma =", total, "rednia =", total / count)
Przykady
doczone
do ksiki
17 g
Program (w doczonych przykadach zapisany jako plik sum1.py) ma jedynie

siedemnacie wykonywanych wierszy. Poniej przedstawiono typowy sposb dziaania
programu po jego uruchomieniu:
Podaj liczby cakowite, po kadej nacinij klawisz Enter lub po prostu nacinij
klawisz Enter, aby zakoczy dziaanie programu.
liczba cakowita: 12
Pikne serce Pythona
liczba cakowita: 7
liczba cakowita: 1x
invalid literal for int() with base 10: '1x'
liczba cakowita: 15
liczba cakowita: 5
liczba cakowita:
ilo = 4 suma = 39 rednia = 9.75
Chocia program jest bardzo krtki, to pozostaje cakiem solidny. Jeeli uytkownik
wprowadzi cig tekstowy, ktry nie moe by skonwertowany na liczb cakowit, problem
zostanie wychwycony przez procedur obsugi bdw. Wspomniana procedura wywietli
odpowiedni komunikat bdu, a kontrola nad programem bdzie przekazana na pocztek
ptli (kontynuacja wykonywania ptli). W ostatnim poleceniu if upewniamy si,
e uytkownik w ogle nie poda adnej liczby wtedy nie zostan wywietlone adne
dane wyjciowe w tym kroku i unikniemy operacji dzielenia przez zero.
Pene omwienie tematu obsugi plikw zostanie przedstawione w rozdziale 7. W tej chwili
bdziemy tworzy pliki poprzez przekierowanie danych wyjciowych funkcji print()
z konsoli, na przykad:
C:\test.py > wynik.txt
Bd
dotyczcy
powiza
plikw
w Windows
26 g
Powysze polecenie spowoduje, e dane wyjciowe wywoania funkcji print()

w przykadowym programie test.py zostan zapisane w pliku wynik.txt. Podana skadnia
dziaa (zazwyczaj) zarwno w konsoli Windows, jak i w konsolach systemw Unix. Jeeli
domyln wersj Pythona jest 2 lub wystpuje bd dotyczcy przypisania plikw w konsoli,
wtedy w przypadku systemu Windows trzeba wyda polecenie C:\Python31\python.exe
test.py > wynik.txt. W przeciwnym razie przyjmujemy zaoenie, e katalog z Pythonem 3
zosta podany w zmiennej PATH, i jeli polecenie test.py > wynik.txt nie zadziaa, najczciej
wystarczajce bdzie polecenie python test.py > wynik.txt. W systemach z rodziny
Unix program musi mie uprawnienia wykonywania (chmod +x test.py) i uruchamiany
jest poleceniem ./test.py, chyba e katalog, w ktrym si znajduje, zosta podany w zmiennej
PATH. W takim przypadku wystarczajce bdzie wydanie polecenia test.py.
Odczyt danych moe by przeprowadzony poprzez przekierowanie danych pliku i uycie
ich jako danych wejciowych. Przekierowanie wykonujemy analogicznie jak przekierowanie
danych wyjciowych do pliku. Jeli jednak przekierowanie zastosujemy w programie sum1.py,
dziaanie programu zakoczy si niepowodzeniem. Wie si to z tym, e funkcja input()
zgosi wyjtek po otrzymaniu znaku EOF (End Of File, czyli koniec pliku). Poniej
przedstawiono solidniejsz wersj programu (plik sum2.py), ktry moe przyjmowa dane
wejciowe albo podane przez uytkownika za pomoc klawiatury albo poprzez przekierowanie
danych z pliku:
print("Podaj liczby cakowite, po kadej nacinij klawisz Enter.
Aby zakoczy dziaanie programu, nacinij klawisze ^D lub ^Z.")
total = 0
count = 0
while True:
try:
line = input()
if line:
49
50
number = int(line)
total += number
count += 1
print(err)
continue
except EOFError:
break
if count:
print("ilo =", licznik, "suma =", suma, "rednia =", suma / licznik)
Po wydaniu polecenia sum2.py < data\sum2.dat (gdzie sum2.dat oznacza plik znajdujcy
si w podkatalogu data i zawierajcy liczby, po jednej liczbie w kadym wierszu) dane
wyjciowe wywietlone w konsoli przedstawiaj si nastpujco:
Podaj liczby cakowite, po kadej nacinij klawisz Enter. Aby zakoczy dziaanie programu,
nacinij klawisze ^D lub ^Z.
ilo = 37 suma = 1839 rednia = 49.7027027027
W programie wprowadzono wiele drobnych zmian, tak aby dziaa prawidowo zarwno
w trybie interaktywnym, jak i podczas przekierowania. Przede wszystkim zmieniono
sposb przerwania z pustego wiersza na znak EOF (Ctrl+D w systemie Unix, Ctrl+Z,
Enter w Windows). Dziki tej zmianie program dziaa solidniej podczas obsugi plikw
z danymi wejciowymi, ktre zawieraj puste wiersze. Zaniechalimy take wywietlania
znaku zachty do wprowadzenia kadej liczby, poniewa nie ma to sensu podczas stosowania
przekierowania. Ponadto uylimy pojedynczego bloku try wraz z dwiema procedurami
obsugi bdw.
Warto zwrci uwag, e jeli zostanie wprowadzona nieprawidowa liczba cakowita
(za porednictwem klawiatury albo w wyniku wystpienia zego wiersza danych w pliku
dostarczajcym danych wejciowych), konwersja int() zgosi wyjtek ValueError. Oznacza to,
e w takim przypadku nie nastpi zwikszenie wartoci ani zmiennej suma, ani zmiennej
licznik. Takiego zachowania programu oczekujemy.
W powyszym kodzie moglibymy zastosowa take dwa oddzielne bloki try suce
do obsugi wyjtkw:
while True:
try:
line = input()
if line:
try:
number = int(line)
print(err)
continue
total += number
count += 1
except EOFError:
break
Preferowanym rozwizaniem jest grupowanie wyjtkw razem i prba zachowania

maksymalnej przejrzystoci gwnego kodu przetwarzajcego.
Pikne serce Pythona
51
Koncepcja 8. tworzenie i wywoywanie funkcji

Bez problemw mona tworzy programy, uywajc w tym celu jedynie typw danych
i struktur kontrolnych, ktre zostay przedstawione we wczeniejszych sekcjach. Jednak
bardzo czsto zachodzi potrzeba wielokrotnego wykonania tej samej operacji, ale z drobn
rnic, na przykad z inn wartoci pocztkow. Python oferuje moliwo hermetyzacji
pakietw na posta funkcji, ktre mona parametryzowa za pomoc argumentw
przekazywanych do funkcji. Poniej przedstawiono ogln skadni tworzenia funkcji:
def nazwa_funkcji(argumenty):
pakiet
Argumenty s opcjonalne, w przypadku podawania wielu argumentw trzeba je rozdzieli

przecinkami. Kada funkcja Pythona posiada warto zwrotn. Domylnie wartoci
zwrotn jest None, chyba e zostanie zwrcona z wewntrz funkcji za pomoc skadni
return warto, gdzie warto oznacza warto zwrotn danej funkcji. Warto zwrotna
moe by pojedyncz wartoci bd krotk wartoci. Ponadto warto zwrotna moe
zosta zignorowana przez wywoujcego funkcj, wwczas bdzie po prostu odrzucona.
Warto zwrci uwag, e def to polecenie dziaajce podobnie jak operator przypisania.
W trakcie wykonywania polecenia def nastpuje utworzenie obiektu funkcji. Poza tym
tworzone jest odniesienie do obiektu o wskazanej nazwie, ktremu nastpnie przypisuje
si odwoanie do obiektu funkcji. Poniewa funkcje s obiektami, to mog by przechowywane
w kolekcjach zbiorw danych i przekazywane jako parametry do innych funkcji, o czym
przekonamy si w kolejnych rozdziaach.
Jednym z zada najczciej wykonywanych w interaktywnych aplikacjach dziaajcych
w konsoli jest pobieranie liczby cakowitej od uytkownika. Poniej przedstawiono
funkcj realizujc to zadanie:
def get_int(msg):
while True:
try:
i = int(line)
return i
print(err)
Powysza funkcja pobiera tylko jeden argument o nazwie liczba. Wewntrz ptli while
uytkownik jest proszony o podanie liczby cakowitej. Jeeli wprowadzi inne dane, wwczas
zostanie zgoszony wyjtek ValueError, nastpi wywietlenie komunikatu bdu i ponowne
wykonanie ptli. Po wprowadzeniu liczby cakowitej zostanie ona zwrcona wywoujcemu
funkcj. Poniej pokazano przykad wywoania tej funkcji:
wiek = pobierz_liczbe("Podaj swj wiek: ")
W powyszym przykadzie podanie wartoci pojedynczego argumentu jest obowizkowe,

poniewa nie zdefiniowano wartoci domylnej. W rzeczywistoci jzyk Python obsuguje
bardzo skomplikowan i elastyczn skadni parametrw funkcji wraz z obsug wartoci
domylnych argumentw oraz argumenty pozycyjne i w postaci sw kluczowych. Wszystkie
zagadnienia zwizane ze skadni funkcji zostan omwione w rozdziale 4.
Polecenie
return
h 191.
52
Chocia tworzenie wasnych funkcji moe przynosi wiele satysfakcji, w wielu przypadkach
nie jest konieczne. Wynika to z faktu, e Python dostarcza wielu wbudowanych funkcji,
a jeszcze wiksza liczba funkcji w moduach znajduje si w bibliotece standardowej jzyka.
Dlatego te wymagana przez programist funkcja moe ju istnie.
Modu w jzyku Python to po prostu plik .py zawierajcy kod Pythona, na przykad
definicj wasnej funkcji lub klasy (wasny typ danych) oraz czasami zmienne. W celu
uzyskania dostpu do funkcjonalnoci zawartej w module naley go zaimportowa,
na przykad:
import sys
W celu zaimportowania moduu uywamy polecenia import wraz z nazw pliku .py,
ale pomijamy rozszerzenie pliku5. Po zaimportowaniu moduu mona uzyska dostp
do dowolnej funkcji, klasy lub zmiennej zawartej w tym module, na przykad:
print(sys.argv)
Operator
kropki (.)
35 g
Modu sys zawiera zmienn argv lista, gdzie pierwszy element to nazwa, pod jak
zostaje wywoany program, natomiast element drugi i kolejne to argumenty programu
uruchamianego z poziomu wiersza polece. Dwa powysze wiersze kodu skadaj si
na cay program echoargs.py. Jeeli program zostanie uruchomiony z poziomu wiersza
polece echoargs.py -v, wwczas w konsoli wywietli ['echoargs.py', '-v']. (W systemie
z rodziny Unix pierwszy wpis moe mie posta './echoargs.py').
Oglnie rzecz biorc, skadnia uywania funkcji pochodzcej z moduu jest nastpujca:
nazwa_moduu.nazwa_funkcji(argumenty). Wymieniona skadnia wykorzystuje operator
kropki (atrybut dostpu) przedstawiony w koncepcji 3. Biblioteka standardowa zawiera
du ilo moduw, wiele z nich bdzie wykorzystanych w niniejszej ksice. Nazwy
wszystkich moduw standardowych s zapisane maymi literami, wic niektrzy programici
stosuj nazwy, w ktrych pierwsza litera kadego sowa jest wielka (na przykad Moj_Modul),
w celu odrnienia moduw wasnych od wbudowanych.
Spjrzmy na jeszcze jeden przykad modu random (w bibliotece standardowej plik
random.py), ktry dostarcza wielu uytecznych funkcji:
import random
x = random.randint(1, 6)
y = random.choice(["jabko", "banan", "winia", "durian"])
Wiersz
shebang
(#!)
27 g
Po wykonaniu powyszych polece zmienna x bdzie zawieraa liczb cakowit

z przedziau od 1 do 6 wcznie, natomiast zmienna y jeden z cigw tekstowych z listy
przekazanej funkcji random.choice().
Wedug konwencji wszystkie polecenia import s umieszczane na pocztku plikw
.py tu po wierszu shebang oraz dokumentacji moduu. (Dokumentacja moduu bdzie
omwiona w rozdziale 5.). Zaleca si w pierwszej kolejnoci importowanie moduw
biblioteki standardowej, nastpnie moduw firm trzecich, a na kocu wasnych.
5
Moduy sys, podobnie jak inne moduy wbudowane oraz moduy zaimplementowane w jzyku C, niekoniecznie
maj odpowiadajce im pliki .py. S jednak uywane w taki sam sposb, jak moduy posiadajce pliki .py.
Przykady
Przykady
W poprzednim podrozdziale czytelnicy mogli pozna jzyk Python wystarczajco, aby zacz
tworzy rzeczywiste programy. W tym podrozdziale mona si bdzie zapozna z dwoma
penymi programami wykorzystujcymi jedynie te konstrukcje Pythona, ktre omwiono do
tej chwili. Bdzie to zarwno pomocne w utrwaleniu zdobytej dotd wiedzy, jak rwnie
pokae moliwoci jzyka.
W kolejnych podrozdziaach czytelnicy bd mogli poznawa coraz bardziej jzyk
Python i jego bibliotek. Pozwoli to na tworzenie bardziej treciwych i solidniejszych
programw ni przedstawione w tym podrozdziale. Najpierw naley jednak pozna podstawy,
na bazie ktrych pniej bdziemy tworzy programy.
bigdigits.py
Pierwszy z omawianych programw jest do krtki, ale zawiera pewne ciekawe aspekty,
midzy innymi list list. Oto sposb dziaania programu: na podstawie liczby podanej
w wierszu polecenia program wywietla w konsoli t sam liczb, uywajc do tego
duych cyfr.
W miejscach, gdzie dua liczba uytkownikw korzysta z tej samej drukarki o ogromnej
szybkoci dziaania, czsto spotykan praktyk jest to, e kady wydruk danego uytkownika
jest poprzedzony stron tytuow zawierajc nazw danego uytkownika oraz pewne
inne informacje wydrukowane za pomoc omawianej tu techniki.
Kod programu bdzie omwiony w trzech czciach: polecenie import, tworzenie
list przechowujcych dane uywane przez program oraz waciwe przetwarzanie
danych. Jednak w pierwszej kolejnoci zobaczmy, jak wyglda przykadowe uruchomienie
programu:
bigdigits.py
*
*
**
**
* *
*
* *
*
******
*
*
*
*
***
41072819
***
*****
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
***
*
***
*
*
* *
*
*
*
*****
***
*
*
***
*
*
*
*
***
*
*
*
****
**
*
*
* * *
*
****
*
*
*
*
***
*
Nie pokazalimy powyej znaku zachty konsoli (lub pocztkowych znakw ./

w przypadku systemu Unix), przyjmujemy za rzecz oczywist, e s one obecne
i stosowane.
import sys
Poniewa program musi odczyta argument z wiersza polecenia (liczb przeznaczon

do wywietlenia), zachodzi potrzeba uzyskania dostpu do listy sys.argv. Program
rozpoczynamy wic od zaimportowania moduu sys.
Kada liczba bdzie przedstawiona jako lista cigw tekstowych. Na przykad poniej
pokazano zero:
53
54
Zero = [" *** ",

" *
* ",
"*
*",
"*
*",
"*
*",
" *
* ",
" *** "]
Szczegem, na ktry warto zwrci uwag, jest to, e lista cigw tekstowych Zero
zostaa rozcignita w wielu wierszach. Polecenia Pythona zazwyczaj stanowi pojedynczy
wiersz, ale mog rozciga si na wiele wierszy, jeli s wyraeniem umieszczonym
w nawiasach, list, zestawem, dosownym sownikiem, list argumentw wywoania funkcji
bd wielowierszowym poleceniem, w ktrym kady znak koczcy wiersz poza ostatnim
jest poprzedzony lewym ukonikiem (\). We wszystkich wymienionych przypadkach
liczba wierszy nie ma znaczenia, podobnie jak wcicia dla drugiego i kolejnego wiersza.
Kada lista przedstawiajca cyfr ma siedem cigw tekstowych, wszystkie o staej
szerokoci, cho ta szeroko jest rna dla kadej z cyfr. Listy pozostaych cyfr stosuj
ten sam wzorzec, ktrego uyto dla cyfry 0. Zostay jednak zapisane w sposb zajmujcy
jak najmniej miejsca, a nie w sposb gwarantujcy najwiksz czytelno dla programisty:
One = [" * ", "** ", " * ", " * ", " * ", " * ", "***"]
Two = [" *** ", "*
*", "* * ", " * ", " * ", "*
# ...
Nime = [" ****", "*
*", "*
*", " ****", "
*", "
", "*****"]
*", "
*"]
Ostatni element danych to lista obejmujca wszystkie listy cyfr:

Digits = [Zero, One, Two, Three, Four, Five, Six, Seven, Eight, Nine]
Istnieje take moliwo bezporedniego utworzenia listy Digits i dziki temu uniknicia
potrzeby tworzenia dodatkowych zmiennych, na przykad:
Digits = [
["
***
", " * * ", "* *", "* *", "* *",
" * * "," *** "],# Zero
[" * ", "** ", " * ", " * ", " * ", " * ", "***"], # One
# ...
[" ****", "*
*", "*
*", " ****", "
*", "
"
*"] # Nine
]
*",
Preferujemy jednak uycie oddzielnej zmiennej dla kadej cyfry zarwno w celu
uatwienia zrozumienia programu, jak rwnie dlatego, e zastosowanie zmiennych jest
bardziej eleganckie.
Pozostaa cz kodu zostaje przedstawiona w pojedynczym bloku, aby czytelnik mg
sprbowa okreli sposb jego dziaania, zanim przejdziemy do omwienia tego kodu.
try:
digits = sys.argv[1]
row = 0
while row < 7:
line = ""
column = 0
Typ
danych set
h 138
Typ
danych dict
h 143
Przykady
55
while column < len(digits):

number = int(digits[column])
digit = Digits[number]
line += digit[row] + " "
column += 1
print(line)
row += 1
except IndexError:
print("uycie: bigdigits.py <liczba>")
print(err, "in", digits)
Cay kod zosta opakowany procedur obsugi wyjtkw, co pozwala na przechwycenie

dwch bdw, jeli cokolwiek pjdzie niezgodnie z oczekiwaniami. Program rozpoczyna
si od pobrania argumentu z wiersza polecenia. Lista sys.argv rozpoczyna si od 0,
podobnie jak wszystkie listy w Pythonie. Element w pozycji o indeksie 0 jest nazw, pod
jak program zosta uruchomiony. Dlatego te w dziaajcym programie lista ta ma
przynajmniej jeden element. Jeeli nie zosta podany aden argument, wwczas nastpi
prba uzyskania dostpu do drugiego elementu w jednoelementowej licie, co doprowadzi
do zgoszenia wyjtku IndexError. W takim przypadku kontrola nad programem jest
natychmiast przekazywana do odpowiedniego bloku odpowiedzialnego za obsug wyjtku.
W omawianym programie bdzie to po prostu komunikat informujcy o sposobie uycia
programu. Wykonywanie programu jest kontynuowane od polecenia po bloku try.
Poniewa w tym programie nie ma kodu poza blokiem try, nastpuje zakoczenie dziaania
programu.
Jeeli nie nastpi zgoszenie wyjtku IndexError, cig tekstowy digits bdzie
przechowywa argument wiersza polecenia, ktrym mamy nadziej bdzie sekwencja
cyfr. (Jak pamitamy z sekcji powiconej koncepcji 2., identyfikatory rozrniaj wielko
liter, wic digits i Digits to zupenie inne elementy). Kada dua cyfra jest przedstawiona
za pomoc siedmiu cigw tekstowych. Dlatego te w celu poprawnego wywietlenia
danych wyjciowych musimy wywietli najwyszy wiersz kadej cyfry, nastpnie kolejny
itd. a do wywietlenia wszystkich wierszy. Do przejcia przez wszystkie wiersze uywamy
ptli while. Rwnie dobrze mona zastosowa polecenie for row in (0, 1, 2, 3, 4, 5, 6):,
a pniej w znacznie lepszy sposb wykorzysta wbudowan funkcj range().
Cig tekstowy line wykorzystujemy do przechowywania cigw tekstowych wiersza
dla wszystkich cyfr uywanych w danej liczbie. Nastpnie mamy ptl przechodzc przez
kolumny, to znaczy przez kady kolejny znak w argumencie wiersza polecenia. Kady
znak jest pobierany za pomoc polecenia digits[column], a nastpnie konwertowany na
liczb cakowit o nazwie number. Jeeli konwersja zakoczy si niepowodzeniem, wtedy
zostanie zgoszony wyjtek ValueError, a kontrola nad program bdzie natychmiast przekazana
odpowiedniej procedurze obsugi wyjtku. W omawianym przykadzie spowoduje to
wywietlenie komunikatu bdu i dziaanie programu zostanie wznowione od polecenia
znajdujcego si tu po bloku try. Jak ju wczeniej wspomniano, poniewa po bloku
try nie ma wicej kodu, program zakoczy dziaanie.
Funkcja
range()
h 158
56
Gdy konwersja zakoczy si powodzeniem, liczba cakowita number bdzie uywana

jako warto indeksu na licie Digits, z ktrej wyodrbniamy list cigw tekstowych dla
danej cyfry (digit). Nastpnie z listy dodajemy cig tekstowy odpowiedniego wiersza (row)
do budowanej linii oraz dodajemy dwie spacje w celu pionowego oddzielenia cyfr od siebie.
Za kadym razem, gdy ptla while koczy dziaanie, wywietlamy zbudowan lini.
Kluczowy moment dla zrozumienia omawianego programu to ten, w ktrym doczamy
cig tekstowy wiersza kadej cyfry do biecego wiersza budowanej linii. Warto uruchomi
program i przeanalizowa sposb jego dziaania. Do omwionego w tej sekcji programu
powrcimy w wiczeniach, aby nieco usprawni wywietlane przez program dane wyjciowe.
generate_grid.py
Jedna z czsto wystpujcych potrzeb to wygenerowanie danych testowych. Nie ma jednego,
oglnego programu sucego do tego celu, poniewa dane testowe kolosalnie si midzy
sob rni. Jzyk Python jest czsto uywany do generowania danych testowych, poniewa
tworzenie i modyfikowanie programw w Pythonie jest bardzo proste. W tej sekcji omwimy
program sucy do generowania siatki losowych liczb cakowitych. Uytkownik podaje
liczb wierszy i kolumn, ktre chce otrzyma, oraz zakres, w jakim maj znajdowa si
wygenerowane liczby. Prac nad programem rozpoczniemy od spojrzenia na wynik
przykadowego uruchomienia programu:
generate_grid.py
wiersze: 4x
invalid literal for int() with base 10: '4x'
wiersze: 4
kolumny: 7
minimum (lub nacinij Enter dla 0): -100
maximum (lub nacinij Enter dla 1000):
643
-45
923
252
625
342
543
128
35
954
540
691
361
941
233
347
520
302
676
408
-92
461
1000
319
372
134
940
-7
Program dziaa interaktywnie, na pocztku popeniamy bd w trakcie podawania

liczby wierszy. Odpowiedzi programu jest komunikat bdu oraz ponowienie proby
o podanie liczby wierszy. W przypadku wartoci maksymalnej nacinito klawisz Enter,
akceptujc tym samym warto domyln.
Kod zostanie omwiony w czterech czciach: polecenie import, definicja funkcji get_int()
znacznie bardziej zoona wersja tej funkcji ni przedstawiona w koncepcji 8., interakcja
z uytkownikiem w celu pobrania uywanych wartoci oraz samo przetwarzanie danych.
import random
Funkcja
random.
randint()
52 g
Modu random jest potrzebny w celu uzyskania dostpu do funkcji random.randint().

def get_int(msg, minimum, default):
while True:
try:
line = input(msg)
Przykady
if not line and default is not None:

return default
i = int(line)
if i < minimum:
print("musi by >=", minimum)
else:
return i
print(err)
Funkcja wymaga podania trzech argumentw: cigu tekstowego komunikatu, wartoci

minimalnej oraz wartoci domylnej. Jeeli uytkownik po prostu nacinie klawisz Enter,
wtedy s dwie moliwoci. W pierwszym przypadku, gdy default wynosi None, to znaczy
warto domylna nie zostaa podana, kontrola nad programem jest przekazywana do wiersza
int(). W tym wierszu konwersja zakoczy si niepowodzeniem (poniewa cigu tekstowego ''
nie mona skonwertowa na posta liczby cakowitej) i zostanie zgoszony wyjtek ValueError.
W drugim przypadku, jeli default jest rna od None, wtedy zostanie zwrcona. W przeciwnym
razie tekst wprowadzony przez uytkownika funkcja sprbuje przekonwertowa na posta
liczby cakowitej. Gdy konwersja zakoczy si powodzeniem, nastpi sprawdzenie,
czy otrzymana liczba cakowita jest przynajmniej rwna zdefiniowanemu minimum.
Widzimy wic, e wartoci zwrotn funkcji zawsze bdzie albo default (jeeli uytkownik
nacisn jedynie klawisz Enter), albo poprawna liczba cakowita rwna bd wiksza
od zdefiniowanego minimum.
rows = get_int("wierszw: ", 1, None)
columns = get_int("kolumny: ", 1, None)
minimum = get_int("minimum (lub nacinij Enter dla 0): ", -1000000, 0)
default = 1000
if default < minimum:
default = 2 * minimum
maximum = get_int("maksimum (lub nacinij Enter dla
minimum, default)
" + str(default) + "): ",
Funkcja get_int() bardzo uatwia pobranie liczby wierszy, kolumn oraz wartoci
minimalnej oczekiwanej przez uytkownika. W przypadku wierszy i kolumn warto
domylna wynosi None, co oznacza, e uytkownik musi poda liczb cakowit. W przypadku
minimum ustalon wartoci domyln jest 0, natomiast dla maksimum ustalon wartoci
domyln jest 1000 lub dwukrotna warto minimum, jeli minimum jest wiksze bd
rwne 1000.
Jak ju wspomniano w poprzednim przykadzie, lista argumentw wywoania funkcji
moe rozciga si na dowoln liczb wierszy, a wcicia s nieistotne w przypadku drugiego
i kolejnych wierszy.
Gdy znana jest ju liczba wierszy i kolumn wymaganych przez uytkownika oraz wartoci
minimalna i maksymalna generowanych liczb, mona przystpi do waciwego przetwarzania
danych.
row = 0
while row < rows:
line = ""
57
58
column = 0
while column < columns:
i = random.randint(minimum, maximum)
s = str(i)
while len(s) < 10:
s = " " + s
line += s
column += 1
print(line)
row += 1
W celu wygenerowania siatki uywamy ptli while, zewntrzna dziaa z wierszami,

rodkowa z kolumnami, a wewntrzna ze znakami. W rodkowej ptli nastpuje wygenerowanie
losowej liczby w ustalonym zakresie, a nastpnie konwersja liczby na cig tekstowy.
Wewntrzna ptla jest uywana w celu dopenienia cigu tekstowego spacjami, tak aby
kada liczba bya przedstawiona jako cig tekstowy o dugoci dziesiciu znakw. Cig
tekstowy line suy do zebrania liczb tworzcych kady wiersz i wywietlenia linii po
dodaniu liczb w kadej kolumnie. W ten sposb koczymy omawianie drugiego przykadu.
Jzyk Python oferuje bardzo zaawansowane funkcje pozwalajce na formatowanie
cigu tekstowego. Poza tym zapewnia doskona obsug ptli for...in, wic znacznie
bardziej rzeczywiste wersje obu programw (bigdigits.py i generate_grid.py) powinny uywa
ptli for...in. Natomiast w programie generate_grid.py mona zastosowa oferowane
przez Pythona funkcje formatowania cigu tekstowego zamiast prymitywnego uzupeniania
spacjami. Jednak na obecnym etapie jestemy ograniczeni do omiu kluczowych
koncepcji Pythona, ktre zostay przedstawione w tym rozdziale. Jak wida, s one
wystarczajce do tworzenia penych i uytecznych programw. W kadym kolejnym
programie czytelnicy bd poznawa nowe funkcje Pythona, wic w miar lektury
ksiki kolejne przedstawiane programy bd coraz bardziej skomplikowane.
Podsumowanie
Czytajc rozdzia, mona si byo dowiedzie, jak edytowa i uruchamia programy
w jzyku Python. Przeanalizowalimy kilka maych, cho kompletnych programw. Jednak
wikszo miejsca w rozdziale powicono na omwienie omiu kluczowych koncepcji
Piknego serca Pythona wystarczajcej liczby konstrukcji jzyka, ktre pozwalaj
na tworzenie rzeczywistych programw.
Zaczlimy od przedstawienia dwch podstawowych typw danych, czyli int i str.
Dosowne liczby cakowite s zapisywane w dokadnie taki sam sposb, jak w wikszoci
innych jzykw programowania. Natomiast dosowne cigi tekstowe s ujmowane albo
w apostrofy, albo w cudzysw. Nie ma to adnego znaczenia, o ile po obu stronach cigu
tekstowego zastosowano te same znaki ograniczenia (tzn. apostrofy lub cudzysw). Istnieje
moliwo przeprowadzenia konwersji midzy liczbami cakowitymi i cigami tekstowymi,
na przykad int("250") i str(125). Jeeli konwersja liczby cakowitej koczy si
niepowodzeniem, nastpuje zgoszenie wyjtku ValueError. Z drugiej strony, warto pamita,
e niemal wszystko mona przekonwertowa na posta cigu tekstowego.
Metoda
str.format()
h 95
Podsumowanie
Cig tekstowy jest sekwencj, wic funkcje i operacje, ktre mona wykonywa
na sekwencjach, mog take by przeprowadzane na cigu tekstowym. Przykadowo dostp
do okrelonego znaku mona uzyska za pomoc operatora dostpu ([]), czenie cigw
tekstowych umoliwia operator +, natomiast doczanie jednego cigu tekstowego do innego
operator +=. Poniewa cigi tekstowe s niezmienne, to w tle operacja doczania powoduje
utworzenie nowego cigu tekstowego czcego podane cigi tekstowe, a nastpnie ponowne
doczenie obiektu cigu znajdujcego si po lewej stronie operatora do nowo utworzonego
cigu tekstowego. Za pomoc ptli for...in mona przej przez cig tekstowy znak po znaku.
Z kolei wbudowana funkcja len() informuje o iloci znakw tworzcych cig tekstowy.
W przypadku obiektw niezmiennych, takich jak cigi tekstowe, liczby cakowite i krotki,
moemy tworzy kod, jakby odniesienie do obiektu byo zmienn, czyli jakby odniesienie
byo obiektem, do ktrego nastpuje odwoanie w tworzonym kodzie. T sam technik
mona zastosowa take w przypadku obiektw pozwalajcych na modyfikacje, cho wszelkie
zmiany takiego obiektu s wprowadzane we wszystkich egzemplarzach tego obiektu
(na przykad we wszystkich odniesieniach do obiektu). To zagadnienie bdzie omwione
w rozdziale 3.
Jzyk Python oferuje wiele wbudowanych kolekcji typw danych, kolejne s dostpne
w bibliotece standardowej. W rozdziale omwilimy typy list i tuple, w szczeglnoci
sposb tworzenia list i krotek, na przykad parzyste = [2, 4, 6, 8]. Listy podobnie
jak wszystkie pozostae elementy w Pythonie s obiektami, wic mona wywoywa
wzgldem nich metody, na przykad polecenie parzyste.append(10) spowoduje dodanie
kolejnego elementu do listy parzyste. Podobnie jak cigi tekstowe, tak i listy oraz krotki
s sekwencjami. Dziki temu moemy przej przez nie element po elemencie, uywajc
do tego ptli for...in, a take ustali liczb elementw za pomoc funkcji len(). Istnieje
take moliwo pobrania okrelonego elementu listy bd krotki przy uyciu operatora
dostpu ([]), poczenia dwch list lub krotek za pomoc operatora + oraz doczenia
jednej do drugiej za pomoc operatora +=. Jeeli wystpi potrzeba doczenia pojedynczego
elementu do listy, naley uy funkcji lista.append() lub operatora += wraz z nazw
doczanego elementu na przykad parzyste += [12]. Poniewa listy mona modyfikowa,
zmian danego elementu mona przeprowadzi za pomoc operatora [], na przykad
parzyste[1] = 16.
Szybki operator tosamoci is i is not suy do sprawdzenia, czy dwa odniesienia do
obiektu odwouj si do tego samego obiektu. Taka moliwo jest szczeglnie uyteczna
podczas przeprowadzenia sprawdzenia wzgldem wbudowanego obiektu None. Dostpne
s wszystkie zwyke operatory porwnania (<, <=, ==, !=, >=, >), ale mog by uywane jedynie
z porwnywalnymi typami danych i tylko wtedy, gdy operatory s obsugiwane. Wszystkie
przedstawione dotd typy danych int, str, list i tuple w peni obsuguj wymieniony
zestaw operatorw porwnania. Prba porwnania niezgodnych typw danych, na przykad
porwnanie wartoci int z list, spowoduje zgoszenie wyjtku TypeError.
Python obsuguje standardowe operatory logiczne and, or i not. Zarwno and, jak i or
s operatorami zwracajcymi operand, ktry zdominowa wyniki to nie moe by warto
boolowska (cho mona j skonwertowa na posta wartoci boolowskiej). Natomiast not
zawsze zwraca warto True lub False.
59
60
Przynaleno typw sekwencji, midzy innymi cigw tekstowych, list i krotek,

mona sprawdzi za pomoc operatorw in i not in. Sprawdzanie przynalenoci
wykorzystuje powolne, liniowe przeszukiwanie list i krotek, natomiast w przypadku cigw
tekstowych potencjalnie szybszy algorytm hybrydowy. Jednak wydajno rzadko jest
problemem poza bardzo duymi cigami tekstowymi, listami i krotkami. W rozdziale 3.
zostan przedstawione tablice asocjacyjne i kolekcje typw danych obie wymienione
konstrukcje zapewniaj bardzo szybkie sprawdzenie przynalenoci. Istnieje take moliwo
okrelenia typu zmiennej obiektu (na przykad typu obiektu, do ktrego odwouje si
odniesienie do obiektu) przy uyciu funkcji type(). Wymieniona funkcja zazwyczaj
stosowana jest jedynie w trakcie procesu usuwania bdw oraz testowania.
Jzyk Python oferuje kilka struktur kontrolnych, midzy innymi polecenia warunkowe
if...elseif...else, ptle warunkowe while, ptle powalajce na przejcie przez sekwencje
for...in oraz bloki obsugi wyjtkw try...except. Zarwno ptla while, jak i for...in
moe by wczeniej zakoczona za pomoc polecenia break. Obie ptle mog rwnie
przekaza kontrol nad programem do pocztku ptli, uywajc w tym celu polecenia
continue.
Obsugiwane s standardowe operatory matematyczne, midzy innymi +, -, * i /,
chocia w przypadku Pythona nietypowe jest, e wynikiem operatora dzielenia (/) zawsze
bdzie liczba zmiennoprzecinkowa, nawet jeli oba operandy s liczbami cakowitymi.
(Znane z innych jzykw programowania dzielenie z pominiciem czci dziesitnej take
jest dostpne w Pythonie za pomoc operatora //). Python oferuje take rozszerzone
operatory przypisania, takie jak += i *=. Powoduj one utworzenie nowych obiektw i ponowne
przeprowadzenie operacji doczenia, jeli lewy operand jest niezmienny. Operatory
arytmetyczne s przeciane przez typy str i list, co zostao ju wczeniej powiedziane.
Do wykonywania operacji wejcia-wyjcia konsoli stosuje si funkcje input() i print().
Uywajc przekierowania pliku w konsoli, mona wykorzysta te same funkcje wbudowane
do odczytywania i zapisywania plikw.
Oprcz wielu moliwoci wbudowanych w Pythona istnieje take obszerna biblioteka
standardowa, ktrej moduy s dostpne po ich zaimportowaniu za pomoc polecenia
import. Jednym z najczciej importowanych moduw jest sys, ktry przechowuje list
argumentw wiersza polecenia sys.argv. Kiedy Python nie zawiera funkcji wymaganej przez
programist, bardzo atwo mona utworzy wasn, uywajc do tego celu polecenia def.
Wykorzystujc wiedz przedstawion w tym rozdziale, mona tworzy krtkie, cho
uyteczne programy w jzyku Python. Z kolejnego rozdziau czytelnik dowie si wicej
na temat typw danych Pythona, zagbimy si w typy int i str oraz przedstawimy nowe.
W rozdziale 3. jeszcze dokadniej przedstawimy krotki i listy, a take opowiemy wicej na
temat kolekcji typw danych. Rozdzia 4. jest powicony na dokadne omwienie
struktur kontrolnych w Pythonie. Czytelnik dowie si rwnie, w jaki sposb tworzy wasne
funkcje, aby funkcjonalno mc umieci w pakiecie i unikn w ten sposb powielania
kodu oraz promowa ponowne uywanie fragmentw kodu.
wiczenia
wiczenia
Przykady
doczone
do ksiki
17 g
Celem wicze przedstawionych poniej oraz w pozostaych rozdziaach ksiki jest

zachcenie czytelnika do eksperymentowania z Pythonem oraz zdobycia dowiadczenia,
ktre pomoe w przyswojeniu materiau przedstawionego w danym rozdziale. Zaprezentowane
przykady i wiczenia obejmuj przetwarzanie zarwno liczbowe, jak i tekstowe oraz s
skierowane do jak najszerszej grupy odbiorcw. Ponadto s na tyle mae, aby pooy nacisk
na mylenie i nauk, a nie po prostu wprowadzanie kodu. W przykadach doczonych
do ksiki znajduj si odpowiedzi do kadego wiczenia.
1. Jedn z odmian programu bigdigits.py jest wersja, w ktrej zamiast gwiazdki (*)
wywietlana jest odpowiednia cyfra, na przykad:
bigdigits_ans.py 719428306
77777
1
9999
4
7 11
9
9
44
7
1
9
9 4 4
7
1
9999 4 4
7
1
9 444444
7
1
9
4
7
111
9
4
222
2
2
2 2
2
2
2
22222
888
333
000
8 3
3
0
0
8
3 0
0
888
33
0
0
8
8
3 0
0
8
8 3 3 0 0
888
333
000
8
8
666
6
6
6666
6
6
6 6
666
W tym celu mona zastosowa dwa podejcia. Najatwiejszym jest po prostu

zamiana gwiazdek w listach. Jednak to podejcie nie jest elastyczne i nie powinno
by zastosowane. Zamiast tego naley zmodyfikowa kod przetwarzajcy dane,
tak aby zamiast za kadym razem dodawa kady wiersz do tworzonej linii, dodawa
cyfry znak po znaku. Ponadto zamiast gwiazdki trzeba uy odpowiedniej cyfry.
Prac nad rozwizaniem mona zacz od skopiowania bigdigits.py i nastpnie
wprowadzi zmiany w mniej wicej piciu wierszach. Nie jest to zadanie trudne,
raczej kosmetyczne. Rozwizanie znajduje si w pliku bigdigits_ans.py.
2. rodowisko IDLE mona wykorzysta jako elastyczny i oferujcy potne
moliwoci kalkulator. Jednak czasami uyteczne bdzie posiadanie kalkulatora
przeznaczonego do okrelonych zada. Zadaniem jest wic utworzenie programu
proszcego uytkownika o podanie liczby (w ptli while) i stopniowo budujcego
list podanych liczb. Kiedy uytkownik zakoczy podawanie liczb (poprzez
nacinicie klawisza Enter), program powinien wywietli wprowadzone liczby,
ilo podanych liczb, ich sum, najmniejsz i najwiksz wprowadzon liczb oraz
warto redni (suma / ilo liczb). Poniej pokazano przykadowe uruchomienie
programu:
average1_ans.py
podaj liczb lub naciniej Enter,
liczby: [5, 4, 1, 8, 5, 2]
ilo = 6 suma = 25 najmniejsza =
aby
aby
aby
aby
aby
aby
aby
zakoczy:
zakoczy:
zakoczy:
zakoczy:
zakoczy:
zakoczy:
zakoczy:
5
4
1
8
5
2
1 najwiksza = 8 rednia = 4.16666666667
61
62
Inicjalizacja potrzebnych zmiennych (pusta lista to po prostu []) wymaga

okoo czterech wierszy. Natomiast ptla while z prost obsug bdw to poniej
pitnastu wierszy kodu. Wywietlenie danych wyjciowych zabierze kilka
dodatkowych wierszy kodu, wic cay program cznie z pustymi wierszami
zwikszajcymi czytelno programu powinien si zmieci w 25 wierszach kodu.
Metody
random.int()
i random.
choice()
52 g
3. W pewnych sytuacjach wystpuje potrzeba wygenerowania tekstu testowego

na przykad w celu wypenienia projektu witryny internetowej, zanim dostpna
bdzie rzeczywista tre witryny. Taki program przydaje si te do zapewnienia
treci podczas tworzenia generatora tekstw. Zadaniem jest utworzenie programu
generujcego wspaniae wiersze (takie, ktre spowoduj wystpienie rumiecw
na twarzach wieszczy).
Prac naley rozpocz od przygotowania listy sw, na przykad zaimkw
(ten, ta), podmiotu (kot, pies, mczyzna, kobieta), czasownikw
(piewa, ucieka, skoczy) oraz przymiotnikw (gony, cichy,
doskonay, zy). Nastpnie ptl trzeba wykona piciokrotnie, w trakcie
kadej iteracji uy funkcji random.choice() w celu pobrania podmiotu, czasownika
i przymiotnika. Za pomoc funkcji random.randint() mona wybra jedn
z dwch struktur zdania: przyimek, podmiot, czasownik i przymiotnik lub po
prostu przyimek, podmiot i czasownik, a nastpnie wywietli zdanie. Poniej
pokazano przykadowy wynik uruchomienia programu:
awfulpoetry1_ans.py
another boy laughed badly
the woman jumped
a boy hoped
a horse jumped
another man laughed rudely
W programie trzeba zaimportowa modu random. List mona zmieci

w czterech dziesiciu wierszach w zalenoci od liczby uytych sw. Sama ptla
wymaga mniej ni dziesiciu wierszy kodu, wic uwzgldniajc puste wiersze,
cay program moe zaj okoo 20 wierszy kodu. Rozwizanie zadania znajduje
si w pliku awfulpoetry1_ans.py.
4. Aby program generujcy wiersze by jeszcze bardziej uniwersalny, do programu
dodamy kod powodujcy, e jeli uytkownik wprowadzi liczb w wierszu polecenia
(z zakresu od 1 do 10 wcznie), program wygeneruje wiersz o podanej liczbie linii.
Jeeli nie zostanie podany argument wiersza polecenia, program bdzie domylnie
generowa i wywietla wiersz zawierajcy pi linii. W tym celu trzeba bdzie
zmieni gwn ptl programu (na przykad na ptl while). Naley pamita,
e operatory porwnania w Pythonie mog by grupowane, wic nie zachodzi
potrzeba uywania operatora logicznego and podczas sprawdzania, czy podany
przez uytkownika argument mieci si w zdefiniowanym zakresie. Dodatkow
funkcjonalno programu mona zmieci w mniej wicej dziesiciu wierszach
kodu. Rozwizanie zadania znajduje si w pliku awfulpoetry2_ans.py.
wiczenia
5. Moliwo obliczenia mediany (wartoci rodkowej) w programie utworzonym

w wiczeniu 2. byaby podan funkcj, ale w tym celu trzeba posortowa list.
W Pythonie list mona bardzo atwo posortowa za pomoc metody lista.sort().
Metoda ta nie zostaa jednak jeszcze omwiona, wic nie zastosujemy jej w tym
wiczeniu. Zadaniem jest rozbudowa programu o blok kodu, ktry bdzie sortowa
list liczb wydajno nie ma tutaj adnego znaczenia, naley po prostu zastosowa
najatwiejsze podejcie. Po posortowaniu listy median bdzie warto rodkowa,
jeli lista ma nieparzyst liczb elementw, bd rednia dwch rodkowych
wartoci w przypadku listy o parzystej liczbie elementw. Median naley obliczy,
a nastpnie wywietli wraz z pozostaymi informacjami.
To do trudne zadanie zwaszcza dla niedowiadczonych programistw.
Jeeli czytelnik ma ju pewne dowiadczenie w programowaniu w jzyku Python,
to zadanie nadal bdzie wyzwaniem, zwaszcza w przypadku uywania Pythona
jedynie w zakresie, ktry dotd omwiono. Kod odpowiedzialny za sortowanie
mona zmieci w mniej wicej dziesiciu wierszach, natomiast obliczenie mediany
(w tym fragmencie kodu nie mona uy operatora modulus, poniewa nie
zosta jeszcze omwiony) w czterech. Rozwizanie zadania znajduje si w pliku
average2_ans.py.
63

Python 3. Kompletne Wprowadzenie Do Programowania. Wydanie II

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Python 3. Kompletne Wprowadzenie Do Programowania. Wydanie II

Uploaded by

Copyright:

Available Formats

Python 3.

Rozdzia 2. Rodzaje danych ..................................................................65

Python 3. Kompletne wprowadzenie do programowania

Cigi tekstowe ..............................................................................80

Rozdzia 3. Kolekcje rodzajw danych ................................................123

Rozdzia 4. Funkcje i struktury kontrolne ...........................................177

Wasne funkcje ...........................................................................189

Rozdzia 5. Moduy ............................................................................213

Rozdzia 6. Programowanie zorientowane obiektowo ...........................251

Python 3. Kompletne wprowadzenie do programowania

Rozdzia 7. Obsuga plikw ................................................................303

Rozdzia 8. Zaawansowane techniki programowania ...........................355

Rozdzia 9. Usuwanie bdw, testowanie i profilowanie .....................427

Rozdzia 10. Procesy i wtkowanie ......................................................453

Rozdzia 11. Praca w sieci ..................................................................471

Rozdzia 12. Programowanie bazy danych ............................................489

Rozdzia 13. Wyraenia regularne ........................................................503

Rozdzia 14. Wprowadzenie do analizy skadniowej ...............................529

Python 3. Kompletne wprowadzenie do programowania

Analiza skadniowa za pomoc moduu PyParsing ..........................550

Rozdzia 15. Wprowadzenie do programowania GUI ..............................585

Rozdzia 1. Szybkie wprowadzenie do programowania proceduralnego

Tworzenie i uruchamianie programw Pythona

Pierwszy wiersz to komentarz. W Pythonie komentarz rozpoczyna si od znaku #

Tworzenie i uruchamianie programw Pythona

W obu przypadkach dane wyjciowe prezentuj si tak samo:

Rozdzia 1. Szybkie wprowadzenie do programowania proceduralnego

Zakadamy, e znajdujemy si w katalogu py3eg. W systemie Windows mona wic

Windows uywa rejestru przypisa plikw w celu automatycznego wywoania

oznacza to, e w systemie znajduje si Python 2 i zosta wywoany zamiast Pythona 3.

Znacznie wygodniejszym rozwizaniem moe by utworzenie pliku py3.bat zawierajcego

Oczywicie polecenie chmod naley wykona tylko jednokrotnie, pniej wystarczy po

Tworzenie i uruchamianie programw Pythona

W systemie Unix podczas wywoywania programu w konsoli nastpuje odczyt dwch

Jeeli bdzie zapisany w pierwszej formie, uyty zostanie wymieniony interpreter.

Rozdzia 1. Szybkie wprowadzenie do programowania proceduralnego

Rysunek 1.1. Konsola Pythona w rodowisku IDLE

bazujcej na Tk (omwiona w rozdziale 15.), a nie jednej z nowoczesnych i oferujcych

Pikne serce Pythona

z fragmentami kodu. Gdy prezentujemy krtkie przykady interaktywne, przyjmujemy

Pikne serce Pythona

Koncepcja 1. typy danych

Rozdzia 1. Szybkie wprowadzenie do programowania proceduralnego

Pikne serce Pythona

Koncepcja 2. odniesienia do obiektw

Skadnia to po prostu odniesienie_do_obiektu = warto. Nie ma koniecznoci

Po czwartym poleceniu (x = z) wszystkie trzy odniesienia do obiektw odwouj si do

Rozdzia 1. Szybkie wprowadzenie do programowania proceduralnego

Rysunek 1.2. Odniesienia do obiektw oraz obiekty

W powyszym przykadzie tworzymy nowe odniesienie do obiektu nazwane droga

Pikne serce Pythona

To znacznie wygodniejsze rozwizanie ni cige wywoywanie funkcji print(), ale dziaa

Koncepcja 3. kolekcje typw danych

Kiedy Python wywietla krotk, ujmuje j w nawias. Wielu programistw naladuje

Rozdzia 1. Szybkie wprowadzenie do programowania proceduralnego

Pikne serce Pythona

Rozdzia 1. Szybkie wprowadzenie do programowania proceduralnego

W przypadku podania pozycji indeksu wykraczajcej poza zakres nastpi zgoszenie

Koncepcja 4. operatory logiczne

Pikne serce Pythona

Warto pamita, e zazwyczaj nie ma wikszego sensu uywanie operatora is w celu

W celu odwrcenia testu tosamoci uywamy operatora is not.

Podczas pracy z liczbami cakowitymi wszystko przebiega zgodnie z oczekiwaniami.

Cigi tekstowe ..............................................................................80

Rozdzia 9. Usuwanie bdw, testowanie i profilowanie .....................427

Analiza skadniowa za pomoc moduu PyParsing ..........................550

Pikne serce Pythona

Koncepcja 7. operacje wejcia-wyjcia