Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00665 009207 10483507 na godz. na dobę w sumie
Po prostu Python - książka
Po prostu Python - książka
Autor: Liczba stron: 440
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-684-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> python - programowanie
Porównaj ceny (książka, ebook, audiobook).

Witamy w świecie Pythona, czyli popularnego języka programowania obiektowego, którego wersja źródłowa jest powszechnie dostępna. Python może być stosowany do wszystkiego -- począwszy od prostych skryptów, aż do programowania witryn WWW i skomplikowanych aplikacji. W celu utrzymania rozsądnej objętości książki, autor ograniczył się do opisania rdzenia samego języka i podstawowych bibliotek. Po ukończeniu lektury czytelnik będzie znał sposoby wykorzystania Pythona zarówno w przypadku typowych, jak i w zaawansowanych zadań stawianych programiście. Na końcu książki przedstawiono sposoby, w jakie można uzyskać dostęp do źródeł informacji dotyczących różnych zagadnień.

Książka jest wyczerpującym przewodnikiem po języku Python. Jej zakres tematyczny został ograniczony do samego rdzenia języka i najczęściej stosowanych modułów bibliotecznych. Informacje o innych modułach można znaleźć w podręczniku 'Python Library Reference', który zwykle jest dołączony do Pythona. Krótki przegląd częściej stosowanych modułów można także znaleźć w dodatku A.

Czy to wystarczy?
Książka jest odpowiednia dla osób, które uczą się języka Python z czyjąś 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.

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

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 Z TGVWTPZ Z. 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 QDLGEV CRRGPFQDLGEVVQGPF 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 H HNQCV 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 Z  TC[  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 RQUARCTCOU CTIU . 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 RQUARCTCOU CTIU MYCTIU . 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[VWNCWVQT KPPG  RTKPVV[VWNV[VWN RTKPVCWVQTCWVQT HQT MX KPKPPGKVGOU  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 CD CTIU Ä 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)

Gdzie kupić całą publikację:

Po prostu Python
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: