Darmowy fragment publikacji:
IDZ DO
IDZ DO
PRZYK£ADOWY ROZDZIA£
PRZYK£ADOWY ROZDZIA£
SPIS TRE(cid:140)CI
SPIS TRE(cid:140)CI
Po prostu Python
KATALOG KSI¥flEK
KATALOG KSI¥flEK
KATALOG ONLINE
KATALOG ONLINE
ZAM(cid:211)W DRUKOWANY KATALOG
ZAM(cid:211)W DRUKOWANY KATALOG
Autor: Chris Fehily
T‡umaczenie: Zygmunt Wereszczyæski
ISBN: 83-7197-684-4
Tytu‡ orygina‡u:
Format: B5, stron: 436
Python Visual QuickStart Guide
TW(cid:211)J KOSZYK
TW(cid:211)J KOSZYK
DODAJ DO KOSZYKA
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
CENNIK I INFORMACJE
ZAM(cid:211)W INFORMACJE
ZAM(cid:211)W INFORMACJE
O NOWO(cid:140)CIACH
O NOWO(cid:140)CIACH
ZAM(cid:211)W CENNIK
ZAM(cid:211)W CENNIK
CZYTELNIA
CZYTELNIA
FRAGMENTY KSI¥flEK ONLINE
FRAGMENTY KSI¥flEK ONLINE
Witamy w (cid:156)wiecie Pythona, czyli popularnego jŒzyka programowania obiektowego,
kt(cid:243)rego wersja (cid:159)r(cid:243)d‡owa jest powszechnie dostŒpna. Python mo¿e by(cid:230) stosowany
do(cid:160) wszystkiego -- pocz„wszy od prostych skrypt(cid:243)w, a¿ do programowania witryn WWW
i skomplikowanych aplikacji. W celu utrzymania rozs„dnej objŒto(cid:156)ci ksi„¿ki,
autor(cid:160) ograniczy‡ siŒ do opisania rdzenia samego jŒzyka i podstawowych bibliotek.
Po(cid:160) ukoæczeniu lektury czytelnik bŒdzie zna‡ sposoby wykorzystania Pythona zar(cid:243)wno
w(cid:160) przypadku typowych, jak i w zaawansowanych zadaæ stawianych programi(cid:156)cie.
Na(cid:160) koæcu ksi„¿ki przedstawiono sposoby, w jakie mo¿na uzyska(cid:230) dostŒp do (cid:159)r(cid:243)de‡
informacji dotycz„cych r(cid:243)¿nych zagadnieæ. Czy to wystarczy?
Ksi„¿ka jest odpowiednia dla os(cid:243)b, kt(cid:243)re ucz„ siŒ jŒzyka Python z czyj„(cid:156) pomoc„ lub
trochŒ programowa‡y w innym jŒzyku programowania (przynajmniej na tyle, ¿e wiedz„
dobrze, co to s„ zmienne, pŒtle i instrukcje warunkowe). Ksi„¿ka nie nadaje siŒ do
wykorzystania jako podrŒcznik do samodzielnej nauki pierwszego jŒzyka
programowania lub do nauki technik programowania stosowanych w administrowaniu
systemem, programowaniu aplikacji WWW lub innych specjalistycznych dziedzinach
(nale¿y o tym pamiŒta(cid:230) przesy‡aj„c recenzjŒ do Amazon.com).
Ksi„¿ka jest wyczerpuj„cym przewodnikiem po jŒzyku Python. Jej zakres tematyczny
zosta‡ ograniczony do samego rdzenia jŒzyka i najczŒ(cid:156)ciej stosowanych modu‡(cid:243)w
bibliotecznych. Informacje o innych modu‡ach mo¿na znale(cid:159)(cid:230) w podrŒczniku (cid:132)Python
Library Reference(cid:148), kt(cid:243)ry zwykle jest do‡„czony do Pythona. Kr(cid:243)tki przegl„d czŒ(cid:156)ciej
stosowanych modu‡(cid:243)w mo¿na tak¿e znale(cid:159)(cid:230) w dodatku A.
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treści
Wprowadzenie
11
Informacja o Pythonie ................................................... .........................................12
Informacja o książce ................................................... ...........................................16
Krótki przegląd................................................... ................................................... .18
Typy wbudowane ................................................... ................................................22
Rozdział 1. Pierwsze kroki
27
Dostęp do dystrybucji Pythona ................................................... ...........................28
Dokumentacja języka Python................................................... ..............................31
Otwieranie okna z wierszem poleceń................................................... ..................33
Definiowanie ścieżki ................................................... ...........................................34
Zastosowanie zmiennych środowiskowych Pythona.............................................37
Uruchamianie programów w trybie interakcyjnym ...............................................38
Uruchamianie programów jako skryptów................................................... ...........40
Zastosowanie IDLE................................................... .............................................42
Określanie opcji wiersza poleceń................................................... ........................44
Przekazywanie argumentów do skryptu ................................................... .............45
S
p
i
s
t
r
e
ś
c
i
Rozdział 2. Wyrażenia i instrukcje
47
Dokumentowanie programów................................................... .............................48
Nadawanie nazw zmiennym ................................................... ...............................50
Tworzenie wyrażeń ................................................... .............................................51
Tworzenie instrukcji z wyrażeń ................................................... ..........................52
Tworzenie zmiennych ................................................... .........................................54
Usuwanie zmiennych ................................................... ..........................................57
Drukowanie obiektów ................................................... .........................................58
Określanie tożsamości obiektu................................................... ............................60
Tworzenie odwołań do tego samego obiektu................................................... ......61
Określanie typu obiektu ................................................... ......................................63
Użycie operatorów logicznych................................................... ............................67
Użycie operatorów porównania ................................................... ..........................69
Porównania kaskadowe................................................... .......................................72
Kolejność obliczeń ................................................... ..............................................73
Podsumowanie informacji o obiektach ................................................... ...............74
5
i
c
ś
e
r
t
s
i
p
S
Po prostu Python
Rozdział 3. Praca z liczbami
75
Informacje o typach liczb................................................... ....................................76
Zasady rozszerzania typów ................................................... .................................78
Podstawowe działania arytmetyczne ................................................... ..................79
Potęgowanie ................................................... ................................................... .....81
Reszta pozostała z dzielenia................................................... ................................82
Uzyskiwanie ilorazu przy dzieleniu ................................................... ....................83
Kontrola kolejności obliczeń ................................................... ..............................84
Przypisania przyrostowe ................................................... .....................................85
Przekształcanie typów liczb ................................................... ................................86
Porównywanie liczb ................................................... ............................................87
Korzystanie z funkcji matematycznych ................................................... ..............88
Zastosowanie zaawansowanych funkcji matematycznych ....................................90
Generowanie liczb losowych ................................................... ..............................92
Rozdział 4. Praca z łańcuchami
95
Tworzenie łańcucha ................................................... ............................................96
Wstawianie znaków specjalnych do łańcucha ................................................... ....98
Łańcuchy Unicode ................................................... ............................................100
Długość łańcucha ................................................... ..............................................106
Indeksowanie łańcucha (pobieranie znaku) ................................................... ......107
Wycinanie łańcucha (pobieranie części łańcucha)...............................................108
Łączenie łańcuchów ................................................... ..........................................110
Powtarzanie łańcucha................................................... ........................................112
Zastosowanie metod i funkcji łańcuchowych ................................................... ...114
Zmiana wielkości liter w łańcuchu ................................................... ...................115
Testowanie łańcuchów ................................................... ......................................117
Przycinanie i wyrównywanie łańcucha................................................... .............120
Wyszukiwanie łańcuchów podrzędnych ................................................... ...........122
Zamiana łańcuchów podrzędnych................................................... .....................126
Konwersja łańcucha ................................................... ..........................................128
Rozdzielanie i łączenie łańcuchów ................................................... ...................129
Operacje listowe stosowane w łańcuchach ................................................... .......131
Przekształcenia łańcuchów................................................... ................................132
Porównywanie łańcuchów ................................................... ................................135
Wyświetlanie sformatowanych łańcuchów................................................... .......139
Rozdział 5. Praca z listami i krotkami
143
Tworzenie listy lub krotki ................................................... .................................144
Określanie rozmiaru (długości) listy lub krotki ................................................... 146
Indeksowanie listy lub krotki (pobieranie pozycji) .............................................147
Wycinanie listy lub krotki (pobieranie segmentu)...............................................149
Kopiowanie listy lub krotki................................................... ...............................151
6
Spis treści
Łączenie list lub krotek ................................................... .....................................154
Powtarzanie listy lub krotki ................................................... ..............................155
Przekształcanie listy lub krotki ................................................... .........................157
Porównywanie list lub krotek ................................................... ...........................159
Sprawdzanie przynależności do listy lub krotki ..................................................161
Modyfikacja listy ................................................... ..............................................162
Zastępowanie pozycji listy................................................... ................................163
Zliczanie pasujących wartości w liście ................................................... .............165
Przeszukiwanie listy................................................... ..........................................166
Dołączanie pozycji do listy ................................................... ...............................167
Usuwanie pozycji z listy ................................................... ...................................169
Sortowanie listy................................................... .................................................172
Wstawianie pozycji do posortowanej listy................................................... ........173
Samodzielne określanie kolejności sortowania listy............................................175
Odwracanie kolejności listy ................................................... ..............................177
Rozdział 6. Praca ze słownikami
179
S
p
i
s
t
r
e
ś
c
i
Użycie operatorów i metod słownikowych................................................... .......180
Tworzenie słownika ................................................... ..........................................181
Wyświetlanie (drukowanie) słownika................................................... ...............183
Uzyskiwanie wartości za pomocą klucza................................................... ..........185
Uzyskiwanie wszystkich wartości ze słownika ................................................... 187
Uzyskiwanie wszystkich kluczy ze słownika ................................................... ...188
Uzyskiwanie wszystkich par klucz-wartość ze słownika ....................................189
Sprawdzanie tego, czy klucz istnieje ................................................... ................190
Zliczanie par klucz-wartość w słowniku................................................... ...........191
Wstawianie lub zastępowanie pary klucz-wartość ..............................................192
Usuwanie pary klucz-wartość ................................................... ...........................193
Usuwanie przypadkowej pary klucz-wartość ................................................... ...194
Oczyszczanie lub usuwanie słownika ................................................... ...............195
Łączenie słowników................................................... ..........................................196
Kopiowanie słownika................................................... ........................................197
Przekształcanie słownika ................................................... ..................................198
Porównywanie słowników ................................................... ................................199
Sortowanie słownika ................................................... .........................................201
Przechowywanie wyliczonych wartości w słowniku...........................................202
Rozdział 7.
Instrukcje sterujące
205
Podział instrukcji na wiersze................................................... .............................206
Tworzenie instrukcji złożonych ................................................... ........................208
Zastosowanie pass do tworzenia pustej instrukcji ...............................................209
Wcinanie bloków instrukcji ................................................... ..............................210
Wiele instrukcji w jednym wierszu................................................... ...................212
7
i
c
ś
e
r
t
s
i
p
S
Po prostu Python
Zastosowanie warunków if ................................................... ...............................213
Zastosowanie warunków if-else................................................... ........................214
Zastosowanie warunków if-elif-else ................................................... .................215
Zastosowanie pętli while................................................... ...................................217
Zastosowanie pętli while-else ................................................... ...........................219
Zastosowania pętli for ................................................... .......................................220
Zastosowania pętli for-else ................................................... ...............................224
Pętla w zakresie liczb całkowitych ................................................... ...................225
Pomijanie części iteracji pętli ................................................... ...........................228
Wychodzenie z pętli ................................................... ..........................................230
Rozdział 8. Funkcje
233
Definiowanie funkcji................................................... .........................................234
Dokumentowanie funkcji ................................................... ..................................236
Wywoływanie funkcji ................................................... .......................................238
Zwracanie wartości przez funkcję................................................... .....................240
Zwracanie wielu wartości funkcji ................................................... .....................244
Określanie argumentów pozycyjnych ................................................... ...............245
Określanie domyślnej wartości parametru................................................... ........246
Określanie argumentów jako słów kluczowych................................................... 248
Określanie dowolnej liczby argumentów pozycyjnych .......................................250
Określanie dowolnej liczby argumentów jako słów kluczowych........................252
Mieszane techniki przekazywania argumentów ..................................................253
Tworzenie funkcji rekurencyjnych ................................................... ...................254
Przekazywanie zmiennych i niezmiennych argumentów do funkcji...................256
Deklaracje zmiennych globalnych ................................................... ....................258
Przypisanie funkcji do zmiennej ................................................... .......................260
Zastosowania narzędzi programowania funkcjonalnego .....................................262
Zastosowanie wyrażeń lambda do tworzenia funkcji ..........................................264
Zastosowanie apply w celu wywołania funkcji ................................................... 266
Użycie map w celu zastosowania funkcji do pozycji sekwencji .........................268
Zastosowanie zip do grupowania pozycji sekwencji ...........................................270
Zastosowanie filter do warunkowego usuwania pozycji sekwencji ....................271
Zastosowanie reduce do redukcji sekwencji................................................... .....272
Zastosowanie skrótów listy do tworzenia list ................................................... ...273
Rozdział 9. Moduły
277
Struktura modułu ................................................... ..............................................278
Tworzenie modułu ................................................... ............................................279
Dokumentowanie modułu ................................................... .................................281
Ładowanie modułu za pomocą import................................................... ..............282
Dostęp do atrybutów ................................................... .........................................284
Tworzenie listy atrybutów obiektu ................................................... ...................286
8
Spis treści
Działania na atrybutach................................................... .....................................287
Ładowanie specyficznych nazw z modułu za pomocą instrukcji from ...............288
Ładowanie modułu pod inną nazwą za pomocą instrukcji as..............................291
Udostępnianie właściwości języka................................................... ....................292
Ładowanie modułu za pomocą funkcji reload ................................................... ..293
Określanie ścieżki wyszukiwania modułów ................................................... .....295
Określanie tego, czy moduł działa jako program.................................................296
Określanie tego, które moduły są załadowane................................................... ..298
Przestrzenie nazw................................................... ..............................................299
Dostęp do przestrzeni nazw ................................................... ..............................301
Reguły zasięgu ................................................... ..................................................304
Zagnieżdżanie funkcji ................................................... .......................................305
Grupowanie modułów w pakiety ................................................... ......................307
Jawne zamykanie programu................................................... ..............................308
Programowe uruchamianie kodu ................................................... ......................309
Rozdział 10. Pliki
311
S
p
i
s
t
r
e
ś
c
i
Otwieranie pliku................................................... ................................................312
Odczyt z pliku ................................................... ................................................... 314
Zapisywanie do pliku ................................................... ........................................318
Zamykanie pliku................................................... ................................................320
Zmiana pozycji w pliku................................................... .....................................321
Obcinanie pliku ................................................... .................................................323
Uzyskiwanie informacji o obiekcie pliku ................................................... .........324
„Drukowanie” do pliku ................................................... .....................................325
Dostęp do standardowych plików wejściowych i wyjściowych..........................326
Znak zachęty dla użytkownika................................................... ..........................330
Korzystanie z systemu plików ................................................... ..........................331
Dostęp do zmiennych środowiskowych................................................... ............333
Zmiana katalogu roboczego ................................................... ..............................334
Wypisywanie zawartości katalogu................................................... ....................335
Tworzenie katalogu ................................................... ...........................................336
Usuwanie katalogu ................................................... ............................................337
Zmiana nazwy pliku lub katalogu ................................................... .....................338
Usuwanie pliku................................................... ..................................................339
Uzyskiwanie informacji o ścieżce................................................... .....................340
Uzyskiwanie informacji o pliku ................................................... ........................342
Dzielenie ścieżek................................................... ...............................................344
Łączenie ścieżek................................................... ................................................346
Zachowywanie obiektów w postaci plików ................................................... ......347
9
i
c
ś
e
r
t
s
i
p
S
Po prostu Python
Rozdział 11. Wyjątki
351
Hierarchia wyjątków ................................................... .........................................353
Obsługa wyjątku................................................... ................................................357
Ignorowanie wyjątku................................................... .........................................362
Pobieranie argumentu wyjątku................................................... ..........................363
Obsługa wszystkich wyjątków................................................... ..........................365
Uruchamianie kodu przy braku wyjątku ................................................... ...........366
Obsługa wielu wyjątków................................................... ...................................367
Uruchamianie obowiązkowego kodu oczyszczającego .......................................370
Jawne wywoływanie wyjątku ................................................... ...........................371
Samodzielne tworzenie wyjątków ................................................... ....................372
Tworzenie asercji ................................................... ..............................................375
Rozdział 12. Klasy
377
Terminologia programowania obiektowego ................................................... .....378
Definiowanie klasy................................................... ............................................379
Dokumentowanie klasy................................................... .....................................380
Dostęp do wbudowanych atrybutów klasy ................................................... .......381
Tworzenie egzemplarza ................................................... ....................................382
Dostęp do wbudowanych atrybutów egzemplarza ..............................................383
Tworzenie zmiennych klasy................................................... ..............................384
Zastosowanie metod specjalnych do przeciążania standardowego zachowania .386
Tworzenie zmiennych egzemplarza za pomocą metody inicjującej....................388
Usuwanie egzemplarza................................................... ......................................391
Tworzenie łańcuchowej reprezentacji egzemplarza ............................................393
Określanie prawdziwości egzemplarza ................................................... .............395
Porównywanie egzemplarzy ................................................... .............................396
Dostęp do atrybutów egzemplarza ................................................... ....................398
Egzemplarz jako lista lub słownik ................................................... ....................400
Operacje matematyczne na egzemplarzach ................................................... ......402
Wywoływanie egzemplarza ................................................... ..............................405
Samodzielne definiowanie i wywoływanie metod ..............................................406
Wyprowadzanie nowych klas z klas istniejących ................................................408
Ukrywanie danych prywatnych ................................................... ........................411
Określanie członkostwa klasy ................................................... ...........................412
Dodatek A
Zasoby poświęcone językowi Python
413
Nauka języka Python................................................... .........................................414
Uzyskiwanie pomocy ................................................... ........................................415
Edycja i usuwanie błędów z kodu................................................... .....................417
Zasoby dla programistów................................................... ..................................418
Skorowidz
421
10
Rozdział 8. Funkcje
Python pozwala na samodzielne tworzenie
funkcji przez użytkownika. Kilka funkcji
wbudowanych omówiono już w poprzednich
rozdziałach (na przykład KF
, UVT
, NGP
i TCPIG
). Wspomniano także o niektórych
funkcjach znanych ze standardowych modułów
(na przykład TCPFQOTCPFQO
i EQR[FGGREQR[
).
Dzięki zastosowaniu funkcji struktura programu
może być modułowa i łatwo można nią zarządzać,
bowiem opakowują one obliczenia i oddzielają
logikę wysokiego poziomu od szczegółów.
Funkcji można używać wielokrotnie, ponieważ
pozwalają one na wielokrotne wykonywanie
dobrze określonych zadań w wielu miejscach
z różnymi wartościami początkowymi.
W tym rozdziale omówiono sposoby
samodzielnego tworzenia funkcji. Opisano
także narzędzia programowania funkcjonalnego
w Pythonie, które umożliwiają zastosowanie
funkcji dla pozycji sekwencji.
F
u
n
k
c
j
e
233
Rozdział 8.
Definiowanie funkcji
Funkcja jest nazwanym blokiem instrukcji, które
wykonują jakąś operację. Instrukcja FGH jest
instrukcją złożoną (patrz: podrozdział „Tworzenie
instrukcji złożonych” w rozdziale 7.), która tworzy
nową funkcję (definiuje jej nazwę, parametry
i blok instrukcji wykonywanych po wywołaniu
funkcji).
FGHFQAPQVJKPI
RCUU
FGHRTKPVAOUI
RTKPV/KOGV[EP[YKGNQUVQR
FGHKUGXGP
PWO
RTKPVPWO
Rysunek 8.1. Powyższe instrukcje definiują trzy
proste funkcje. Trafnie nazwana instrukcja
do_nothing jest najprostszą funkcją Pythona.
Funkcja print_msg wyświetla łańcuch. Funkcja
iseven ma listę parametrów; wyświetla ona 1,
jeśli jej argument jest liczbą parzystą, albo 0
w przeciwnym wypadku
i
j
c
k
n
u
f
e
i
n
a
w
o
i
n
i
f
e
D
Jak zdefiniować funkcję?
1. Wpisz:
FGHHWPE
RCTCOANKUV
DNQM
Po uruchomieniu ta złożona instrukcja tworzy
nowy obiekt funkcji i przypisuje go do nazwy
HWPE (rysunek 8.1). Nazwa HWPE jest poprawną
nazwą Pythona (patrz: podrozdział
„Nadawanie nazw zmiennym” w rozdziale 2.),
RCTCOANKUV reprezentuje zero lub więcej
parametrów oddzielonych przecinkami
(są one opisane w dalszej części tego
rozdziału), zaś DNQM jest wciętym blokiem
instrukcji.
Wskazówki
u Zdefiniowanie funkcji nie oznacza jej
uruchomienia, bowiem funkcja jest
uruchamiana tylko wtedy, gdy zostanie
wywołana (patrz: podrozdział „Wywoływanie
funkcji” w dalszej części tego rozdziału).
u Podobnie jak w przypadku wszystkich
innych obiektów w języku Python nie trzeba
deklarować typów obiektów zwracanej
wartości, parametrów lub zmiennych funkcji.
Taka elastyczność oznacza, że można
zdefiniować jedną funkcję i wykorzystywać
ją z obiektami różnego typu (na przykład
funkcja NGP
działa na łańcuchach, listach,
krotkach i słownikach).
u Instrukcja FGH jest instrukcją złożoną, zatem
u Funkcje mogą być definiowane wewnątrz
krótką definicję funkcji można zapisać
w jednym wierszu:
innych funkcji (patrz: podrozdział
„Zagnieżdżanie funkcji” w rozdziale 9.).
FGHUSWCTG
ZTGVWTPZZ.
234
Funkcje
u Funkcje są obiektami i mogą być
przypisywane do zmiennych (patrz:
podrozdział „Przypisywanie funkcji do
zmiennej” w dalszej części tego rozdziału).
u Można utworzyć niewielkie anonimowe
funkcje, które nie będą związane z żadnymi
nazwami (patrz: podrozdział „Zastosowanie
wyrażeń lambda do tworzenia funkcji”
w dalszej części tego rozdziału).
u Do funkcji można przypisać dowolne
atrybuty (patrz: podrozdział „Dostęp
do atrybutów” w rozdziale 9.).
u
Funkcja języka Python jest równoważna
podprogramowi stosowanemu w języku
Perl lub funkcji stosowanej w języku C.
Do tworzenia podprogramów w języku
Perl wykorzystywana jest instrukcja UWD.
W odróżnieniu od definicji funkcji w językach
Perl i C instrukcja FGH Pythona jest instrukcją
wykonywalną (czyli tworzącą obiekt).
W językach C i Java wymagane jest określenie
typu danych wartości zwracanych przez
funkcje i wartości każdego parametru
(w języku Python nie jest to wymagane).
D
e
f
i
n
i
o
w
a
n
i
e
f
u
n
k
c
j
i
235
Parametry nie są argumentami
W literaturze informatycznej można
czasami spotkać się z zamiennie
stosowanymi określeniami parametr
i argument, które w rzeczywistości znaczą
co innego. Parametr jest nazwą, która
pojawia się na liście parametrów
w nagłówku definicji funkcji (czyli
w instrukcji FGH). Uzyskuje on wartość
z wywołania danej funkcji. Argument
natomiast jest faktyczną wartością lub
odwołaniem przekazanym do funkcji
przez wywołanie.
Na przykład w poniższej definicji funkcji:
FGHUWO
Z[
TGVWTPZ
[
Z i [ są parametrami, natomiast
w wywołaniu funkcji:
UWO
i są argumentami. Więcej informacji
na temat wywoływania funkcji można
znaleźć w podrozdziale „Wywoływanie
funkcji” w dalszej części tego rozdziału.
Rozdział 8.
Dokumentowanie funkcji
W przedstawionych dotąd przykładach oznaczania
komentarzy opisujących kod stosowano znak
(patrz: podrozdział „Dokumentowanie
programów” w rozdziale 2.). Python pozwala
również na opcjonalne użycie literału
łańcuchowego w pierwszym wierszu bloku
funkcji. Łańcuch ten (zwany łańcuchem
dokumentacyjnym) powinien zawierać
informację o sposobie wywołania funkcji
i krótko opisywać jej działanie.
Łańcuch dokumentacyjny pełni specjalną rolę,
bowiem jest przypisywany do atrybutu AAFQEAA
funkcji i można uzyskać do niego dostęp za
pomocą operatora kropki w fazie działania
programu. Nie jest to możliwe w przypadku
komentarzy poprzedzonych znakiem .
Dostęp do łańcucha dokumentacyjnego
funkcji
1. Wpisz HWPEAAFQEAA.
Nazwa HWPE jest nazwą funkcji, która może
być kwalifikowana za pomocą nazwy modułu.
Po nazwie HWPE nie należy używać nawiasów
(rysunek 8.2).
FGHFQAPQVJKPI
0KEPKGTQDK
RCUU
FGHRTKPVAOUI
TWMWLGđCēEWEJ
RTKPV/KOGV[EP[YKGNQUVQR
FGHKUGXGP
PWO
KUGXGP
KPVGIGT $QQNGCP
TWMWLGIF[PWOLGUVRCT[UVG
ÄCNDQYRTGEKYP[OY[RCFMW
RTKPVPWO
FQAPQVJKPIAAFQEAA
0KEPKGTQDK
URTKPVAOUIAAFQEAA
RTKPVU
TWMWLGđCēEWEJ
RTKPVKUGXGPAAFQEAA
KUGXGP
KPVGIGT $QQNGCP
TWMWLGIF[PWOLGUVRCT[UVGCNDQ
ÄYRTGEKYP[OY[RCFMW
Rysunek 8.2. Tutaj dodano łańcuchy dokumentacyjne
do funkcji zdefiniowanych na rysunku 8.1. Łańcuchy
dokumentacyjne w potrójnych cudzysłowach mogą
zajmować wiele wierszy i zachowywać ich
formatowanie przy wyświetlaniu
i
j
c
k
n
u
f
e
i
n
a
w
o
t
n
e
m
u
k
o
D
236
RTKPVUVTAAFQEAA
UVT
QDLGEV UVTKPI
4GVWTPCPKEGUVTKPITGRTGUGPVCVKQPQHVJG
ÄQDLGEV+HVJGCTIWOGPVKUCUVTKPIVJG
ÄTGVWTPXCNWGKUVJGUCOGQDLGEV
RTKPVLQKPAAFQEAA
5LQKP
UGSWGPEG UVTKPI
4GVWTPCUVTKPIYJKEJKUVJGEQPECVGPCVKQP
ÄQHVJGUVTKPIUKPVJGUGSWGPEG6JG
ÄUGRCTCVQTDGVYGGPGNGOGPVUKU5
=?CRRGPFAAFQEAA
.CRRGPF
QDLGEVCRRGPFQDLGEVVQGPF
KORQTVOCVJ
RTKPVOCVJUSTVAAFQEAA
USTV
Z
4GVWTPVJGUSWCTGTQQVQHZ
Rysunek 8.3. Wyświetlenie łańcucha
dokumentacyjnego wbudowanej funkcji pozwala
szybko uzyskać pomoc
Funkcje
Wskazówki
u Łańcuch dokumentacyjny musi być
umieszczony w pierwszym wierszu za
instrukcją FGH.
u Jeśli łańcuch dokumentacyjny nie zostanie
podany, to domyślną wartością atrybutu
AAFQEAA staje się 0QPG.
u W przedstawionych w książce przykładach
często pomijane są łańcuchy dokumentacyjne
ze względu na oszczędność miejsca, lecz do
dobrej praktyki należy używanie ich we
wszystkich funkcjach. Za takie podejście
będą wdzięczni użytkownicy. Warto również
pamiętać o tym, że niektóre programy
narzędziowe korzystają z łańcuchów
dokumentacyjnych przy tworzeniu
dokumentacji pomocniczej.
u Łańcuchy dokumentacyjne są także dostępne
w funkcjach i metodach wbudowanych
(patrz: rysunek 8.3).
u Łańcuch dokumentacyjny można również
dodać do modułu (patrz: podrozdział
„Dokumentowanie modułu” w rozdziale 9.)
oraz do klasy (patrz: podrozdział
„Dokumentowanie klasy” w rozdziale 12.).
D
o
k
u
m
e
n
t
o
w
a
n
i
e
f
u
n
k
c
j
i
237
FQAPQVJKPI
RTKPVAOUI
/KOGV[EP[YKGNQUVQR
PWO
KUGXGP
PWO
Rysunek 8.4. Wywołania trzech funkcji
zdefiniowanych na rysunku 8.1
Rozdział 8.
Wywoływanie funkcji
Funkcje nie działają zaraz po ich zdefiniowaniu.
Aby tak się stało, należy je jawnie wywołać.
Wywołanie funkcji jest wyrażeniem, które
uruchamia funkcję. Część programu, z którego
funkcja jest wywoływana, bywa nazywana
wywołującym. W tej książce przedstawiano już
wywołania wbudowanych funkcji Pythona
(na przykład NGP
). Funkcje zdefiniowane
przez użytkownika są wywoływane w taki sam
sposób: poprzez użycie nazwy funkcji, za którą
w nawiasach podana jest lista jej argumentów.
Jak wywołać funkcję?
1. Wpisz:
HWPE
CTIANKUV.
i
j
c
k
n
u
f
e
i
n
a
w
y
ł
o
w
y
W
Podczas wykonywania program wywołujący
zatrzymuje się i trwa w tym stanie do
momentu, gdy HWPE zakończy działanie
i sterowanie powróci znów do wywołującego
(rysunek 8.4).
Nazwa HWPE jest nazwą funkcji, zaś CTIANKUV
oznacza zero lub więcej argumentów
oddzielonych przecinkami, które są
przekazywane do funkcji (zostanie to
omówione później).
238
FGHH
RTKPVH
H
FGHH
RTKPVH
H
H
H
Rysunek 8.5. Dozwolone jest odwołanie do funkcji
przed ich zdefiniowaniem, lecz nie ich wywoływanie.
Funkcja f2 może pojawić się w definicji f1, zanim
sama f2 zostanie zdefiniowana, ale dopiero po
zdefiniowaniu f2 można wywołać f1
Funkcje
Wskazówki
u Nawet wtedy, gdy do funkcji nie są
przekazywane żadne argumenty,
w wywołaniu należy wpisać puste nawiasy.
u Funkcja musi być zdefiniowana przed jej
wywołaniem. Można jednak odwołać się
do funkcji przed jej zdefiniowaniem
(rysunek 8.5).
u Opis wywołania funkcji zwracającej jakąś
wartość można znaleźć w podrozdziale
„Zwracanie wartości przez funkcję”
w dalszej części tego rozdziału.
u To, czy dany obiekt jest wywoływalny,
można stwierdzić za pomocą wbudowanej
funkcji ECNNCDNG
QDKGMV. Funkcja ta
zwraca 1 (prawda), jeśli argument QDKGMV
jest wywoływalny, a w przeciwnym
wypadku zwraca 0 (fałsz). Do obiektów
wywoływalnych zaliczane są funkcje
zdefiniowane przez użytkownika, funkcje
wbudowane, metody obiektów wbudowanych,
obiekty klas oraz metody egzemplarzy klas.
W
y
w
o
ł
y
w
a
n
i
e
f
u
n
k
c
j
i
239
Rozdział 8.
Zwracanie wartości
przez funkcję
Wartość zwracana jest tym wynikiem działania
funkcji, który jest przesyłany do programu
wywołującego daną funkcję. Wartość tę można
określić za pomocą instrukcji TGVWTP.
Jak uzyskać wartość funkcji?
1. W ciele funkcji wpisz:
TGVWTPGZRT.
Ta instrukcja kończy bieżące wywołanie
funkcji. Oblicza ona wyrażenie GZRT
i wysyła jego wartość (jako wartość
zwracaną) do programu wywołującego.
Wyrażenie GZRT jest wyrażeniem. Jeśli GZRT
zostanie pominięte, to podstawione tu będzie
0QPG.
FGHKUGXGP
PWO
TGVWTPPWO
FGHKURTKOG
P
EQWPVP
YJKNGEQWPV
KHPEQWPV
TGVWTP
EQWPV
TGVWTP
FGHRTKOGU
O
NKUVC=?
HQTKKPTCPIG
O
KHKURTKOG
K
NKUVCCRRGPF
K
TGVWTPNKUVC
FGHXQYGNU
U
X
HQTEKPU
KHEKPCGKQW# +17
X
E
TGVWTPX
FGHCUEKK
U
CUE]_
HQTEKPU
KHPQVCUEJCUAMG[
E
CUE=E?QTF
E
TGVWTPCUE
Rysunek 8.6. — ciąg dalszy na następnej stronie
ę
j
c
k
n
u
f
z
e
z
r
p
i
c
ś
o
t
r
a
w
e
i
n
a
c
a
r
w
Z
240
Funkcje
Wywoływanie funkcji,
która zwraca wartość
1. Wpisz
OKGPPCHWPE
CTIANKUV.
Podczas wykonywania tego wyrażenia,
program wywołujący jest zatrzymywany
do momentu, gdy HWPE zakończy działanie.
Wówczas sterowanie powraca do
wywołującego. Zmienna OKGPPC uzyskuje
wartość zwróconą przez funkcję
(rysunek 8.6).
Zmienna OKGPPC jest zmienną, HWPE jest
nazwą funkcji, zaś CTIANKUV reprezentuje
argumenty przekazywane do funkcji.
CKUGXGP
DKURTKOG
ERTKOGU
FXQYGNU
UGMYQLC
GCUEKK
KEM
RTKPVC
RTKPVD
RTKPVE
=?
RTKPVF
GQC
RTKPVG
] E M K _
Rysunek 8.6. Pokazane tu funkcje zwracają wartości
różnych typów. Funkcja iseven określa to, czy jej
argument jest liczbą parzystą i zwraca 1 (prawda)
albo 0 (fałsz). Funkcja isprime określa to, czy jej
argument jest liczbą pierwszą i zwraca 1 albo 0.
Zwróćmy uwagę na to, że isprime ma dwie instrukcje
return (sterowanie powraca do programu
wywołującego wtedy, gdy którakolwiek z tych
instrukcji zostanie wykonana). Funkcja primes
zwraca listę zawierającą liczby pierwsze, które są
mniejsze niż jej argument. Funkcja vowels zwraca
łańcuch zawierający samogłoski pochodzące z jej
argumentu. Funkcja ascii zwraca słownik
zawierający kody ASCII (wartości) znaków (kluczy)
jej argumentu
Z
w
r
a
c
a
n
i
e
w
a
r
t
o
ś
c
i
p
r
z
e
z
f
u
n
k
c
j
ę
241
Rozdział 8.
Na rysunkach przedstawionych w rozdziale 7.
(od 7.22 do 7.26) pokazano kilka przykładów
działania pętli HQT. Skrypty od 8.1 do 8.5 zawierają
te same przykłady przerobione na funkcje,
które można wielokrotnie wykorzystywać.
Na rysunku 8.7 pokazano kilka przykładów
wywołań tych funkcji.
Skrypt 8.1. Funkcja unique pobiera sekwencję
i zwraca listę, która zawiera wszystkie pozycje jej
argumentu (bez duplikatów)
FGHWPKSWG
UGS
TGUWNV=?
HQTZKPUGS
KHZPQVKPTGUWNV
TGUWNVCRRGPF
Z
TGVWTPTGUWNV
Skrypt 8.2. Funkcja intersection pobiera dwie
sekwencje i zwraca listę, która zawiera pozycje
występujące jednocześnie w obydwu jej argumentach
Skrypt 8.3. Funkcja union pobiera dwie sekwencje
i zwraca listę, zawierającą wszystkie pozycje, które
pojawiają się w obu jej argumentach (bez duplikatów)
FGHKPVGTUGEVKQP
UGSUGS
TGUWNV=?
HQTZKPUGS
KHZKPUGS
KHZPQVKPTGUWNV
TGUWNVCRRGPF
Z
TGVWTPTGUWNV
FGHWPKQP
UGSUGS
TGUWNVUGS=?9[MQPCPKGMQRKK
HQTZKPUGS
KHPQVZKPUGS
TGUWNVCRRGPF
Z
TGVWTPTGUWNV
Skrypt 8.4. Funkcja combine pobiera dwie sekwencje
i zwraca listę, która zawiera każdą pozycję pierwszegoi
argumentu połączoną w parę z każdą pozycją
drugiego argumentu w postaci dwupozycyjnych krotek
Skrypt 8.5. Funkcja all_in pobiera dwie sekwencje
i zwraca 1 (prawda), jeśli wszystkie pozycje
pierwszego argumentu występują w drugim
argumencie, albo 0 (fałsz) w przeciwnym wypadku
FGHEQODKPG
UGSUGS
TGUWNV=?
HQTZKPUGS
HQT[KPUGS
TGUWNVCRRGPF
Z[
TGVWTPTGUWNV
FGHCNNAKP
UGSUGS
TGUWNV
HQTZKPUGS
KHZPQVKPUGS
TGUWNV
DTGCM
TGVWTPTGUWNV
ę
j
c
k
n
u
f
z
e
z
r
p
i
c
ś
o
t
r
a
w
e
i
n
a
c
a
r
w
Z
242
Funkcje
Wskazówki
u Jeśli sterowanie wyjdzie poza funkcję bez
uruchamiania instrukcji TGVWTP, to zwracana
jest wartość 0QPG (rysunek 8.8).
u Instrukcja TGVWTP może występować tylko
wewnątrz definicji funkcji.
u Zwracanie wielu wartości przez funkcję
opisano w następnym podrozdziale.
u
Instrukcja TGVWTP jest używana do
zwracania wartości funkcji także
w językach Perl i C. Wartość 0QPG zwracana
przez funkcję w Pythonie jest podobna do
XQKF w języku C. W języku Perl wartością
domyślną jest wartość ostatniego wyrażenia
obliczonego w bloku, zaś w języku Python
wartością domyślną jest 0QPG.
Z
w
r
a
c
a
n
i
e
w
a
r
t
o
ś
c
i
p
r
z
e
z
f
u
n
k
c
j
ę
U=C#C
Ä
?
RTKPVWPKSWG
U
= C #
?
UOKOGV[EP[YKGNQUVQR
UUGMYQLC
RTKPVKPVGTUGEVKQP
UU
= G Y Q U ?
U=?
U=?
RTKPVWPKQP
UU
=?
U
U
RTKPVEQODKPG
UU
=
Ä
?
UCGQ
UUGMYQLC
CNNAKP
UU
Rysunek 8.7. Przykładowe wywołania funkcji
ze skryptów od 8.1 do 8.5
CFQAPQVJKPI
DRTKPVAOUI
/KOGV[EP[YKGNQUVQR
EKUGXGP
RTKPVCDE
0QPG0QPG0QPG
Rysunek 8.8. Wszystkie funkcje zdefiniowane na
rysunku 8.1 zwracają None, czyli domyślną wartość
zwracaną przez funkcję nie posiadającą instrukcji
return (lub przez funkcję, w której return istnieje,
lecz nie jest uruchamiane)
243
i
j
c
k
n
u
f
i
c
ś
o
t
r
a
w
u
l
e
i
w
e
i
n
a
c
a
r
w
Z
Rozdział 8.
Zwracanie wielu wartości
funkcji
Jeśli liczba zwracanych wartości nie jest duża,
to należy zwracać je w postaci krotki.
Zastosowanie krotki umożliwia wówczas łatwe
przypisanie każdej zwracanej wartości do jej
własnej zmiennej za pomocą mechanizmu
pakowania i rozpakowywania (patrz: podrozdział
„Tworzenie zmiennych” w rozdziale 2.). Jeśli
w instrukcji TGVWTP poda się wiele wyrażeń, będą
one zwrócone jako krotka.
Jak uzyskać wiele wartości z funkcji?
1. W ciele funkcji wpisz:
TGVWTPGZRTGZRT
Taka instrukcja kończy bieżące wywołanie
funkcji. Wyrażenia GZRTGZRTsą
obliczane i odsyłane do programu
wywołującego jako krotka zawierająca
zwracane wartości.
WyrażeniaGZRTGZRTsą dwoma
(lub więcej) wyrażeniami oddzielonymi za
pomocą przecinków.
Wywoływanie funkcji,
która zwraca wiele wartości
1. Wpisz:
OKGPPCOKGPPCHWPE
CTIANKUV.
Po uruchomieniu takiego wyrażenia program
wywołujący zatrzymuje się aż do momentu
zakończenia działania HWPE. Później sterowanie
powraca do programu wywołującego.
Pierwsza pozycja zwróconej krotki jest
przypisywana do zmiennej OKGPPC, druga
do zmiennej OKGPPC itd. (patrz: rysunek 8.9).
Nazwa HWPE jest nazwą funkcji, CTIANKUV
reprezentuje argumenty przekazywane do
funkcji, zaś OKGPPCOKGPPC
oznaczają jedną lub więcej zmiennych
oddzielonych przecinkami. Liczba zmiennych
musi być taka jak liczba pozycji w zwracanej
krotce.
244
FGHHTCEKPV
Z
KKPV
Z
HZK
TGVWTPHNQCV
HHNQCV
K
HTCEKPVHTCEKPV
RTKPVHTCE
RTKPVKPV
FGHNGVVGTU
U
HTQOUVTKPIKORQTVNGVVGTUYJKVGURCEG
XEYQ
UUVT
U
HQTEJKPU
KHEJKPCGKQW[# +17;
X
EJ
GNKHEJKPNGVVGTU
E
EJ
GNKHEJKPYJKVGURCEG
Y
EJ
GNUG
Q
EJ
TGVWTPXEYQ
UOKOGV[EP[YKGNQUVQR
XEYQNGVVGTU
U
XEYQ
KG[[KGQQ OOVEPYNUVR
Rysunek 8.9. Funkcja fracint zwraca część ułamkową
i część całkowitą liczby w postaci dwupozycyjnej
krotki (symulując działanie funkcji math.modf).
Funkcja letters zwraca samogłoski, spółgłoski, znaki
odstępu i inne znaki pochodzące z jej argumentu
w postaci krotki łańcuchów
Wskazówki
u Pozycje zwracanej krotki mogą być
obiektami różnych typów.
u Jeśli liczba zmiennych i liczba pozycji
w zwracanej krotce nie są sobie równe,
Python wywołuje wyjątek 8CNWG TTQT.
FGHIGVAEQNQT
TGFITGGPDNWG
MQNQT[]
DNCEM
DNWG
ITGGP
E[CP
TGF
OCIGPVC
[GNNQY
YJKVG
_
TID
TGFITGGPDNWG
KHMQNQT[JCUAMG[
TID
TGVWTPMQNQT[=TID?
GNUG
TGVWTPTID
RTKPVIGVAEQNQT
OCIGPVC
RTKPVIGVAEQNQT
DNCEM
RTKPVIGVAEQNQT
RTKPVIGVAEQNQT
6TCEGDCEM
OQUVTGEGPVECNNNCUV
(KNGUVFKP NKPGKP!
6[RG TTQTIGVAEQNQT
VCMGUGZCEVN[
ÄCTIWOGPVU
IKXGP
Rysunek 8.10. Funkcja get_color pobiera trzy
argumenty pozycyjne, które reprezentują składowe
koloru (red, green i blue) i zwracają jego nazwę,
jeśli jest ona znana (w przeciwnym wypadku funkcja
zwraca krotkę zawierającą wartości argumentu)
Funkcje
Określanie argumentów
pozycyjnych
Argumenty pozycyjne muszą być przekazane do
funkcji dokładnie w takiej kolejności, w jakiej
podane są w definicji funkcji. Jest to normalny
sposób przekazywania argumentów, który był
prezentowany już wcześniej w przypadku
funkcji wbudowanych Pythona. Przy braku
domyślnych wartości parametrów (patrz:
następny podrozdział), liczba przekazywanych
argumentów musi być równa liczbie parametrów
określonych w definicji funkcji. Na rysunku
8.10 pokazano kilka przykładów ilustrujących
to zagadnienie.
Definiowanie parametrów
pozycyjnych w nagłówku funkcji
1. Wpisz:
FGHHWPE
RCTCORCTCO .
Nazwa HWPE jest nazwą funkcji, a RCTCO
RCTCOoznaczają nazwy parametrów
pozycyjnych, które są oddzielone przecinkami.
Wywoływanie funkcji
z argumentami pozycyjnymi
1. Wpisz:
HWPE
CTICTI.
NazwaHWPE jest nazwą funkcji, a CTI
CTIsą argumentami (wyrażeniami)
oddzielonymi przecinkami, które odpowiadają
parametrom pozycyjnym funkcji.
Wskazówka
u Jeśli liczba argumentów pozycyjnych i liczba
parametrów pozycyjnych nie są sobie równe,
Python wywołuje wyjątek 6[RG TTQT.
O
k
r
e
ś
l
a
n
i
e
a
r
g
u
m
e
n
t
ó
w
p
o
z
y
c
y
j
n
y
c
h
245
Rozdział 8.
Określanie domyślnej
wartości parametru
Wartość domyślna jest przypisywana do
parametru automatycznie, gdy w wywołaniu
funkcji nie zostanie przekazana żadna wartość.
Wartości domyślne wbudowanych funkcji
Pythona pokazano już wcześniej (na przykład
dla funkcji TQWPF
Z=P? można podać tylko
wartość Z, bowiem wartością domyślną P jest 0).
Wartości domyślne są określane na liście
parametrów w nagłówku funkcji (patrz:
poprzedni podrozdział). Jeśli trzeba określić
wartość domyślną parametru, to w nagłówku
— zamiast wielkości RCTCO definiującej
określony parametr — należy wpisać RCTCO
YCTVQħèAFQO[ħNPC (YCTVQħèAFQO[ħNPC jest tu
wyrażeniem).
Parametry ze zdefiniowanymi wartościami
domyślnymi muszą być podawane po parametrach
bez tych wartości. Oto przykład błędnego
nagłówka funkcji:
FGHH
Z[0KGRQRTCYP[PCIđÎYGM
W wywołaniu funkcji można podać opcjonalnie
argument, który zastąpi wartość domyślną.
Na rysunku 8.11 pokazano kilka przykładów
ilustrujących to zagadnienie.
u
r
t
e
m
a
r
a
p
i
c
ś
o
t
r
a
w
j
e
n
l
ś
y
m
o
d
e
i
n
a
l
ś
e
r
k
O
FGHIGVAEQNQT
TGFITGGPDNWG
MQNQT[]
DNCEM
DNWG
ITGGP
E[CP
TGF
OCIGPVC
[GNNQY
YJKVG
_
TID
TGFITGGPDNWG
KHMQNQT[JCUAMG[
TID
TGVWTPMQNQT[=TID?
GNUG
TGVWTPTID
RTKPVIGVAEQNQT
DNCEM
RTKPVIGVAEQNQT
TGF
RTKPVIGVAEQNQT
ITGGP
RTKPVIGVAEQNQT
DNWG
RTKPVIGVAEQNQT
FGHTGRGCV
ZTC[
TGVWTPUVT
ZTC[
RTKPVTGRGCV
RTKPVTGRGCV
RTKPVTGRGCV
6TCEGDCEM
OQUVTGEGPVECNNNCUV
(KNGUVFKP NKPGKP!
6[RG TTQTTGRGCV
VCMGUCVNGCUVCTIWOGPV
Ä
IKXGP
Rysunek 8.11. Tutaj zmieniono nagłówek funkcji
get_color z rysunku 8.10. Wszystkie jej parametry
mają teraz wartość domyślną równą zero. Pierwszy
argument funkcji repeat jest wymagany, a drugi
argument jest opcjonalny
246
FGHCHHKZ
ZNKUVC=?
NKUVCCRRGPF
Z
TGVWTPNKUVC
RTKPVCHHKZ
=?
RTKPVCHHKZ
=?
RTKPVCHHKZ
=?
FGHCHHKZ
ZNKUVC0QPG
KHNKUVCKU0QPGNKUVC=?
NKUVCCRRGPF
Z
TGVWTPNKUVC
RTKPVCHHKZ
=?
RTKPVCHHKZ
=?
RTKPVCHHKZ
=?
Rysunek 8.12.
Funkcja affix dodaje x do listy lista
(modyfikując ją w miejscu). Python oblicza wartość
domyślną argumentu lista tylko raz (gdy definiowanai
jest funkcja affix), a zatem lista zachowuje swoją
wartość między kolejnymi wywołaniami affix.
W funkcji affix2 przeniesiono wartość domyślną
do ciała funkcji, zatem wartość lista jest obliczana
przy każdym nowym wywołaniu
(a nie współużytkowana przez kolejne wywołania)
Funkcje
Wskazówki
u Nie ma sensu stwierdzenie, że parametr jest
opcjonalny (przypisanie mu jakiejś wartości
jest opcjonalne).
u Jeśli zostanie określony domyślny argument,
to należy również określić wszystkie
argumenty leżące po jego lewej stronie.
Nie można pominąć argumentu domyślnego
poprzez pozostawienie pustego miejsca
w wywołaniu funkcji. Przy nagłówku funkcji
określonym jak poniżej:
FGHH
CDE
nie można wywoływać funkcji, jeśli pominie
się D i poda E. Gdy tak się stanie, Python zgłosi
wyjątek 5[PVCZ TTQT:
H
$đæFUMđCFPK
u Wartość domyślna jest obliczana
i zachowywana tylko raz podczas
definiowania funkcji, a nie podczas jej
wywołania. Takie zachowanie oznacza,
że jeśli wartość domyślna jest obiektem
zmiennym (listą lub słownikiem), będzie
ona gromadzić wszystkie zmiany dokonywane
w miejscu przy kolejnych wywołaniach
funkcji. Czasem może to być zgodne
z oczekiwaniami, ale nie zawsze tak jest.
Na rysunku 8.12 pokazano kilka przykładów
współużytkowania wartości domyślnej przez
kolejne wywołania funkcji, a także
przykłady pokazujące, jak unikać tego
współużytkowania poprzez zastosowanie
0QPG jako wartości domyślnej. Jeśli wartość
domyślna jest obiektem niezmiennym
(liczbą, łańcuchem lub krotką), to nie
występuje efekt jej współużytkowania przy
różnych wywołaniach funkcji, ponieważ
żadna próba modyfikacji nie spowoduje
utworzenia nowego obiektu ani zmiany już
istniejącego. Więcej informacji na temat
przekazywania argumentów można znaleźć
w podrozdziale „Przekazywanie argumentów
zmiennych i niezmiennych do funkcji”
w dalszej części tego rozdziału.
247
O
k
r
e
ś
l
a
n
i
e
d
o
m
y
ś
l
n
e
j
w
a
r
t
o
ś
c
i
p
a
r
a
m
e
t
r
u
Rozdział 8.
Określanie argumentów
jako słów kluczowych
Do funkcji można przekazywać argumenty jako
słowa kluczowe za pomocą nazw odpowiednich
parametrów (a nie na podstawie ich położenia).
Wystarczy po prostu w wywołaniu funkcji
wpisać PCYCCTI. Definicja funkcji nie
wymaga żadnych zmian, by można było używać
takiego sposobu przekazywania argumentów.
Przekazywanie argumentów jako słów
kluczowych przydaje się najbardziej wtedy, gdy
funkcja ma dużą liczbę parametrów, z których
większość ma taką samą wartość domyślną.
Załóżmy, że trzeba wywołać fikcyjną funkcję
wyszukującą dany tekst w pliku:
FGHUGCTEJ
VGMUVRNKM
OCVEJAECUG
OCVEJAYJQNGAYQTF
OCVEJAYKNFECTFU
TGXGTUG
Parametr TGXGTUG zmienia kolejność
przeszukiwania. Jeśli trzeba będzie rozpocząć
przeszukiwanie wstecz, a nie do przodu
i pozostałe wartości domyślne będą mogły być
przyjęte, wywołanie tej funkcji z użyciem
argumentów pozycyjnych może być
następujące:
UGCTEJ
UGMYQLCFTGYCVZV
Oto jego równoważnik z użyciem argumentów
jako słów kluczowych:
UGCTEJ
UGMYQLCFTGYCVZVTGXGTUG
Warto zwrócić uwagę na zalety wywołania ze
słowami kluczowymi: jest ono bardziej czytelne,
można pominąć opcjonalne argumenty i można
umieszczać słowa kluczowe w dowolnej kolejności.
w
ó
t
n
e
m
u
g
r
a
e
i
n
a
l
ś
e
r
k
O
248
Funkcje
Wywoływanie funkcji z argumentami
w postaci słów kluczowych
1. Wpisz:
HWPE
RQUACTIUMG[YQTFCTI
MG[YQTFCTI
NazwaHWPE jest nazwą funkcji, RQUACTIU to
argumenty pozycyjne (jeśli takie istnieją),
zaś CTI, CTI są argumentami
(wyrażeniami) przekazywanymi do
parametrów nazwanych MG[YQTF, MG[YQTF
w definicji funkcji (rysunek 8.13).
Oto kilka reguł stosowania argumentów
w postaci słów kluczowych:
u w odróżnieniu od argumentów pozycyjnych
argumenty w postaci słów kluczowych nie
muszą być podawane w tej samej kolejności,
w jakiej występują na liście argumentów
w definicji funkcji;
u argument pozycyjny nie może następować
po argumencie w postaci słowa kluczowego
(patrz: rysunek 8.13);
u nie można używać argumentów
zduplikowanych, równocześnie podając
je jako pozycyjne i jako słowa kluczowe
(patrz: rysunek 8.13).
Wskazówka
u Użycie argumentów w postaci słów
kluczowych w wywołaniach funkcji
wbudowanych nie jest dozwolone. W takiej
sytuacji Python zgłasza wyjątek 6[RG TTQT.
O
k
r
e
ś
l
a
n
i
e
a
r
g
u
m
e
n
t
ó
w
FGHIGVAEQNQT
TGFITGGP
ÄDNWG
MQNQT[]
DNCEM
DNWG
ITGGP
E[CP
TGF
OCIGPVC
[GNNQY
YJKVG
_
TID
TGFITGGPDNWG
KHMQNQT[JCUAMG[
TID
TGVWTPMQNQT[=TID?
GNUG
TGVWTPTID
RTKPVIGVAEQNQT
TGF
TGF
RTKPVIGVAEQNQT
ITGGP
ÄDNWGTGF
YJKVG
RTKPVIGVAEQNQT
ÄDNWG
YJKVG
RTKPVIGVAEQNQT
DNWG
RTKPVIGVAEQNQT
TGF
5[PVCZ TTQTPQPMG[YQTFCTICHVGTMG[YQTF
ÄCTI
RTKPVIGVAEQNQT
TGF
6TCEGDCEM
OQUVTGEGPVECNNNCUV
(KNGUVFKP NKPGKP!
6[RG TTQTIGVAEQNQT
IQVOWNVKRNGXCNWGU
ÄHQTMG[YQTFCTIWOGPV TGF
RTKPVIGVAEQNQT
RWEG
6TCEGDCEM
OQUVTGEGPVECNNNCUV
(KNGUVFKP NKPGKP!
6[RG TTQTIGVAEQNQT
IQVCPWPGZRGEVGF
ÄMG[YQTFCTIWOGPV RWEG
Rysunek 8.13. Przykłady wywołań funkcji
z argumentami w postaci słów kluczowych i kilka
przykładów błędów popełnianych przy takich
wywołaniach
249
FGHOGCP
PWOU
KHNGP
PWOU
TGVWTP
GNUG
UWOC
HQTZKPPWOUUWOC
Z
TGVWTPUWOCNGP
PWOU
RTKPVOGCP
RTKPVOGCP
RTKPVOGCP
Rysunek 8.14. Funkcja mean pobiera dowolną
liczbę argumentów i zwraca ich średnią arytmetyczną
w
ó
t
n
e
m
u
g
r
a
y
b
z
c
i
l
j
e
n
l
o
w
o
d
e
i
n
a
l
ś
e
r
k
O
Rozdział 8.
Określanie dowolnej liczby
argumentów pozycyjnych
Funkcja może pobierać zmienną (czyli taką, która
nie jest ustalona z góry) liczbę argumentów
pozycyjnych. Kilka z takich funkcji już omawiano
(na przykład OCZ
i OKP
, które pobierają listy
argumentów o zmiennej długości). Przy
wywołaniu takiej funkcji Python dopasowuje
normalne argumenty pozycyjne (począwszy od
lewego), a później umieszcza każdy nadmiarowy
argument w krotce, która może być wykorzystana
w funkcji.
Definiowanie funkcji pobierającej
dowolną liczbę argumentów
pozycyjnych
1. Wpisz:
FGHHWPE
RQUARCTCOUCTIU.
NazwaHWPE jest nazwą funkcji, RQUARCTCOU
są parametrami pozycyjnymi (jeśli takie
istnieją), a CTIU jest krotką, która uzyskuje
każde nadmiarowe argumenty pozycyjne
( nie jest częścią nazwy parametru).
Wywołanie funkcji z dowolną liczbą
argumentów pozycyjnych
1. Wpisz:
HWPE
RQUACTIUCTICTI.
NazwaHWPE jest nazwą funkcji, RQUACTIU są
zwykłymi argumentami pozycyjnymi (jeśli
takie występują), zaś CTI CTI są
argumentami nadmiarowymi (wyrażeniami),
które są umieszczone w krotce.
Na rysunku 8.14 pokazano funkcję obliczającą
średnią arytmetyczną dowolnej liczby swoich
argumentów. W skryptach 8.2 i 8.3
przedstawionych w tym rozdziale pokazano
funkcje, które odpowiednio zwracają przecięcie
i złączenie dwóch sekwencji.
250
Funkcje
Skrypty 8.6 i 8.7 zawierają zmodyfikowane
funkcje obliczające przecięcie i złączenie
dowolnej liczby sekwencji. Na rysunku 8.15
pokazano przykłady wywołań skryptów 8.6 i 8.7.
Wskazówki
u Jeśli do funkcji nie przekazano żadnych
argumentów nadmiarowych, to CTIU staje
się domyślnie pustą krotką.
u Opis wprowadzania dowolnej liczby
argumentów w postaci słów kluczowych
podano w następnym podrozdziale.
u
u
Zapis CTIU wprowadzono w wersji 2.0
języka Python.
W języku Perl argumenty podprogramu
są gromadzone w tablicy o nazwie A.
W języku C do przechowywania list
argumentów o zmiennej długości używa się
i XCANKUV.
O
k
r
e
ś
l
a
n
i
e
d
o
w
o
l
n
e
j
l
i
c
z
b
y
a
r
g
u
m
e
n
t
ó
w
Skrypt 8.6. Funkcja intersection pobiera dowolną
liczbę sekwencji i zwraca listę, która zawiera
pozycje wspólne dla wszystkich jej argumentów
FGHKPVGTUGEVKQP
UGSU
Y[PKM=?
HQTZKPUGSU=?
HQT[KPUGSU=?
KHZPQVKP[
DTGCM
GNUG
Y[PKMCRRGPF
Z
TGVWTPY[PKM
Skrypt 8.7. Funkcja union pobiera dowolną liczbę
sekwencji i zwraca listę, która zawiera wszystkie
pozycje pojawiające się w jej argumentach
(bez duplikatów)
FGHWPKQP
UGSU
Y[PKM=?
HQTUGSKPUGSU
HQTZKPUGS
KHPQVZKPY[PKM
Y[PKMCRRGPF
Z
TGVWTPY[PKM
UUGMYQLC
UYKGNQUVQR
UHQTOCNFGJ[F
RTKPVKPVGTUGEVKQP
UUU
= U G G Y Q Q ?
RTKPVWPKQP
UUU
= U G M Y Q L C K
Ä N V R H T O F J
Ä [ ?
Rysunek 8.15. Przykładowe wywołania funkcji ze
skryptów 8.6 i 8.7
251
w
ó
t
n
e
m
u
g
r
a
y
b
z
c
i
l
j
e
n
l
o
w
o
d
e
i
n
a
l
ś
e
r
k
O
Rozdział 8.
Określanie
dowolnej liczby argumentów
jako słów kluczowych
Funkcja może pobierać zmienną (czyli taką,
która nie jest ustalona z góry) liczbę argumentów
w postaci słów kluczowych, jeśli nazwa jej
ostatniego parametru rozpoczyna się od
znaków . Przy wywołaniu takiej funkcji
Python dopasowuje normalne argumenty
pozycyjne (począwszy od lewego), a potem
dopasowuje nadmiarowe argumenty pozycyjne
(patrz: poprzedni podrozdział) i umieszcza
każdy nadmiarowy argument podany jako
słowo kluczowe w słowniku, który może być
wykorzystany w funkcji. Na rysunku 8.16
pokazano przykład takiej funkcji.
Definiowanie funkcji pobierającej
dowolną liczbę argumentów
w postaci słów kluczowych
1. Wpisz nagłówek definicji funkcji:
FGHHWPE
RQUARCTCOUCTIUMYCTIU.
NazwaHWPE jest nazwą funkcji, RQUARCTCOU
to zwykłe parametry pozycyjne funkcji (jeśli
takie występują), CTIU jest krotką, która
odbiera nadmiarowe argumenty pozycyjne
(jeśli takie istnieją), zaś MYCTIU jest
słownikiem, który odbiera każde nadmiarowe
argumenty w postaci słów kluczowych
( nie jest częścią nazwy parametru).
Wywoływanie funkcji z dowolną liczbą
argumentów w postaci słów kluczowych
1. Wpisz:
HWPE
RQUACTIUMG[YQTFCTI
MG[YQTFCTI
NazwaHWPE jest nazwą funkcji, RQUACTIU są
zwykłymi i nadmiarowymi argumentami
pozycyjnymi (jeśli takie istnieją), a CTI,
CTIto nadmiarowe argumenty
(wyrażenia) w postaci słów kluczowych,
które są umieszczane w słowniku
z odpowiadającymi im kluczami MG[YQTF,
MG[YQTF.
252
FGHMUKCMC
V[VWNCWVQTKPPG
RTKPVV[VWNV[VWN
RTKPVCWVQTCWVQT
HQT
MXKPKPPGKVGOU
RTKPVMX
MUKCMC
6JGTCR[
.QFIG CXKF
Y[FCYEC2GPIWKP
HQTOCVOKGMMCQRTCYC
UVTQP
TQM
V[VWN6JGTCR[
CWVQT.QFIG CXKF
HQTOCVOKGMMCQRTCYC
Y[FCYEC2GPIWKP
UVTQP
TQM
Rysunek 8.16. Funkcja ksiązka gromadzi w słowniku
inne nadmiarowe argumenty w postaci słów
kluczowych i wyświetla pary klucz-wartość
należące do tego słownika
Wskazówki
u Jeśli nie będą przekazywane żadne
nadmiarowe argumenty w postaci słów
kluczowych, to domyślnie słownik MYCTIU
stanie się słownikiem pustym.
u Argumenty, które nie są przekazywane
jako słowa kluczowe, muszą występować
przed argumentami przekazywanymi
w postaci słów kluczowych.
u
Zapis MYCTIU wprowadzono
w wersji 2.0 języka Python.
FGHCTIAFGOQ
CDCTIU
ÄMYCTIU
RTKPV#TIWOGPV[PQTOCNPG
RTKPV VCCDD
RTKPV#TIWOGPV[PCFOKCTQYG
RQ[E[LPG
RTKPV VCTIU
RTKPV#TIWOGPV[PCFOKCTQYGMNWEQYG
RTKPV VMYCTIU
CTIAFGOQ
#TIWOGPV[PQTOCNPG
CD
#TIWOGPV[PCFOKCTQYGRQ[E[LPG
#TIWOGPV[PCFOKCTQYGMNWEQYG
]_
CTIAFGOQ
DC
#TIWOGPV[PQTOCNPG
CD
#TIWOGPV[PCFOKCTQYGRQ[E[LPG
#TIWOGPV[PCFOKCTQYGMNWEQYG
]_
CTIAFGOQ
#TIWOGPV[PQTOCNPG
CD
#TIWOGPV[PCFOKCTQYGRQ[E[LPG
#TIWOGPV[PCFOKCTQYGMNWEQYG
]_
CTIAFGOQ
Z[
#TIWOGPV[PQTOCNPG
CD
#TIWOGPV[PCFOKCTQYGRQ[E[LPG
#TIWOGPV[PCFOKCTQYGMNWEQYG
] Z [ _
CTIAFGOQ
DZ[
#TIWOGPV[PQTOCNPG
CD
#TIWOGPV[PCFOKCTQYGRQ[E[LPG
#TIWOGPV[PC
Pobierz darmowy fragment (pdf)