Python Programowanie

David M. Beazley

PYTHON

Wydawnictwo RM

L

Prorrram

Programowanie: Python David M. Beazley Tłumaczenie: Janusz Machowski Translation copyright © 2002 by Wydawnictwo RM Original English language title: Python Essential Reference, by David M. Beazley by Pearson Education, Inc., Copyright © 2001 by New Riders Publishing. All rights reserved. Published by arrangement with the original publisher, New Riders Publishing. Wydawnictwo RM, 00-987 Warszawa 4, skr. poczt. 144 [email protected] www.rm.com.pl Żadna część tej pracy nie może być powielana i rozpowszechniana, w jakiejkolwiek formie i w jakikolwiek sposób (elektronicz- ny, mechaniczny) włącznie z fotokopiowaniem, nagrywaniem na taśmy lub przy użyciu innych systemów, bez pisemnej zgody wydawcy. Wszystkie nazwy handlowe i towarów występujące w niniejszej publikacji są znakami towarowymi zastrzeżonymi lub nazwami zastrzeżonymi odpowiednich firm odnośnych właścicieli. Nazwy i adresy firm, nazwiska i adresy osób, nazwy towarów i inne dane wykorzystane w przykładach są fikcyjne i jakakolwiek zbieżność z rzeczywistością jest wyłącznie przypadkowa. Wydawnictwo RM dołożyło wszelkich starań, aby zapewnić najwyższą jakość tej książce. Jednakże nikomu nie udziela żadnej rękojmi ani gwarancji. Wydawnictwo RM nie jest w żadnym przypadku odpowiedzialne za jakąkolwiek szkodę (łącznie ze szko- dami z tytułu utraty zysków związanych z prowadzeniem przedsiębiorstwa, przerw w działalności przedsiębiorstwa lub utraty informacji gospodarczej) będącą następstwem korzystania z informacji zawartych w niniejszej publikacji, nawet jeśli Wydaw- nictwo RM zostało zawiadomione o możliwości wystąpienia szkód. ISBN 83-7243-218-X Redaktor prowadzący: Danuta Cyrul Redakcja: Krystyna Knap Korekta: Mirosława Szymańska Projekt graficzny okładki: Grażyna Jędrzejec Redaktor techniczny: Elżbieta Giżyńska Skład: Artur Wolke Druk i oprawa: Oficyna Wydawnicza READ ME - Drukarnia w Lodzi Wydanie I Warszawa 2002 10987654321 Moim rodzicom

Spis tre ści

Wstęp..................................................XVII Co jest w książce?.........................................XVII Stosowane konwencje......................................XVIII Witryna WWW..........................................XVIII Rozdział 1: Wprowadzenie do j ęzyka..................................1 Uruchamianie programów w Pythonie...............................1 Zmienne i wyrażenia arytmetyczne.................................3 Instrukqe warunkowe........................................4 Pliki wejściowe i wyjściowe.....................................5 Napisy.................................................5 Listy i tupie...............................................6 Pętle...................................................8 Słowniki................................................9 Funkqe................................................10 Klasy.................................................11 Wyjątki................................................11 Moduły................................................12 Rozdział 2: Konwencje leksykalne i składnia.............. ...............15 Struktura linii i wcięcia.......................................15 Identyfikatory i słowa zarezerwowane..............................16 Literały................................................17 Operatory, ograniczniki i symbole speqalne...........................20 Napisy dokumentacyjne......................................20 Rozdział 3: Typy i obiekty............................. .......... 21 Terminologia............................................. 21 Tożsamość i typ obiektu....................................... 22 Zliczanie odniesień i odzyskiwanie pamięci............................ 22 Odniesienia i kopie.......................................... 23 Typywbudowane.......................................... 24 Typ None............................................. 25 Typy numeryczne........................................ 25 Typy sekwencyjne........................................ 26 Typy mapujące.......................................... 30 Typy wy woły walne....................................... 31 Moduły.............................................. 33 Klasy............................................... 34 Instanqeklas........................................... 34 Pliki................................................ 35 Typy wewnętrzne........................................ 35 Metody speqalne........................................... 37 Tworzenie, usuwanie i reprezentowanie obiektów..................... 37 Dostęp do atrybutów...................................... 38 Metody sekwencji i mapowania................................ 39 Operacje matematyczne.................................... 41

VIII Python Operacje porównania......................................43 Obiekty wywoływalne.....................................44 Uwagi na temat wydajności i pamięci...............................44 Rozdział 4: Operatory i wyra żenia...................................47 Działania na liczbach........................................47 Działania na sekwenq'ach......................................49 Działania na słownikach.......................................53 Przypisania rozszerzone......................................53 Operator atrybutu (.).........................................54 Konwersja typów.........................................54 Napisy Unicode...........................................55 Wyrażenia i wartości boolowskie..................................58 Równość i tożsamość obiektów...................................58 Kolejność obliczeń..........................................58 Rozdział 5: Przepływ sterowania.................... ................61 Warunki................................................61 Pętle..................................................61 Wyjątki................................................63 Definiowanie nowych wyjątków..................................66 Aserqe i wartość__debug__....................................67 Rozdział 6: Funkcje i programowanie funkcjonalne... ......................69 Funkqe................................................69 Przekazywanie parametrów i wartości powrotnych.......................71 Reguły obowiązywania zasięgu..................................72 Rekurencja..............................................73 Funkcja applyO............................................73 Operator lambda...........................................74 map(), zip(), reduceO i filterO....................................74 Wybieranie listowe..........................................75 eval(), execO, execfileO i compileO.................................76 Rozdział 7: Klasy i programowanie obiektowe........ ....................79 Instrukqa class............................................79 Instanqe klasy............................................80 Zliczanie odniesień i usuwanie instanqi..............................81 Dziedziczenie.............................................82 Polimorfizm.............................................83 Ukrywanie informaqi........................................83 Przeciążanie operatorów......................................84 Klasy, typy i sprawdzanie przynależności.............................85 Rozdział 8: Moduły i pakiety....................... ...............87 Moduły................................................87 Ścieżka poszukiwań modułu....................................89 Ładowanie i kompilowanie modułów...............................89 Przeładowywanie modułu.....................................90 Pakiety................................................91 Rozdział 9: Wej ście i wyj ście......................................95 Czytanie opq'i i zmiennych środowiskowych...........................95 Pliki..................................................96 Standardowe strumienie: wejściowy, wyjściowy i diagnostyczny...............98 Instrukqa print............................................99 Przechowywanie obiektów....................................100 Spis treści IX Wejście/wyjście z użyciem Unicode...............................100 Kodowanie danych Unicode.................................102 Właściwości znaków Unicode................................104 Rozdział 10: Środowisko wykonania programu....................... .... 105 Opqe interpretera i środowisko.................................. 105

Sesje interakcyjne.......................................... 107 Uruchamianie aplikaqi napisanych w Pythonie......................... 108 Pliki konfiguracyjne środowiska................................. 108 Udostępnianie nowych możliwości................................ 109 Kończenie działania programu.................................. 109 Dodatek A: Biblioteka Pythona...................... ..............111 Funkqe i wyjątki wbudowane...................................112 Funkqe wbudowane......................................112 Wyjątki wbudowane......................................119 Usługi Pythona...........................................122 atexit...............................................122 copy...............................................122 copy_reg............................................123 gc.................................................124 marshal.............................................125 new...............................................126 operator.............................................126 piekle i cPickle.........................................127 site...............................................130 sys................................................131 traceback............................................134 types...............................................135 warnings............................................136 weakref.............................................138 UserDict, UserList i UserString................................141 Matematyka.............................................142 array...............................................142 cmath..............................................144 math...............................................144 random.............................................145 Obsługa napisów..........................................147 codecs..............................................147 re.................................................151 string..............................................157 StringlOicStringlO......................................160 struct...............................................160 unicodedata...........................................162 Zarządzanie danymi i trwałe przechowywanie obiektów....................165 anydbm.............................................166 bsddb..............................................167 dbhash..............................................168 dbm...............................................168 dumbdbm............................................168 gdbm..............................................169 shelve..............................................169 whichdb.............................................170 Usługi systemu operacyjnego...................................171 commands...........................................171 crypt...............................................172

Python errno...............................................172 fcntl...............................................177 filecmp..............................................179 fileinput.............................................181 findertools...........................................182 fnmatch.............................................182 getopt..............................................183 getpass..............................................184 gettext..............................................184 glob...............................................187 grp................................................188 gzip...............................................188 locale...............................................189 macfs..............................................190 macostools...........................................194 mmap..............................................195 msvcrt..............................................197 os.................................................198 os.path..............................................213 popen2..............................................215 pwd...............................................216 readline.............................................217 resource.............................................218 shutil...............................................219 signal..............................................220 stat................................................223 statvfs..............................................224 tempfile.............................................224 termios.............................................225 time...............................................229 tty................................................232 _winreg.............................................232 zipfile..............................................235 zlib................................................238 Wątki.................................................240 Podstawy wątków.......................................240 WątkiwPythonie.......................................241 thread..............................................241 threading............................................242 Queue..............................................248 Programowanie sieciowe.....................................249 asyncore.............................................252 BaseHTTPServer........................................255 cgi................................................258 CGIHTTPServer........................................262 Cookie..............................................262 ftplib...............................................265 httplib..............................................266 imaplib.............................................271 nntplib..............................................272 poplib..............................................272 robotparser...........................................272 select...............................................273 SimpleHTTPServer......................................274 Spis treści XI smtplib.............................................275 socket..............................................275 SocketServer..........................................282 urllib...............................................284

urlparse.............................................286 webbrowser...........................................287 Obsługa i kodowanie danych internetowych..........................287 base64..............................................288 binascii.............................................288 binhex..............................................289 mailcap.............................................290 mimetools............................................290 mimetypes...........................................292 MimeWriter...........................................295 multifile.............................................297 quopri..............................................299 rfc822..............................................299 uu................................................302 xdrlib..............................................302 Działanie w trybie ograniczonym.................................305 rexec...............................................306 Bastion..............................................309 Inne moduły.............................................310 bisect...............................................310 cmd...............................................310 md5...............................................313 sha................................................313 shlex...............................................314 DebugerPythona..........................................315 Profiler Pythona...........................................318 profile..............................................318 pstats..............................................319 Moduły nieudokumentowane...................................320 Usługi Pythona.........................................320 Przetwarzanie napisów....................................321 Moduły systemu operacyjnego................................321 Sieć................................................321 Obsługa danych internetowych...............................321 Usługi multimedialne.....................................322 SGIIrix.............................................322 Usługi specyficzne dla Sun-a.................................322 Różne..............................................322 Dodatek B: Rozszerzanie i osadzanie Pythona........ ...................323 Udostępnianie dodatkowych modułów.............................323 Przykład modułu rozszerzenia................................324 Kompilowanie rozszerzeń.....................................326 Konwertowanie danych z Pythona na C.............................328 Konwertowanie danych z C na Pythona.............................331 Obsługabłędów...........................................333 Zliczanie odwołań.........................................335 Wywoływanie Pythona z poziomu C...............................336 Warstwa obiektów abstrakcyjnych................................337 Funkqe niskiego poziomu dla typów wbudowanych......................341

XII Python Definiowanie nowych typów................................... 345 Metody specjalne typów...................................... 352 Wątki................................................. 356 Osadzanie.............................................. 356 Narzędzia do budowy rozszerzeń................................ 358 Extension Classes....................................... 358 Boost Python Library..................................... 359 Dodatek C: Podsumowanie zmian...................... ............361 Pythonl.6..............................................361 Python2.0..............................................361 Python2.1..............................................362 Indeks............................................. .....363

0 autorze David M. Beazley jest autorem SWIG, popularnego pakietu oprogramowania umożliwiającego integrowanie programów C z różnymi językami interpretowa- nymi, łącznie z Pythonem, Perlem i Tcl. Od 1996 roku jest związany ze społeczno- ścią Pythona i aktualnie pracuje nad projektami dotyczącymi debugowania w trybie mieszanym rozszerzeń języków skryptowych. Dave spędził kilka lat pracując w Dziale Fizyki Teoretycznej w Los Alamos National Laboratory, gdzie pomagał w pionierskim wykorzystaniu Pythona do uruchamiania wysoko wy- dajnego oprogramowania symulacyjnego na komputerach równoległych. Obecnie jest pracownikiem naukowym Wydziału Informatyki Uniwersytetu Chi- cagowskiego, gdzie prowadzi zajęcia z systemów operacyjnych, sieci i kom- pilatorów. Można się z nim skontaktować pisząc na adres beazleydcs.uchicago.edu.

O recenzentach Do drugiego* wydania tej książki znaczny wkład wnieśli jej dwaj recenzenci: Paul F. Dubois i Mats Wichmann. Kiedy już były gotowe wszystkie rozdziały, przejrzeli je pod kątem zawartości i kompozyqi. Ich uwagi miały istotne znaczenie dla zapewnienia książce najwyższego poziomu i sprostania zapotrzebowa- niu użytkowników na dobre źródło informacji technicznej. Paul F. Dubois ukończył matematykę na Uniwersytecie Kalifornijskim w Berke- ley. W1970 roku uzyskał doktorat z matematyki na Uniwersytecie Kalifornijskim w Davis. Po sześciu latach pracy naukowo-dydaktycznej zatrudnił się w 1976 roku w Lawrence Livemore National Laboratory. Piastował tam szereg stano- wisk jako specjalista od informatyki i metod numerycznych. Od 1999 roku uczestniczy w Programie Diagnozowania i Porównywania Modeli Klimatycz- nych w Dziale Badań Atmosferycznych, gdzie używa Pythona do tworzenia na- rzędzi dla modeli klimatycznych. Paul jest autorem między innymi pionierskich prac z dziedziny sterowania obli- czeniami i wykorzystania technik obiektowych w programach naukowych. Jest też redaktorem Działu Programów Naukowych czasopisma IEEE Computing in Science and Engineering. Mats Wichmann jest konsultantem i szkoleniowcem. W 1980 roku ukończył in- formatykę na Uniwersytecie Kalifornijskim w Berkeley i przez wiele lat zarządzał pracami programistycznymi z dziedziny systemów operacyjnych dla różnych firm korzystających z Uniksa. Jego poszukiwania języka programowania umożliwiającego realizację różnych zadań, poczynając od pisania skryptów administracyjnych aż po tworzenie skomplikowanych aplikacji, zostały pomyśl- nie zakończone w momencie stworzenia Pythona. Mats jest autorem kursu Py- thona opracowanego dla dużej firmy szkoleniowej. Obecnie mieszka w Questa w stanie Nowy Meksyk i można się z nim skontaktować pisząc na adres m. wich- [email protected].

* amerykańskiego

Podziękowania Książka ta nigdy by nie powstała bez udziału i pomocy wielu osób. Po pierwsze, chciałbym podziękować za krytyczne uwagi dwóm recenzentom, Matsowi Wichmannowi i Paulowi Dubois. Dziękuję również recenzentom pierwszego wydania*, Davidowi Ascherowi i Paulowi Dubois, za cenne komentarze i wskazówki. Ogromną pomoc uzyskałem wówczas także od licznej rzeszy programistów używających Pythona - byli to Guido van Rossum, Jeremy Hylton, Fred Drake, Roger Masse i Barry Warsaw. Chciałbym też podziękować zespołowi New Riders za oddanie i wsparcie w trakcie pisania tej książki. Specjalne słowa uznania należą się redaktor Robin Drake, która wykonała ogromną pracę przy obu wydaniach, a także składaczom, Ronie- mu Wise'owi i Amy Parker, których cierpliwość i upór przeszły moje najśmielsze oczekiwania i umożliwiły przygotowanie w terminie tego wydania. Chciałbym również podkreślić heroiczne wysiłki Tima Bella, który nie tylko zasugerował wprowadzenie mnóstwa poprawek do pierwszej książki, ale zdołał również w ostatniej chwili przeczytać i poprawić wiele błędów w nowym wydaniu. Oto lista osób, które poczyniły krytyczne uwagi do pierwszego* wydania tej książki: Jan Decaluwe, Mike Coleman, Andrew Kuchling, Greg Ward, Richard Wolff, Holger Durer, Patrick Moran, Christian Norgaard Storm Pedersen, Dustin Mitchell, Benjamin Smith, Michael Drumheller, Brett Porter, Tim Bell, Michael Dyck, Ian Thomas Cohen, Steve Burns, David Morrill, Dennis McCoy, Paul Du- bois, Peter Koren, Richard Gruet, Hamish Lawson, Michael Rodgers, Eric Rowe, Phil Austin, Aaron Digulla, Jack Gilbert, Joseph Sachs, Cecil Edwards i Daniel Klein. Zrobiłem wszystko, co w mojej mocy, aby uwzględnić ich sugestie w obec- nym wydaniu. * amerykańskiego

Podziel si ę swoj ą opini ą Jako czytelnik tej książki jesteś dla nas najważniejszym jej krytykiem i komenta- torem. Cenimy twoją opinię i chcielibyśmy się dowiedzieć, co robimy dobrze, co moglibyśmy robić lepiej i jakie dziedziny publikacji ciebie interesują. Pragniemy poznać wszystkie uwagi, które masz nam do przekazania. Jako redaktor naczelny zespołu Web Development w New Riders Publishing za- chęcam cię do nadsyłania swoich uwag. Możesz kierować je bezpośrednio do mnie faksem, emailem lub zwykłą pocztą, podając co ci się podobało, a co nie po- dobało w tej książce, a także co możemy zrobić, aby nasze książki były lepsze. Pamiętaj, że nie mogę ci pomóc w problemach technicznych związanych z tema- tyką tej książki oraz z powodu ogromnej ilości otrzymywanych wiadomości nie zawsze jestem w stanie udzielić indywidualnej odpowiedzi. Pisząc do mnie nie zapomnij podać tytułu tej książki i autora, a także swojego nazwiska i numeru telefonu lub faksu. Przeczytam starannie twoje uwagi i podzielę się nimi z autorem oraz redaktorami, którzy pracowali nad tą książką. Faks: 317-581-4663 Email: [email protected] Adres: Stephanie Wall Executive Editor New Riders Publishing 201 West 103rd Street Indianapolis, IN 46290 USA

Wstęp

Książka ta została pomyślana jako zwięzły informator o języku programowania Python. Chociaż doświadczony programista może na jej podstawie nauczyć się tego języka, nie pełni ona roli wyczerpującego podręcznika do nauki programowania. Jej celem jest raczej dokładne i zwięzłe zaprezentowanie samego języka, zawartości jego biblioteki oraz rozszerzeń API. Od czytelnika oczekuje się wcze- śniejszego kontaktu z Py thonem lub innymi językami programowania, takimi jak C lub Java. Ponadto do zrozumienia niektórych składników biblioteki Pythona może się przydać znajomość tematów związanych z programowaniem systemowym (na przykład podstawowych koncepcji systemu operacyjnego, zarządzania procesami czy sieci). Pakiet dystrybucyjny Pythona jest dostępny bezpłatnie pod adresem http: //www. python. org. Istnieją gotowe wersje dla Uniksa, Windows, Ma- cintosha i Javy. Wymieniona witryna zawiera ponadto dowiązania do dokumentacji, poradników typu „jak to zrobić" i całej gamy modułów rozszerzeń.

Co jest w ksi ążce? Informacje zawarte w tej książce odnoszą się do Pythona 2.1.1 chociaż jest to ję- zyk, który się stale rozwija, większość opisywanych tematów nie powinna stracić na aktualności również w przyszłych wersjach Pythona 2.x. Ponadto spora ich część ma zastosowanie także do jego wcześniejszych wydań. W mniejszym stopniu odnosi się to również do JPythona, czyli kompletnej implementacji Pythona w Javie, ale o tym nie będzie raczej mowy w tej książce. Wraz z ewolucją Pythona musiała siłą rzeczy nastąpić ewoluqa drugiego wydania* tej książki, w którym należało uwzględnić nowe cechy wersji 2.1 oraz dodatkowe moduły biblioteczne. Zamiast podawać na końcu zestawienie nowych ele- mentów języka, wtopiłem informacje o nich w cały tekst, bez stosowania widocz- nych wyróżnień. Szczegółowy opis zmian języka można łatwo znaleźć w doku- mentach online. Na koniec trzeba zaznaczyć, że w skład pakietu dystrybucyjnego Pythona wchodzą setki stron dokumentacji. Niniejsza książka jest w dużym stopniu oparta na tej dokumentacji, ale zawiera też liczne rozszerzenia i uzupełnienia, a część tematów z kolei pomija. Większość powtórzonego materiału ma w książce bardziej zwięzłą postać. Ponadto w wielu miejscach zmieniłem przykłady i opisy. Poświęciłem też więcej miejsca różnym modułom bibliotecznym. Dotyczy to * amerykańskiego

XVIII____________________________________________________________________________Pyfan w szczególności sieciowych i systemowych modułów niskiego poziomu, ba- zujących z reguły na setkach opcji wymienionych na stronach dokumentacji Uniksa i innych dodatkowych źródeł informacji. Natomiast w celu nadania książce bardziej zwięzłego i przejrzystego kształtu wiele przestarzałych i mniej istotnych modułów zostało w ogóle pominiętych. Nie ma tutaj też informacji o takich narzędziach, jak Tkinter czy XML, ani o rozszerzeniach COM, gdyż są to tematy wykraczające poza ramy tej książki i poświęcono im oddzielne pozycje. Pisząc tę książkę starałem się zamieścić w niej dosłownie wszystko, co było mi potrzebne do korzystania z Pythona i jego ogromnej kolekqi modułów. Chociaż nie jest to z pewnością systematyczne i eleganckie wprowadzenie do języka, mam nadzieję, że jeszcze przez wiele lat będzie użyteczną pozycją w twojej bibliotece programowania. Zachęcam także do dzielenia się ze mną swoimi uwagami. David Beazley Chicago, IL 01-06-2001

Stosowane konwencje tekst o stałej szeroko ści znaków Typy danych, klasy, moduły, stałe i tak dalej - w zasadzie wszystko, co stanowi część języka Python lub polecenia, które można wpisać do komputera. Czcionka o stałej szerokości znaku jest również używana w przypadku adre- sów internetowych, na przykład www. python. org. kursywa o stałej szerokości znaków Zmienne, jak na przykład x w funkcji abs (x). [] Nawiasy kwadratowe użyte w składni wskazują elementy nieobowiązkowe - na przykład obiekt w dir ( [obiekt] ). Z kolei zapis [arg = value] oznacza, że value jest domyślną wartością arg. Ponadto nawiasy kwadratowe służą w Pythonie do oznaczania list. W każdym przypadku ich rola jest kwestią interpretacji. W Jest to znak kontynuacji kodu wstawiany wszędzie tam, gdzie nie powinno być przejścia do nowego wiersza, ale doszło do niego z powodu braku miejsca na stronie.

Witryna WWW Aby ściągnąć pliki źródłowe listingów zamieszczonych w tej książce, zajrzyj na stronę www. newriders . com. Rozdział 1

Wprowadzenie do j ęzyka

Pierwszy rozdział zawiera krótkie wprowadzenie do Pythona. Jego celem jest przedstawienie najważniejszych cech tego języka bez zbytniego wnikania w szcze- góły. Z tego powodu znajdziesz tutaj jedynie ogólne omówienie podstawowych elementów Pythona, takich jak zmienne, wyrażenia, przepływ sterowania, funkqe oraz instrukqe wejścia/wyjścia. Celem tego rozdziału nie jest dostarczenie wyczerpujących informacji ani omówienie różnych zaawansowanych możliwo- ści Pythona. Mimo to na podstawie zawartego tutaj materiału doświadczeni pro- gramiści powinni być w stanie tworzyć nawet dość skomplikowane programy. Natomiast osobom początkującym radzę najpierw zrobić kilka przykładów, aby mogły się lepiej wczuć w styl tego języka.

Uruchamianie programów w Pythonie

Programy napisane w Pythonie są wykonywane przez interpreter. W komputerach uniksowych interpreter uruchamia się przez wpisanie polecenia python. W systemach windowsowych i Macintoshach interpreter jest traktowany jak aplikaqa (trzeba wybrać odpowiednie polecenie z menu Start lub kliknąć dwukrotnie właściwą ikonę na Pulpicie). Po wystartowaniu interpretera na ekranie pojawia się znak zgłoszenia umożliwiający wpisywanie programów wykonywanych na bieżąco w prostej pętli czytającej. Zamieszczony niżej przykład przedstawia komunikat o prawach autorskich i znak zgłoszenia »> wyświetlany przez interpreter zaraz po jego uruchomieniu oraz rezultat wpisania przez użytkowni- ka znanego polecenia „Witaj świecie": Python 2.1 (#1, Apr 20 2001, 14:34:45) [GCC 2.95.2 19991024 (release)] on sunos5 Type "copyright", "credits" or "license" for more i nformation. >» print "Witaj świecie" Witaj świecie >>> Programy można również zapisywać w plikach, na przykład: # witaj świecie.py print "Witaj świecie" Pliki źródłowe Pythona mają przyrostek . py. Znak # oznacza komentarz, który rozciąga się do końca linii.

Python Aby wykonać program zapisany w pliku witaj świecie, py, wystarczy w pokazany niżej sposób podać interpreterowi nazwę tego pliku: % python witaj świecie.py Witaj świecie % W systemach windowsowych programy napisane w Pythonie można urucha- miać przez dwukrotne kliknięcie ikony pliku . py. Spowoduje to załadowanie interpretera i wykonanie programu w oknie konsoli. W takim przypadku okno konsoli zniknie z ekranu natychmiast po zakończeniu programu (często zanim jeszcze zdążysz przeczytać wyniki). Aby tego uniknąć, powinieneś korzystać ze zintegrowanego środowiska programowania, takiego jak Idle czy Pythonwin. In- nym sposobem jest uruchamianie programu przy użyciu pliku .bat zawie- rającego taką instrukq'e, jak python -i witaj świecie .py, która powoduje wejście interpretera w tryb interakcyjny po zakończeniu programu. W Macintoshach można uruchamiać programy z poziomu standardowo dołączonego zintegrowanego środowiska programowania. Komputery te są również wyposażane w narzędzie BuildApplet, które pozwala zamienić program napisany w Pythonie w dokument automatycznie uruchamiający interpreter w chwili otwarcia. Na poziomie interpretera do uruchomienia programu służy zademonstrowana niżej funkcja execfile (): >» execf ile ("witaj świecie.py") Witaj świecie W Uniksie można również uruchomić Pythona z poziomu skryptu powłoki, uży- wając dyrektywy #!: #!/usr/local/bin/python print "Witaj świecie" Interpreter działa aż do napotkania końca pliku wejściowego. W trybie interakcyjnym można wyjść z programu wprowadzając znak końca pliku (EOF) lub wy- bierając polecenie Exit z menu rozwijanego. W Uniksie znakiem końca pliku jest kombinacja klawiszy [Ctrl+Dl, natomiast w systemach windowsowych - [Ctrl+Z]. W celu zakończenia programu można również wywołać funkcję sys . exit () lub zgłosić wyjątek SystemExit. Na przykład: >» import sys »> sys.exit() lub »>raise SystemExit Rozdział 1: Wprowadzenie do języka

Zmienne i wyra żenia arytmetyczne Program z listingu 1.1 pokazuje użycie zmiennych i wyrażeń w prostym oblicza- niu procentu składanego: Listing 1.1 Proste obliczanie procentu składanego # Suma pocz ątkowa # Stopa procentowa # Liczba lat kapitał = 1000 stopa =0.05 liczbalat = 5 rok = 1 while rok <= liczbalat: kapitał = kapitał*(1+stopa) print rok, kapitał rok += 1 Wyniki generowane przez ten program wyglądają następująco: 1 1050.0 2 1102.5 3 1157.625 4 1215.50625 5 1276.2815625 Python jest językiem o dynamicznie ustalanych typach danych i nazwy zmiennych mogą reprezentować różnego typu wartości w trakcie wykonywania pro-

gramu. W rzeczywistości nazwy używane w programie są jedynie etykietami dla różnych wielkości i obiektów, a operator przypisania tworzy po prostu związek między daną nazwą a jakąś wartością. Różni się to na przykład od języka C, w którym nazwa reprezentuje konkretne położenie i wielkość fragmentu pamię- ci, w którym można zapisywać wartości. Dynamiczne działanie Pythona widać na przykładzie zmiennej kapitał z listingu 1.1. Na początku otrzymuje ona wartość całkowitą. Natomiast kolejne jej wartości są wynikiem działania instrukcji przypisania: kapitał = kapitał*(1+stopa) Instrukcja ta oblicza wartość wyrażenia arytmetycznego i zapamiętuje ją ponownie w zmiennej kapitał.Gdy następuje to po raz pierwszy, zapisana pierwotnie w tej zmiennej liczba całkowita 1000 zostaje bezpowrotnie utracona. Co więcej, rezultatem tej instrukcji jest zmiana typu zmiennej. W tym konkretnym przypadku typ zmiennej kapitał zmienia się z całkowitego na zmiennoprzecinkowy, gdyż taki jest typ zmiennej stopa. Znak końca linii oznacza koniec pojedynczej instrukcji. Aby umieścić w jednej linii kilka różnych instrukcji, trzeba oddzielić je średnikami. Oto przykład: kapitał = 1000; stopa = 0.05; liczbalat = 5; Instrukcja while sprawdza wartość umieszczonego w niej wyrażenia warunko- wego. Jeśli wartością tego wyrażenia jest prawda, następuje wykonanie zawarto- ści instrukcji while i ponowne sprawdzenie warunku. Takie działanie powtarza się aż do momentu, w którym wyrażenie warunkowe będzie miało wartość fałsz. Ponieważ zawartość pętli jest ustalan i na podstawie wcięcia, w każdej iteracji in-

Python Rozdział 1: Wprowadzenie do języka strukcji while z listingu 1.1 będzie wykonywana zawartość trzech następnych linii. Python nie definiuje wielkości wcięcia, a jedynie wymaga, aby wielkość ta była jednakowa w ramach całego bloku. Wadą programu z listingu 1.1 jest niezbyt elegancki wygląd danych wyjścio- wych. Aby go poprawić, można wyrównać obie kolumny liczb do prawej i ogra- niczyć dokładność wartości zmiennej kapitał do dwóch cyfr po przecinku. W tym celu wystarczy użyć w instrukcji print następującego napisu forma- tującego: print "%3d %0.2f" % (rok, kapitał) Oto, jak będą teraz wyglądały dane wyjściowe programu: 1050.00 1102.50 1157.63 1215.51 1276.28 Napisy formatujące zawierają zwykły tekst oraz sekwencje specjalnych znaków, takich jak " % d ", " % s " czy " % f ". Sekwencje te określają sposób formatowania danych konkretnego typu - w tym konkretnym przypadku liczb całkowitych, napi- sów oraz liczb zmiennoprzecinkowych. Sekwenqe znaków speqalnych mogą za- wierać również modyfikatory określające szerokość i dokładność zapisu liczbo- wego. Na przykład sekwencja "%3d" oznacza liczbę całkowitą wyrównaną do prawej w kolumnie o szerokości 3 znaków, a " %2 f " liczbę zmiennoprzecinkową z tylko dwiema widocznymi cyframi po przecinku. Działanie napisów forma- tujących jest niemal identyczne, jak w funkcji sprintf () języka C i będzie szczegółowo opisane w rozdziale 4 zatytułowanym „Operatory i wyrażenia".

Instrukcje warunkowe Do wykonywania prostych testów służą instrukcje if i else. Oto przykład: # Znalezienie najwi ększej liczby (z) spo śród a i b if a < b: z = b else: z = a Zawartość klauzul if i else ustalana jest na podstawie wcięć. Klauzula else nie jest obowiązkowa. Aby utworzyć pustą klauzulę, można użyć instrukcji pass: if a < b: pass else: z = a # Nic nie rób Używając słów kluczowych or, and i not można tworzyć wyrażenia boolowskie: if b >= a and b <= c: print "b nale ży do przedziału <a,c>" if not (b < a or b > c): print "b nadal nale ży do przedziału <a,c>" Do sprawdzania wielu różnych warunków można używać instrukcji elif. Oto przykład: if a == '+': op = PLUS elif a == '-': op = MINUS elif a == '*': op = RAZY else: raise RuntimeError, "Nieznany operator"

pliki wej ściowe i wyj ściowe Oto przykład programu otwierającego plik i czytającego linia po linii jego zawar- tość: f = open("co ś.txt")

linia = f.readline() while linia: print linia, # linia = f.readlineO f.close () # Uzyskanie obiektu typu plik # Wywołanie metody readlineO dla pliku na ko ńcu blokuje znak ko ńca linii Funkqa open () zwraca nowy obiekt typu plik. Za pomocą metod tego obiektu można wykonywać różne operacje plikowe. Metoda readline () wczytuje po- jedynczą linię wejściową, łącznie ze znakiem przejścia do następnej linii. Po dojś- ciu do końca pliku metoda zwraca pusty napis. Aby skierować dane wyjściowe programu do jakiegoś pliku, możesz użyć znaków >> w instrukq'i print, jak to jest pokazane w następnym przykładzie: f = open("wyj ście","w") # Otwarcie pliku do pisania while rok <= liczbalat: kapitał = kapitał* (1 + stcpa) print »f,"%3d %0.2f" % (rok, kapitał) rok += 1 f.close () Do zapisywania danych w plikach można używać także metody write (). Na przykład instrukcję print z poprzedniego przykładu można zastąpić instrukcją f write("%3d %0.2fin" % (rok, kapitał)

Napisy Aby utworzyć literał napisowy, trzeba go umieścić w pojedynczych, podwójnych lub potrójnych znakach cytowania. Oto przykłady: a = 'Witaj świecie' b = "Python jest super" c = """Jak wygl ąda przypis 5?""" Na końcu napisu musi występować ten sam znak cytowania, co na początku. Na- pisy zaczynające się trzema znakami cytowania obejmują cały tekst ciągnący się aż do następnych trzech znaków cytowania, podczas gdy napisy umieszczone w pojedynczych lub podwójnych znakach cytowania muszą się mieścić w jednej

Python linii logicznej. Potrójny znak cytowania może składać się zarówno z apostrofów (zobacz następny przykład), jak i cudzysłowów (zobacz poprzedni przykład). Napisy potrójnie cytowane są szczególnie przydatne w sytuacji tekstów ciągnących się przez kilka linii, jak to jest pokazane niżej: print '''Content-type: text/html <hl> Witaj świecie </hl> Kliknij <a href="http://www.python.org">tutaj</a>. ■ i t Napisy to sekwencje znaków indeksowanych przy użyciu kolejnych liczb całko- witych zaczynając od zera. Aby wybrać pojedynczy znak z napisu, wystarczy użyć operatora indeksowania s [ i ]. Oto przykład: a = "Witaj świecie" b = a[4] # b = 'j' Aby wybrać -podciąg, można użyć operatora wycinania s [ i : j ]. Powoduje on wybranie wszystkich elementów napisu s, których indeks k spełnia warunek i<=k<j. Jeśli któryś z indeksów zostanie pomięty, w jego miejsce zostanie przy- jęty domyślnie początek lub koniec napisu: c = a[0:5] d = a[6:] e = a[3:8] # c = "Witaj" # d = "świecie" # e = "aj św" Do konkatenaqi napisów służy operator plus (+): g = a + " To jest test" Do konwersji innych typów danych na napisy można używać funkcji s t r () albo repr () lub odwrotnych apostrofów O, które są skróconą formą zapisu funkcji repr (). Oto przykłady: s = "Warto ści ą x jest " + str(x) s = "Warto ści ą y jest " + repr(y) s = "Warto ści ą y jest " + ~y~ W wielu przypadkach funkcje s t r () i repr () dają ten sam rezultat. Istnieją jednak subtelne różnice między ich składniami, o których będziemy mówić w dal- szych rozdziałach.

Listy i tupie 0 ile napisy są sekwencjami znaków, to listy i tupie są sekwencjami własnoręcz- nie określonych obiektów. Oto jak wygląda utworzenie listy: imiona = [ "Dawid", "Marek", "Anna", "Filip"] Listy są indeksowane liczbami całkowitymi zaczynając od zera. Korzystając z operatora indeksowania można sięgać do poszczególnych elementów listy 1 modyfikować je: a = imiona[2] imiona[0] = "Jerzy" # Zwraca trzeci element listy - "Anna" # Zmienia pierwszy element na "Jerzy" Długość listy można ustalić za pomocą funkcji len (): print len(imiona) # Podaje liczb ę 4 Rozdział 1: Wprowadzenie do języka Aby dodać nowy element na końcu listy, można użyć metody append (): imiona.append("Kasia") Aby wstawić nowy element do środka listy, można użyć metody insert (): imiona.insert(2, "Szymon") Do pobrania lub zmiany porcji listy można użyć operatora wycinania: # Zwraca ["Jerzy", "Marek" ] # Zwraca ["Szymon", "Anna", # "Filip", "Kasia" ] # Zamienia drugi element listy # imiona na 'Jerzy' imiona[0:2] = ['Dawid', 'Marek','Jerzy'] # Zamienia dwa pierwsze # elementy listy imiona na # elementy z prawej. imiona[0:2]

imiona[2:] imiona[l] = 'Jerzy' Do konkatenacji list można używać operatora plus (+): a = [1,2,3] + [4,5] # Wynikiem jest lista [1,2 ,3,4,5] Lista może się składać z dowolnych obiektów Pythona, nawet z innych list, jak to jest pokazane w kolejnym przykładzie: a= [1, "Dawid", 3.14, ["Marek", 7, 9, [100,101]], 10] Dostęp do list zagnieżdżonych wygląda następująco: a[3] [2] a[3] [3] [1] # Zwraca "Dawid' # Zwraca 9 # Zwraca 101 Program z listingu 1.2 pokazuje bardziej zaawansowane możliwości list. Jego zadaniem jest wczytanie liczb z pliku i podanie najmniejszej oraz największej z tych wartości. Listing 1.2 Zaawansowane mo żliwo ści list import sys f = open(sys.argv[1]) swarto ści = f.readlines() f.close () # Załadowanie modułu sys # Nazwa pliku w linii polecenia # Wczytanie wszystkich linii na list ę # Konwersja wszystkich wczytanych warto ści z napisów na liczby # zmiennoprzecinkowe fwarto ści = [float(s) for s in swarto ści] # Podanie warto ści min i max print "Warto ść minimalna to ", min(fwarto ści) print "Warto ść maksymalna to ", max(fwarto ści) W pierwszej linii tego programu występuje instrukcja import, która ładuje moduł sys z biblioteki Pythona. Metoda open () używa nazwy pliku dostarczonej w postaci opcji linii polecenia i zapisanej na liście sys . argv. Metoda readlines () wczytuje wszystkie linie pliku wejściowego i tworzy z nich listę napisów. Wyrażenie [float (s) for s in swartości] przebiega wszystkie elementy listy swartości i po zastosowaniu do każdego z nich funkcji float ()

Python umieszcza go na nowej liście. Ta szczególnie wygodna metoda konstrukcji nosi nazwę wyczerpywania listy. Po konwersji wszystkich linii wejściowych na listę liczb zmiennoprzecinkowych następuje wywołanie funkcji wbudowanych min () i max (), które odnajdują odpowiednio wartość minimalną i maksymalną na liście. Z listami jest blisko spokrewniony inny typ danych - tuple. Tuple tworzy się umieszczając grupy wartości w nawiasach okrągłych i oddzielając poszczególne elementy przecinkami, na przykład: a = (1,4,5,-9,10) b = (7,) osoba = (imi ę, nazwisko, telefon) # Tupla jednoelementowa # (zwró ć uwag ę na dodatkowy przecinek) Czasem Python rozpoznaje zamiar użycia tupli nawet wtedy, gdy brakuje nawia- sów okrągłych: a = 1,4,5,-9,10 b = 7, osoba = imi ę, nazwisko, telefon Tupie dopuszczają w większości te same operacje co listy, łącznie z indeksowaniem, wycinaniem i konkatenacją. Jedyna różnica polega na tym, że nie można modyfikować zawartości tupli po jej utworzeniu - ani modyfikować poszczegól- nych elementów, ani dodawać nowych.

Pętle W zamieszczonych wcześniej prostych pętlach była wykorzystywana instrukqa while. Innym sposobem utworzenia pętli jest użycie instrukqi for, która dokonuje iteracji po wszystkich elementach zbioru takiego jak napis, lista czy tupla. Oto przykład: for i in range (1,10): print "2 do pot ęgi %d wynosi %d" % (i, 2**i) Funkcja range (i, j) tworzy listę wartości całkowitych z przedziału od i do j -1. Jeśli wartość początkowa zostanie pominięta, Python przyjmie w jej miejsce liczbę zero. Jako trzeci, nieobowiązkowy argument, można podać przyrost. Na przykład: a = range (5) b = range (1,8) c = range(0,14,3) d = range(8,1,-1) # a - [0,1,2,3,4] # b = [1,2,3,4,5,6,7] # c = [0,3,6,9,12] # d = [8,7,6,5,4,3,2] Instrukcja for pozwala przebiegać zbiory wartości dowolnego typu, a nie tylko całkowitego: a = "Witaj świecie" # Wypisanie znaków wyst ępuj ących w a for c in a: print c b = ["Dawid","Marek","Anna","Filip"] # Wypisanie składników listy Rozdział 1: Wprowadzenie do języka for imi ę in b: print imi ę Działanie funkcji range () polega na konstruowaniu listy wartości z przedziału określonego przez trzy argumenty: początek, koniec i przyrost. W przypadku dużych zakresów jest to kosztowny proces, zarówno w kategoriach pamięci, jak i czasu wykonania. Aby tego uniknąć, można użyć funkcji xrange (), jak to jest pokazane niżej: for i in xrange(1,10): print "2 do pot ęgi %d wynosi %d" % (i, 2**i) a = xrange(100000000)

b = xrange(0,100000000, 5) a = [0,1,2, ..., 99999999] # b = [0,5,10, ...,99999995] Zamiast gotowej sekwencji wartości, funkqa xrange () tworzy konstrukqe, która przy każdej próbie dostępu wyznacza element na podstawie wartości początk^ wej, końcowej i przyrostu. o-

Słowniki Słownik to tablica haszująca, zwana też asocjacyjną, zawierająca obiekty poindek- sowane za pomocą kluczy. Aby utworzyć słownik, trzeba umieścić jego elementy w nawiasach klamrowych, na przykład: a - { "nazwa" : "beazley", "katdomowy" : "/home/beazley", 'uid' 500 Aby sięgnąć do któregoś elementu słownika, trzeba użyć odpowiedniego klucza indeksującego, na przykład: u = a["nazwa"] d = a["katdomowy"] Z kolei wstawianie lub modyfikowanie elementów słownika wygląda nastę- pująco: a["nazwa"] = "pxl" a["katdomowy"] = "/home/pxl" a["powłoka"] = "/usr/bin/tcsh" Chociaż napisy są najczęściej używanym typem klucza, Python dopuszcza również wiele innych obiektów, łącznie z liczbami i rupiami. Pewne obiekty, w tym listy i słow- niki, nie mogą być używane jako klucze, gdyż ich zawartość może ulegać zmianom. Do sprawdzania obecności jakiegoś elementu w słowniku służy metoda has_key (). Oto przykład: if a.has_key("nazwa"): nazwa = a["nazwa"] else: nazwa = "nieznany u żytkownik" Ten sam rezultat można uzyskać stosując bardziej skrócony zapis: nazwa = a.get("nazwa", "nieznany u żytkownik")

10 Python Aby uzyskać listę kluczy słownika, można użyć metody keys (): k = a.keys() # k = ["nazwa","katdomowy","uid","powłoka' Do usuwania elementów słownika służy instrukcja del: del a["nazwa"]

Funkcje Do tworzenia funkqi służy instrukcja def, której użycie ilustruje kolejny przykład: def reszta(a,b): q = a/b r = a - q*b return r Aby wywołać jakąś funkqe, wystarczy podać jej nazwę, a następnie jej argumenty ujęte w nawiasy okrągłe. Na przykład wynik = reszta (37,15). Do zwró- cenia przez funkcję wielu wartości jednocześnie można użyć tupli: def podziel(a,b): q = a/b r = a - q*b return (q,r) # Je śli a i b s ą liczbami całkowitymi, # q równie ż jest liczb ą całkowit ą W przypadku zwracania wielu wartości przez tupię często wygodnie jest wywoływać funkcję w sposób następujący: iloraz, reszta = podziel(1456,33) Aby przypisać parametrowi wartość domyślną, można użyć następującej konstrukqi: def poł ącz(nazwahosta, port, timeout=300): # tre ść funkcji W przypadku podania wartości domyślnych w definicji funkcji, można pomijać je w kolejnych wywołaniach tej funkcji. Na przykład: poł ącz ('www.python.org', 80) W wywołaniach funkcji można również podawać nazwy argumentów i ich war- tości, i to w dowolnej kolejności, co ilustruje kolejna instrukqa: poł ącz(port=80,nazwahosta="www.python.org") W przypadku tworzenia zmiennych lub przypisywania im wartości wewnątrz funkcji mają one zakres lokalny. Aby zmodyfikować w treści funkcji zmienną globalną, trzeba użyć w następujący sposób instrukcji global: a = 4.5 def co ś (): global a # Zmiana globalnej zmiennej a Rozdział 1: Wprowadzenie do języka 11

Klasy Instrukcja class pozwala definiować nowe typy obiektów i jest używana w programowaniu obiektowym. Oto przykład klasy definiującej prosty stos: class Stos: def # Inicjalizacja stosu __init__(self) : self.stos = [ ] def włó ż(self,obiekt): self.stos.append(obiekt) def zdejmij(self): return self.stos.pop() def rozmiar(self): return len (self.stos) Metody klasy są definiowane za pomocą instrukcji def. Pierwszy argument każ- dej metody odnosi się zawsze do samego obiektu. Standardowo używa się dla tego argumentu nazwy self. Wszystkie operacje wykorzystujące atrybuty obiektu muszą się jawnie odwoływać do zmiennej self. Metody o nazwach poprzedzonych i zakończonych dwoma podkreśleniami mają specjalne znaczenie.

Na przykład metoda__init__służy do inicjalizowania obiektu zaraz po jego utworzeniu. Oto kilka przykładów kodu wykorzystującego klasę Stos: s = Stos() s.włó ż("Dawid") s.włó ż(42) s.włó ż([3,4,5]) x = s.zdejmij() y = s.zdejmij() del s # Utworzenie stosu # Wło żenie na stos kilku elementów # x = [3,4,5] # y = 42 # Usunięcie stosu

Wyj ątki Po wystąpieniu w twoim programie błędu zgłaszany jest wyjątek i na ekranie pojawia się komunikat w rodzaju: Traceback (most recent call last): File "<interactive input>", line 42, in co ś.py NameError: a Komunikat o błędzie podaje typ wykrytego błędu oraz jego lokalizację. Wystąpienie błędu powoduje zazwyczaj przerwanie wykonania programu. Mo- żna jednak próbować przechwycić wyjątek i obsłużyć go samodzielnie za po- mocą instrukcji try i except. Oto przykład: try: f = open ("plik.txt","r") except IOError, e: print e

12 Pytiion Gdy nastąpi wyjątek typu IOError, szczegółowe informacje o jego przyczynie zostaną umieszczone w zmiennej e, a sterowanie przekazane do kodu w bloku except. W przypadku zgłoszenia innego rodzaju wyjątku sterowanie przejdzie do wewnętrznego bloku kodu (o ile taki występuje). Jeśli żaden błąd nie nastąpi, zawartość bloku except zostanie zignorowana. Instrukcja raise pozwala samodzielnie zgłaszać wyjątki. W takim przypadku możesz użyć jednego z wbudowanych wyjątków, na przykład: raise RuntimeError, "Bł ąd nie do naprawienia" Możesz też utworzyć własny wyjątek, co jest opisane w rozdziale 5, „Przepływ sterowania", w podrozdziale zatytułowanym „Definiowanie nowych wyjątków".

Moduły W miarę tworzenia coraz większych programów będziesz prawdopodobnie chciał dzielić je na mniejsze pliki dla ułatwienia ich konserwaqi. Z tego względu Python umożliwia wstawianie różnych definicji do plików i używanie ich w postaci modułów, które można importować do własnych programów i skryptów. Aby utworzyć moduł, musisz wstawić odpowiednie instrukcje i definiqe do pliku o tej samej nazwie co moduł. (Uwaga: plik musi mieć przyrostek .py). Na przykład: # plik : dziel.py def podziel(a,b): q = a/b r = a - q*b return (q,r) # Je śli a i b to liczby całkowite, q równie ż # jest liczb ą całkowit ą Aby użyć modułu w jakimś programie, musisz skorzystać z instrukcji import: import dziel a, b = dziel.podziel(2305, 29) Instrukcja import tworzy nową przestrzeń nazw, która zawiera wszystkie obiekty zdefiniowane w podanym module. Aby sięgnąć do tej przestrzeni, wystarczy użyć jako prefiksu nazwy modułu. W ostatnim przykładzie stosowny zapis miał postać dziel. podziel (). Jeśli chcesz dokonać importu modułu pod zmienioną nazwą, musisz użyć w instrukcji import nieobowiązkowego kwalifikatora as. Oto przykład: import dziel as co ś a,b = co ś.podziel(2305,29) Rozdział 1: Wprowadzenie do języka 13 Jeśli chcesz importować konkretne definicje z modułu do bieżącej przestrzeni nazw, możesz użyć instrukcji from: from dziel import podziel a,b = podziel(2305,29) # Niepotrzebny ju ż prefix dziel Aby załadować całą zawartość modułu do bieżącej przestrzeni nazw, możesz użyć następującego zapisu: from dziel import * Na koniec trzeba wspomnieć o funkcji dir (), która listuje zawartość modułu i jest użytecznym narzędziem podczas pracy w trybie interakcyjnym, gdyż pozwala wyświetlić wszystkie funkcje i zmienne dostępne w module: »> import string >» dir (string) ['__builtins__', ■__doc__', '__file__', '__name__', '_idmap', '_idmapL', '_lower', '_swapcase', '_upper', 'atof, 'atof error', 'atoi', 'atoi_error', 'atol', 'atol_error', 'capita lize',~ 'capwords', 'center 1, 'count 1, 'digits', 'expandtabs', 'find',

Rozdział 2

Konwencje leksykalne i składnia

W tym rozdziale opisane są konwencje leksykalne i składnia programów pisa- nych w Pythonie. Znajdziesz tutaj omówienie takich tematów, jak struktura linii, słowa zarezerwowane, literały, operatory i leksemy. Ponadto opisane jest szcze- gółowo użycie literałów tekstowych Unicode.

Struktura linii i wci ęcia Każda instrukcja programu kończy się znakiem przejścia do nowej linii. Długie instrukqe można zapisywać w kilku kolejnych liniach, stosując znak kontynuacji (\), jak to jest pokazane w poniższym przykładzie: a = math.cos(3*(x-n)) + \ math.sin(3*(y-n)) Znak kontynuacji linii nie jest potrzebny w przypadku definicji potrójnie cytowa- nych napisów, list, tupli i słowników. Mówiąc bardziej ogólnie, każdy fragment : programu ujęty w nawiasy okrągłe (...), kwadratowe [...], klamrowe {...} lub po- trójne znaki cytowania może ciągnąć się przez wiele linii bez użycia znaku kontynuacji. Wcięcia służą do wydzielania różnych bloków kodu, takich jak treść funkcji, warunku, pętli czy klasy. Wielkość wcięcia zastosowana w pierwszej instrukcji bloku może być dowolna, natomiast wszystkie wcięcia w ramach danego bloku muszą być takie same. Na przykład: if a: instrukcjal # Jednakowe wci ęcia instrukcja2 else: instrukcja3 instrukcja4 # Niejednakowe wci ęcia (bł ąd) Jeśli treść funkcji, warunku, pętli lub klasy jest krótka i składa się tylko z kilku instrukcji, można próbować umieścić ją w jednej linii. Na przykład: if a: instrukcjal else: instrukcja2

16 Python Aby utworzyć pusty blok instrukqi, możesz użyć instrukcji pass, jak to jest pokazane poniżej: if a: pass else: instrukcje Chociaż do robienia wcięć można używać znaków tabulacji, taka praktyka nie jest zalecana. Napotkane znaki tabulacji są konwertowane na spacje niezbędne do ustawienia się w najbliższej kolumnie o numerze będącym wielokrotnością liczby 8. (Na przykład wstawienie znaku tabulacji w kolumnie 11 powoduje zastąpienie go pięcioma spacjami, co powoduje przejście do kolumny 16). Po uruchomieniu Pythona z opcją -t i wykryciu niespójnego użycia spacji i tabulacji w ramach tego samego bloku programu wyświetlany jest komunikat ostrzegawczy. Opcja -tt powoduje z kolei zgłaszanie wyjątków TabError w takich sytuaqach zamiast wyświetlania ostrzeżenia. Aby umieścić kilka instrukcji w jednej linii, musisz oddzielić je średnikami (;). Li- nia zawierająca tylko jedną instrukcję również może się kończyć średnikiem. Znak # wskazuje początek komentarza ciągnącego się aż do końca bieżącej linii. Nie dotyczy to jednak sytuacji, w której # występuje wewnątrz zacytowanego napisu. Na koniec dodajmy, że interpreter ignoruje wszystkie puste linie, chyba że działa w trybie interakcyjnym.

Identyfikatory i słowa zarezerwowane Identyfikator to nazwa używana do wskazywania konkretnej zmiennej, funkcji, klasy, modułu lub innego obiektu. Identyfikatory mogą się składać z liter, cyfr i znaków podkreślenia (_), nie mogą jednak nigdy zaczynać się od cyfry. Aktualnie dozwolone są jedynie litery A-Z oraz a-z ze zbioru znaków ISO-Latin. Ponieważ wielkość liter w identyfikatorach ma znaczenie, nazwa BYLECO jest inną nazwą niż byle co. W identyfikatorach nie wolno używać symboli specjalnych, takich jak $, % czy @. Ponadto niedozwolone jest korzystanie ze słów zarezerwowanych, takich jak if, else czy for. Oto lista wszystkich słów zarezerwowanych: and elif global or assert else if pass break except import print class exec in raise continue finally is return def for lambda try del from not while Identyfikatory rozpoczynające się lub kończące znakami podkreślenia mają znaczenie specjalne. Na przykład identyfikatory rozpoczynające się jednym podkre- śleniem, jak _by leco, nie są importowane przez instrukqe from module import *. Identyfikatory z dwoma podkreśleniami na początku i na końcu, takie jak__i nit__, są zarezerwowane dla specjalnych metod, a identyfikatory z dwoma podkreśleniami na początku, takie jak__mo j e, są używane do implementowania prywatnych składowych klasy, co jest opisane w rozdziale 7 zaty-

L Rozdział 2: Konwencje leksykalne i składnia 17 tułowanym „Klasy i programowanie obiektowe". Z tego względu powinno się unikać wykorzystywania tego typu identyfikatorów do celów ogólnych.

Literały Python oferuje cztery wbudowane typy numeryczne: liczby całkowite, długie liczby całkowite, liczby zmiennoprzecinkowe i liczby zespolone. Liczba taka jak 1234 jest interpretowana jako liczba całkowita dziesiętna. Aby za-

pisać liczbę całkowitą w postaci ósemkowej lub szesnastkowej, trzeba poprze- dzić ją odpowiednio znakiem 0 lub 0x - na przykład 064 4 lub 0xl00fea8. Długie liczby całkowite zapisuje się z małą lub dużą literą „1" na końcu, na przykład 1234567890L.W odróżnieniu od zwykłych liczb całkowitych, których zakres zależy w komputerze od jego dokładności, długie liczby całkowite mogą być teoretycznie dowolnie duże (nie mogą jedynie przekroczyć wielkości dostęp- nej pamięci). Liczby w rodzaju 123.34il.2334e+02są traktowane jako liczby zmiennoprzecinkowe. Liczba całkowita lub zmiennoprzecinkowa z małą lub dużą literą „j" na końcu, na przykład 12 . 3 4 J, jest traktowana jako liczba urojona. Dodając liczbę rzeczywistą do urojonej, na przykład 1.2 + 12.34J, można tworzyć dowolne liczby zespolone. Aktualnie Python dopuszcza stosowanie dwóch rodzajów literałów napisowych: • ASCII (8-bitowe znaki) • Unicode (16-bitowe znaki) Najczęściej używanym typem danych napisów są znaki 8-bitowe, gdyż nadają się do reprezentowania zarówno zbioru ASCII oraz ISO-Latin, jak i surowych danych binarnych w postaci sekwenqi bajtów. Standardowo 8-bitowe literały napisowe definiuje się umieszczając tekst w apostrofach ('), cudzysłowach (") lub potrójnych znakach cytowania (' ' ' lub"""). Na końcu napisu musi zawsze występować ten sam rodzaj cytowania co na początku. Odwrotny ukośnik (\) jest znakiem ucieczki, który pozwala zapobiec interpretaqi różnych znaków specjalnych, takich jak znak przejścia do nowej linii, odwrotny ukóśnik, znaki cytowania czy znaki niedrukowalne. W tabeli 2.1 podane są wszystkie rozpoznawane kody ucieczki. Wszystkie pozostałe nie są akceptowane i pozostają w napisie bez zmian, łącznie z poprze- dzającym je odwrotnym ukośnikiem. Napisy mogą ponadto zawierać osadzone w nich puste bajty, a także dane binarne. Napis utworzony przy użyciu trzech znaków cytowania może ciągnąć się przez wiele linii, obejmując nie poprzedzone znakiem ucieczki znaki przejścia do nowej linii oraz cytowania. Tabela 2.1 Standardowe kody ucieczki Znak \ W V Opis Kontynuaqa linii Odwrotny ukośnik Apostrof Dokończenie tabeli na następnej stronie

18 Python Dokończenie tabeli z poprzednie) strony Znak Opis \" Cudzysłów \a Dzwonek \b Backspace \e Esc \0 Puste \n Przejście do nowej linii \v Tabulaqa pionowa \t Tabulacja pozioma \r Powrót karetki \f Przejście do nowej strony \000 Wartość ósemkowa (\000do\377) \xhh Wartość szesnastkowa (\x00do\xff) \uhhh Wartość znaku w Unicode (tylko napisy Unicode)

Napisy Unicode są używane do reprezentowania wielobajtowych znaków mię- dzynarodowych i umożliwiają korzystanie z 65 536 różnych znaków jednocze- śnie. Literały napisowe Unicode definiuje się poprzedzając zwykły literał napisowy małą lub dużą literą „u", na przykład u " wi ta j ". W napisach Unicode każdy znak jest reprezentowany wewnętrznie przez 16-bitową wartość całkowitą. Ze względu na notację wartość ta jest zapisywana jako U+XXXX, gdzie XXXX to czterocyfrowa liczba szesnastkowa. (Uwaga: Podana notacja jest tylko konwen- cją używaną przy opisie znaków Unicode i nie należy do składni Pythona). Na przykład U+0 0 6 8 jest znakiem Unicode reprezentującym literę h w zestawie zna- ków Latin-1. Podczas definiowania literałów znakowych Unicode zwykłe znaki i kody ucieczki są mapowane bezpośrednio na liczby porządkowe Unicode z prze- działu [U+0000, U+OOFF]. Na przykład napis "witaj \n" jest mapowany na sekwenq'e wartości ASCII 0x77, 0x69, 0x74, 0x61, 0x6a, 0x0a, natomiast napis u"witaj\n" jest mapowany na sekwencję wartości Unicode U+0077, U+0069, U+0074, U+0061, U+006A i U+000A. Znaki pomocnicze Unicode są definiowane przy użyciu sekwenqi ucieczki \uXXXX. Taka sekwenqa może pojawiać się tylko wewnątrz literałów napisowych Unicode i musi zawsze zawierać czterocyfrowa wartość szesnastkowa. Na przykład: s = U"\u0077\u0069\u0074\u0061\u006a\u000a" W starszych wersjach Pythona znaki Unicode można było definiować przy uży- ciu sekwencji ucieczki \ xXXXX. Chociaż taki zapis nadal jest dozwolony, zamiast niego powinno się używać sekwencji \uXXXX. Znaki Unicode z przedziału [U+0000, U+01FF] można również definiować za pomocą ósemkowych sekwencji ucieczki \000. Literały napisowe Unicode nie powinny być definiowane przy użyciu sekwencji surowych bajtów odpowiadających wielobajtowemu kodowaniu danych Unico- Rozdzial 2: Konwencje leksykalne i składnia 19 de, takiemu jak UTF-8 czy UTF-16. Na przykład zapisanie zakodowanego w UTF-8 surowego napisu w postaci u'M\303\27411erf da siedmioznakową sekwenqe Unicode U+004D, U+00C3, U+00BC, U+006C, U+006C, U+0065, U+0072, co prawdopodobnie nie będzie tym, o co ci chodziło. Bierze się to stąd, że w UTF-8 wielobajtowa sekwencja \303\274 powinna być potraktowana jako reprezentacja U+00FC, a nie U+00C3, U+OOBC. Więcej szczegółów o kodowaniu znaków Unicode znajdziesz w rozdziale 3 „Typy i obiekty", w rozdziale 4 „Ope- ratory i wyrażenia" oraz w rozdziale 9 „Wejście i wyjście". Napisy można również poprzedzać dużą lub małą literą „r", na przykład r' \n\"\ Takie napisy zwane są surowymi napisami, gdyż wszystkie wystę-

pujące w nich odwrotne ukośniki nie są interpretowane - innymi słowy zawie- rają cały oryginalny tekst, łącznie z ukośnikami. Surowe napisy nie mogą się koń- czyć pojedynczym odwrotnym ukośnikiem, na przykład r"\". W przypadku definiowania surowych napisów Unicode z użyciem przedrostka ur lub UR sekwencje ucieczki \uXXXX nadal są interpretowane jako znaki Unicode, o ile liczba poprzedzających je odwrotnych ukośników (\) jest nieparzysta. Na przykład ur"\ul234" definiuje surowy napis Unicode ze znakiem U+1234, natomiast ur"\\ul234" definiuje siedmioznakowy napis Unicode, którego dwa pierwsze znaki to odwrotne ukośniki, a pozostałych pięć to literał " u 12 3 4 ". Trzeba również pamiętać, że w momencie definiowania surowych literałów napisowych Unicode przedrostek „r" musi występować po przedrostku „u", jak to miało miejsce w pokazanych przykładach. Sąsiadujące ze sobą napisy (oddzielone białymi znakami lub znakiem kontynuacji linii), takie jak " wi ta j " ' świecie' są konkatenowane i tworzą jeden spójny napis: "witajświecie". Konkatenowanie obejmuje dowolne kombinaqe napisów: zwykłe, surowe i Unicode. Jeśli jednak wśród konkatenowanych napisów występuje Unicode, to wynikiem tej operaqi będzie również napis Unicode. W efekcie zapis "witaj" u"świecie" daje to samo co zapis u"witaj" + u "świecie". Ponadto na skutek pewnych subtelnych aspektów implementaqi znaków Unicode zapis " s 1" u" s2 " może dawać nieco inny rezultat, niż zapis u " s 1 s 2 ". Szczegółowe wyjaśnienie tego procesu znajdziesz dalej w rozdziale 4 oraz dodatku A („Biblioteka Pythona"). Po uruchomieniu Pythona z opcją -U w linii polecenia wszystkie literały napisowe są interpretowane jako napisy Unicode. Wartości umieszczone w nawiasach kwadratowych [...], okrągłych (...) i klamrowych {...} są traktowane odpowiednio jako listy, tupie i słowniki, co ilustruje kolejny przykład: a = [ 1, 3.4, 'hello 1 b = ( 10, 20, 30 ) c = { 'a': 3, 'b':42 } # Lista # Tupla # Słownik

20 Python

Operatory, ograniczniki i symbole specjalne Oto lista leksemów reprezentujących operatory rozpoznawane przez Pythona: * * * * — »=

o Kolejna porcja leksemów to ograniczniki wyrażeń, list, słowników i różnych fragmentów instrukcji: ( ) []{},:.* = ; Na przykład znak równości (=) służy do oddzielania nazwy zmiennej od przypi- sywanej jej wartości, a przecinek (,) do oddzielania kolejnych argumentów funkcji, elementów listy, tupli i tak dalej. Kropka (.) wykorzystywana jest zarówno w liczbach zmiennoprzecinkowych, jak i wielokropkach (...) używanych w rozszerzonych operacjach wycinających. Python wykorzystuje także kilka dodatkowych symboli specjalnych: # \ Natomiast znaki @, $ i ? mogą się pojawiać w programie tylko wewnątrz zacyto- wanych literałów znakowych.

Napisy dokumentacyjne Jeśli pierwszą instrukcją w definicji modułu, klasy lub funkcji jest napis, zostanie on potraktowany jako napis dokumentacyjny zawierającego go obiektu. Oto przykład: def silnia (n): "Jest to funkcja obliczaj ąca silni ę" if (n <= 1): return 1 else: return n*silnia(n-1) Narzędzia do przeglądania kodu i generowania dokumentacji korzystają czasem z tego typu napisów dokumentacyjnych. Aby odczytać taki napis, można użyć atrybutu__doc__obiektu, jak to jest pokazane poniżej: >» print silnia.__doc__ Jest to funkcja obliczaj ąca silni ę Wcięcie napisu dokumentacyjnego musi być identyczne jak w przypadku wszystkich pozostałych instrukcji w definicji. Ponadto napisy umieszczone w sąsiadujących ze sobą, ale oddzielnych liniach, nie są konkatenowane i nie tworzą jednego napisu dokumentacyjnego. Rozdział 3

Typy i obiekty

Wszystkie dane przechowywane w programach napisanych w Pythonie korzy- stają z koncepcji obiektu. Obiektami są nawet podstawowe typy danych, takie jak liczby, napisy, listy i słowniki. Można też samemu definiować obiekty w postaci klas lub typów rozszerzonych. W tym rozdziale omówimy model obiektowy Py- thona i dokonamy przeglądu wszystkich wbudowanych typów danych tego ję- zyka. W następnym zaś rozdziale zajmiemy się operatorami i wyrażeniami.

Terminologia Każda porcja danych zapisanych w programie jest obiektem. Z kolei każdy obiekt ma swoją tożsamość, typ i wartość. Kiedy piszesz na przykład a = 42, tworzysz obiekt typu całkowitego o wartości 42. Tożsamość obiektu może być traktowana jako wskaźnik do jego miejsca w pa- mięci. W podanym przykładzie lokalizaqe obiektu w pamięci wskazuje nazwa a. Typ obiektu (sam będący speqalnym rodzajem obiektu) opisuje wewnętrzną re- prezentację obiektu, jak również dozwolone dla niego metody i operacje. Po utworzeniu obiektu konkretnego typu jest on czasem nazywany instancją danego typu

(nie należy jednak nigdy mylić instancji typu z instancją klasy zdefiniowanej przez użytkownika). Gdy obiekt już istnieje, nie można zmienić jego tożsamości ani typu. Jeśli można zmienić wartość obiektu, mówi się o nim, że jest to obiekt zmienny. W przeciwnym wypadku mówi się, że jest to obiekt stały. Obiekty zawierające odniesienia do innych obiektów są nazywane kontenerami lub kolekcjami. Wiele obiektów nie tylko przechowuje dane, lecz również definiuje liczne atrybuty tych danych i metody. Atrybut to właściwość lub wartość skojarzona z obiektem. Z kolei metoda to funkcja, której wywołanie powoduje wykonanie pewnej operacji na obiekcie. Dostęp do atrybutów i metod odbywa się przy użyciu operatora kropki (.), jak to jest pokazane w kolejnym przykładzie: a = 3 + 4j r = a.real b = [1, 2, 3] b.append(7) # Utworzenie liczby zespolonej # Pobranie cz ęści rzeczywistej (atrybut) # Utworzenie listy # Dodanie nowego elementu za pomoc ą metody append

22 Python

Tożsamo ść i typ obiektu Wbudowana funkqa id () podaje tożsamość w postaci liczby całkowitej. Liczba ta odpowiada zwykle lokalizacji obiektu w pamięci, chociaż zależy to od implementacji. Operator i s służy do porównywania tożsamości dwóch obiektów. Na- tomiast funkcja type () zwraca typ obiektu. Oto przykład: # Porównanie dwóch obiektów def porównaj(a,b): print 'To żsamość a: ', id(a) print 'To żsamość b: ', id(b) if a is b: print 'a i b to ten sam obiekt' if a == b: print 'a i b maj ą t ę sam ą warto ść' if type(a) is type(b): print 'a i b s ą tego samego typu' Typ obiektu sam w sobie jest obiektem. Obiekt ten ma szczególną definicję i jest zawsze taki sam dla każdej instancji danego typu. W rezultacie można porówny- wać typy danych przy użyciu operatora is. Standardowy moduł types zawiera obiekty typów dla wszystkich wbudowanych typów danych i pozwala przepro- wadzać ich kontrolę. Na przykład: import types if type(s) is types.ListType: print 'To jest lista' else: print 'To nie jest lista' Porównując ze sobą typy obiektów, wśród których występują klasy zdefiniowane przez użytkownika, lepiej jest czasem użyć funkcji isinstanceO opisanej w rozdziale 7, „Klasy i programowanie obiektowe". Funkcja isinstance(s, C) prawidłowo wykrywa instancje s klas pochodnych od C, jak również instancje samej klasy C.

Zliczanie odniesie ń i odzyskiwanie pami ęci Wszystkie obiekty mają zliczane odniesienia. Liczba odniesień do obiektu rośnie za każdym razem, gdy zostaje on przypisany do nowej nazwy lub umieszczony w kontenerze, takim jak lista, tupla czy słownik, jak to jest pokazane niżej: a = 3.4 b = a c - [] c.append(b) # Utworzenie obiektu '3.4' # Zwi ększenie liczby odniesie ń do '3.4' '3.4 # Zwi ększenie liczby odniesie ń do W przykładzie tym tworzony jest pojedynczy obiekt zawierający wartość 3.4. Zmienna a to po prostu nazwa odnosząca się do nowo utworzonego obiektu. W momencie przypisania a do b zmienna b staje się nową nazwą tego samego obiektu i wzrasta liczba odniesień do tego obiektu. Podobnie liczba ta wzrasta z chwilą umieszczenia b na liście. W omawianym przykładzie powstaje tylko jeden obiekt zawierający wartość 3.4. Wszystkie operacje z wyjątkiem pierwszej ograniczają się tylko do tworzenia nowych odniesień do tego obiektu. Rozdział 3: Typy i obiekty 23 Liczba odniesień do obiektu zmniejsza się wskutek użycia instrukcji del lub w momencie wyjścia odniesienia poza zasięg (lub zmiany przypisania). Oto przykład: del a # Zmniejszenie liczby odniesie ń do 3.4 b = 7.8 # Zmniejszenie liczby odniesie ń do 3.4 c[0]=2.0 # Zmniejszenie liczby odniesie ń do 3.4 Po zmniejszeniu do zera liczby odniesień do obiektu następuje odzyskanie zajmowanej przez niego pamięci. Jednak w niektórych przypadkach może istnieć

cykliczna zależność między kolekcją nieużywanych już obiektów. Na przykład: a = { b = { a['b'] b['a'] del a del b = b # a zawiera odniesienie do b = a # b zawiera odniesienie do a W podanym fragmencie instrukcja del zmniejsza liczbę odniesień do a i b oraz usuwa nazwy używane przez odniesienia do tych obiektów. Ponieważ jednak każdy z tych obiektów zawiera odwołanie do drugiego, liczba odwołań nie scho- dzi do zera i obiekty muszą pozostać alokowane. Aby rozwiązać ten problem, interpreter wykonuje okresowo sprawdzanie pętli i w momencie wykrycia wśród nich niedostępnych obiektów usuwa je. Algorytm szukania pętli można uspraw- nić i kontrolować za pomocą funkcji z modułu gc opisanego w dodatku A, „Bi- blioteka Pythona".

Odniesienia i kopie Gdy program wykonuje instrukqe przypisania typu a = b, powstaje nowe odniesienie do b. W przypadku stałych obiektów, takich jak liczby i napisy, tego rodzaju przypisanie tworzy w rzeczywistości kopię b. Całkiem inaczej natomiast zacho- wują się obiekty zmienne, takie jak listy i słowniki. Weźmy następujący przykład: b = [1,2,3,4] a = b a[2] = -100 print b # a jest odniesieniem do b # Zmiana elementu w 'a' # Daje w wyniku '[1, 2, -100, 4] Ponieważ w tym przykładzie a i b odnoszą się do tego samego obiektu, zmiana dokonana w jednej z tych zmiennych jest od razu widoczna w drugiej. Aby tego uniknąć, trzeba utworzyć kopię obiektu zamiast nowego odniesienia. Są dwa typy operacji kopiowania, które można stosować do kontenerów obiek- tów takich jak listy i słowniki: płytkie kopiowanie i głębokie kopiowanie. Płytkie kopiowanie tworzy nowy obiekt, ale umieszcza w nim odniesienia do elementów zawartych w oryginalnym obiekcie. Oto przykład: 1, 2, [3,4] ] Utworzenie płytkiej kopii b. b = [ a = b[:] a.append(100) print b a[2] [0] = -100 print b # # Dodanie elementu do a. # Daje w wyniku '[1,2, [3,4]]'. # Modyfikacja elementu a. # Daje w wyniku '[1,2, [-100,4] b bez zmian,

24 Python W tym przypadku a i b są co prawda różnymi obiektami listowymi, ale zawierają wspólne elementy. W efekcie zmiana jednego z elementów a powoduje jednocze- śnie zmianę odpowiedniego elementu b, jak to zostało pokazane w przykładzie. Głębokie kopiowanie tworzy najpierw nowy obiekt, a następnie rekurencyjnie kopiuje do niego całą zawartość obiektu źródłowego. Nie istnieje żadna wbudowana funkcja do tworzenia głębokich kopii obiektów. Można jednak korzystać z funkcji copy. deepcopy () z biblioteki standardowej, której działanie demon- struje kolejny przykład: import copy b = [1, 2, [3, 4] ] a = copy.deepcopy(b)

Typy wbudowane Interpreter Pythona ma wbudowanych ponad 20 typów danych pogrupowanych w kilka głównych kategorii wymienionych w tabeli 3.1. Część kategorii obejmuje znane typy obiektów, takie jak liczby i sekwencje. Inne z kolei są wykorzystywane podczas wykonywania programów i nie są zbyt przydatne dla większości pro- gramistów. Podstawowe wbudowane typy obiektów zostaną omówione w kolejnych podrozdziałach. Tabela 3.1 Typy wbudowane w Pythona Kategoria typu Nazwa typu Opis Nic NoneType Obiekt pusty Liczba IntType Liczba całkowita LongType Liczba całkowita dowolnej długości FloatType Liczba zmiennoprzecinkowa ComplexType Liczba zespolona Sekwenqa StringType Napis znakowy UnicodeType Napis znakowy Unicode ListType Lista TupleType Tupla XRangeType Zwracany przez xrange () BufferType Bufor; zwracany przez buf f er () Mapujący DictType Słownik Wywoływalny BuiltinFunctionType Funkcje wbudowane BuiltinMethodType Metody wbudowane ClassType Klasy FunctionType Funkqe zdefiniowane przez użytkownika InstanceType Instanqa klasy MethodType Związana metoda klasy UnboundMethodType Niezwiązana metoda klasy Moduł ModuleType Moduł Klasa ClassType Definiqa klasy Rozdział 3: Typy i obiekty 25 Kategoria typu Nazwa typu Opis Instanqa klasy InstanceType Instancja klasy Plik FileType Plik Wewnętrzny CodeType Skompilowany kod bajtowy FrameType Ramka wykonania TracebackType Ślad wyjątku na stosie SliceType Generowany przez rozszerzone

wycinki

EllipsisType Używany w rozszerzonych wycinkach

Uwaga: Typy ClassType i InstanceType dwukrotnie pojawiają się w tabeli 3.1, gdyż w pewnych szczególnych sytuacjach zarówno klasy, jak i instancje mogą być wywoływane. Typ None Typ None oznacza pusty obiekt. Python udostępnia tylko jeden pusty obiekt, zapisywany w programie jako None. Obiekt ten jest zwracany przez funkcje, które nie zwracają jawnie żadnej wartości. Obiektu None używa się często jako domy- ślnej wartości argumentu nieobowiązkowego, tak aby funkqa mogła wykryć, czy w jej wywołaniu została podana jakakolwiek wartość dla tego argumentu. Obiekt None nie ma żadnych atrybutów, a w wyrażeniach boolowskich daje wartość fałsz. Typy numeryczne Python wykorzystuje cztery typy numeryczne: liczby całkowite, długie liczby całkowite, liczby zmiennoprzecinkowe i liczby zespolone. Wszystkie obiekty numeryczne są stałe i mają określony znak. Typ całkowity reprezentuje liczby bez części ułamkowej z przedziału od -2147483648 do 2147483647 (w niektórych komputerach zakres ten może być wię- kszy). Wewnętrznie liczby całkowite są zapisywane na 32 lub więcej bitach w kodzie binarnym uzupełnieniowym z uzupełnieniem do 2. Jeśli wynik jakiegoś działania przekracza dozwolony zakres wartości, powoduje to zgłoszenie wyjątku Over f lowError. Długie liczby całkowite to również liczby pozbawio- ne części ułamkowej, ale o nieograniczonym zakresie (w praktyce obowiązuje jedynie limit wynikający z wielkości dostępnej pamięci). Liczby zmiennoprzecinkowe są reprezentowane według obowiązującego w danym komputerze schematu podwójnej precyzji (64-bitowego). Zazwyczaj jest nim IEEE 754, który zapewnia około 17 dokładnych cyfr oraz wykładnik z prze- działu -308 do 308. Jest to to samo, co typ double w języku C. Python nie udo- stępnia 32-bitowych liczb zmiennoprzecinkowych (pojedynczej precyzji). Jeśli zajętość pamięci i precyzja liczb mają znaczenie w twoim programie, rozważ uży- cie wersji Numerical Python (http: //numpy. sourcef orge . net). Liczby zespolone są reprezentowane w postaci par liczb zmiennoprzecinkowych. Części rzeczywista i urojona liczby zespolonej z są dostępne jako z . real i z. imag.

26 Python Typy sekwencyjne Sekwencje reprezentują uporządkowane zbiory obiektów poindeksowanych przy użyciu nieujemnych liczb całkowitych i obejmują napisy, napisy Unicode, listy, tupie, obiekty xrange oraz bufory. Napisy i bufory są sekwencjami znaków, obiekty xrange sekwenqami liczb całkowitych, a listy i tupie - sekwencjami dowolnych obiektów Pythona. Napisy, napisy Unicode i tupie są niezmienne, natomiast listy dopuszczają wstawianie, usuwanie i zamianę elementów. Bufory zo- staną opisane w dalszej części tego podrozdziału. W tabeli 3.2 wymienione są operatory i metody, które mają zastosowanie do wszystkich typów sekwencyjnych. Do wyboru elementu i sekwencji s służy operator indeksowania s[i], natomiast do wyboru podsekwencji - operator wycinania s[i:j]. (Oba te działania są opisane w rozdziale 4). Aby poznać długość dowolnej sekwencji, wystarczy użyć wbudowanej funkcji len (s). Minimalną i maksymalną wartość w sekwencji zwracają odpowiednio wbudowane funkcje min (s) i max (s). Funkcje te mają jednak zastosowanie tylko do tych sekwencji, których elementy można uporządkować (zazwyczaj są to liczby i napisy). Tabela 3.3 przedstawia dodatkowe operatory, których można używać w odnie- sieniu do zmiennych sekwencji, takich jak listy. Tabela 3.2 Operacje i metody mające zastosowanie do wszystkich sekwencji Zapis Działanie s[i] Zwraca i-ty element sekwencji s[i:j] Zwraca wycinek len(s) Liczba elementów w s min(5) Wartość minimalna w s max(s) Wartość maksymalna w s

Tabela 3.3 Operatory mające zastosowanie do sekwencji zmiennych Zapis Działanie s[i] = v Przypisanie wartości do elementu s[i:j) = t Przypisanie wartości do wycinka del s[i] Usunięcie elementu del s[i:j] Usunięcie wycinka Ponadto w przypadku list można stosować metody wymienione w tabeli 3.4. Wbudowana funkcja list (s) konwertuje dowolnego typu sekwencję na listę. Jeśli s jest już listą, funkqa konstruuje nową listę będącą płytką kopią s. Metoda s. append (x) dodaje nowy element x na końcu listy. Metoda s. index (x) szuka na liście pierwszego wystąpienia x. Jeśli nie ma takiego, zgłaszany jest wyjątek Value Error. Z kolei metoda s. remove (x) usuwa z listy pierwsze wystąpie- nie x. Metoda s. extend (t) wydłuża listę przez dodanie do niej elementów se- Pozdział 3: Typy i obiekty 27 kwencji t. Metoda s. sort () sortuje elementy listy. Jej nieobowiązkowym argumentem może być funkcja porównująca. Funkcja ta powinna przyjmować dwa argumenty i zwracać wartość ujemną, dodatnią albo zero w zależności od tego, czy pierwszy argument jest odpowiednio mniejszy od drugiego, większy od niego lub równy mu. Metoda s. reverse () odwraca kolejność elementów na liś- cie. Metody sort () i reverse () działają bezpośrednio na elementach listy („w miejscu") i zwracają obiekt None. Tabela 3.4 Metody listy Metoda Opis list(s) Konwertuje sekwenqe s na listę s.append(x) Dodaje nowy element x na końcu s s.extend(t) Dodaje nową listę t na końcu s

s.count(x) Zlicza wystąpienia x w s s.index(x) Zwraca najmniejszy indeks i, gdzie s[i] == x s.insert(i,x) Umieszcza x w elemencie 0 indeksie i s.pop([i]) Zwraca i-ty element i usuwa go z listy. Bez podania i

zwracany jest ostatni element s. remove (x) Odnajduje x i usuwa go z listy s s. reverse () Odwraca w miejscu kolejność elementów s s. sort ( [ cmpfunc] ) Sortuje w miejscu elementy s. cmpfunc to funkqa

porównująca Python udostępnia dwa rodzaje obiektów reprezentujących napisy. Napisy standardowe są sekwencjami bajtów zawierających 8-bitowe dane. Wśród nich mogą występować również dane binarne, a także puste bajty (null). Drugi rodzaj napi- sów to napisy Unicode, będące sekwencjami 16-bitowych znaków zakodowanych w formacie znanym jako UCS-2. Pozwala to korzystać z 65 536 różnych zna- ków jednocześnie. Chociaż najnowszy standard Unicode dopuszcza 1 milion róż- nych znaków jednocześnie, te dodatkowe wartości nie są aktualnie obsługiwane przez Pythona. Z tego względu trzeba je kodować w postaci specjalnych dwu- znakowych (4-bajtowych) sekwencji zwanych parami zastępczymi, których inter- pretaqa zależy od aplikaqi. Python nie sprawdza zgodności danych z Unicode ani nie kontroluje sposobu użycia par zastępczych. Zarówno napisy standardowe, jak i Unicode pozwalają stosować wszystkie metody wymienione w tabeli 3.5. Chociaż są to metody działające na instancjach na- pisów, żadna z nich nie modyfikuje w rzeczywistości dostarczanych im danych. W efekcie metody takie jak s.capi tal i ze (), s.center () czy s.expandtabs () zwracają zawsze nowy napis i nie zmieniają zawartości s. Metody sprawdzające napisy, takie jak s.isalnum() lub s.isupper() zwracają prawdę lub fałsz, w zależności od tego, czy wszystkie znaki w napisie spełniają podany warunek. Ponadto wszystkie te metody zwracają fałsz w sytuaqi, gdy długość napisu s wynosi zero. Metody s. find (), s. index (), s. rf ind () i s. rindex () są używane do szukania podciągów w s. Każda z tych funkcji zwraca liczbę całkowitą wskazującą indeks, od którego zaczyna się podciąg w s.

28 Python Ponadto, jeśli dany podciąg nie zostanie znaleziony, metoda find() zwraca wartość -1, a metoda index () zgłasza wyjątek ValueError. Wiele metod obiektów napisowych ma nieobowiązkowe parametry start i end, umożli- wiające zdefiniowanie początku i końca wycinka w s. Metoda s. translate () służy do zastępowania znaków w napisie i jest opisana w dodatku A przy okazji omawiania modułu string. Metoda s. encode () jest używana do kodowania napisów. Wśród jej danych wejściowych podaje się nazwę sposobu kodowania, taką jak 'ascii', 'utf-8' czy ' utf -16 '. Metoda ta służy najczęściej do konwertowania napisów Unicode na format odpowiedni dla operacji wejś- cia/wyjścia i jest opisana w rozdziale 9, zatytułowanym „Wejście i wyjście". Bar- dziej szczegółowe informacje o metodach napisowych można znaleźć w doku- mentaqi modułu string w dodatku A. Tabela 3.5 Metody napisowe

1 Metoda Opis s.capitalize () Zmienia pierwszą literę s na dużą.

s,center(width) Wyśrodkowuje napis w polu o długości wi dth.

s. count (sub [,start [, end] ] ) Zlicza wystąpienia podciągu sub. s.encode([encoding [,errors]]) Zwraca zakodowaną wersję napisu. s.endswith Sprawdza obecność podciągu suffix na (suffix [,start [,end]]) końcu napisu. s.expandtabs([tabsize]) Zamienia znaki tabulaqi na spaqe. s.find(sub [, start [,end]]) Znajduje pierwsze wystąpienie podciągu sub w napisie. s. index (sub [, start [,end]]) Znajduje pierwsze wystąpienie podciągu sub w napisie lub zgłasza wyjątek. s.isalnum() Sprawdza, czy wszystkie znaki w napisie są znakami alfanumerycznymi. s.isalpha () Sprawdza, czy wszystkie znaki w napisie są znakami alfabetu. s.isdigit () Sprawdza, czy wszystkie znaki w napisie

są cyframi. s.islower () Sprawdza, czy wszystkie litery w napisie

są małe. s.isspace () Sprawdza, czy wszystkie znaki w napisie

są białymi znakami. s.istitle () Sprawdza, czy wielkość liter w napisie

pasuje do tytułu (czy każdy wyraz zaczyna się

dużą literą).

s. isupper () Sprawdza, czy wszystkie litery w napisie są duże.

s. join (t) Łączy wszystkie napisy na liście t używając

s jako separatora. s.ljust(width) Wyrównuje s do lewej w napisie o długości width. Rozdział 3: Typy i obiekty 29 Metoda Opis s. lower () Zwraca s z wszystkimi literami

zamienionymi na małe. s.lstripO Usuwa początkowe białe znaki. s.replace(old, new [,maxreplace]) Zastępuje stary podciąg nowym. s.rfind(sujb [, start [,end]]) Znajduje ostatnie wystąpienie podciągu sub. s.rindex(sub [, start [,end]]) Znajduje ostatnie wystąpienie podciągu sub lub zgłasza wyjątek. s. rjust (width) Wyrównuje s do prawej w napisie o długości width. s.rstrip () Usuwa końcowe białe znaki z napisu. s. split([sep [,maxsplit]]) Dzieli napis używając sep jako separatora. maxspli t określa maksymalną liczbę podziałów do wykonania. s.splitlines([keepends]) Dzieli napis na listę wierszy. Jeśli keepends wynosi 1, końcowe znaki nowej linii zostają zachowane. s.startswith Sprawdza, czy napis zaczyna się od

podciągu (prefix [,start [,end]]) prefix. s.striper Usuwa początkowe i końcowe białe znaki. s.swapcase () Zwraca napis z małymi literami zamienionymi na duże i odwrotnie. s.title () Zwraca napis z wielkością liter jak w

tytułach. s.translate(table [, deletechars]) Tłumaczy napis używając znakowej tablicy

translacyjnej. s.upper () Zwraca s z wszystkimi literami

zamienionymi na duże. Wbudowana funkcja range ([i,] j [, stride] ) konstruuje listę zawierającą kolejne liczby całkowite k z przedziału od i do j (i <= k <= j). Parametry i oraz stride (krok) są nieobowiązkowe. Ich wartości domyślne to odpowiednio Oil. Funkcja wbudowana xrange ( [i, ] j [, stride] ) wykonuje podobne działanie, tyle że zwraca stałą sekwencję typu XRangeType. Zamiast przecho- wywać wszystkie wartości z podanego przedziału na liście, sekwencja ta wylicza po prostu każdą z nich w momencie próby dostępu. W efekcie wymaga to znacznie mniej pamięci - zwłaszcza w przypadku dużych sekwencji liczb całkowitych. XRangeType udostępnia tylko jedną metodę, s. tolist (), która zamienia ten obiekt na listę. Obiekty typu buforowego są zazwyczaj używane do zapewnienia sekwencyj- nego interfejsu dla obszaru pamięci, w którym każdy bajt jest traktowany jako 8-bitowy znak. Chociaż nie istnieje speqalna składnia przeznaczona do definiowania obiektów typu buforowego, można je tworzyć za pomocą wbudowanej funkcji buff er (obj [, offset [, size] ] ). Obiekty typu buforowego korzystają zazwyczaj z tej samej pamięci, co kryjący się pod nimi obiekt obj. Z tego powodu można ich czasem używać jako bardziej efektywnego mechanizmu pobierania wycinków napisów lub innych danych tworzących ciągi bajtów. Ponadto bufory

30 Python mogą być czasem używane do korzystania z surowych danych reprezentujących zawartość innych typów Pythona, takich jak tablice czy napisy Unicode. Bufory mogą być stałe lub zmienne, w zależności od rodzaju obiektu obj. Typy mapuj ące Obiekt mapujący reprezentuje dowolną kolekcję obiektów poindeksowanych przy użyciu innej kolekqi o niemal dowolnych wartościach kluczy. W odróżnieniu od sekwencji obiekt mapujący nie jest uporządkowany i może być indeksowany za pomocą liczb, napisów i innych obiektów. Obiekty mapujące mogą być zmieniane. Słowniki są jedynym wbudowanym typem mapującym w Pythonie i odpowiadają tablicom haszującym lub asocjacyjnym w innych językach. Kluczami słowników mogą być dowolne stałe obiekty: napisy, liczby, tupie i tak dalej. Listy, słowniki lub tupie zawierające zmienne obiekty nie mogą być wykorzystywane jako klucze. (Typ słownikowy wymaga, aby wartości klucza pozostawały nie zmienione). Aby wybrać element obiektu mapującego, trzeba użyć operatora indeksowania m[k], gdzie k jest wartością klucza. Jeśli klucz nie zostanie znaleziony, nastąpi zgłoszenie wyjątku KeyError. Funkcja len (m) zwraca liczbę elementów zawartych w obiekcie mapującym. Wszystkie dostępne metody i operacje są wymienione w tabeli 3.6 Tabela 3.6 Metody i operacje dozwolone dla typów mapujących Zapis Opis len (m) Zwraca liczbę elementów w m. mik] Zwraca element m o kluczu k. m[k] = x Ustawia m[k] na x. del m[k] Usuwam[k] z/n. m.clear () Usuwa wszystkie elementy z m. m.copy () Zwraca kopię m. /n.has_key (k) Zwraca 1, jeśli w m występuje klucz ic,aw przeciwnym razie 0. m.items() Zwraca listę par {klucz, wartość). m.keys () Zwraca listę wartości kluczy. m. update(b) Dodaje wszystkie obiekty ze słownika b do m. m.values() Zwraca listę wszystkich wartości w m. m.qet(k [,v]) Zwraca element m[k], jeśli taki występuje, a w przeciwnym wypadku V. m.setdefault Zwraca element m[k], jeśli taki występuje, a w przeciwnym wy- (* [, v]) padku v i ustawia m [ k} = v. ;n.popitein() Usuwa losową parę {klucz, wartość) z m i zwraca ją w postaci tupli.

Metoda m. clear () usuwa wszystkie elementy z m. Metoda m. copy () tworzy płytką kopię elementów zawartych w obiekcie mapującym i umieszcza je w nowym obiekcie mapującym. Metoda m. items () zwraca listę składającą się z par {klucz, wartość). Metoda m. keys () zwraca listę wszystkich wartości klu- Pozdział 3: Typy i obiekty cza, a metoda m. values () listę wszystkich obiektów w m. Metoda m. update (b) aktualizuje bieżący obiekt mapujący, wstawiając do niego wszystkie pary {klucz, wartość) znalezione w obiekcie mapującym b. Metoda m.get {k, [,v]) pobiera obiekt o kluczu k, a jeśli taki nie istnieje i jest podana wartość v, zwraca tę wartość. Metoda m. setdefault (Jfc, [,v]) działa podobnie jak m. get (), z tą różnicą, że zwracając wartość v ustawia jednocześnie m[k] = v. W przypadku braku v zwracany jest obiekt None. Ostatnia metoda w tabeli, m. popi tem (), jest używana do iteracyjnego usuwania zawartości słownika. Typy wywoływalne Typy wywoływalne reprezentują obiekty, które wspomagają wywoływanie funkq'i. Istnieje kilka rodzajów tego typu obiektów, w tym funkcje zdefiniowane

przez użytkownika, funkcje wbudowane i metody związane z klasami. Funkcje zdefiniowane przez użytkownika są obiektami wywoływalnymi tworzony- mi na poziomie modułu przy użyciu instrukcji def lub operatora lambda. (Funkcje zdefiniowane wewnątrz klasy nazywane są metodami i będą opisane w dalszej części). Funkcje zachowują się podobnie jak wszystkie inne obiekty Py- thona, co oznacza, że można przypisywać je do zmiennych oraz umieszczać w listach, tuplach i słownikach, jak to jest pokazane w kolejnym przykładzie: def CJSS ( X, y) : print '%s + %s daje %s' % (str(x), str(y), str(x+y) ) # Przypisanie do nowej zmiennej byleco = co ś byleco(3,4) # Wywołanie funkcji # Wstawienie do kontenera d = { } d['sprz ężenie'] = co ś d['sprz ężenie'] (3,4) # Wywołanie 'co ś' 'co ś' zdefiniowanej powy żej Funkcja zdefiniowana przez użytkownika f ma następujące atrybuty: Atrybutfy) Opis f. doc lub f. f unc doc Napis dokumentacyjny f.__name__lub f. func name Nazwa funkqi f.__diet__lub f. func diet Słownik zawierający atrybuty funkcji f. func code Skompilowany kod bajtowy f. func_defaults Tupla zawierająca domyślne argumenty f.func_globals Słownik definiujący globalną przestrzeń nazw f. func__closure Tupla zawierająca dane związane z zagnieżdżonymi zasięgami Metody to funkqe działające tylko na instancjach obiektu. Metody są zazwyczaj definiowane wewnątrz definicji klasy, jak to jest pokazane w listingu 3.1.

32 Python Listing 3.1 Definiowanie metody # Kolejka obiektów szeregowanych według priorytetu class KolejkaPriorytetów: def__init__(self): self.elementy = [ ] # Lista (priorytet, element) def wstaw(self,priorytet,element): for i in range(len(self.elementy)): if self.elementy[i][0] > priorytet: self.elementy.insert(i,(priorytet,element)) break else : self.elementy.append((priorytet,element)) def usu ń (self) : try: return self.elementy.pop(0)[1] except IndexError: raise RuntimeError, 'Kolejka jest pusta' Obiekt typu metoda niezwiązana to metoda, która nie została związana z żadną kon- kretną instancją obiektu. Metody zawarte w definicji klasy są niezwiązane, dopóki nie zostaną dołączone do jakiegoś obiektu. Na przykład: m = KolejkaPriorytetów.insert # Metoda niezwi ązana Aby wywołać metodę niezwiązana, musisz jako pierwszy argument podać in- stancję jakiegoś obiektu: pq = KolejkaPriorytetów() m = KolejkaPriorytetów.wstaw m(pq,5,"Python") # Wywołanie pq.wstaw(5,"Python") Obiekt typu metoda związana to funkqa, która została związana z konkretną instan- cją obiektu. Na przykład: pq = KolejkaPriorytetów() n = pq.wstaw # Nowa instancja KolejkiPriorytetów # n jest metod ą zwi ązan ą z pq Metoda związana zawiera jawne odniesienie do stowarzyszonej z nią instancji, dzięki czemu można ją wywoływać w następujący sposób: n(5,"Python") # Wywołanie pq.wstaw(5,"Python") Metody związane i niezwiązane są po prostu obwolutami zwykłych funkcji. Oto lista atrybutów zdefiniowanych dla obiektów tego typu: Atrybut Opis m. doc Napis dokumentacyjny m. name Nazwa metody m. diet Atrybuty metody m.im class Klasa, w której metoda jest zdefiniowana m.im func Obiekt-funkcja implementujący metodę TT).im self Instanqa skojarzona z metodą (None w przypadku metody

niezwiązanej) Jak dotąd koncentrowaliśmy się na funkcjach i metodach, ale do wywoły walnych obiektów należą również klasy (będą opisane za chwilę). W momencie wywo- Pozdział 3: Typy i obiekty 33 łania klasy tworzona jest jej nowa instancja. Ponadto, jeśli klasa definiuje metodę _init__O, ta ostatnia jest wywoływana w celu zainicjalizowania nowo utworzonej instancji. Takie działanie miało miejsce w przypadku klasy Kolej- kaPriorytetów w ostatnim przykładzie. Instancja klasy również daje się wywoływać, o ile w klasie tej jest zdefiniowana specjalna metoda__cali__(). Jeśli taka metoda jest zdefiniowana dla instancji klasy x, to zapis x (a rgs) powoduje wywołanie metody x.__cal 1__(a rgs). Ostatnimi typami obiektów wywoływalnych są funkcje i metody wbudowane. Funkcje i metody wbudowane odpowiadają kodowi w modułach rozszerzeń i zazwyczaj są napisane w języku C lub C++. Oto lista atrybutów dostępnych dla tych obiektów:

Atrybut Opis b. doc__ Napis dokumentacyjny b. name Nazwa funkcji/metody b. self Instancja skojarzona z metodą b. members__ Lista nazw atrybutów metody W przypadkujunkcji wbudowanych, takich jak len (), atrybut__self__jest ustawiany na None, co wskazuje, że funkcja nie jest związana z żadnym konkretnym obiektem. W przypadku metod wbudowanych, takich jak x. append (), gdzie x jest obiektem listowym, atrybut__self__jest ustawiany na x. Moduły Obiekty typu modułowego to kontenery zawierające obiekty ładowane za pomocą instrukcji import. Na przykład, jeśli w programie występuje instrukcja import coś, powoduje ona przypisanie nazwy coś do odpowiedniego obiektu modułowego. Moduły definiują przestrzeń nazw implementowaną przy użyciu słownika udostępnianego przez atrybut__diet__. Wszędzie tam, gdzie nastę- puje odniesienie do atrybutu modułu (za pomocą operatora kropki), jest on tłumaczony na odnośnik do słownika. Na przykład m. x jest równoważne zapiso- wi m.__diet__[ "x" ]. Podobnie instrukcja przypisania wartości do argumentu, taka jak m. x=y odpowiada instrukcji m.__diet__[ "x" ] = y. Oto lista at- rybutów dostępnych dla modułów: Atrybut m.__diet m.__doc_ m.__name_ m.__file_ m.__path Opis Słownik skojarzony z modułem Napis dokumentacyjny modułu Nazwa modułu Plik, z którego moduł został załadowany W pełni kwalifikowana nazwa pakietu, zdefiniowana w momencie odniesienia się modułu do pakietu

34 Python Klasy Klasy są tworzone za pomocą instrukqi class, opisanej w rozdziale 7. Klasy, podobnie jak moduły, są implementowane przy użyciu słownika, który zawiera wszystkie obiekty zdefiniowane wewnątrz klasy, i mają własną przestrzeń nazw. Odniesienia do atrybutów klasy, takie jak ex, są tłumaczone na odnośniki do słownika postaci c.__diet__[ "x" ] . Jeśli dany atrybut nie zostanie znaleziony w słowniku, dalsze poszukiwanie przenosi się na listę klas bazowych z uwzględnieniem kolejności, w jakiej zostały one wymienione w definicji klasy pochodnej. Każda klasa bazowa jest sprawdzana rekurencyjnie (razem ze swoimi klasami bazowymi). Przypisanie wartości do atrybutu, takie jak c. y - 5 powoduje zawsze aktualizację atrybutu__diet__klasy c, a nie słownika której- kolwiek klasy bazowej. Oto lista atrybutów zdefiniowanych dla klas: Atrybut Opis c. diet Słownik skojarzony z klasą c. doc Napis dokumentacyjny klasy c. name Nazwa klasy c. module Nazwa modułu, w którym klasa została zdefiniowana c. bases Tupla z klasami bazowymi

Instancje klas Instancja klasy to obiekt utworzony przez wywołanie obiektu-klasy. Każda instancja ma własną lokalną przestrzeń nazw, zaimplementowaną w postaci słow- nika. Słownik ten i skojarzony z instancją obiekt-klasa mają następujące atrybuty: Atrybut Opis x.__diet x. class

Słownik skojarzony z instanqa Klasa, do której należy instanqa

Po napotkaniu odniesienia do atrybutu jakiegoś obiektu, na przykład x. a, interpreter szuka najpierw w lokalnym słowniku pozycji x.__diet__[ "a" ]. Jeśli jej nie znajdzie, kontynuuje wyszukiwanie w klasie zdefiniowanej przez atrybut __class__. Jeśli dalej niczego nie znajdzie, zaczyna przeszukiwać klasy bazowe, jak to zostało już opisane wcześniej. Jeśli i te poszukiwania zakończą się fia- skiem, a w klasie obiektu jest zdefiniowana metoda__ge tattr__(), interpreter próbuje znaleźć atrybut za pomocą tej metody. Przypisanie wartości do atrybutu typu x. a = 4 zawsze powoduje aktualizację x.__diet__zamiast słow- ników klas czy klas bazowych. Rozdział 3: Typy i obiekty 35 Pliki OBIEKT-PLIK reprezentuje otwarty plik i jest zwracany przez funkcję wbudowaną open () (a także niektóre funkqe z biblioteki standardowej). Bardziej szczegółowe informacje o tym typie znajdziesz w rozdziale 9. Typy wewn ętrzne Niektóre obiekty używane przez interpreter są również dostępne dla użytkowni- ka. Dotyczy to takich obiektów, jak: ślad, kod, ramka, wycinek i wielokropek. OBIEKTY TYPU KOD Obiekty typu kod reprezentują surowy skompilowany kod bajtowy i są zazwyczaj zwracane przez wbudowaną funkcję compile (). Obiekty tego typu są podobne do funkcji z tą różnicą, że nie zachowują żadnego związku z prze- strzenią nazw, w której zostały zdefiniowane, ani nie przechowują informacji o domyślnych wartościach argumentów. Oto tabela z listą atrybutów obiektu-kodu c (wszystkie nadają się tylko do odczytu):

Atrybut c.co_name c.co_argcount c.co_nlocals c.co_varnames c.co_code c.co_consts c.co_names c.co_filename c.co_firstlineno c.co_lnotab c.co_stacksize c.co flags Opis Nazwa funkcji Liczba argumentów pozycyjnych (razem z wartościami domyślnymi) Liczba zmiennych lokalnych używanych przez funkqe Tupla zawierająca nazwy zmiennych lokalnych Napis reprezentujący surowy kod bajtowy Tupla zawierająca literały używane przez kod bajtowy Tupla zawierająca nazwy używane przez kod bajtowy Nazwa pliku, w którym został skompilowany kod Numer pierwszej linii funkcji Napis zamieniający adresy względne kodu bajtowego na numery linii Wymagany rozmiar stosu (z uwzględnieniem zmiennych lokalnych) Liczba całkowita z flagami interpretera. Bit 2 jest ustawiany, gdy funkq'a dopuszcza zmienną liczbę argumentów pozycyjnych za pomocą parametru „*args". Bit 3 jest ustawiany, gdy funkqa dopuszcza dowolne słowa kluczowe w argumentach za pomocą parametru „ * * kwargs". Wszystkie pozostałe bity są zarezerwowane OBIEKTY TYPU RAMKA Obiekty typu ramka są używane do reprezentowania ramek wykonania i wy- stępują najczęściej w obiektach typu ślad (opisanych w dalszej części tego roz- działu). Oto tabela z listą atrybutów tylko do odczytu obiektu-ramki f:

36 Python Atrybut Opis f.f_back Poprzednia ramka stosu (w „kierunku" wywołania) Jf. f code Aktualnie wykonywany obiekt-kod f.f locals Słownik dla zmiennych lokalnych f.£ globals Słownik dla zmiennych globalnych f.t builtins Słownik dla nazw wbudowanych f.f_restricted Ma wartość 1, gdy obowiązuje ograniczony tryb

wykonania f.f_lineno Numer linii f.f_lasti Bieżąca instrukcja. Jest to indeks w ramach napisu kodu bajtowego f_code Kolejna tabela zawiera atrybuty obiektu f, które można modyfikować (korzy- stają z nich debugery i inne narzędzia): Atrybut Opis f.f_trace Funkqa wywoływana na wstępie każdej źródłowej linii

kodu f. f_exc_ _type Typ ostatniego wyjątku f.f exc value Wartość ostatniego wyjątku f. f_exc_ _traceback Siad ostatniego wyjątku OBIEKTY TYPU ŚLAD Obiekty typu ślad są tworzone w momencie zgłoszenia wyjątku i zawierają informacje o śladzie stosu. Gdy zaczyna działać procedura obsługi wyjątku, można pobrać ślad stosu za pomocą funkcji sys . exc_inf o (). Oto lista atry- butów tylko do odczytu dostępnych dla obiektów typu ślad: Atrybut Opis t. tb next Następny poziom w śladzie stosu (w kierunku ramki wykonania, w której nastąpił wyjątek) t.tb_framę Obiekt ramki wykonania na bieżącym poziomie t.tb lineno Numer linii, w której nastąpił wyjątek t.tb_lasti Instrukcja wykonywana na bieżącym poziomie OBIEKTY TYPU WYCINEK Obiekty-wycinki służą do reprezentowania wycinków w rozszerzonej składni wycinka typu a[i:j: krok] ,a[i:j, n:m] lub a [. . ., i:j]. Obiekty- wycinki powstają również w wyniku użycia funkcji wbudowanej slice ( [i, ] j [,stride]). Oto lista atrybutów tylko do odczytu dostępnych dla obiektów typu wycinek: Atrybut s. start s.stop s. step Opis Dolna granica wycinka; nie ma, jeśli nie została podana Górna granica wycinka; nie ma, jeśli nie została podana Krok wycinka; nie ma, jeśli nie został podany Rozdział 3: Typy i obiekty 31 OBIEKT TYPU WIELOKROPEK Obiekt-wielokropek jest używany do zaznaczenia obecności wielokropka (...) w wycinku. Istnieje tylko jeden obiekt tego typu, dostępny za pomocą nazwy wbudowanej Ellipsis. Nie ma on żadnych atrybutów i daje wartość prawda.

Metody specjalne Wszystkie wbudowane typy danych składają się z pewnych danych i kolekcji speqalnych metod obiektowych. Nazwy metod speqalnych są zawsze poprzedzone i zakończone dwoma znakami podkreślenia (__). Metody te są automatycznie wy- zwalane przez interpreter w trakcie wykonywania programu. Na przykład opera-

cja x + yjest mapowana na wewnętrzną metodę x.__add__(y), a operacja indeksowania x[k] jest mapowana na metodę x.__ge t i tem__(k). Zachowanie się każdego typu danych zależy całkowicie od zbioru zaimplementowanych dla niego metod specjalnych. Chociaż nie można zmienić działania wbudowanych typów danych (ani nawet wywoływać bezpośrednio za pomocą nazw ich metod specjalnych), możliwe jest użycie klas do zdefiniowania nowych obiektów zachowujących się podobnie jak typy wbudowane. Aby to osiągnąć, trzeba zaimplementować metody speq'alne opisane w dalszej części tego podrozdziału. Tworzenie, usuwanie i reprezentowanie obiektów W tabeli 3.7 wymienione są metody inicjalizowania, usuwania i reprezentowania obiektów. Metoda__init__() inicjalizuje atrybuty obiektu i jest wywoływana natychmiast po utworzeniu każdego nowego obiektu. Metoda __del__() jest wywoływana w momencie, gdy obiekt ma zostać usunięty. Można z niej korzystać tylko wtedy, gdy wiadomo, że dany obiekt na pewno nie będzie już więcej używany. Warto pamiętać, że instrukcja del x zmniejsza jedynie licznik odniesień obiektu i niekoniecznie powoduje wywołanie metody __del__(). Tabela 3.7 Metody specjalne tworzenia, usuwania i reprezentowania obiektów Metoda init__(self [,args] del__(self) repr__(self) str__(self) cmp__(self, other) hash__(self) nonzero (self) Opis Iniqalizuje nową instancję obiektu Usuwa instanqe obiektu Tworzy pełną reprezentację napisową obiektu Tworzy nieformalną reprezentaqe napisową Porównuje dwa obiekty i zwraca wartość ujemną, dodatnią lub zero Wylicza 32-bitowy indeks haszujący Zwraca 0 lub 1 w zależności od wyniku testu na prawdę

38 Python Rozdział 3: Typy i obiekty 39 Metody__repr__() i__str__() tworzą reprezentacje napisowe obiektu. Metoda__repr__() zwraca zwykle napis z wyrażeniem, którego ewaluacja powoduje ponowne utworzenie obiektu. Metoda ta jest wywoływana przez funkcję wbudowaną repr () oraz przez operator odwrotnych apostrofów 0). Oto przykład: Tabela 3.8 Metody specjalne służące dostępowi do atrybutu a = [2,3,4,5] # Utworzenie listy s = repr(a) # s = ' [2, 3, 4, 5] ' # Uwaga: mo żna równie ż u żyć s = b = eval(s) # Zamienia s z powrotem w list ę zwraca Jeśli nie można utworzyć napisu z wyrażeniem, metoda__repr__ zgodnie z konwencją napis postaci < . . . komun i ka t. . . >, jak to jest pokazane poniżej: f = open("co ś") a = repr(f) # a = "<open file 'co ś', mode 'r' at dc030>" Metoda__str__() jest wywoływana przez funkcję wbudowaną str () oraz przez instrukcję print. Różni się od__repr__() tym, że zwracany przez nią napis bywa bardziej zwięzły i komunikatywny dla użytkownika. W przypadku niezdefiniowania tej metody wywoływana jest metoda__repr__(). Metoda__cmp__(self, other) jest używana przez różne operatory porów- nania. Jeśli self < other, zwracana jest wartość ujemna, jeśli self == other, zwracane jest zero, a jeśli self > other, zwracana jest wartość dodatnia. Jeśli metoda ta nie jest zdefiniowana dla obiektu, porównywanie będzie się odbywało tylko według tożsamości. Ponadto każdy obiekt może definiować alternatywny zestaw funkcji porównujących dla każdego operatora relacji. Nazywa się to boga- tym porównywaniem i będzie o nim mowa w dalszej części rozdziału. Metoda nonzero () służy do sprawdzania wartości prawda i powinna zwracać zawsze 0 lub 1. Jeśli nie jest zdefiniowana, w celu ustalenia prawdy wywoływa- na jest metoda__len__(). Ostatnia już metoda,__hash__(), oblicza war- tość całkowitą klucza haszującego używaną w działaniach na słowniku. (War- tość tę można również uzyskać za pomocą funkcji wbudowanej hash ()). War- tość zwracana przez tę metodę powinna być identyczna dla dwóch obiektów traktowanych przez operację porównania jako równe. Ponadto nie powinno się definiować tej metody dla obiektów zmiennych, gdyż jakakolwiek zmiana obiektu spowoduje również zmianę wartości klucza haszującego, co uniemożliwi znalezienie obiektu przy następnym sprawdzaniu słownika. Jeśli obiekt definiuje metodę__hash__(), powinien również definiować metodę__cmp__(). Dostęp do atrybutów W tabeli 3.8 wymienione są metody, które odczytują, zapisują i usuwają atrybuty obiektu przy użyciu odpowiedniego operatora: kropki (.) lub del. Metoda getattr__ (self, name) setattr__ (self, name, value) delattr (self, name) Opis Zwraca atrybut self. name. Ustawia atrybut self .name = value. Usuwa atrybut self. name. Oto przykłady: a = x. s x. s = b del x.s # Wywołuje # Wywołuje

# Wywołuje getattr setattr delattr (x,"s'\ b) (x,"s") W przypadku instanqi klas metoda__getattr__() wywoływana jest tylko wtedy, gdy poszukiwanie atrybutu w lokalnym słowniku obiektu lub w definicji odpowiedniej klasy zakończyło się niepowodzeniem. Metoda ta powinna zwró- cić wartość atrybutu, a jeśli go nie ma, zgłosić wyjątek AttributeError. Metody sekwencji i mapowania W tabeli 3.9 wymienione są metody używane przez obiekty emulujące sekwencje i obiekty mapujące. - ̂Tabela 3.9 Metody sekwencji i mapowania Metoda Opis »

_len__(self) Zwraca długość self. _getitem__(self, key) Zwraca self [key]. setitem_ (self, key, value) Ustawia self [key] = value. delitem (self, key) Usuwa self [key]. __getslice__(self, i, 3) Zwraca self [i: j]. setslice (self, Ifjf s) Ustawia self [i: j] = s. delslice (self, 1,3) Usuwa self [i: j]. __contains__(self, obj) Sprawdza obecność obj w self.

Oto przykłady:

a = [1,2,3,4,5,6] len (a) # __len__(a) x = a[2] # getitem (a, 2) a[l] = 7 # setitem (a,1,7) del a[2] # __delitem__(a, 2) x = a[l:5] # getslice (a,1,5) a[l:3] = [10,11,12] # __setslice__(a,1,3, [10,11,12]) del a[1:4] # delslice (a,1,4) Metoda__len__jest wywoływana przez funkcję wbudowaną len (), która zwraca nieujemną długość. Funkcja ta sprawdza też wartość prawda w sytuacji, gdy nie została zdefiniowana metoda__nonzero__(). Tam, gdzie trzeba operować indywidualnymi elementami, nadaje się metoda __getitem__(), która zwraca elementy na podstawie wartości klucza. Klu-

40 Python czem może być dowolny obiekt Pythona, ale w przypadku sekwencji jest nim zazwyczaj liczba całkowita. Do przypisania wartości do elementu służy z kolei me- toda__set item__(). Natomiast wszędzie tam, gdzie operacja del ma usunąć pojedynczy element, wywoływana jest metoda__de litem__(). Metody wycinków wspomagają działanie operatora wycinania s[i:j]. Metoda __getslice__() zwraca wycinek, który zazwyczaj jest sekwencją tego samego typu co jego obiekt źródłowy. Indeksy i i j muszą być wartościami całkowity- mi, ale ich interpretacja zależy od metody. W miejsce brakujących wartości i i j podstawiane są odpowiednio wartości 0 i sys .maxint. Metoda__setsli- ce__() przypisuje wartości do wycinka. Z kolei metoda__del slice__() usuwa wszystkie elementy z podanego wycinka. Metoda__contains__() służy do implementowania operatora in. Oprócz implementacji już opisanych metod obiekty sekwencyjne i mapujące im- plementują kilka metod matematycznych, w tym__add__(),__radd__(), __mul__() i__rmul__(), których celem jest wspomaganie konkatenacji i replikacji sekwencji. Będą one krótko opisane w dalszej części tego rozdziału. Python obsługuje także rozszerzone operacje wycinania, które przydają się szczególnie podczas pracy z wielowymiarowymi strukturami danych, takimi jak macierze czy tablice. Od strony syntaktycznej specyfikowanie rozszerzonego wycinka może wyglądać następująco: a = m[0:100:10] # Wycinek krokowy (krok=10) b = m[l:10, 3:20] # Wycinek wielowymiarowy c = m[0:100:10, 50:75:5] # Wycinek wielowymiarowy krokowy m[0:5, 5:10] = n # Przypisanie do rozszerzonego wycinka del m[:10, 15:] # Usuni ęcie rozszerzonego wycinka Ogólny format każdego wymiaru wycinka rozszerzonego ma postać i:j[: krok], gdzie ostatni element, krok, jest nieobowiązkowy. Tak jak w przypadku zwykłych wycinków, można pominąć wartość początkową i końcową wycinka rozszerzonego. Ponadto dostępny jest specjalny obiekt znany jako wielokropek (Ellipsis) i zapisywany w postaci trzech kropek (...), który oznacza dowolną liczbę poprzedzających lub następujących dalej wymiarów w wycinku rozszerzonym: a = m[..., 10:20] # dost ęp do wycinka rozszerzonego przy # u życiu wielokropka m[10:20, ...] = n W przypadku wycinków rozszerzonych metody__get item__(),__se- titem__() i__delitem__() implementują odpowiednio dostęp, modyfikowanie i usuwanie. Jednak zamiast wartości całkowitej przekazuje się do tych metod tupie zawierające jeden lub więcej wycinków i co najwyżej jedną instancję wielokropka (Ellipsis). Na przykład: a = m[0:10, 0:100:5, ...] powoduje wywołanie__get item__(): a =__getitem__(m, (slice(0,10,None), slice(0,100,5) , Ellipsis)) Rozdział 3: Typy i obiekty 41 W chwili obecnej żaden z wbudowanych typów danych nie obsługuje wycinków rozszerzonych, dlatego korzystanie z nich spowoduje najprawdopodobniej błąd. Mimo to istniejące rozwiązania, zwłaszcza o charakterze naukowym, mogą ofe- rować nowe typy i obiekty dopuszczające operacje z udziałem takich wycinków. Operacje matematyczne W tabeli 3.10 wymienione są metody specjalne, które muszą być implementowane przez obiekty emulujące liczby. Operaqe matematyczne wiążą argumenty od lewej do prawej; jeśli pojawia się wyrażenie takie jak x + y, interpreter próbuje wywołać metodę x.__add__(y). Metody specjalne o nazwach zaczynających się od litery „r" przeznaczone są do operacji o odwróconej kolejności operan- dów. Na przykład, jeśli x w działaniu x + y nie pozwala użyć metody __add__(), interpreter spróbuje wywołać metodę y.__add__(x). Tabela 3.10 Metoc^peracji matematycznych

Metoda I Rezultat __add__ (self, other) __sub__ (self, other) __mul__ (self, other) __div__ (self, other) __mod__(self, other) __divmod__ (self, other) __pow__ (self, other [, modulo}) __lshift__ (self, other) _rshift__ (self, other) _and__ (self, other) __or__ (self, other) __xor__ (self, other) __radd__ (self, other) _rsub__ (self, other) _rmul__ (self, other) _rdiv__ (self, other) _rmod__ (self, other) _rdivmod__ (self, other) _rpow__ (self, other) _rlshift__ (self, other) _rrshift__ (self, other) _rand__ (self, other) _ror__ (self, other) _rxor__ (self, other) _iadd__ (self, other) _isub__ (self, other) self + other self - other * self * other self / other self % other divmod (self, other) self ** other, pow (self, other, modulo) self « other self » other self & other self | other self A other other + self other - self other * self other / self other % self divmod (other, self) other ** self other « self other » self other & self other | self ther A self self += other elf -= other Dokończenie tabeli na następnej stronie

42 Python Dokończenie tabeli z poprzedniej strony Metoda Rezultat _imul_ (self,other) self *= other idiv {self, other) self /= other imod (self,other) self %= other ipow (self, other) self **= other iand (self, other) self &= other ior (self, other) self | = other ixor (self, other) self A= other __ilshift__(self, other) self <<= other __irshift__(self, other) self >>= other __neg__(self) -self pos (self) +self abs (self) abs (self) invert (self) -self __int__(self) int (self) long (self) long (self) __float__(self) float (self) __complex__(self) complex (self) __oct__(self) oct (self) _hex__(self) hex (self) __coerce__(self, other) Wymuszenie typu

Metody__i add__(),__i sub__() i tak dalej są używane do wspomagania operacji matematycznych „w miejscu", takich jak a+=b czy a-=b (zwanych rów- nież przypisaniami rozszerzonymi). Rozróżnienie między tymi operatorami a standardowymi metodami arytmetycznymi wynika stąd, że implementacja ope- ratorów „w miejscu" umożliwia pewien margines dostosowania, takiego jak optymalizacja wykonania. Jeśli na przykład parametr s e 1 f nie jest współużytko- wany, być może daje się zmodyfikować jego wartość w miejscu, bez konieczności alokowania nowego obiektu na wynik. Metody konwersji__int__(),__long__(),__float__{) i__complex__() dokonują konwersji obiektu na jeden z czterech wbudowanych typów numerycznych. Natomiast metody__oct__() i__hex__() zwracają napisy reprezentujące odpowiednio ósemkową i szesnastkową wartość obiektu. Metoda__coerce__(x, y) używana jest w przypadku różnych typów argu- mentów operacji arytmetycznej. Wynikiem działania tej metody jest tupla z war- tościami x i y przekonwertowanymi na wspólny typ numeryczny, a jeśli taka konwersja nie jest możliwa, zwracana jest wartość None. W trakcie obliczania rezultatu działania x op y, gdzie op jest operatorem typu „+", stosowane są nastę- pujące reguły: Rozdział 3: Typy i obiekty 43 1. Jeśli x ma zdefiniowaną metodę__coerce__(), zastąp x i y wartościami zwróconymi przez x.__coerce__(y). Jeśli w rezultacie otrzymasz None, przejdź do punktu 3. 2. Jeśli x ma zdefiniowaną metodę__op__(), wykonaj x.__op__(y). W przeciwnym razie przywróć oryginalne wartości x i y i przejdź dalej. 3. Jeśli y ma zdefiniowaną metodę__coerce__(), zastąp x i y wartościami zwróconymi przez y.__coerce__(x). Jeśli w rezultacie otrzymasz None, zgłoś wyjątek. 4. Jeśli y ma zdefiniowaną metodę__rop__(), wykonaj y.__rop__(x). W przeciwnym razie zgłoś wyjątek.

Chociaż istnieją operaqe arytmetyczne zdefiniowane dla napisów, w metodzie __coerce__() nie można podawać ani napisów standardowych, ani Unicode. Interpreter obsługuje tylko ograniczoną liczbę operacji z udziałem mieszanych wbudowanych typów danych. Oto kilka najważniejszych: • Jeśli x jest napisem, x % y uruchamia operację formatowania napisu, bez względu na typ y. • Jeśli x jest sekwencją, x + y oznacza konkatenację sekwencji. • Jeśli jeden z operandów x lub y jest sekwencją, a drugi liczbą całkowitą, x * y oznacza powtórzenie sekwencji. Operacje porównania W tabeli 3.11 wymienione są metody speq'alne, które obiekt może implemento- wać w celu uzyskania indywidualnych wersji operatorów relaqi (<, >, <=, >=, ==, ! =). Noszą one nazwę bogatych porównań i pojawiły się po raz pierwszy w Pytho- nie 2.1. Każda z tych funkcji pobiera dwa argumenty i może zwracać obiekt dowolnego typu Pythona, łącznie z wartością boolowską i listą. Korzystając z tej możliwości, można na przykład utworzyć pakiet numeryczny, który będzie po- równywał element po elemencie dwie macierze i zwracał rezultat również w postaci macierzy. Gdy porównanie nie będzie możliwe, bogate porównania mogą zgłaszać wyjątek. Tabela 3.11 Metody porównuj ące Metoda Rezultat

__It__ (self, other) self < other __le__ (self, other) self <= other __gt__ (self, other) self > other __ge__ (self, other) self >= other __ec3__ (self, other) self == other ne (self, other) self != other

44 Python Rozdział 3: Typy i obiekty 45 Obiekty wywoływalne Obiekty mogą wreszcie emulować funkqe, udostępniając metodę__cali__(self [, a rgs ]). Jeśli obiekt x udostępnia tę metodę, można go wywoływać tak jak funkcję, to znaczy zapis x(argl, arg2, . . .) oznacza wywołanie x.__call__(self, argl, arg2, ...).

Uwagi na temat wydajno ści i pami ęci Wszystkie obiekty Pythona muszą zawierać przynajmniej liczbę całkowitą pełniącą rolę licznika odniesień, deskryptor definiujący typ obiektu oraz właści- we dane. W tabeli 3.12 podane są orientacyjne dane o wymaganiach pamięcio- wych różnych wbudowanych obiektów oparte na implementacji Pythona 2.0 w języku C w komputerze 32-bitowym. Dokładne wartości mogą się nieco różnić w zależności od implementacji interpretera i architektury maszyny. (Na przy- kład wymagania pamięciowe mogą być dwukrotnie większe w komputerach 64-bitowych). Chociaż sam być może nigdy nie będziesz musiał sprawdzać zu- życia pamięci, Python bywa wykorzystywany w różnych krytycznych aplikacjach uruchamianych zarówno na superkomputerach, jak i komputerach przeno- śnych, gdzie wydajność i zużycie pamięci mogą mieć istotne znaczenie. Zamiesz- czone tutaj informaqe o zużyciu pamięci przez różne typy wbudowane powinny pomóc programistom przy projektowaniu takich aplikacji. Tabela 3.12 Wymagania pamięci dla wbudowanych typów danych Typ Rozmiar

Liczba całkowita 12 bajtów Długa liczba całkowita 12 bajtów + (nbitów/16 + 1)*2 bajty Liczba zmiennoprzecinkowa 16 bajtów Liczba zespolona 24 bajty Lista 16 bajtów + 4 bajty na każdy element Tupla 16 bajtów + 4 bajty na każdy element Napis 20 bajtów + 1 bajt na każdy znak Napis Unicode 24 bajty + 2 bajty na każdy znak Słownik 24 bajty + 12*2n bajtów, n = Iog2(welementów)+1 Instancja klasy 16 bajtów plus obiekt - słownik Obiekt xrange 24 bajty

Ponieważ napisy są używane dość często, interpreter stara się je na różne sposoby optymalizować. Po pierwsze, napis s może być internowany za pomocą funkcji wbudowanej intern (). Funkcja ta przegląda zawartość wewnętrznej tablicy haszującej i sprawdza, czy podany napis już w niej występuje. Jeśli tak, zamiast kopii napisu w obiekcie zapisywane jest odniesienie do istniejącego napisu. Jeśli nie, dane z s są dodawane do tablicy haszującej. Internowane napisy pozostają w interpreterze aż do zakończenia jego działania. W przypadku problemów z pa- mięcią nie powinno się internować rzadko używanych napisów. Ponadto, aby przyśpieszyć przeglądanie słownika, interpreter przechowuje ostatnie wyliczo- ne wartości tablicy haszującej dla napisów. Słowniki są implementowane przy użyciu tablicy haszującej z otwartym indeksowaniem. Liczba pozycji alokowanych w słowniku jest dwa razy większa od najmniejszej potęgi 2 większej niż liczba obiektów przechowywanych w słowniku. Wraz ze zwięk- szaniem się liczby obiektów w słowniku jego rozmiar rośnie dwukrotnie. Zazwyczaj około połowy miejsc alokowanych w słowniku jest nieużywanych. Wykonanie programu Pythona to przede wszystkim sekwencja wywołań funkcji korzystających z metod opisanych wcześniej w podrozdziale „Metody specjal-

ne". Aby uzyskać lepszą wydajność programu, dobrze jest nie tylko wybrać najbardziej efektywny algorytm, ale także zapoznać się z modelem obiektowym Py- thona i spróbować zminimalizować liczbę wywołań wspomnianych metod. Do- tyczy to szczególnie wyszukiwania nazw w modułach i klasach. Weźmy jako przykład następujący fragment kodu: import d = 0.0 for i in xrange (1000000) : d = d + math.sqrt(i) W tym przypadku każda iteracja pętli wymaga dwukrotnego szukania nazwy. Po pierwsze, trzeba odszukać moduł math, który należy do globalnej przestrzeni nazw, a po drugie obiekt funkcyjny o nazwie sqr t. Popatrzmy teraz na zmodyfi- kowaną wersję tego kodu: from math import sqrt d = 0.0 for i in xrange (1000000) : d = d + sqrt (i) W drugiej wersji wyszukiwanie jednej nazwy zostało wyeliminowane z pętli. W rezultacie tej zmiany podany fragment kodu wykonywał się na komputerze autora (PC 200 MHz) ponad dwa razy szybciej niż poprzednia jego wersja. Niepotrzebne wywołania metod można również wyeliminować, starannie uży- wając wartości tymczasowych i unikając zbytecznych poszukiwań w słownikach i sekwencjach. Jako przykład weźmy dwie klasy przedstawione w listingu 3.2: Listing 3.2 Nieptrzebne wywołania metod class Punkt: def__init__(self ,x, y, z) : self.x = x self.y = y self.z = z class Wielobok: def__init__(self) : self.pkty = [ ] def dodajpkt(self,pt): self.pkty.append(pt) def obwód(self): d = 0.0 self.pkty.append(self.pkty[0] ) # Chwilowe domkni ęcie wieloboku

46 Python for i in xrange(len(self.pkty)-1): d2 = (self.pkty[i+l].x - self.pkty[i].x)**2 + \ (self.pkty[i+l].y - self.pkty[i].y)**2 + \ (self.pktyti+1].z - self.pkty[i].z)**2 d = d + math.sqrt(d2) self.pkty.pop() # Przywrócenie oryginalnej list y punktów return d W pokazanej metodzie obwód () każde wystąpienie self.pkty [i ] powoduje dwa wywołania specjalnej metody wyszukującej - raz w słowniku, a raz w sekwencji. Można zmniejszyć liczbę wyszukiwań, przepisując metodę w sposób pokazany w listingu 3.3: Listing 3.3 Ulepszona wersja listingu 3.2 Rozdział 4 class Wielobok

def obwód(self) d = 0.0 pkty = self .pkty pkty .append (pkty[0]) for i in xrange(len(pkty)-1): pl = pktyti+1] P2 = pkty[i] d2 = (pl.x - p2.x)**2 + \ (pl.y - p2.y)**2 + \ (pl.z - p2.z)**2 d = d + math.sqrt(d2) pkty • pop() return d Chociaż poprawa wydajności uzyskiwana dzięki takim modyfikacjom nie jest z reguły zbyt duża (15-20%), zrozumienie budowy używanego modelu obiektowego i sposobu wywoływania metod specjalnych pomaga w pisaniu szybszych programów. Oczywiście w sytuacji, gdy wydajność jest sprawą kluczową, można zawsze przenieść pewne funkqe programu do modułu rozszerzenia Pythona na- pisanego w języku C.

Operatory i wyra żenia

W tym rozdziale opiszemy operatory wbudowane w Pythona oraz podamy ko- lejność reguł stosowanych przy wyliczaniu wartości wyrażeń.

Działania na liczbach Oto lista działarUłbzwolonych dla wszystkich typów numerycznych: Działanie Opis x + y Dodawanie x - y Odejmowanie x * y Mnożenie x / y Dzielenie x ** y Potęgowanie OdO x % y Modulo (x mod y) -x Znak ujemny +x Znak dodatni W przypadku liczb całkowitych dzielenie powoduje obcięcie wyniku do części całkowitej. W efekcie 7/4 daje wartość 1, a nie 1,75. Operator modulo zwraca resztę z dzielenia x / y. Na przykład 7 % 4 daje wartość 3. W przypadku liczb

zmiennoprzecinkowych operator modulo zwraca natomiast resztę zmiennoprze- cinkową z dzielenia x / y,czylix - int (x / y) * y. W przypadku liczb zespolonych operator modulo zwraca z kolei wartość x -int((x/y).real) * y. Kolejna lista zawiera operatory bitowe przesunięcia i logiczne, które mogą być używane tylko dla liczb całkowitych i długich liczb całkowitych: Działanie Opis x « y Przesunięcie w lewo x » y Przesunięcie w prawo x & y Koniunkqa bitowa x | y Alternatywa bitowa x A y Rozłączna alternatywa bitowa ~x Negacja bitowa

48 Python \ Operacje bitowe zakładają, że liczby całkowite są reprezentowane w kodzie binarnym uzupełnieniowym z uzupełnieniem do 2. Na długich liczbach całkowi- tych operacje te przebiegają tak, jakby bit znaku znajdował się nieskończenie da- leko z lewej. Istnieją ponadto następujące funkcje wbudowane, które można stosować do wszystkich typów numerycznych: Funkcja Opis abs(x) Zwraca wartość bezwzględną divmod(x,y) Zwraca (int(x / y) , x % y) pow(x,y [,modulo]) Zwraca (x ** y) % modulo round(x,[n]) Zaokrągla x do najbliższej wielokrotności 10 ~n (tylko dla liczb zmiennoprzecinkowych)

Funkqa abs() zwraca wartość bezwzględną argumentu. Funkcja divmod() zwraca iloraz i resztę z operaqi dzielenia pierwszego argumentu przez drugi. Funkcja po w () może być używana zamiast operatora * *, ale umożliwia także trój- argumentowe „potęgowanie modulo" (często stosowane w algorytmach szy- frujących). Funkcja round () zaokrągla liczbę zmiennoprzecinkową x do najbliż- szej wielokrotności 10 do potęgi -n. Pominięcie n powoduje domyślne przyjęcie w jego miejsce wartości 0. Gdy wartość x wypada dokładnie w połowie między dwoma sąsiednimi wielokrotnościami, następuje zaokrąglenie wyniku w kierunku „od zera" (na przykład wartość 0 .5 zostanie zaokrąglona dol,a-0.5do-l). Zamieszczone w kolejnej tabeli operatory porównania mają standardową inter- pretację matematyczną i zwracają albo 1 (prawda), albo 0 (fałsz): Działanie Opis x < y Mniejsze niż x > y Większe niż x == y Równe x ! = y Nierówne (to samo co <>) x >= y Większe niż lub równe x <= y Mniejsze niż lub równe

Porównania mogą tworzyć łańcuchy, na przykład w < x < y < z. Takie wyraże- nia są obliczane jako w < x and x < y and y < z. Wyrażenia takie jak x < y > z są dozwolone, ale mogą być mylące dla innych osób czytających kod (trzeba koniecznie pamiętać, że w takim wyrażeniu nie dochodzi w ogóle do porównania xi z). Liczby zespolone mogą być porównywane jedynie przy użyciu operatora rów- ności (==) i nierówności (! =). Próby porównań liczb zespolonych za pomocą takich operatorów, jak <, <=, > czy >= są z matematycznego punktu widzenia bez- sensowne i powodują zgłoszenie wyjątku TypeError. Rozdział 4: Operatory i wyrażenia 49 Działania z użyciem liczb są poprawne tylko wtedy, gdy ich operandy są tego samego typu. W przypadku różnicy następuje wymuszenie konwersji jednego typu na drugi: 1. Jeśli któryś z operandów jest liczbą zespoloną, drugi operand jest również konwertowany na liczbę zespoloną. 2. Jeśli któryś z operandów jest liczbą zmiennoprzecinkową, drugi operand jest również konwertowany na liczbę zmiennoprzecinkową. 3. Jeśli któryś z operandów jest długą liczbą całkowitą, drugi operand jest rów- nież konwertowany na długą liczbę całkowitą. 4. Jeśli żaden z podanych przypadków nie zachodzi, obie liczby muszą być liczbami całkowitymi i nie trzeba dokonywać konwersji.

Działania na sekwencjach Oto lista działań, które mogą być wykonywane na typach sekwencyjnych, łącznie z napisami, listami i tuplami: Działanie Opis s + r Konkatenacja s * n, n * s Tworzenie n kopii s, gdzie n jest liczbą całkowitą s % d Formatowanie napisu (tylko napisy) s[i) Indeksowanie s[i:j] Wycinanie x in s, x not in s Sprawdzanie obecności for x in s: Iteracja len(s) Długość min(s) Element najmniejszy max(s) Element największy

Operator + powoduje konkatenację dwóch sekwencji tego samego typu. Opera- tor s * n tworzy n kopii sekwenqi s. Są to jednak płytkie kopie, czyli w praktyce powstają tylko odniesienia do właściwego elementu. Jako przykład rozpatrzmy następujący fragment kodu: a = [3,4,5] b = [a] c = 4*b # Lista # Lista zawieraj ąca a # Cztery kopie b # Teraz modyfikacja a a[0] = -7 # Sprawdzenie c print c Dane wyjściowe tego programu wyglądają następująco: [[-7, 4, 5], [-7, 4, 5], [-7, 4, 5], [-7, 4, 5]]

50 Python Najpierw na liście b zostaje umieszczone odniesienie do listy a. Następnie w wyniku replikacji b powstają cztery dodatkowe odniesienia do a. Na koniec po zmo- | dyfikowaniu a zmiana ta jest przenoszona na pozostałe „kopie" a. Taki efekt J mnożenia sekwencji jest z reguły nieoczekiwany i rzadko kiedy bywa zamierzo- : ny przez programistę. Jednym ze sposobów obejścia tego problemu jest ręczne "I utworzenie replikowanej sekwencji poprzez zdublowanie zawartości a. Oto '* przykład: a = [ 3, 4, 5 ] c = [a[:] for j in range(4)] # [:] tworzy kopi ę listy Do tworzenia kopii obiektów można również użyć modułu copy z biblioteki : standardowej. Operator indeksowania s[n] zwraca n-ty obiekt z sekwencji, w której pierwszym obiektem jest s [ 0 ]. Używając ujemnych indeksów, można pobierać elementy liczone od końca sekwencji. Na przykład s[-l] zwraca ostatni element. Pró- | ba dostępu do elementu spoza zakresu indeksów powoduje zgłoszenie wyjątku ? IndexError. f Operator wycinania s[i:j] pobiera podciąg sekwencji s składający się z ele- t mentów o indeksie k takim, że i <= k < j. Zarówno i, jak i j muszą być liczbami « całkowitymi lub długimi liczbami całkowitymi. Jeśli indeks początkowy lub koń- ?

cowy zostanie pominięty, w jego miejsce zostanie przyjęty odpowiednio ' początek lub koniec całej sekwencji. Używając ujemnych indeksów, można po- i bierać elementy liczone od końca sekwencji. Jeśli i lub j wypada poza zakresem, ~ przyjmuje się w jego miejsce początek lub koniec sekwencji, w zależności od tego, czy podana wartość wypada odpowiednio przed pierwszym, czy za ostatnim elementem sekwencji. ? Operator x in s sprawdza, czy obiekt x występuje w sekwencji s i jeśli tak, zwraca 1, a w przeciwnym razie 0. Z kolei operator x not in s sprawdza, czy "i obiekt x nie występuje w sekwencji s. Operator x in s przegląda wszystkie elementy sekwencji i jest opisany dokładniej w rozdziale 5, zatytułowanym „Przepływ sterowania". Funkcja len (s) zwraca liczbę elementów w sekwencji, natomiast min (s) i max (s) zwracają odpowiednio minimalną i maksymalną wartość w sekwencji, chociaż ich wynik ma sens tylko wtedy, gdy elementy sekwencji dają się uporządkować przy użyciu operatora <. (Na przykład nie ma - sensu szukać maksymalnej wartości na liście obiektów typu plik). Napisy i tupie są niezmienne i nie dopuszczają modyfikacji po ich utworzeniu. Natomiast listy dopuszczają następujące działania zmieniające ich wartość: Działanie Opis s[i] = x Przypisanie do indeksu s[i:j] = r Przypisanie do wycinka del s[i] Usunięcie elementu del s[i:j] Usunięcie wycinka

Rozdział 4: Operatory i wyrażenia 51 Operator s[i] = x zmienia i-ty element listy na odniesienie do obiektu x, zwię- kszając jednocześnie licznik odniesień tego ostatniego. Indeksy ujemne odliczane są względem końca listy, a próba przypisania wartości do elementu o indeksie spoza zakresu powoduje zgłoszenie wyjątku IndexError. Operator przypisania do wycinka s[i: j] = r powoduje zastąpienie elementów o indeksie k, gdzie i <= k < j, elementami sekwencji r. Indeksy mogą przyjmować te same wartości co w przypadku wycinków, a w przypadku wyjścia poza zakres są do- pasowywane odpowiednio do początku lub końca listy. Jeśli trzeba, sekwencja s jest rozszerzana lub redukowana w celu pomieszczenia wszystkich elementów

z r. Oto przykład: a - [1,2,3,4,5] a[l] =6 # a = [1,6,3,4,5] a[2:4] = [10,11] # a = [1,6,10,11,5] a[3:4] = [-1,-2,-3] # a = [1,6,10,-1,-2,-3,5] a[2:] = [0] , # a = [1,6,0] Operator del s[i] usuwa i-ty element listy i zmniejsza jego licznik odniesień. Operator s[i: j] usuwa wszystkie elementy wycinka. Porównywanie sekwencji odbywa się przy użyciu operatorów <, >, <=, >=, == i ! =. Podczas porównywania dwóch sekwencji najpierw porównywane są ich pierwsze elementy. Jeśli są różne, decyduje to o wyniku całego porównania. Jeśli są takie same, porównywane są następne w kolejności, drugie elementy obu sekwencji. Proces ten jest kontynuowany do momentu natrafienia na dwa różne elementy lub sprawdzenia wszystkich elementów jednej z sekwencji. Jeśli a jest początkowym fragmentem b, to a < b. Kolejność napisów jest ustalana na podstawie porządku leksykograficznego. Każdy znak ma przypisany unikatowy indeks ustalony na podstawie komputerowego zestawu znaków (takiego jak ASCII czy Unicode). Jeden znak jest mniejszy od drugiego, jeśli jego indeks jest mniejszy. Operator s % d tworzy sformatowany napis. Operand s jest napisem forma- tującym, a d kolekcją obiektów w tupli lub obiektem mapującym (słownikiem). Napis s może być napisem standardowym lub Unicode. Działanie tego operatora przypomina działanie funkcji sprintf () w C. Napis formatujący zawiera dwa rodzaje obiektów: zwykłe znaki (które nie są modyfikowane) oraz elementy opi- sujące konwersję, z których każdy ma zostać zastąpiony przez sformatowany napis reprezentujący element podanej tupli lub obiektu mapującego. Jeśli d jest tupią, liczba elementów opisujących konwersję musi odpowiadać dokładnie licz- bie obiektów w d. Jeśli d jest obiektem mapującym, każdy element opisujący kon- wersję musi być skojarzony z poprawną nazwą klucza w obiekcie mapującym (za pomocą nawiasów okrągłych, jak to będzie za chwilę opisane). Każdy element opisujący konwersję zaczyna się od znaku %, a kończy jednym ze znaków konwersji podanych w tabeli 4.1.

52 Python] Rozdział 4: Operatory i wyrażenia 53 Tabela 4.1 Znaki formatujące napisy Znak Format wyjścia d,i Dziesiętna liczba całkowita lub długa liczba całkowita u Liczba całkowita lub długa liczba całkowita bez znaku o Ósemkowa liczba całkowita lub długa liczba całkowita X Szesnastkowa liczba całkowita lub długa liczba całkowita X Szesnastkowa liczba całkowita (duże litery) f Liczba zmiennoprzecinkowa [ - ] m. dddddd e Liczba zmiennoprzecinkowa [ - ] m. dddddde±xx E Liczba zmiennoprzecinkowa [ - ] m. ddddddE±xx g,G Dla wykładników mniejszych od -4 lub większych od precyzji używaj

%e lub %E; w przeciwnym razie używaj %f s Napis lub dowolny obiekt. Do generowania napisów kod formatujący używa str () r Taki sam napis jak w wyniku repr () c Pojedynczy znak % Literał % Pomiędzy % a znakiem konwersji mogą występować w podanej kolejności nastę- pujące modyfikatory: 1. Nazwa kluczowa w nawiasach okrągłych, która wybiera konkretny element obiektu mapującego. Jeśli taki element nie istnieje, zgłaszany jest wyjątek KeyError. 2. Jeden lub kilka następujących znaków: • Kropka (.) oznaczająca wyrównanie do lewej. • Plus (+) oznaczający jawne podanie znaku liczby (nawet jeśli jest ona dodatnia). • Zero (0) oznaczające cyfrę wypełniającą konkretną pozyqe liczby. 3. Liczba określająca minimalną szerokość pola. Konwertowana wartość zostanie w razie potrzeby dopełniona spacjami z lewej (lub z prawej, jeśli użyjesz! flagi „-"), dla uzyskania wymaganej szerokości. 1 4. Kropka (.) oddzielająca specyfikację szerokości pola od specyfikacji dokład-f ności. \ 5. Liczba określająca maksymalną podawaną na wyjściu liczbę znaków napisu, f liczbę cyfr po kropce dziesiętnej liczby zmiennoprzecinkowej lub minimalną: liczbę cyfr liczby całkowitej. I Ponadto zamiast liczby określającej szerokość pola może być zawsze używana - gwiazdka (*), która oznacza, że szerokość pola ma być odczytana z następnego elementu tupli. Oto kilka fragmentów kodu ilustrujących użycie znaków i modyfikatorów konwersji: a = 42 b = 13.142783 c = "witaj" d= {'x':13, 'y ł :l.54321, ■z':' świecie'} e = 5628398123741234L print print print print print print print a to %d'

%10d %f %+010d %E %(x)-10d %0.4s %s' %*.*f '\% e = %d' $ e a (a,b) % (a,b) %(y)0.3g' % d % (c, d['z']) (5,3,b) "a to 42" 42 13.142783" "+000000042 1.314278E+01' "13 1.54" "wita świecie" "13.143" "e = 5628398123741234"

Działania na słownikach Słowniki służą mapowaniu nazw na obiekty. Oto lista działań, które można wy- konywać na słownikach: Działanie x = d[k] d[k] = x del d[k] len(d) Opis Indeksowanie za pomocą klucza Przypisanie do klucza Usunięcie według klucza Liczba elementów w słowniku Wartościami kluczy mogą być dowolne obiekty stałe, takie jak napisy, liczby czy tupie. Ponadto klucze słownika mogą mieć postać list wartości oddzielonych przecinkami. Na przykład: d = { } d[l,2,3] = "coś" d[l,0,3] = "cokolwiek1 W tym przypadku wartości kluczy mają postać tupli, co oznacza, że to samo moż- na zapisać w sposób następujący: d[ (1,2,3)] = "coś" d[ (1,0,3)] = "cokolwiek1

Przypisania rozszerzone Python udostępnia następujące operatory przypisania rozszerzonego: Działanie Opis x += y X = X

+ y

x -= y X = x - y x *= y X = X

* y

x /= y X = X / y

54 Pytfion Działanie Opis X * *= y x = X ** y X %= y X = X % y X &= y X = X & y X l= y X = X I y X A= y X = X A y X »= y X = X » y X «= y X = X « y Operatory te mogą być używane wszędzie tam, gdzie jest dozwolone zwykłe przypisanie. Oto kilka przykładów: a = 3 b = [1,2] a += 1 b[l] += 10 c %= ("Douglas", # a # b # c [1, 12] "Douglas Adams" "Adams") Przypisanie rozszerzone nie zmienia obiektów stałych ani nie modyfikuje ich „w miejscu". W efekcie instrukcja x += y tworzy całkowicie nowy obiekt x o wartości x + y. Klasy zdefiniowane przez użytkownika mogą za pomocą metod specjalnych (opisanych w rozdziale 3, „Typy i obiekty") zmieniać działanie ope- ratorów przypisania rozszerzonego.

Operator atrybutu (.) Operator kropka (.) umożliwia dostęp do atrybutów obiektu. Na przykład: cos.x = 3 print co ś.y a = co ś.byleco(3,4,5) del cos.x Operator atrybutu może występować wiele razy w jednym wyrażeniu, na przykład coś . y. a. b. Może także występować w pośrednich wynikach funkcji, typu a = coś . by leco (3,4,5) . spam. Aby usunąć atrybut, wystarczy użyć instrukqi de 1, na przykład del cos.x.

Konwersja typów Czasami okazuje się konieczne przekonwertowanie jednego typu wbudowanego na drugi. Oto lista funkcji wbudowanych dokonujących jawnej konwersji po- szczególnych typów: Funkcja int(x [,base]) long(x [,base]) float(x) Opis Konwertuje x na liczbę całkowitą Konwertuje x na długą liczbę całkowitą Konwertuje x na liczbę zmiennoprzecinkową Rozdział 4: Operatory i wyrażenia 55 Funkcja Opis complex(real [,imag]) Tworzy liczbę zespoloną str(x) Konwertuje obiekt x na reprezentację napisową repr(x) Konwertuje obiekt x na wyrażenie tekstowe eval (str) Wyznacza wartość napisu i zwraca obiekt

tupie(s) Konwertuje sekwenqe s na tupię list(s) Konwertuje sekwencję s na listę chr (x) Konwertuje liczbę całkowitą na znak unichr(x) Konwertuje liczbę całkowitą na znak Unicode ord(x) Konwertuje pojedynczy znak na jego wartość

całkowitą hex(x) ̂ _ Konwertuje liczbę całkowitą na napis

szesnastkowy oct(x) Konwertuje liczbę całkowitą na napis ósemkowy Ten sam napis, który generuje funkqa repr (x), można uzyskać przy użyciu odwrotnych apostrofów, pisząc *x\ Zwróć uwagę, że funkqe str () i repr () mogą dawać różne wyniki. Funkcja repr () tworzy zazwyczaj tekst wyrażenia, który można następnie podać w wywołaniu funkcji eval () i odtworzyć oryginalny obiekt. Z kolei funkcja s t r () generuje zwartą i czytelnie sformatowaną re- prezentację obiektu (jest wykorzystywana przez instrukqe print). Funkcja ord () zwraca całkowitą wartość porządkową znaku standardowego lub Unico- de. Funkcje chr () i unichr () konwertują odpowiednio taką wartość z powrotem na znak standardowy lub znak Unicode. Do konwersji napisów z powrotem na liczby lub inne obiekty służą funkcje int (), long () i float (). Funkcja eval () potrafi z kolei konwertować na obiekty napisy zawierające poprawne wyrażenia. Oto kilka przykładów: a = int("34") # a = 34 b = Iong("0xfe76214", 16) # b = 266822164L (0xfe76214L) b = float("3.1415926") # b = 3.1415926 c = eval("3, 5, 6") # c = (3,5,6)

Napisy Unicode Używanie napisów standardowych i napisów Unicode w tym samym programie może nastręczać trochę trudności. Ich źródłem bywa występowanie na- pisów w różnych działaniach, takich jak konkatenowanie napisów, porówny- wanie ich, przeglądanie słowników czy podawanie wśród argumentów funkcji wbudowanych. Aby przekonwertować napis standardowy s na napis Unicode, trzeba użyć funkcji wbudowanej Unicode (s [, encoding [, errors] ]) .Aby przekonwer- tować napis Unicode u na napis standardowy, trzeba użyć metody u.encode ( [ encoding [, errors ]]). Oba wymienione operatory konwersji wyma- gają użycia specjalnej reguły kodowania, określającej sposób mapowania 16-bitowych znaków Unicode na sekwencje 8-bitowych znaków w napisach standar-

56 Python dowych i odwrotnie. Parametr kodowania dostarczany jest w formie napisu i ma jedną z następujących wartości: Wartość Opis 1ascii' 7-bitowy kod ASCII •latin-11 lub 'iso-8859-11 ISO 8859-1 Latin-1 •utf-81 8-bitowe kodowanie zmiennej długości •utf-16' 16-bitowe kodowanie zmiennej długości (Little Endian lub Big Endian) •utf-16-le1 UTF-16, kodowanie Little Endian •utf-16-be1 UTF-16, Kodowanie Big Endian 'unicode-escape' Taki sam format jak literałów Unicode u "napis " 'raw-unicode-escape' Taki sam format jak literałów Unicode ur "napis " Domyślny sposób kodowania ustawiany jest w module site i można go spraw- dzić za pomocą wywołania sys .getdefaultencoding (). W większości przypadków jest to typ 'ascii1, co oznacza, że znaki ASCII o wartościach z przedziału [0x00,0x7f] są bezpośrednio mapowane na znaki Unicode z zakresu ] [U+0000,U+007F]. Szczegółowe informacje o pozostałych sposobach kodowania znajdziesz w rozdziale 9, zatytułowanym „Wejście i wyjście". Gdy podczas konwertowania napisów wystąpi znak, którego nie da się przeko- dować, może nastąpić zgłoszenie wyjątku UnicodeError. Na przykład, jeśli obowiązuje sposób kodowania 'ascii', znak Unicode taki jak U+1F28 nie może zostać przekonwertowany, ponieważ jego wartość jest zbyt duża. Podob- nie napis " \xf c " nie może zostać przekonwertowany na Unicode, gdyż zawiera znak o wartości spoza zakresu dozwolonego dla kodu ASCII. O sposobie obsługi błędów kodowania decyduje parametr errors. Może on przyjmować jedną z następujących trzech wartości: Wartość 'strict' 'ignore' 'replace' Opis działania Zgłaszanie wyjątku UnicodeError przy błędach dekodowania Ignorowanie nieważnych znaków Usuwanie nieważnego znaku i wstawianie w jego miejsce znaku zastępującego (U+FFFD w Unicode, •' ? ' w napisach standardowych) Domyślnym sposobem obsługi błędów jest 'strict'. Gdy wyrażenie zawiera oba rodzaje napisów, standardowe i Unicode, napisy standardowe są automatycznie konwertowane na Unicode przy użyciu funkcji wbudowanej Unicode (). Oto przykład: s = "witaj" t = u" świecie" w = s + t # w = Unicode(s) + t Rozdział 4: Operatory i wyra żenia 57 Gdy napisy Unicode są używane w metodach napisowych zwracających nowy napis (jak opisane w rozdziale 3), wynik jest zawsze zwracany w Unicode. Na przykład: a = "Witaj świecie" b = a.replace(" Świecie' u"wiosno") # Generuje u"Witaj wiosno" Co więcej, nawet jeśli nastąpi zero zastąpień i napis wyjściowy będzie identyczny jak źródłowy, i tak zostanie zwrócony napis Unicode. Jeśli jednym z argumentów przekazywanych operatorowi % jest obiekt Unicode, ostateczny rezultat jest konwertowany na Unicode w momencie łączenia tego obiektu z resztą. Jeśli napis Unicode jest używany jako napis formatujący z opera-

torem %, wszystkie argumenty są najpierw konwertowane na Unicode, a następ- nie łączonezgodnie z podanymi regułami formatu. Oto przykład: c = "%s %s" % ("Hello", u"World") # c = "Hello " + u"World" d = u"%s %s" % ("Hello", "World") # d = u"Hello " + u"World" Gdy funkcje s tr () i repr () są stosowane do napisów Unicode, ich wartości po- wrotne są automatycznie zamieniane na napisy standardowe. W przypadku napisu Unicode u funkcja str (u) daje wartość u.encode (), a funkcja repr (u) wartość u"%s" % repr(u.encode('unicode-escape1)). Ponadto większość funkqi wbudowanych i bibliotecznych, które działają wyłącznie na napisach standardowych, automatycznie zamienia napisy Unicode na standardowe przy użyciu domyślnego sposobu kodowania. Jeśli taka zamiana nie jest możliwa, zgłaszany jest wyjątek UnicodeError. Napisy standardowe i Unicode można porównywać ze sobą. W takim przypadku przed dokonaniem porównania napisy standardowe są zamieniane na Unico- de przy użyciu domyślnej metody kodowania. Taka zamiana następuje również wtedy, gdy porównanie ma miejsce podczas operacji na liście lub słowniku. Na przykład operaqa 'x' in [u'x1, u'y1, u'z1] zamienia najpierw ' x' na Unicode i zwraca prawdę. W przypadku sprawdzania obecności znaku w napisie, takiego jak 'W inu'Witaj świecie' znak 'W jest zamieniany na Uni- code przed rozpoczęciem sprawdzania. Podczas wyliczania wartości hasza za pomocą funkcji hash () napisy standardowe i Unicode dają identyczne wartości, o ile napis Unicode zawiera wyłącznie znaki z przedziału [U+0000,U+007F]. Dzięki temu oba rodzaje napisów mogą być używane wymiennie jako klucze słownika, o ile oczywiście napisy Unicode ograniczają się do znaków ASCII. Na przykład: a = { } a[u"co ś"] = 1234 print a["co ś"] # Daje 1234 Trzeba jednak pamiętać, że takie zachowanie się klucza słownika może nie za- działać, jeśli domyślny sposób kodowania zmieni się kiedykolwiek na inny niż 'ascii ' lub jeśli napis Unicode zawiera znaki spoza ASCII. Na przykład gdy domyślnym sposobem kodowania znaków jest 'utf-8 ', można doprowadzić do sytuacji, w których napisy o różnych wartościach hasza zostaną uznane za równe. Na przykład:

58 Pytiion Rozdział 4: Operatory i wyrażenia 59 a = u"M\uOOfcller" b = "M\303\27411er" print a == b print hash(a)==hash(b) # Napis Unicode # wersja a zakodowana w utf-8 # Daje 'I 1, prawda # Daje 'O 1, fałsz Tabela 4.2 Kolejność operatorów (od najwyższego priorytetu do najniższego)

Wyrażenia i warto ści boolowskie Używając słów kluczowych and, orinot można tworzyć wyrażenia boolowskie. Operatory te mają następujące działanie: Działanie x or y x and y not x Opis Jeśli x ma wartość fałsz, zwróć y; w przeciwnym razie zwróć x Jeśli x ma wartość fałsz, zwróć x; w przeciwnym razie zwróć y Jeśli x ma wartość fałsz, zwróć 1; w przeciwnym razie zwróć 0 Gdy używasz wyrażenia do ustalenia wartości boolowskiej, czy jest to prawda, czy fałsz, każda liczba różna od zera lub niepusty napis, lista, tupla albo słownik są traktowane jak prawda. Zero, None i pusta lista, tupla oraz słownik są uznawane za fałsz. Wyrażenia boolowskie są obliczane od lewej do prawej i korzystają z prawego operandu tylko wtedy, gdy jest on potrzebny do ustalenia końcowej wartości. Na przykład wyrażenie a and b wymaga sprawdzenia b tylko wtedy, gdy a ma wartość prawda.

Równo ść i to żsamo ść obiektów Operator równości x == y sprawdza, czy wartości x i y są sobie równe. W przypadku list i tupli porównywane są poszczególne elementy i wynikiem po- równania jest prawda, jeśli każda para elementów jest sobie równa. W przypadku słowników wartość prawda zwracana jest tylko wtedy, gdy x i y mają ten sam zestaw kluczy i wszystkie obiekty o tym samym kluczu mają równe wartości. Operatory tożsamości x is y i x is not y sprawdzają, czy ich operandy odnoszą się do tego samego obiektu w pamięci. W ogólności może tak być, że x == y, ale nie zachodzi x is not y. Porównywanie dwóch obiektów o niekompatybilnych typach danych, na przykład pliku z liczbą zmiennoprzecinkową, bywa dozwolone, ale wynik może być dowolny i nie mieć żadnego sensu. Ponadto takie porównanie może spowo- dować zgłoszenie wyjątku.

Kolejno ść oblicze ń

L W tabeli 4.2 podana jest kolejność działań obowiązująca w Pythonie. Na począt- ku wymienione są operatory o najwyższym priorytecie, a na końcu o najniższym. Oznacza to, że operatory z początku tabeli są wykonywane przed operatorami z jej końca. Wszystkie operatory z wyjątkiem potęgowania (* *) są wyliczane od lewej do prawej. (Uwaga: operatory umieszczone w tej samej komórce tabeli, takie jak x * y, x / y i x % y, mają ten sam priorytet). Operator

Działanie

[...], {-..} Tworzenie tupli, list i słowników

Konwersja napisów s[i], s [i:j], s.attr Indeksowanie, wycinanie i pobieranie atrybutów f(...) Wywoływanie funkcji +x, -x, ~x Operatory unarne x ** y Potęgowanie (prawostronnie łączne) x * y, x 1 y, x % y Mnożenie, dzielenie, modulo x + y, x - y Dodawanie, odejmowanie x « y, x » y \ Przesuwanie bitów x & y Koniunkqa bitowa x A y Alternatywa bitowa rozłączna x | y Alternatywa bitowa x < y, x <= y, Porównywanie i sprawdzanie tożsamości oraz

obecności w sekwenqi

x > y, x >= y, x == y, x != y x <> y x is y, x is not y x in s, x not in s not x Negaqa logiczna x and y Koniunkqa logiczna x or y Alternatywa logiczna lambda args: expr Funkqa anonimowa

Rozdział 5

Przepływ sterowania

W tym rozdziale omówimy instrukcje związane z przepływem sterowania w programie. Wśród omawianych tematów znajdą się warunki, pętle i wyjątki.

Warunki Instrukqe if, elseielif umożliwiają warunkowe wykonywanie kodu. Ogól- ny format instrukcji warunkowej wygląda następująco: if wyrażenie: instrukcje elif wyrażenie: instrukcje elif wyrażenie: instrukcje else: instrukcje Jeśli nie chcesz definiować żadnych działań alternatywnych, możesz pominąć w instrukcji warunkowej zarówno klauzulę e 1 s e, jak i e 1 i f. W przypadku braku jakiejkolwiek instrukqi w danej klauzuli można umieścić w niej instrukqe pass: if wyrażenie: pass else: instrukcje # Nic nie rób

Pętle Do implementowania pętli służą instrukcje for i while. Ogólna postać każdej z nich wygląda następująco: while wyrażenie: instrukcje for i in s: instrukcje Instrukq'a whi le wykonuje następujący po niej blok kodu do momentu, aż skojarzone z nią wyrażenie będzie miało wartość fałsz. Instrukcja for wykonuje natomiast swój blok kodu po jednym razie dla każdego kolejnego elementu sekwenqi s. Jeśli elementami sekwencji są tupie o identycznych rozmiarach, można użyć następującego wariantu instrukcji for:

62 Python Rozdział 5: Przepływ sterowania for x,y, z in s: instrukcje W takim przypadku s musi być sekwencją tupli trójelementowych. W każdej iteracji zmiennym x, y i z będzie przypisywana zawartość kolejnej tupli. Aby przerwać wykonywanie pętli, można użyć instrukqi break. Oto przykład funkcji pobierającej linie tekstu od użytkownika do momentu wprowadzenia przez niego linii pustej: while 1: poi = raw_input('Wpisz polecenie > ') if not pol: break # Brak danych, koniec p ętli # przetworzenie polecenia Aby przejść do następnej iteracji pętli (zanim jeszcze zostanie wykonana cała jej zawartość), można użyć instrukcji continue. Instrukcja ta jest raczej rzadko używana, ale bywa czasami przydatna, zwłaszcza gdy testowanie jeszcze jednego warunku i dodanie kolejnego poziomu wcięcia spowodowałoby zbytnie za- gnieżdżenie programu lub jego niepotrzebną komplikaqe. Oto przykład wykorzystania tej instrukcji w pętli wyświetlającej tylko nieujemne wartości z listy: for a in s: if a < 0: continue print a # Pomini ęcie elementu ujemnego Instrukcje break i continue odnoszą się tylko do najbardziej wewnętrznej pę- tli, która jest aktualnie wykonywana. Jeśli trzeba wyskoczyć z całej struktury za- gnieżdżonych pętli, można użyć wyjątku. Python nie udostępnia instrukcji sko- ku (goto). Konstruując pętlę można dołączyć do niej instrukcję else. Oto dwa przykłady: # while-else while i < 10: do co ś i = i + 1 else: print 'Zrobione' # for-else for a in s: if a == 'szukam': break else: print 'Nie znaleziono! I 1 :■ i Przejście do klauzuli else następuje dopiero wtedy, gdy wiadomo już, że pętla nie będzie więcej wykonywana. Ma to miejsce albo od razu na początku (jeśli | w ogóle nie dochodzi do wykonania pętli), albo po ostatniej iteracji. Klauzula else może zostać jednak całkowicie pomięta, jeśli w trakcie którejś iteracji pętli dojdzie w niej do wykonania instrukqi break.

Wyj ątki Zgłoszenie wyjątku oznacza wystąpienie błędu i przerwanie normalnego prze- pływu sterowania w programie. Aby samodzielnie zgłosić wyjątek, można użyć instrukqi raise. Ogólny format tej instrukcji ma postać raise wyjątek [, wartość], gdzie wyjątek oznacza rodzaj wyjątku, a wartość niesie bardziej szczegółową informaqe o tym wyjątku. Na przykład: raise RuntimeError, 'Bł ąd nie do naprawienia' Jeśli instrukcja raise zostanie użyta bez argumentów, spowoduje ponowne zgłoszenie ostatniego wyjątku (chociaż działa to tylko w trakcie obsługi poprzednio zgłoszonego wyjątku). Aby przechwycić wyjątek, trzeba użyć instrukcji try i except, jak to jest poka-

zane poniżej: try: f = open('co ś') except IOError, e: print "Nie mo żna otworzy ć 'co ś': ", e Gdy następuje wyjątek, interpreter zatrzymuje wykonanie instrukcji w bloku try i szuka klauzuli except odpowiadającej zgłoszonemu wyjątkowi. Jeśli j ą znajdzie, przekazuje sterowanie do pierwszej instrukcji w jej bloku. W przeciwnym razie wyjątek jest przekazywany na zewnątrz bloku, w którym występuje instrukqa try. Blok ten może być sam umieszczony w konstrukqi t ry-except, która obsłuży wyjątek. Jeśli w wyniku takiego przekazywania „w górę" wyjątek dotrze do najwyższego poziomu programu i nie zostanie nigdzie przechwycony, interpreter przerwie dalsze wykonanie i wyświetli komunikat o błędzie. Jeśli trzeba, nie przechwycone wyjątki mogą być również przekazywane do zdefiniowanej przez użytkownika funkcji sys . excepthook (), jak to jest opisane w dodatku A „Biblioteka Pythona". Drugi, nieobowiązkowy argument instrukcji except jest nazwą zmiennej, w któ- rej po wystąpieniu wyjątku umieszczana jest wartość podana w instrukcji raise. Procedura obsługi wyjątku może sprawdzać tę wartość w celu uzyskania dodatkowych informacji o przyczynie błędu. Używając kolejnych klauzul except, można utworzyć wiele bloków obsługu- jących różne wyjątki: try: do co ś except IOError, e: # Obsługa bł ędu I/O except TypeError, e: # Obsługa bł ędu w typie except NameError, e: # Obsługa bł ędu w nazwie

64 Python Rozdział 5: Przepływ sterowania 65 Do obsługi wielu różnych wyjątków można również użyć tylko jednego bloku, na przykład: try: do co ś except (IOError, TypeError, NameError), e: # Obsługa bł ędów I/O, typu i nazwy Aby zignorować wyjątek, można użyć w następujący sposób instrukcji pass: try: do co ś except IOError: pass # Nic nie rób (wspaniale). Aby przechwytywać wszystkie wyjątki, wystarczy pominąć nazwę wyjątku 1 i wartość: try: do co ś except: print 'Nast ąpił bł ąd1 Tabela 5.1 Wyjątki wbudowane Wyjątek Opis Exception Korzeń wszystkich wyjątków

SystemExit Generowany przez sys . exit () StandardError Baza wszystkich wyjątków wbudowanych ArithmeticError Baza wyjątków arytmetycznych FloatingPointError Nieudana operaqa zmiennoprzecinkowa OverflowError Nadmiar arytmetyczny ZeroDivisionError Operacja modulo lub dzielenia przez zero AssertionError Zgłaszany przez instrukqe assert AttributeError Zgłaszany wskutek nieprawidłowej nazwy

atrybutu EnvironmentError Błędy wewnętrzne Pythona

IOError Błąd związany z plikiem lub operacją I/O OSError Błąd systemu operacyjnego WindowsError Błąd w Windows EOFError Zgłaszany po osiągnięciu końca pliku ImportError Niepowodzenie instrukcji import Keyboardlnterrupt Generowany przez klawisze przerwania (zazwyczaj [Ctrl+C]) LookupError Błąd w indeksie lub kluczu IndexError Pozyq'a sekwencji spoza zakresu KeyError Nie istniejący klucz słownika MemoryError Wyj ście poza pamięć NameError Niemożliwa do znalezienia nazwa lokalna lub globalna Wyjątek Opis UnboundLocalError Niezwiązana zmienna lokalna RuntimeError Ogólny błąd „wszystkiego" NotlmplementedError Nie zaimplementowana funkqa SyntaxError Błąd składni TabError Nieprawidłowe użycie tabulaqi (generowany przez opqę-tt) IndentationError Nieprawidłowe wcięcie SystemError Błąd systemowy w interpreterze nie uniemożliwiający działania

TypeError Użycie w operaqi nieprawidłowego typu ValueError Nieprawidłowa wartość lub jej brak UnicodeError Błąd w kodowaniu Unicode

Instrukqa try dopuszcza również użycie klauzuli else, która może występo- wać po ostatniej klauzuli except. Blok klauzuli else wykonywany jest wtedy, gdy w bloku try nie dojdzie do zgłoszenia wyjątku. Oto przykład: try: f = open('co ś', 'r') except IOError: print 'Nie mo żna otworzy ć pliku co ś' else: dane = f.readO f.close () Instrukqa finally definiuje działania, które mają zakończyć wykonanie kodu zawartego w bloku try. Na przykład: f = open('co ś','r') try: # Jakie ś działania finally: f.close() print "Zamkni ęcie pliku bez wzgl ędu na wszystko. " Klauzula finally nie służy do przechwytywania błędów. Używa się jej raczej do wstawiania kodu, który ma być wykonywany zawsze, bez względu na to, czy błąd wystąpił, czy nie. W przypadku niezgłoszenia wyjątku kod z klauzuli finally jest wykonywany natychmiast po wykonaniu bloku try. Jeśli zaś zostanie zgłoszony wyjątek, sterowanie zostanie najpierw przekazane do pierwszej instrukqi klauzuli finally, a po wykonaniu całego kodu tej klauzuli nastąpi ponowne zgłoszenie tego samego wyjątku, ale tym razem w celu przechwycenia przez inną procedurę obsługi wyjątku. Klauzule finally i except nie mogą występować w ramach tej samej instrukcji try. Zdefiniowane w Pythonie wyjątki wbudowane są wymienione w tabeli 5.1 (wię- cej szczegółowych informaqi o tych wyjątkach znajdziesz w dodatku A).

66 Python Rozdział 5: Przepływ sterowania 67 Wszystkie wyjątki z tej samej grupy mogą być przechwytywane za pomocą jednej klauzuli except, jeśli się poda w niej nazwę tej grupy. Na przykład: try: instrukcje except LookupError: # Bł ąd IndexError lub KeyError instrukcje lub try: instrukcje except StandardError: instrukcje # Wszystkie bł ędy wbudowane

Definiowanie nowych wyj ątków Wszystkie wyjątki wbudowane są zdefiniowane na zasadzie klas. Aby utworzyć nowy wyjątek, trzeba utworzyć nową definiq'e klasy, dziedziczącą po klasie exceptions . Exception, na przykład: import exceptions # Exception class class NetworkError(exceptions.Exception): def__init__(self, args=None) : self.args = args Nazwa args powinna być używana tak, jak to jest pokazane wyżej. Dzięki temu wartość podawana w instrukqi raise może być prawidłowo drukowana w ramach śladu lub innych informacji diagnostycznych. Innymi słowy instrukcja raise NetworkError, "Nie mo żna odnale źć hosta. " tworzy instancję wyjątku NetworkError za pomocą wywołania NetworkError("Nie mo żna odnale źć hosta. ") Nowy obiekt będzie się wyświetlał jako NetworkError: Nie można odna- leźć hosta. Jeśli użyjesz innej nazwy niż self . args lub nie zapiszesz argumentu, stracisz możliwość prawidłowego wyświetlania wyjątku. Podczas zgłoszenia wyjątku nieobowiązkowa wartość podana w instrukcji raise jest używana jako argument konstruktora klasy wyjątku. Jeśli konstruktor wymaga więcej niż jednego argumentu, można zgłosić wyjątek na dwa sposoby: import exceptions # Klasa wyj ątku class NetworkError(exceptions.Exception): def__init__(self,errno,msg) : self.args = (errno, msg) self.errno = errno self.errmsg = msg # Zgłoszenie wyj ątku (wiele argumentów) def error2 () : raise NetworkError(1, 'Host not found') # Zgłoszenie wyj ątku (wiele argumentów) def error3(): raise NetworkError, (1, 'Host not found') Wyjątki oparte na klasach umożliwiają tworzenie hierarchii wyjątków. Na przykład zdefiniowany wcześniej wyjątek NetworkError może posłużyć jako klasa bazowa dla wielu innych, bardziej konkretnych błędów typu: class HostnameError(NetworkError): ps pass class TimeoutError(NetworkError): pass def error3(): raise HostnameError def error4(): raise TimeoutError try: error3 () except NetworkError: import sys print sys.exc_type

# Podaje typ wyj ątku W tym przypadku instrukqa except NetworkError przechwytuje dowolny wyjątek wywodzący się od NetworkError. Aby znaleźć konkretny typ zgłoszo- nego błędu, trzeba sprawdzić zmienną sys .exc_type. Z kolei zmienna sys . exc_value zawiera wartość ostatniego wyjątku. Alternatywą jest korzystanie z funkqi sys . exc_inf o (), która zwraca informacje o wyjątku w sposób niezależny od zmiennych globalnych i działa poprawnie również w przypadku wielu wątków.

Asercje i wartość___debug Instrukcja assert używana jest do wstawiania kodu debugującego program. Ogólna postać tej instrukqi wygląda następująco: assert test [, data] gdzie test jest wyrażeniem, które powinno mieć wartość prawda lub fałsz. Jeśli test ma wartość fałsz, instrukcja assert zgłasza wyjątek AssertionError ewentualnie razem z podaną w niej nieobowiązkową wartością data. Na przykład: def write_data(file,data): assert file, "write_data: podany plik to None! Instrukqa assert jest tłumaczona wewnątrz translatora na następujący kod: if__debug__: if not (test): raise AssertionError, data W Pythonie występuje wbudowana stała tylko do odczytu__debug__, która ma wartość 1, chyba że interpreter działa w trybie optymalizacji (włączanym za pomocą opcji -O). Chociaż stała ta jest używana głównie przez asercje, można ją również wykorzystywać do włączania własnego kodu debugującego program.

68 Python Instrukcja assert nie powinna być używana do wykonywania kodu niezbędne- go do poprawnego działania programu, gdyż grozi to pominięciem go w przy- * padku uruchomienia Pythona w trybie optymalizacji. Szczególnym błędem jest wykorzystywanie instrukcji assert do sprawdzania danych wprowadzanych przez użytkownika. Zamiast tego powinna ona służyć do sprawdzania tych warunków, które mają być zawsze spełnione - jeśli jeden z nich zostanie po- gwałcony, będzie to oznaczać błąd w programie, a nie pomyłkę użytkownika. Na przykład, jeśli pokazana wcześniej funkcja writedata () miałaby służyć końcowemu użytkownikowi, instrukcję assert należałoby zamienić na kon- wencjonalną instrukcję if i odpowiednią procedurę obsługi błędu. Rozdział 6

Funkcje i programowanie funkcjonalne

Większość poważnych programów jest dzielonych na funkqe w celu uzyskania lep- szej modularności i usprawnienia ich konserwacji. Python pozwala bardzo łatwo definiować funkcje, wykorzystując różne pomysły zaczerpnięte z języków programowania funkqonalnego, ułatwiające wykonywanie pewnych zadań. W tym rozdziale omówimy funkcje, funkcje anonimowe, elementy programowania funkqonalnego, jak również funkqe eval () i execf i le () oraz instrukcję exec. Wyjaśni- my także, czym jest wybieranie listowe - szczególna metoda konstruowania list.

Funkcje Do definiowania funkcji służy instrukcja def. Oto przykład: def dodaj(x,y): return x+y Aby wywołać funkqe, należy napisać jej nazwę, a po niej tupię zawierającą argumenty funkqi, na przykład a = dodaj (3,4). Kolejność i liczba argumentów musi się zgadzać z podaną w definicji funkcji. W przypadku stwierdzenia różni- cy zgłaszany jest wyjątek TypeError. Przypisując wartości parametrom występującym w definicji funkcji, można usta- lać wartości domyślne jej argumentów: def coś(x,y,z = 42): Gdy w definicji funkqi występuje parametr z podaną wartością domyślną, parametr ten oraz wszystkie następujące po nim parametry są nieobowiązkowe. Jeśli któryś z parametrów nieobowiązkowych nie ma przypisanej wartości w definicji funkqi, powoduje to zgłoszenie wyjątku SyntaxError. Parametry funkcji przyjmują zawsze takie same wartości domyślne, jakie miały użyte w tym celu obiekty podczas definiowania funkcji. Na przykład: a = 10 def fun(x = a): print x a = 5 fun () # Zmiana warto ści 'a 1. # Wyświetla '10' (warto ść domy ślna bez zmian)

70 Python Rozdział 6: Funkcje i programowanie funkcjonalne 71 Jednak wykorzystywanie obiektów zmiennych jako wartości domyślnych może prowadzić do niezamierzonych sytuacji: a = [10] def fun(x = a): print x a.append(20) fun() # Wyświetla '[10, 20]' Jeśli na końcu nazwy ostatniego parametru występuje gwiazdka (*), to funkcja może przyjmować dowolną liczbę argumentów: def fprintf(file, fmt, *args): file.write(fmt % args) # Wywołanie fprintf. args gets (42, "witaj świecie", fprintf(out,"%d %s %f", 42, "witaj świecie", 3.45) 3.45) W tym przypadku wszystkie argumenty do zapisania są umieszczane w postaci rupii w zmiennej args. Aby przekazać tupię args do innej funkcji, jakby to były argumenty, można użyć następującej składni: def printf(fmt, *args): # Wywołanie innej funkcji i przekazanie do niej arg s fprintf(sys.stdout, fmt, *args) Można również przekazywać argumenty funkcji, jawnie nazywając każdy parametr i podając jego wartość: def fun(w,x,y,z): print w,x,y,z # Specyfikacja argumentów za pomoc ą nazw parametrów foo(x=3, y=22, w='witaj', z=[l,2]) Przy tego typu wywołaniu (zwanym wywołaniem z użyciem argumentów hasłowych) kolejność parametrów nie ma żadnego znaczenia. Jeśli jednak nie używasz wartości domyślnych, to musisz wtedy jawnie podać nazwy wszystkich parametrów funkqi. Pominięcie któregokolwiek z obowiązkowych parametrów lub podanie choć jednej nazwy niezgodnej z tą, jaka występuje w definicji funkcji, spowoduje zgłoszenie wyjątku TypeError. Argumenty pozycyjne i argumenty hasłowe mogą występować nawet w tym samym wywołaniu funkqi, o ile tylko wszystkie argumenty pozycyjne są podane jako pierwsze. Na przykład: fun('witaj1, 3, z=[l,2], y=22) Jeśli ostatni parametr w definicji funkcji zaczyna się od dwóch gwiazdek (**)/ wszystkie dodatkowe argumenty hasłowe (takie, które nie pasują do żadnej nazwy parametru - ang. keyword arguments) są umieszczane w słowniku i przekazywane do tej funkcji. Oto przykład: def spam(**parms): print "Podałe ś nast ępuj ące argumenty:" for k in parms.keys(): print "%s = %s" % (k, parms[k]) spam(x=3, a="witaj", co ś=(2, 3)) Można również łączyć dodatkowe argumenty hasłowe z listami argumentów zmiennej długości, o ile tylko nazwa ostatniego parametru zaczyna się od dwóch gwiazdek (**): # Akceptuje zmienn ą liczb ę argumentów pozycyjnych lub hasłowych def spam(x, *argpoz, **arghas): print x, argpoz, arghas Argumenty hasłowe mogą być także przekazywane do innej funkcji przy użyciu składni **arghas: def wołajfun(fun, *arg, print arg print arghas fun(*arg, **arghas) ^arghas) I wreszcie począwszy od wersji Pythona 2.1 funkcje i metody mogą mieć dołączo- ne dowolne atrybuty. Na przykład:

def fun(): print "Witaj świecie" fun.tajne = 1 fun.prywatne = 1 Atrybuty funkqi są przechowywane w słowniku dostępnym za pomocą atrybutu __diet__funkcji lub metody. Atrybuty funkcji są używane przede wszystkim w specjalistycznych aplikaqach, takich jak analizatory składni czy aplikacje sieciowe, które chciałyby dodać pewne informaq'e do funkcji. Poprzednio jedynym miejscem zapisywania takich informacji były napisy dokumentacyjne.

Przekazywanie parametrów i warto ści powrotnych Podczas wywoływania funkcji jej parametry są przekazywane przez odwołanie. Jeśli jakiś obiekt zmienny (taki jak lista lub słownik) zostaje przekazany do. funkcji, gdzie następnie ulega modyfikacji, taka zmiana będzie widoczna również w miejscu wywołania tej funkcji. Na przykład: a = [1,2,3,4,5] def fun (x): x[3] = -55 fun(a) print a # Modyfikacja elementu x # Przekazanie a # Wypisuje [1,2,3,-55,5] Instrukqa return służy do zwracania wartości przez funkcję. Jeśli instrukcja ta zostanie pominięta lub nie podasz w niej żadnej wartości, funkcja zwróci obiekt None. Aby zwrócić wiele wartości, można je umieścić w tupli: def dzielnik(a): d = 2 while (d <= (a/2)): if ((a/d)*d == a): return ( (a/d),d) d = d + 1 return (a,1)

72 Python flozdziaf 6: Funkcje i programowanie funkcjonalne 73 Wiele wartości zwróconych za pomocą tupli można przypisać do pojedynczej zmiennej: x,y = dzielnik(1243) (x,y) = dzielnik(1243) Zwrócone warto ści trafiaj ą do x i y. Wersja alternatywna. To samo działanie.

Reguły obowi ązywania zasi ęgu Za każdym razem, gdy dochodzi do wykonania jakiejś funkcji, tworzona jest nowa lokalna przestrzeń nazw. Przestrzeń ta obejmuje nazwy parametrów funkcji, jak również nazwy zmiennych używanych w treści tej funkcji. Przystępując do rozwiązania nazwy, interpreter zaczyna zawsze od przeszukania lokalnej przestrzeni nazw. (Przeczytaj uwagi poniżej dotyczące zagnieżdżania zasięgów). Jeśli nie zostanie znaleziona pasująca nazwa, przeszukiwana jest globalna prze- strzeń nazw. Globalną przestrzenią nazw dla funkcji jest zawsze moduł, w któ- rym funkcja ta została zdefiniowana. Jeśli przeszukiwanie globalnej przestrzeni nazw również zakończy się niepowodzeniem, interpreter sprawdza na koniec wbudowaną przestrzeń nazw. Gdy i to nic nie da, zgłaszany jest wyjątek Name- Error. Jedną z cech szczególnych przestrzeni nazw jest operowanie zmiennymi global- nymi z wnętrza funkcji. Przyjrzyj się następującemu fragmentowi kodu: a = 42 def fun () : a = 13 fun () print a Wykonanie tego kodu powoduje wyświetlenie wartości 42, mimo wrażenia, że zmienna a powinna zostać zmodyfikowana wewnątrz funkqi fun. Gdy w treści funkqi następuje przypisanie wartości do zmiennej, ta ostatnia jest zawsze umieszczana w lokalnej przestrzeni nazw. W efekcie zmienna a w treści funkqi z ostatniego przykładu odnosi się do całkowicie nowego obiektu o wartości 13. Aby zmienić tę sytuaqe, można użyć instrukcji global. Instrukcja ta sprawia po prostu, że podana w niej lista nazw zostaje przypisana do globalnej przestrzeni nazw. Korzysta się z niej tylko wtedy, gdy trzeba wewnątrz funkqi zmodyfiko- wać jakąś zmienną globalną. Instrukcję global można umieszczać w dowolnym miejscu treści funkcji, i to wielokrotnie. Na przykład: a = 42 def fun () : global a a = 13 fun () print a # 'a' nale ży do globalnej przestrzeni nazw Wszystkie wersje Pythona zezwalają na zagnieżdżanie definicji funkcji. Jednak przed pojawieniem się wersji 2.1 zagnieżdżone funkqe nie zapewniały zagnie- żdżonych zasięgów nazw. W efekcie program korzystający z zagnieżdżanych funkcji nie zawsze działał zgodnie z oczekiwaniami. Na przykład w Pythonie 2.0 poniższy fragment kodu był dozwolony, ale nie działał prawidłowo: def funl(): x = 10 def fun2() : print ' while x > 0: fun2() x -= 1 # Zagnie żdżona definicja funkcji # Szuka x w globalnej przestrzeni nazw funl() # Zgłasza wyj ątek NameError z powodu 'x' W tym przykładzie podczas wykonywania zagnieżdżonej funkcji f un2 () jej glo-

balna przestrzeń nazw jest taka sama, jak globalna przestrzeń nazw fun 1 (), czyli modułu, w którym ta funkqa jest zdefiniowana. W rezultacie interpreter nie jest w stanie wewnątrz funkcji funl () rozwiązać żadnego symbolu z przestrzeni nazw f un2 () i zgłasza wyjątek NameError. Począwszy od Pythona 2.1 zagnieżdżanie zasięgów jest już zaimplementowane (tak więc powyższy przykład zadziała prawidłowo). Podczas rozwiązywania nazw najpierw sprawdzany jest lokalny zasięg, a następnie wszystkie kolejne za- sięgi zewnętrzne. W przypadku niepowodzenia, tak jak poprzednio sprawdzane są globalna oraz wbudowana przestrzeń nazw. Zwróć też uwagę, że w Pythonie 2.1 zagnieżdżanie zasięgów jest nieobowiązkowe i działa tylko wtedy, gdy wstawisz do swojego programu instrukcję from__future__import nested_scopes (zobacz rozdział 10, zatytułowany „Środowisko wykonania programu"). Ponadto, jeśli zależy ci na zgodności ze starszymi wersjami Pythona, powinieneś unikać stosowania funkcji zagnieżdżonych. Jeśli zmienna lokalna jest używana przed przypisaniem do niej wartości, powoduje to zgłoszenie wyjątku UnboundLocalError. Oto przykład: def fun () : print i i = 0 # Zgłasza wyj ątek UnboundLocalError

Rekurencja Python nakłada ograniczenie na liczbę rekurencyjnych wywołań funkcji. Aktual- nie obowiązujący limit zwraca funkqa sys .getrecursionlimit (). Uży- wając zaś funkqi sys . setrecursionlimit () można zmienić tę wartość. Do- myślnie ustawiona jest liczba 1000. W momencie przekroczenia maksymalnej liczby wywołań rekurencyjnych zgłaszany jest wyjątek Runtime Error.

Funkcja apply () Funkcja apply (func [, args [, kwargs]]) służy do pośredniego wywoływania funkqi, której argumenty zostały skonstruowane w postaci tupli lub słownika. Parametr args to tupla zawierająca argumenty pozycyjne, które trzeba przekazać do funkcji. Jeśli pominiesz tę tupię, żadne argumenty nie zo- staną przekazane. Z kolei parametr kwargs to słownik zawierający argumenty hasłowe (keyword arguments). Obie zamieszczone niżej instrukcje dają ten sam rezultat: fun(3, "x", imi ę='Dawid', id=12345) apply(fun (3, "x"), { 'imi ę1: 'Dawid' 'id': 12345 })

74 Python Rozdział 6: Funkcje i programowanie funkcjonalne 75 W starszych wersjach Pythona funkcja apply () stanowiła jedyną metodę wywoływania funkcji, w której argumenty były zawarte w tupli lub słowniku. Teraz można to robić w następujący sposób: a = (3,"x") b = { 'imi ę' fun(*a,**b) 'Dawid', 'id 1: 12345 } # To samo, co wy żej

Operator lambda Aby utworzyć funkcję anonimową w postaci wyrażenia, trzeba użyć instrukcji lambda: lambda argumenty : wyrażenie argumenty to lista argumentów oddzielonych przecinkami, a wyrażenie to wyrażenie wykorzystujące te argumenty. Na przykład: a = lambda x print a(2,3) y : x+y # daje 5 Kod definiowany w instrukqi lambda musi być poprawnym wyrażeniem. Nie może w nim występować wiele instrukcji „niewyrażeniowych", takich jak print, for czy while. Wyrażenia lambda podlegają tym samym regułom za- sięgu co funkq'e.

map (),zip (), reduce() i filter() Funkcja t = map (func, s) wykonuje funkcję func dla każdego elementu s i zwraca wynik w postaci nowej listy t. Każdy element t spełnia zasadę t [ i ] = func (s[i]). Funkcja podawana w map powinna wymagać tylko jednego argumentu. Na przykład: a = [1, 2, 3, 4, 5, 6] def coś(x): return 3*x b = map(coś,a) # b = [3, 6, 9, 12, 15, 18] To samo można by policzyć za pomocą funkcji anonimowej pisząc: b = mapdambda x: 3*x, a) # b = [3, 6, 9, 12, 15, 18] Funkcja map () może być również wywoływana z wieloma listami, czyli t = map (func, sl, s2, . . ., sn). W takim przypadku każdym elementem t jest t[i] = func(sl[i] , s2[i] , ..., sn [ i ]), a funkcja przekazy wana do map () musi akceptować tyle samo argumentów, ile jest podanych list. Wynik ma taką samą liczbę elementów, jak najdłuższa lista z sl, s2, . . ., sn. Podczas wykonywania funkcji krótsze listy są w razie potrzeby uzupełniane za pomocą wartości None do liczby elementów najdłuższej listy. Jeśli zamiast funkcji podana jest wartość None, przyjmowana jest domyślnie funkcja tożsamościowa. W przypadku przekazania wielu list do map {None, sl, s2, . . ., sn) funkcja zwraca listę tupli, z których każda zawiera po jednym elemencie z każdej listy. Na przykład: a = [1,2,3,4] b = [100,101,102,103] c = map(None, a, b) # c = [(1,100), (2,101), (3,102), (4,103)] Alternatywą dla map () jest utworzenie listy tupli przy użyciu funkcji zip (sl, s2, . . ., sn). Funkqa ta pobiera kolekcję sekwencji i zwraca nową listę t, w której każdy element ma postać t [ i ] = (sl[i], s2[i], ..., sn [i]). W odróżnieniu od map () funkcja zip () obcina długość t do najkrótszej sekwencji spośród sl, s2, . . ., sn. Na przykład: d = [1,2,3,4,5,6,7] e = [10,11,12] f = zip(d,e) #

f = [(1,10), (2,11), (3,12)] Funkqa reduce (func, s) pobiera dane z sekwencji i zwraca na ich podstawie pojedynczą wartość (na przykład sumę, wartość maksymalną i tak dalej). Jej działanie polega na zastosowaniu najpierw funkcji func do dwóch pierwszych elementów s, następnie zastosowaniu jej do uzyskanego wyniku i trzeciego elementu s, potem do kolejnego wyniku i czwartego elementu i tak dalej, aż do wyczerpania całej sekwencji. Funkcja func musi przyjmować dwa argumenty i zwracać pojedynczą wartość. Na przykład: def suma(x,y): return x+y b = reduce (suma, a) # b = ( ( (1+2)+3)+4) = 10 Funkcja filter (func, s) filtruje elementy s przy użyciu funkcji filtrującej func (), która zwraca wartość prawda lub fałsz. W efekcie zwracana jest nowa sekwenqa, która składa się z elementów x należących do s, dla których func (x) daje wartość prawda. Na przykład: c = filter(lambda x: x < 4, a) # c = [1, 2, 3] Jeśli zamiast func podana jest wartość None, przyjmowana jest domyślnie funkqa tożsa- mościowa i filter () zwraca wszystkie elementy s, które dają wartość prawda.

Wybieranie listowe Wiele operacji wykorzystujących funkcje map () i filter () można zastąpić operatorem konstrukcji list zwanym wybieraniem listowym. Jego składnia wygląda następująco: [wyra żenie for eleml in sekwencjal for elem2 in sekwencja2 for elemN in sekwencjaN if warunek] Składnia ta odpowiada z grubsza następującemu fragmentowi kodu: s = [] for eleml in sekwencjal: for elem2 in sekwencja2:

76 Python for elemN in sekwencjaN: if warunek: s.append (wyra żenie) Aby lepiej zrozumieć tę składnię, przyjrzyj się przykładom z listingu 6.1: Listing 6.1 Wybieranie listowe __________________________ a = [-3,5,2,-10,7,8] b = 'abc' c = [2*s for s in a] # c = [-6,10,4,-20,14,16] d = [s for s in a if s >= 0] # d = [5,2,7,8] e = [(x,y) for x in a for y in b if x > 0] f = [(1,2), (3,4), (5,6) g = [math.sqrt(x*x+y*y) for x,y in f] # e ■« [(5, 'a 1), (5, 'b'), (5, 'c'), # (2,'a'),(2,'b'),(2,'c 1), # (7,'a 1), (7,'b 1), (7,'c 1), # (8,'a'), (8,'b'), (8,'c')] # f = [2.23606, 5.0, 7.81024] h = reduce(lambda x,y: x+y, # Suma kwadratów [math.sqrt(x*x+y*y) for x,y in f]) Sekwencje podawane w operatorze wyboru listowego nie muszą być tej samej długości, gdyż ich zawartość jest przeglądana za pomocą zagnieżdżonego zbioru pętli for, jak to zostało pokazane na przykładzie. Lista wynikowa składa się z kolejnych wartości wyrażenia. Klauzula if jest nieobowiązkowa. Jeśli jednak występuje, za każdym razem następuje sprawdzenie warunku i dołączenie war- tości wyrażenia tylko wtedy, gdy warunek ten jest spełniony. Jeśli wybór listowy jest używany do konstruowania listy tupli, jej wartości muszą być ujęte w nawiasy okrągłe. Na przykład zapis [(x,y) for x in a for y in b] ma prawidłową składnię, natomiast [x, y for x in a for y in b] nie. Na koniec trzeba zwrócić koniecznie uwagę, że zmienne definiowane wewnątrz wyboru listowego są wyliczane w ramach bieżącego zasięgu i pozostają zdefiniowane po dokonaniu wyboru listowego. Na przykład w zapisie [x for x in a] zmienna iteracyjna x nadpisuje poprzednio zdefiniowaną wartość x (jeśli taka istniała), a po utworzeniu listy zachowuje wartość ostatniego utworzonego elementu.

eval (), exec (), execf ile () i compile () Funkcja eval (str [, globals [, locals] ] ) wykonuje wyrażenie zawarte w napisie str i zwraca uzyskany wynik. Na przykład: a = eval('3*math.sin(3.5+x) + 7.21) Z kolei instrukcja exec wykonuje dowolny kod Pythona zawarty w jej argumencie napisowym. Kod ten jest wykonywany w ramach bieżącej przestrzeni nazw - tak, jakby faktycznie występował w miejscu instrukcji exec. Na przykład:

L a = [3, 5, 10, 13] exec "for i in a: print i" Rozdział 6: Funkcje i programowanie funkcjonalne 77 Ostatnia z omawianych tutaj funkcji, execf ile (filename [, globals [, locals]]), wykonuje zawartość pliku. Oto przykład: execfile("coś.py") Wszystkie te funkqe wykonują się w ramach przestrzeni nazw kodu, który je wywołuje (przestrzeń ta używana jest do rozwiązywania wszelkich nazw symbolicznych pojawiających się w napisie lub pliku). W wywołaniu każdej z tych

funkcji można też podać (nieobowiązkowo) jeden lub dwa słowniki pełniące odpowiednio rolę globalnej i lokalnej przestrzeni nazw dla realizowanego przez nie kodu. Na przykład: globalne = { ' x': 7, ■y1: 10, 'ptaki 1: lokalne = { } ['Papuga', 'Jaskółka', 'Albatros'] # Wykorzystanie powy ższych słowników jako globalnej i lokalnej # przestrzeni nazw a = eval("3*x + 4*y", globalne, lokalne) exec "for b in ptaki: print b" in globalne, lokalne # Nietypowa składnia execfile("co ś.py", globalne, lokalne) Jeśli pominiesz jedną lub obie przestrzenie nazw, zostaną użyte bieżące ustawienia tych przestrzeni. Ponadto, w związku z problemami wynikającymi z za- gnieżdżania zasięgów, stosowanie exec lub execfile() w treści funkcji może powodować zgłaszanie wyjątku SyntaxError, jeśli funkcja ta zawiera dodatkowo zagnieżdżone definiqe funkcji lub korzysta z operatora lambda. Zwróć uwagę, że składnia exec w podanym przykładzie różni się od składni eval () i execfile () .Wynika to stąd, że exec jest instrukcją (podobną do print czy while), podczas gdy eval () i execfile () są funkqami wbudowanymi. Gdy do exec, eval () lub execfile () przekazywany jest napis, analizator składni kompiluje najpierw ten napis na kod bajtowy. Ponieważ jest to kosztowny proces, lepszym wyjściem może być prekompilacja kodu i wykorzystywanie tego samego kodu bajtowego w kolejnych wywołaniach, zwłaszcza jeśli kod ten ma być wykonywany wiele razy. Funkcja compile (str, filename, kind) kompiluje napis na kod bajtowy. Argument str zawiera napis, który ma być skompilowany, a filename to nazwa pliku, w którym napis ten został zdefiniowany (używana do generowania śladu). Argument kind określa typ kompilowanego kodu - 'single' to pojedyncza instrukcja, ' exec ' to zbiór instrukcji, a ' eval' to wyrażenie. Obiekt typu kod zwracany przez funkcję compile () może zostać następnie przekazany do funkq'i eval () lub instrukcji exec. Na przykład: str = "for i in range(0,10): print i" c = compile(str,'','exec') # Kompilacja na obi ekt typu kod exec c # Wykonanie go str2 = "3*x + 4*y" c2 = compile(str2, result = eval(c2) 'eval') # Kompilacja na wyra żenie # Wykonanie go

Rozdział 7

Klasy i programowanie obiektowe

Klasy są podstawowym narzędziem używanym do tworzenia struktur danych i nowych rodzajów obiektów. Rozdział ten zawiera dokładne omówienie klas, ale nie stanowi w zamyśle wprowadzenia do programowania i projektowania obiektowego. Od czytelnika oczekuje się pewnego doświadczenia w posługiwa- niu się strukturami danych i programowaniu obiektowym w innych językach, takich jak C czy Java. (Dodatkowe informacje o terminologii i wewnętrznej implementacji obiektów znajdują się w rozdziale 3, zatytułowanym „Typy i obiekty").

Instrukcja class Klasa definiuje zbiór atrybutów skojarzonych z kolekcją obiektów zwanych instancjami. Atrybuty te obejmują zazwyczaj zmienne nazywane zmiennymi klasy i funkcje nazywane metodami. Klasy są definiowane przy użyciu instrukcji class. Treść klasy składa się z szeregu instrukcji wykonywanych tylko raz w momencie definiowania klasy (zobacz listing 7.1). Listing 7.1 Klasy ________________________________________________________________ class Konto: "Prosta klasa" typ_konta = "Podstawowe" def__init__(self, nazwisko, saldo) : "Inicjalizacja nowej instancji Konta" self.nazwisko = nazwisho self.saldo = saldo def wpłata(self,kwota): "Wpłata na konto" self.saldo = self.saldo + kwota def wypłata(self,kwota): "Pobranie z konta" self.saldo = self.saldo - kwota def info (self): "Stan konta" return self.saldo

80 Python Rozdział 7: Klasy i programowanie obiektowe 81 Obiekty tworzone podczas wykonywania treści klasy są umieszczane w obiekcie klasy służącym jako przestrzeń nazw. Na przykład składowe klasy Kont o są do- stępne w następujący sposób: Konto.typ_konta Konto.__init__ Konto.wpłata Konto.wypłata Konto.info Trzeba pamiętać, że instrukcja class nie tworzy żadnej instancji klasy (na przykład w podanym fragmencie kodu nie doszło do utworzenia żadnego konta). Klasa definiuje jedynie zbiór atrybutów dzielonych przez wszystkie instancje, które zostaną dopiero utworzone. Funkcje zdefiniowane wewnątrz klasy (metody) operują zawsze na instancji klasy przekazywanej do nich przez pierwszy argument. Zgodnie z konwencją argument ten nosi nazwę self, choć dozwolone jest używanie dowolnego identyfikatora. Zmienne klasy, takie jak t yp_konta, są dzielone przez wszystkie instancje klasy (innymi słowy nie są one tworzone oddzielnie dla każdej instancji). Cho- ciaż klasa definiuje własną przestrzeń nazw, przestrzeń ta nie stanowi zasięgu kodu stanowiącego treść klasy. W rezultacie odniesienia do innych atrybutów klasy muszą używać w pełni kwalifikowanych nazw, jak to jest pokazane w na- stępnym przykładzie: class co ś: def metl(self): print "metl! " def met2(self): metl (self) coś.metl(self) I jeszcze jedno na koniec. Nie można definiować metod klasy, które nie działają na instancjach: class co ś: def dodaj(x,y): return x+y a = co ś.dodaj(3,4) # Źle! 'metl 1 generuje NameError # To działa # TypeError. Pierwszym argumentem musi by ć # instancja klasy

Instancje klasy Instancje klasy powstają w wyniku wywołania obiektu klasy jako funkcji. Po- wstaje wówczas nie tylko nowa instancja, ale również wywoływana jest metoda __init__() tej klasy (o ile została wcześniej zdefiniowana). Na przykład: # Utworzenie kilku kont a = Konto("Gerard", 1000.00) # Wywołuje # Konto.__init__(a, "Gerard", 1000.00) b = Konto("Bogdan", 100000000000L) Po utworzeniu nowej instanqi klasy jej atrybuty i metody są dostępne za pomocą operatora kropki (.). Na przykład: a.wpłata(lOO.OO) b.wypłata(sys.maxint) nazwisko = a.nazwisko print a.typ_konta # Wywołuje Konto.wpłata(a,100.00) # Wywołuje Konto.wypłata(b,sys.maxint) # Pobiera nazwisko # Podaje typ konta Wewnętrznie każda instancja jest implementowana przy użyciu słownika do- stępnego przez jej atrybut__diet__(opisany szczegółowo w rozdziale 3). Słownik ten zawiera informacje unikatowe dla każdej instanqi. Na przykład: >» print a.__diet__ {'saldo': 1100.0, 'nazwisko': 'Gerard'}

»> print b.__diet__ {'saldo': 97852516353L, 'nazwisko 1: 'Bogdan'} Za każdym razem, gdy są modyfikowane atrybuty instancji, zmiany te zachodzą w lokalnym słowniku tej instancji. Wewnątrz zdefiniowanych w klasie metod atrybuty są modyfikowane za pomocą instrukcji przypisania do zmiennej self, jak to miało miejsce w pokazanych wcześniej metodach__init__(), wpłata () i wypłata () klasy Konto. W każdej chwili można za to dodać do instancji nowe atrybuty, choćby w taki sposób: a.numer = 123456 Dodaje atrybut 'numer' do a.__dict_ Mimo że przypisanie wartości do atrybutów następuje zawsze w lokalnym słow- niku instanqi, dostęp do tych atrybutów jest nieco skomplikowany. Przy każdej próbie dostępu interpreter przeszukuje najpierw słownik instancji. Jeśli nie znajdzie w nim pasującej nazwy, szuka dalej w słowniku obiektu klasy, która posłużyła do utworzenia instancji. Jeśli dalej nic nie znajdzie, przeszukuje kolejne klasy bazowe (szczegółowe informacje o klasach bazowych znajdziesz dalej w podrozdziale „Dziedziczenie"). Jeśli i to nic nie da, próbuje na koniec znaleźć atrybut za pomocą wywołania metody__getattr__() rodzimej klasy (jeśli taka jest zdefiniowana). Jeśli i ta ostatnia próba zakończy się niepowodzeniem, zgłaszany jest wyjątek AttributeError.

Zliczanie odniesie ń i usuwanie instancji Każda instancja ma swój licznik odniesień. Gdy jego wartość dojdzie do zera, instancja zostaje usunięta. W takim momencie interpreter próbuje odszukać skoja- rzoną z tym obiektem metodę__de 1__() i wywołuje ją, jeśli istnieje. W praktyce rzadko kiedy trzeba definiować w klasie metodę__del__. (). Jedynym wyjątkiem jest sytuacja, gdy usunięcie obiektu wymaga dodatkowego „sprząta- nia", takiego jak zamknięcie pliku, lub połączenia sieciowego albo zwolnienia innych zasobów systemowych. Ale nawet wówczas niebezpiecznie jest polegać na metodzie__del__(), gdyż nie ma gwarancji, że zostanie ona wywołana w momencie zamykania interpretera. Lepszym rozwiązaniem jest zdefiniowanie metody takiej jak close (), której program będzie jawnie używał do kończenia swojej pracy. Na koniec zwróć uwagę, że instancje, dla których jest zdefiniowana metoda__del__(), nie mogą być zwalniane przez cyklicznie działające narzę- dzie Pythona do pozyskiwania pamięci (co jest poważnym argumentem przeciw- ko definiowaniu tej metody, o ile nie jest potrzebna). Więcej szczegółów znajdziesz w dodatku A, „Biblioteka Pythona", przy okazji modułu gc.

80 Python Rozdział 7: Klasy i programowanie obiektowe 81 Obiekty tworzone podczas wykonywania treści klasy są umieszczane w obiekcie klasy służącym jako przestrzeń nazw. Na przykład składowe klasy Kont o są do- stępne w następujący sposób: Konto.typ_konta Konto.__init__ Konto.wpłata Konto.wypłata Konto.info Trzeba pamiętać, że instrukcja class nie tworzy żadnej instancji klasy (na przykład w podanym fragmencie kodu nie doszło do utworzenia żadnego konta). Klasa definiuje jedynie zbiór atrybutów dzielonych przez wszystkie instancje, które zostaną dopiero utworzone. Funkcje zdefiniowane wewnątrz klasy (metody) operują zawsze na instancji klasy przekazywanej do nich przez pierwszy argument. Zgodnie z konwencją argument ten nosi nazwę self, choć dozwolone jest używanie dowolnego identyfikatora. Zmienne klasy, takie jak t yp_konta, są dzielone przez wszystkie instancje klasy (innymi słowy nie są one tworzone oddzielnie dla każdej instancji). Cho- ciąż klasa definiuje własną przestrzeń nazw, przestrzeń ta nie stanowi zasięgu kodu stanowiącego treść klasy. W rezultacie odniesienia do innych atrybutów klasy muszą używać w pełni kwalifikowanych nazw, jak to jest pokazane w na- stępnym przykładzie: class co ś: def metl(self): print "metl! " def met2(self): metl(self) # Źle! 'metl' generuje NameError coś.metl(self) # To działa I jeszcze jedno na koniec. Nie można definiować metod klasy, które nie działają na instancjach: class co ś: def dodaj(x,y): return x+y a = co ś.dodaj(3,4) # TypeError. Pierwszym argumentem musi by ć # instancja klasy

Instancje klasy Instancje klasy powstają w wyniku wywołania obiektu klasy jako funkcji. Po- wstaje wówczas nie tylko nowa instancja, ale również wywoływana jest metoda __init__() tej klasy (o ile została wcześniej zdefiniowana). Na przykład: # Utworzenie kilku kont a = Konto("Gerard", 1000.00) # Wywołuje # Konto.__init__(a, "Gerard", 1000.00) b = Konto("Bogdan", 100000000000L) Po utworzeniu nowej instancji klasy jej atrybuty i metody są dostępne za pomocą operatora kropki (.). Na przykład: a.wpłata(100.00) b.wypłata(sys.maxint) nazwisko = a.nazwisko print a.typ_konta # Wywołuje Konto.wpłata(a,100.00) # Wywołuje Konto.wypłata(b,sys.maxint) # Pobiera nazwisko # Podaje typ konta Wewnętrznie każda instancja jest implementowana przy użyciu słownika do- stępnego przez jej atrybut__diet__(opisany szczegółowo w rozdziale 3). Słownik ten zawiera informacje unikatowe dla każdej instancji. Na przykład: >>> print a.__diet__ {'saldo': 1100.0, 'nazwisko': 'Gerard'} >>> print b.__diet__ {'saldo': 97852516353L, 'nazwisko': 'Bogdan'}

Za każdym razem, gdy są modyfikowane atrybuty instancji, zmiany te zachodzą w lokalnym słowniku tej instancji. Wewnątrz zdefiniowanych w klasie metod atrybuty są modyfikowane za pomocą instrukcji przypisania do zmiennej self, jak to miało miejsce w pokazanych wcześniej metodach__init__(), wpłata() iwypłata() klasy Konto. W każdej chwili można za to dodać do instancji nowe atrybuty, choćby w taki sposób: a.numer = 123456 # Dodaje atrybut 'numer' do a.__ diet__ Mimo że przypisanie wartości do atrybutów następuje zawsze w lokalnym słow- niku instancji, dostęp do tych atrybutów jest nieco skomplikowany. Przy każdej próbie dostępu interpreter przeszukuje najpierw słownik instancji. Jeśli nie znajdzie w nim pasującej nazwy, szuka dalej w słowniku obiektu klasy, która posłużyła do utworzenia instancji. Jeśli dalej nic nie znajdzie, przeszukuje kolejne klasy bazowe (szczegółowe informacje o klasach bazowych znajdziesz dalej w podrozdziale „Dziedziczenie"). Jeśli i to nic nie da, próbuje na koniec znaleźć atrybut za pomocą wywołania metody__getattr__() rodzimej klasy (jeśli taka jest zdefiniowana). Jeśli i ta ostatnia próba zakończy się niepowodzeniem, zgłaszany jest wyjątek AttributeError.

Zliczanie odniesie ń i usuwanie instancji Każda instancja ma swój licznik odniesień. Gdy jego wartość dojdzie do zera, instancja zostaje usunięta. W takim momencie interpreter próbuje odszukać skoja- rzoną z tym obiektem metodę__de 1__() i wywołuje ją, jeśli istnieje. W praktyce rzadko kiedy trzeba definiować w klasie metodę__del__(). Jedynym wyjątkiem jest sytuacja, gdy usunięcie obiektu wymaga dodatkowego „sprząta- nia", takiego jak zamknięcie pliku, lub połączenia sieciowego albo zwolnienia innych zasobów systemowych. Ale nawet wówczas niebezpiecznie jest polegać na metodzie__del__(), gdyż nie ma gwarancji, że zostanie ona wywołana w momencie zamykania interpretera. Lepszym rozwiązaniem jest zdefiniowanie metody takiej jak close (), której program będzie jawnie używał do kończenia swojej pracy. Na koniec zwróć uwagę, że instancje, dla których jest zdefiniowana metoda__del__(), nie mogą być zwalniane przez cyklicznie działające narzę- dzie Pythona do pozyskiwania pamięci (co jest poważnym argumentem przeciw- ko definiowaniu tej metody, o ile nie jest potrzebna). Więcej szczegółów znajdziesz w dodatku A, „Biblioteka Pythona", przy okazji modułu gc.

82 Python Rozdział 7: Klasy i programowanie obiektowe 83 Czasem program używa instrukqi del do usunięcia odniesienia do obiektu. Jeśli powoduje to zmniejszenie licznika odniesień danego obiektu do zera, wywoływa- na jest metoda__del__(). Ogólnie jednak instrukcja del nie implikuje bezpo- średnio wywołania tej metody.

Dziedziczenie Dziedziczenie to mechanizm tworzenia nowych klas zawężających lub modyfi- kujących zachowanie się jakiejś istniejącej już klasy. Oryginalna klasa nazywana jest w takiej sytuacji klasą bazową lub superklasą, zaś nowa klasa nazywana jest klasą pochodną lub podklasą. Gdy klasa powstaje w wyniku dziedziczenia, standardowo „dziedziczy" wszystkie atrybuty swojej klasy bazowej. Klasa potomna może jednak przedefiniować dowolne z tych atrybutów, jak i dodać do nich własne. Dziedziczenie zapisuje się w instrukcji klas za pomocą listy oddzielonych przecinkami nazw klas bazowych. Oto przykład: class A: varA = 42 def metodal(self): print "Klasa A class B: varB = 37 def metodal(self): print "Klasa B def metoda2(self) : print "Klasa B metodal" metodal' metoda2' class C(A,B): # Dziedziczy po A i B varC =3.3 def metoda3(self): print "Klasa C : metoda3" class D: pass class E(C,D): pass Podczas wyszukiwania atrybutu zdefiniowanego w klasie bazowej, sprawdzane są wszystkie klasy bazowe (przy użyciu algorytmu przeszukiwania w głąb) w takiej kolejności, w jakiej występują w definicji klasy pochodnej. W przypadku klasy E z ostatniego przykładu będzie to więc kolejność C, A, B, D. Gdyby szukany symbol był zdefiniowany w kilku klasach bazowych, w wyniku tego procesu zo- stałby użyty pierwszy znaleziony. Na przykład: c = C() c.metoda3() c.metodal() c. varB # Tworzy 'C # Wywołuje C.metoda3(c) # Wywołuje A.metodal(c) # Si ęga do B.varB Jeśli klasa pochodna definiuje atrybut o tej samej nazwie, co atrybut klasy bazowej, instanq'e klasy pochodnej będą używały atrybutu tej klasy, a nie klasy bazowej. Gdyby zaszła kiedykolwiek potrzeba odwołania się do oryginalnego atrybutu, można wówczas użyć w pełni kwalifikowanej nazwy atrybutu: class D(A): def metodal(self): print "Class D A.metodal(self) metodal" # Wywołuje metod ę klasy bazowej Taka możliwość przydaje się szczególnie podczas inicjalizowania instanqi klasy. W momencie tworzenia instancji nie jest bowiem wywoływana metoda __i nit__() klasy bazowej. WTezultacie to klasa pochodna musi w razie po-

trzeby prawidłowo zainiq'alizowac swoją klasę bazową. Na przykład: class D(A): def__init__(self, argsl) : # Inicjalizacja klasy bazowej (A) A.__init__(self) # Inicjalizacja klasy bie żącej (D) Podobne działania mogą być również potrzebne w trakcie definiowania „sprzątania" w metodzie__del__().

Polimorfizm Polimorfizm, inaczej wiązanie dynamiczne, opiera się w całości na procesie wyszukiwania atrybutu opisanym dokładnie w poprzednim podrozdziale dotyczącym dziedziczenia. Przy każdej próbie dos tępu do metody w formie obiekt.metoda (), lokalizacja tej metody następuje w wyniku przeszukiwania kolejno atrybutu __diet__instanqi, definicji klasy tej instancji, a następnie klas bazowych. Pierwsza znaleziona pozycja jest uznawana za metodę, którą należy wykonać.

Ukrywanie informacji Standardowo wszystkie atrybuty są „publiczne". Oznacza to, że wszystkie atrybuty instancji klasy są dostępne bez żadnych ograniczeń. W efekcie wszystko, co jest zdefiniowane w klasie bazowej, jest dziedziczone i udostępniane przez jej klasę pochodną. Taki mechanizm bywa często niepożądany w aplikacjach obiektowych, gdyż pociąga za sobą ujawnianie wewnętrznej implementaqi obiektu oraz może prowadzić do konfliktów między przestrzenią nazw zdefiniowaną w klasie pochodnej i tą, która jest zdefiniowana w klasie bazowej. Aby rozwiązać ten problem, wszystkie nazwy w klasie, które zaczynają się od dwóch znaków podkreślenia, takie jak__coś, są przekształcane na nowe nazwy postaci _NazwaKlasy__coś. Jest to skuteczny sposób na uzyskanie przez klasę prywatnych atrybutów, gdyż takie same nazwy używane w klasie pochodnej i w klasie bazowej nie będą już ze soi ą kolidować. Na przykład: class A: def__init__(self): self.__X = 3 class B(A): def__init__(self) : A.__init__(self) self. X = 37 Zamienia si ę w self. A X # Zamienia si ę w self._B__X

84 Python Rozdział 7: Klasy i programowanie obiektowe 85 Chociaż opisana reguła stwarza pozory ukrywania danych, w rzeczywistości nie istnieje na razie żaden bezpośredni mechanizm uniemożliwiający dostęp do „prywatnych" atrybutów klasy. W szczególności, jeśli nazwa klasy i nazwa jej atrybutu prywatnego są znane, można dostać się do tego ostatniego, jawnie po- dając jego przekształconą nazwę.

Przeci ążanie operatorów Obiekty zdefiniowane przez użytkownika mogą korzystać ze wszystkich operato- rów wbudowanych Pythona, jeśli tylko zaimplementuje się w ich klasach metody specjalne opisane w rozdziale 3. Na przykład klasa z listingu 7.2 implementuje liczby zespolone dopuszczające korzystanie z niektórych standardowych operato- rów matematycznych i mieszanie ich z liczbami całkowitymi oraz zmiennoprzecinkowymi (dzięki sprowadzaniu do zgodności typów). Listing 7.2 Operatory matematyczne i sprowadzanie do zgodno ści typów class Complex: def__init__(self, real, imag=0) : self.real = float(real) self.imag = float(imag) def__repr__(self) : return "Complex(%s,%s)" % (self.real, self.imag) def__str__(self): return "(%g+%gj)" % (self.real, self.imag) # self + inna liczba def__add__(self, inna): return Complex(self.real + inna.real, self.imag + i nna.imag) # self - inna def__sub__(self, inna): return Complex(self.real - inna.real, self.imag - i nna.imag) # -self def__neg__(self) : return Complex(-self.real, -self.imag) # inna + self def__radd__(self, inna): return Complex.__add__(inna, self) # inna - self def__rsub__(self, inna): return Complex.__sub__(inna, self) # Zmiana innych typów numerycznych na complex def__coerce__(self, inna): if isinstance(inna,Complex): return self,inna try: # Czy mo żna konwertowa ć na float return self, Complex(float(inna)) except ValueError: pass W podanym przykładzie warto zwrócić uwagę na kilka rzeczy: • Po pierwsze, standardowym zadaniem metody__repr__() jest utworzenie napisu, którego ewaluaqa powodowałaby odtworzenie obiektu. W tym przypadku powstaje więc napis "Complex (r, i) ". Z drugiej strony występuje metoda__str__(), która tworzy napis przeznaczony do ładnego formatowania wyjścia (jest to napis, który zostałby wyprodukowany przez instrukqe print). • Po drugie, aby dopuścić stosowanie operatorów z liczbami zespolonymi wy- stępującymi zarówno po lewej, jak i po prawej ich stronie, dla każdego z nich muszą być zdefiniowane dwie metody:__op__() i__rop__(). • I wreszcie metoda__coerce__, która obsługuje operacje o mieszanych typach danych. W tym przypadku to inne typy numeryczne są konwertowane na wartości zespolone, aby można ich było użyć w metodach arytmetycznych klasy Complex.

Klasy, typy i sprawdzanie przynale żności

Aktualnie istnieje w Pythonie rozróżnienie między typami i klasami. Szczególnie typy wbudowane, takie jak listy i słowniki nie mogą być ustalane za pomocą dziedziczenia, a klasy nie mogą definiować nowych typów. W rzeczywistości wszystkie definiqe klas mają typ ClassType, a wszystkie instancje klas mają typ InstanceType. W efekcie podane niżej wyrażenie ma wartość prawda dla dowolnych dwóch obiektów, które są instancjami jakiejś klasy (nawet, jeśli są to dwie różne klasy): type(a) == type(b) Aby sprawdzić przynależność obiektu do jakiejś klasy, można użyć funkcji wbudowanej isinstance (obj, cnamei. Funkq'a ta zwraca wartość prawda, jeśli obiekt obj należy do klasy cname lub jej dowolnej klasy pochodnej. Na przykład: class A: pass class B(A): pass class C: pass a = A() b = B() c = C() isinstance(a,A) isinstance(b,A) isinstance(b,C) # Instancja 'A' # Instancja 'B' # Instancja 'C # Zwraca 1 # Zwraca 1, B pochodzi od A # Zwraca 0, C nie pochodzi od A Z kolei funkcja wbudowana issubclassU, B) zwraca wartość prawda, jeśli klasa A jest podklasą klasy B. Na przykład: issubclass(B,A) issubclass(C,A) # Zwraca 1 # Zwraca 0 Funkcja isinstance () może być używana do porównywania typu obiektu z dowolnym wbudowanym typem danych: import types isinstance (3, types.IntType) # Zwraca 1 isinstance (3, types.FloatType) # Zwraca 0 Jest to zalecany sposób sprawdzania typu, jako że rozróżnienie między typami a klasami może zniknąć w przyszłych wersjach Pythona.

Rozdział 8

Moduły i pakiety

Długie programy pisane w Pythonie są często organizowane w postaci pakietu modułów. Ponadto dużą liczbę modułów można znaleźć w bibliotece Pythona. W tym rozdziale bardziej szczegółowo niż dotąd zajmiemy się systemem modułów i pakietów.

Moduły Dowolny poprawny plik źródłowy Pythona można zamienić w moduł, ładując go przy użyciu instrukcji import. Weźmy jako przykład następujący fragment kodu: # plik: plik.py a = 37 # Zmienna def funl: # Funkcja print "To jest funl" class co ś: # Klasa def fun2(self): . print "To jest co ś.fun2" b = co ś () # Utworzenie instancji Aby załadować ten kod w formie modułu, trzeba użyć instrukcji import plik. Gdy instrukcja import ładuje jakiś moduł po raz pierwszy, wykonuje nastę- pujące trzy działania: 1. Tworzy nową przestrzeń nazw, która służy za przestrzeń nazw dla wszystkich obiektów zdefiniowanych w pliku źródłowym modułu. Przestrzeń ta jest przeszukiwana, gdy funkcje i metody zdefiniowane w module używają instrukcji global. 2. Wykonuje kod zawarty w module w ramach nowo utworzonej przestrzeni nazw. 3. Tworzy w kodzie wywołującym nazwę odnoszącą się do przestrzeni nazw modułu. Nazwa ta pokrywa się z nazwą modułu i jest używana w nastę- pujący sposób: import plik # Ładuje i wykonuje moduł module 'plik 1 print plik.a # Odczytuje składowa, modułu ' plik' plik.funl() c = plik.fun2()

88 Python Rozdział 8: Moduły i pakiety 89 Aby dokonać importu wielu modułów jednocześnie, trzeba podać w instrukcji import listę nazw tych modułów oddzielonych przecinkami, na przykład: import socket, os, regex Używając kwalifikatora as można importować moduły pod zmienionymi nazwami. Na przykład: import os as system import socket as sieci, thread as w ątki system.chdir("..") sieci.gethostname() Instrukcja from pozwala ładować wybrane definicje z modułu do bieżącej przestrzeni nazw. Instrukcja ta jest niemal identyczna jak import z tą różnicą, że zamiast tworzyć nazwę odnoszącą się do nowo utworzonej przestrzeni nazw modułu, umieszcza w bieżącej przestrzeni nazwy odnoszące się do wymienionych w niej obiektów zdefiniowanych w tym module: from socket import gethostname print gethostname() socket.gethostname() # Wstawia gethostname do bie żącej # przestrzeni nazw # Niepotrzebna nazwa modułu # NameError: socket Instrukcja from akceptuje ponadto listy oddzielonych przecinkami nazw: modułów. Używając znaku gwiazdki (*) można ponadto załadować wszystkie definicje występujące w module z wyjątkiem tych, których nazwy zaczynają się od podkreślenia. Na przykład: from socket import gethostname, socket from socket import * # Ładuje wszystkie definicje do bie żącej # przestrzeni nazw Moduły mogą dokładniej kontrolować zbiór nazw, które są importowane przez instrukcj ę from moduł import *, definiuj ąc listę__all__. Na przykład: # plik: plik.py __all__= ['funl 1, 'co ś'] # Nazwy importowane przez * Ponadto używając kwalifikatora as można przemianowywać konkretne obiekty\ importowane przez from. Na przykład: from socket import gethostname as hostname h = hostname() Instrukcja import może występować w dowolnych miejscach programu. Kod każdego modułu jest jednak ładowany i wykonywany tylko raz, bez względu n~ to, ile razy pojawi się w tej instrukcji. Każda kolejna instrukq'a import tworzy po prostu odniesienie do przestrzeni nazw modułu utworzonej w czasie poprzedniego importu. Wszystkie aktualnie załadowane moduły są wymienione w słow- niku dostępnym za pomocą zmiennej sys .modules. Słownik ten mapuje nazwy modułów na występujące w nich obiekty. Zawartość tego słownika pozwala ustalić, czy instrukcja import ma załadować świeżą kopię modułu. Instrukq'a from moduł import * może być używana tylko na najwyższym poziomie modułu. W szczególności nie wolno korzystać z niej wewnątrz treści funkqi, gdzie kolidowałaby z obowiązującymi regułami zasięgu. Każdy moduł definiuje zmienną__name__, która zawiera nazwę modułu. Pro- gramy mogą sprawdzać tę zmienną, aby ustalić, do którego modułu należy aktualnie wykonywany kod. Na najwyższym poziomie interpretera znajduje się moduł o nazwie__main__. Programy uruchamiane z poziomu linii polecenia lub wprowadzane interakcyjnie są wykonywane wewnątrz modułu__main__. Czasami program może chcieć zmienić swoje działanie w zależności od tego, czy został zaimportowany, czy też wykonuje się w module__main__. Można to zrobić w następujący sposób: # Sprawdzenie, czy kod został uruchomiony jako prog ram if__name__== '__main__': # Tak

instrukcje else: # Nie, został zaimportowany jako moduł instrukcje

Ścieżka poszukiwa ń modułu W momencie ładowania modułu interpreter szuka go w katalogach wymienionych na liście zapisanej w zmiennej sys . path. Oto jak wygląda typowa wartość tej zmiennej: ['', '/usr/local/lib/python2.0', 1/usr/local/lib/pyth©n2.0/plat-sunos5', Vusr/local/lib/python2.0/lib-tk', '/usr/local/lib/python2.O/lib-dynload 1, 1/usr/local/lib/python2.O/site-packages'] Pusty napis odnosi się do bieżącego katalogu. Aby dodać nowy katalog do ścieżki poszukiwań, wystarczy po prostu dopisać go do listy.

Ładowanie i kompilowanie modułów Do tej pory wszystkie prezentowane w tym rozdziale moduły miały postać pli- ków zawierających kod napisany w Pythonie. W praktyce jednak moduły łado- wane za pomocą instrukcji import można podzielić na następujące cztery ogól- ne kategorie: • Programy napisane w Pythonie (pliki . py) • Skompilowane rozszerzenia C lub C++ w postaci bibliotek dzielonych lub plików DLL • Pakiety zawierające kolekcje modułów • Moduły wbudowane napisane w języku C i dołączane do interpretera Py thona

90 Python Szukając modułu coś interpreter szuka w każdym katalogu z listy zapisanej w zmiennej sys . path następujących plików (w podanej niżej kolejności): 1. Katalogu coś definiującego pakiet 2. Pliku coś . so, cośmodule. so, cośmodule . sl lub cośmodule. dli (rozszerzenia po kompilacji) 3. Pliku coś . pyo (tylko wtedy, gdy została użyta opcja -0 lub -00) 4. Pliku coś.pyc 5. Pliku coś.py Pakietami zajmiemy się wkrótce. Skompilowane rozszerzenia są opisane w dodatku B, zatytułowanym „Rozszerzanie i osadzanie Pythona". Jeśli chodzi o plik • PY/ przy pierwszym imporcie modułu jest on kompilowany na kod bajtowy i zapisywany z powrotem na dysku jako plik . pyc. Podczas kolejnych importo- wań interpreter ładuje ten prekompilowany kod bajtowy, chyba że data modyfikacji pliku . py jest nowsza (w takim przypadku plik .pyc jest generowany ponownie). Pliki z końcówką . pyo są używane przy włączonej opcji -0 interpretera. Pliki te zawierają kod bajtowy pozbawiony numerów linii, asercji i innych informacji potrzebnych do debugowania. W rezultacie pliki te są mniejsze i umożliwiają nieco szybszą pracę interpretera. Zastąpienie opcji -0 opcją -00 powoduje dodatkowo usunięcie z pliku napisów dokumentacyjnych. Usuwanie tych napisów ma miejsce w trakcie tworzenia pliku .pyo, a nie podczas jego ładowania. Jeśli żaden z podanych dotąd plików nie istnieje w katalogach wymienionych na zmiennej sys .path, interpreter sprawdza, czy użyta nazwa nie pasuje do żadnego modułu wbudowanego. Jeśli nie, zgłaszany jest wyjątek Im- portError. Kompilacja plików do postaci . pyc lub . pyo następuje tylko w wyniku użycia instrukcji import. Programy uruchomione z linii polecenia lub dostarczone przez standardowy strumień wejściowy nie generują takich plików. Gdy instrukcja import szuka plików, porównuje nazwy plików z uwzględnie- niem wielkości liter - nawet w tych komputerach, których system plików tego nie rozróżnia (jak na przykład Windows, choć ten akurat zachowuje oryginalną pi- sownię). W efekcie instrukcja import coś spowoduje tylko import pliku coś . py, a nie COŚ . PY. Pamiętaj jednak, że wersje Pythona wcześniejsze niż 2.1 nie radziły sobie z takim przypadkiem prawidłowo na wszystkich platformach. Jeśli zależy ci na zachowaniu zgodności z wcześniejszymi wersjami interpretera, staraj się uni- kać używania nazw modułów, które różniłyby się tylko wielkością liter.

Przeładowywanie modułu Funkcja wbudowana reload () umożliwia przeładowanie i wykonanie kodu zawartego w module załadowanym wcześniej za pomocą instrukcji import. Funk- cja ta przyjmuje tylko jeden argument wskazujący konkretny moduł. Na przykład: Rozdział 8: Moduły i pakiety 91 import co ś ... jaki ś kod reload(co ś) # Przeładowanie co ś Wszystkie operaq'e związane z modułem przeładowanym w wyniku wywołania reload () będą od tego momentu używały nowej wersji jego kodu. Nie spowoduje to natomiast aktualizacji obiektów utworzonych przez wcześniej załado- waną wersję modułu. W rezultacie nie mogą istnieć obok siebie odniesienia do obiektów w starym i nowym kodzie modułu. Ponadto nie można za pomocą r e - load () przeładowywać skompilowanych rozszerzeń napisanych w C lub C++. Zasadniczo należy unikać przeładowywania modułów, chyba że ma to miejsce podczas pisania lub debugowania programu.

Pakiety Pakiety pozwalają grupować moduły i udostępniać je pod jedną wspólną nazwą. Technika ta pomaga rozwiązywać konflikty w przestrzeni nazw między nazwami modułów używanych w różnych aplikaqach. Aby zdefiniować pakiet, wystarczy utworzyć katalog o nazwie tego pakietu i wstawić do niego plik __init__.py. Od tego momentu można umieszczać w nim dowolne pliki źródłowe, skompilowane rozszerzenia, a nawet tworzyć podpakiety. Przykłado- wa organizacja pakietu może wyglądać następująco: Grafika/ __init__.py ElemPodst/ __init__.py linie.py wypełnienia.py tekst.py Grafika2w/ __init__.py wykresy2w.py Grafika3w/ __init__.py wykresy3w.py Formaty/ __init__.py gif.py png.py tiff.py jpeg.py Instrukcja import pozwala ładować moduły z pakietu na kilka sposobów: • import Grafika.ElemPodst.wypełnienia Powoduje załadowanie podmodułu Grafika. ElemPodst. wypełnienia. Używając składników tego modułu, trzeba je jawnie nazywać, na przykład Grafika.ElemPodst.wypełnienia.pełne(obraz,x,y,kolor). • from Grafika.ElemPodst import wypełnienia Powoduje załadowanie podmodułu wypełnienia, ale z możliwością uży- wania go bez podawania nazwy pakietu jako przedrostka, na przykład wypełnienia.pełne(obraz,x,y,kolor).

92 Python • from Grafika.ElemPodst.wypełnienia import pełne Powoduje załadowanie podmodułu wypełnienia, ale z możliwością bezpo- średniego dostępu do funkcji pełne, na przykład pełne (obraz, x, y, kolor). Za każdym razem, gdy jest importowana jakakolwiek część pakietu, zostaje wy- konany kod z pliku__i ni t__. py. W wersji minimalnej może to być nawet pusty plik, ale może także zawierać kod przeznaczony specjalnie do inicjalizacji pakietu. Podczas importowania wykonywane są wszystkie napotkane pliki __init__. py. Oznacza to, że pokazana wcześniej instrukcja import Grafi- ka.ElemPodst.wypełnienia spowoduje wykonanie pliku__init__.py zarówno z katalogu Grafika, jak i ElemPodst. W przypadku pakietów istnieje pewien szczególny problem z instrukcją typu from Grafika.ElemPodst import * W zamierzeniu powinna ona importować do bieżącej przestrzeni nazw wszystkie moduły pakietu. Ponieważ jednak konwenqa nazewnictwa plików inaczej wygląda w poszczególnych systemach (zwłaszcza, jeśli chodzi o rozróżnianie wielkości liter), Python nie może ustalić dokładnie, które to będą moduły. W efekcie podana instrukcja importuje po prostu wszystkie moduły zdefiniowane w pliku__init__. py z katalogu ElemePodst. Można zmienić to zacho-, wanie definiując listę__all__zawierającą nazwy wszystkich modułów skojarzonych z pakietem. Definicja tej listy powinna znajdować się w pliku __init__. py pakietu, na przykład: # Grafika/ElemPodst/__init__.py __all__= ["linie","tekst","wypełnienia", ...] Teraz, gdy użytkownik zastosuje instrukcję from Grafika. ElemPodst import *, zgodnie z oczekiwaniami zostaną załadowane wszystkie podmoduły wymienione na liście. Importowanie samej nazwy pakietu nie pociąga za sobą importu wszystkich zawartych w nim podmodułów. Na przykład poniższy fragment kodu nie będzie działał prawidłowo: import Grafika Grafika.ElemPodst.wypełnienia.pełne(obraz, x, y, ko lor) # Nie działa! Ponieważ jednak instrukcja import Grafika wykonuje plik__init__.py z katalogu Gr a f i ka, można doprowadzić do automatycznego importu przez nią wszystkich podmodułów pisząc: # Grafika/__init__.py import ElemPodst, Grafika2w, Grafika3w # Grafika/ElemPodst/__init__.py import linie, wypełnienia, tekst, Rozdział 8: Moduły i pakiety Moduły zawarte w tym samym katalogu pakietu mogą odwoływać się do siebie nawzajem bez podawania pełnej nazwy pakietu. Na przykład moduł Grafi- ka. ElemPodst .wypełnienia może importować moduł Graf ika. Elem- Podst. linie używając po prostu instrukcji import linie. Jeśli jednak moduły są ulokowane w różnych podkatalogach, muszą stosować pełne nazwy pakietowe. Na przykład, jeśli moduł wykresy2wz podpakietu Grafika.Gra- fika2w musi użyć modułu linie z podpakietu Graf ika. ElemPodst, musi zastosować instrukcję typu from Graf ika. ElemPodst import linie. W razie potrzeby moduł może znaleźć swoją w pełni kwalifikowaną nazwę zaglądając do zmiennej__name__. Oto przykład kodu, który importuje moduł z sąsiedniego podpakietu znając jego nazwę, a nie znając nazwy ich wspólnego pakietu nadrzędnego Cna wyższym poziomie): # Grafika/Grafika2w/wykresy2w.py # Ustalenie nazwy pakietu nadrz ędnego bie żącego pakietu import string pakiet_bazowy = string.join(string.split(__name__, '.')[:-2],'.') # Import modułu ../ElemPodst/wypełnienia.py

exec "from %s.ElemPodst import wypełnienia" % (paki et_bazowy,) Na koniec została nam jeszcze do omówienia specjalna zmienna__path__, którą Python definiuje w momencie importowania pakietu. Zmienna ta zawiera listę katalogów przeglądanych w poszukiwaniu podmodułów pakietu. (Zmien- na __path__jest indywidualną dla pakietu wersją zmiennej sys.path). Zmienna__path__jest dostępna z poziomu kodu zapisanego w plikach __i n i t__. py i na początku zawiera tylko jeden element - nazwę katalogu pakietu. Jeśli trzeba, pakiet może dodać nowe katalogi do listy__path__, aby zmienić ścieżkę poszukiwań podmodułów. Teraz instrukcja import Grafika będzie już importować wszystkie podmo- duły i udostępniać je za pomocą w pełni kwalifikowanych nazw.

Rozdział 9

Wejście i wyjście

W tym rozdziale znajdziesz szczegółowy opis wejścia /wyjścia Pythona, łącznie z opcjami linii polecenia, zmiennymi środowiskowymi, operacjami wejścia/wy- jścia na plikach, znakami Unicode i trwałym zapamiętywaniem obiektów.

Czytanie opcji i zmiennych środowiskowych Po uruchomieniu interpretera opcje linii polecenia są umieszczane na liście sys.argv. Pierwszym elementem tej listy jest zawsze nazwa programu. Wszystkie następne to opqe podane w linii polecenia po nazwie programu. Oto przykładowy program, który pokazuje, jak można dostać się do tych opqi: # podajopcje.py # Wyświetla wszystkie opcje podane w linii polecenia import sys for i in range(len(sys.argv)): print "sys.argv[%d] = %s" % (i, sys.argv[i]) Po uruchomieniu program ten generuje następujące dane na wyjściu: % python podajopcje.py co śl co ś2 -p sys.argv[0] = podajopcje.py sys.argv[1] = co śl sys.argv[2] = co ś2 sys.argv[3] = -p % Zmienne środowiskowe są dostępne za pomocą słownika os.environ. Na przykład: import os path = os.environ["PATH"] user = os.environ["USER"] editor = os.environ["EDITOR"] itd. ... Aby zmienić ustawienie którejś zmiennej środowiskowej, trzeba zmodyfikować odpowiedni element zmiennej os . environ. Innym sposobem jest użycie funkcji os . putenv (). Na przykład: os.environ["NIC"] = "BRAK" os.putenv("NIC", "BRAK")

Python Rozdział 9: Wejście i wyjście 97

Pliki Funkcja wbudowana open (name niżej pokazane: , mode] ) otwiera i tworzy pliki, jak to jest f = open('czyt') f = open('pisz','w') # Otwarcie 'czyt' do czytania # Otwarcie do pisania Plik może zostać otwarty w jednym z trzech trybów (mode): czytania (' r' od read), pisania (' w' od write) i dodawania (' a ' od append). Po znaku trybu może występować litera ' b', oznaczająca dane binarne, na przykład ' rb' lub ' wb'. Nie jest to obowiązkowe w Uniksie, ale w Windows tak, i dlatego lepiej to robić, jeśli zależy nam na przenaszalności programu. Ponadto można otwierać plik do aktualizacji, dodając znak plus (+) po znaku trybu, na przykład ' r+ ' lub ' w+'. Plik otwarty do aktualizacji umożliwia zarówno pisanie w nim, jak i czytanie go, o ile tylko wszystkie operacje wyjścia zapisują swoje dane w pliku przed przystąpieniem do jego czytania. Po otwarciu pliku w trybie ' w+ ' jego długość jest od razu na wstępie skracana do zera. Funkcja open () zwraca obiekt-plik, udostępniający metody wymienione w tabeli 9.1. Tabela 9.1 Metody pliku Metoda Opis f.read([n]) Czyta maksymalnie n bajtów. f.readline ( [n] ) Czyta maksymalnie n znaków z jednej linii danych wejściowych. Bez podania n czytana jest cała linia. f.readlines () Czyta wszystkie linie i zwraca je jako listę. f.xreadlines () Zwraca nieprzejrzysty obiekt - sekwencję, z którego każda iteraqa pobiera kolejną linię pliku. f.write(s) Zapisuje napis s. f.writelines (2) Zapisuje wszystkie napisy z listy 1. i".close () Zamyka plik. f.tellO Zwraca bieżący wskaźnik do pliku. f.seek(offset [, where]) Skacze do nowego miejsca w pliku. f .isatty () Zwraca 1, jeśli f jest terminalem interakcyjnym. f. flush () Zrzuca na dysk zawartość buforów wyjściowych. f .truncate([size]) Skraca plik do co najwyżej size bajtów. f.filenoO Zwraca deskryptor pliku (liczba całkowita). f. readinto{buffer, nbytes) Wczytuje nbytes danych do wskazanego obiektu-bufora. Metoda read () zwraca w postaci napisu cały plik, chyba że jest podany nie- obowiązkowy argument n, wyznaczający maksymalną liczbę wczytywanych bajtów. Metoda readline () zwraca następną linię wejściową, łącznie z kończącym ją znakiem przejścia do nowej linii. Z kolei metoda readlines () wczytuje wszystkie linie wejściowe i zwraca je w postaci listy napisów. Metoda readline () pozwala za pomocą nieobowiązkowego argumentu n określić maksy- malną długość linii. Jeśli wczytywana linia ma więcej niż n bajtów, tylko pierwsze n bajtów jest zwracanych przez funkcję. Pozostałe linie wejściowe pozostają bez zmian i będą zwracane w wyniku kolejnych operacji czytania. Zarówno metoda readline (), jaki readlines () uwzględniają rodzaj platformy, na której się wykonują, i prawidłowo radzą sobie z różnymi reprezentacjami znaku przejś- cia do nowej linii (na przykład '\n' lub '\r\n'). Metoda xreadlines () zwraca specjalny nieprzejrzysty obiekt - sekwencję, który pozwala wczytywać

w pętli kolejne linie pliku wejściowego zamiast pobierać go w całości do pamięci, jak to robi metoda readlines (). Oto przykład: for linia in f.xreadlines(): # Jakie ś działania na linii Metoda write () zapisuje pojedynczy napis w pliku, a metoda writelines () zapisuje od razu całą ich listę. W obu przypadkach napisy mogą zawierać dane binarne, łącznie z osadzonymi w nich znakami pustymi (null). Metoda seek () umożliwia bezpośredni dostęp do różnych miejsc pliku wyzna- czanych za pomocą dwóch argumentów: przesunięcia (offset) i nieobowiązko- wej reguły odliczania (where). Jeśli where ma wartość 0 (wartość domyślna), metoda s e e k () zakłada, że przesunięcie jest podane względem początku pliku. Jeśli where ma wartość 1, przesunięcie jest podane względem bieżącej pozycji w pliku. Jeśli natomiast where ma wartość 2, przesunięcie jest podane względem końca pliku. Metoda f ileno () zwraca liczbę całkowitą stanowiącą deskryptor pliku i używaną czasem przez pewne moduły biblioteczne do wykonywania operacji wejścia /wyjścia na niskim poziomie. W systemach, które obsługują duże pliki (większe niż 2 GB), metody seek() i tell () używają długich liczb całkowitych. Aby to jednak nastąpiło, może być konieczna rekonfiguracja lub nawet rekompilacja interpretera Pythona. Obiekty-pliki mają także swoje atrybuty, których opis znajdziesz w poniższej tabeli. Atrybut f. closed .f .mode f.name .f .softspace Opis Wartość boolowska, która wskazuje stan pliku: 0, gdy jest otwarty, a 1, gdy jest zamknięty. Tryb I/O pliku. Nazwa pliku, jeśli został on utworzony przez funkcję open (). W przeciwnym razie jest to napis wskazujący źródło pliku. Wartość boolowska wskazująca, czy znak wyświetlany przy użyciu instrukcji print musi być poprzedzony spacją. Klasy emulujące pliki muszą udostępniać zapisywalny atrybut o tej nazwie i nadawać mu wstępnie wartość zero.

98 Python

Standardowe strumienie: wej ściowy, wyj ściowy i diagnostyczny Interpreter udostępnia trzy standardowe obiekty - pliki znane jako standardowy strumień wejściowy (standard input), standardowy strumień wyjściowy (standard output) i standardowy strumień diagnostyczny (standard error). Każdy z nich jest dostępny w module sys pod odpowiednią dla siebie nazwą: sys. stdin, sys . stdout i sys . stderr. Obiekt stdin to plik odpowiadający strumieniowi znaków dostarczanych do interpretera. Obiekt stdout to plik otrzymujący dane produkowane przez instrukcje print. Natomiast obiekt stderr to plik, do którego trafiają komunikaty o błędach. Obiekt stdin jest najczęściej mapowany na klawiaturę użytkownika, astdinistdout-na monitor. Metody opisane w poprzednim podrozdziale mogą być używane do wykonywania operacji na nie przetworzonych danych wejściowych i wyjściowych użyt- kownika. Oto przykład funkcji wczytującej linię ze standardowego strumienia wejściowego: def czytlO : tekst = "" while 1: znak = sys.stdin.read(1) tekst = tekst + znak if znak == '\n': break return tekst Alternatywą jest wczytanie linii tekstu ze standardowego strumienia wejściowe- go za pomocą funkcji wbudowanej raw_input (prompt): s = raw_input("wpisz co ś : ") print "Wpisałe ś '%s'" % (s,) Jeśli chodzi o przerwania klawiaturowe (powodowane często przez kombinację klawiszy [Ctrl+C]), powodują one zgłoszenie wyjątku Keyboardlnterrupt, który można przechwycić za pomocą procedury obsługi wyjątku. Jeśli trzeba, można zastąpić wartości sys . stdin, sys . stdout i sys . stderr innymi obiektami-plikami, co wpłynie oczywiście na zachowanie instrukcji print i funkcji operujących na nie przetworzonych danych wejściowych. War- tości sys . stdin, sys . stdout i sys . stderr w momencie uruchamiania interpretera są ponadto dostępne za pomocą obiektów sys.__stdin__, sys .__stdout__i sys .__stderr__. Zwróć uwagę, że w niektórych przypadkach wartości sys . stdin, sys . stdout isys.stderr mogą ulec zmianie wskutek użycia zintegrowanego środowiska programowania (Integrated Development Environment - IDE). Na przykład po uruchomieniu Pythona w ramach Idle, obiekt sys . stdin jest zastępowany przez obiekt zachowujący się jak plik, ale będący w rzeczywistości obiektem należącym do środowiska programowania. W takiej sytuacji pewne metody niskiego poziomu, takie jak read () czy seek (), mogą być niedostępne. Rozdział 9: Wejście i wyjście 99

Instrukcja print Instrukcja print zapisuje dane wyjściowe w pliku reprezentowanym przez sys . stdout. Argumentami tej instrukcji mogą być różne obiekty oddzielone przecinkami, na przykład: print "Oto warto ści: ", x, y, z Dla każdego obiektu wywoływana jest funkcja str (), która na podstawie jego wartości generuje napis wyjściowy. Wszystkie napisy, po dodaniu jednej spacji

oddzielającej, są łączone ze sobą, tworząc ostateczny napis wyjściowy. Napis ten jest uzupełniany znakiem przejścia do nowej linii, chyba że na końcu instrukcji print występuje przecinek. W takim przypadku na końcu napisu pojawi się tylko dodatkowa spacja. Oto kilka przykładów: print "Oto warto ści: ", x, y, z, w # Wygenerowanie tego samego tekstu przez dwie instrukcje print print "Oto warto ści: ", x, y, # Bez znaku przej ścia do nowej linii print z, w Aby wygenerować sformatowane dane wyjściowe, można użyć operatora formatowania napisów (%) opisanego dokładnie w rozdziale 4, „Operatory i wyraże- nia". Na przykład: print "Oto warto ści: %d %7.5f %s" % (x,y,z) # Sformatowane we/wy Aby przekierować wynik instrukqi print, można użyć specjalnego modyfikatora »pli k, gdzie pl i k jest obiektem plikiem umożliwiającym pisanie. Oto przykład: f = open ("output","w") print »f, "witaj świecie" f.close () Łączenie formatowanego wejścia/wyjścia wykorzystującego słowniki z potrój- nie cytowanymi napisami stanowi uniwersalną metodę komputerowego generowania tekstu. Wyobraź sobie na przykład, że chcesz napisać następujący krótki formularz listowy z wypełnianymi miejscami na nazwisko, przedmiot i kwotę: Drogi Panie Bush! Prosz ę odesła ć mój mikser lub zapłaci ć mi $50.00. Z powa żaniem, Joe Python W tym celu można utworzyć potrójnie cytowany napis zawierający tekst i dopa- sowane do słownika specyfikatory formatu: form = """\ Drogi Panie % (nazwisko)s, Prosz ę odesła ć mój %(przedmiot)s lub zapłaci ć mi $%(kwota)0.2f. Z powa żaniem, Joe Python

100 Python print form % { 'nazwisko 1: 'Bush 1, 'przedmiot': 'mikser' 'kwota': 50.00, W przypadku formularzy liczących wiele linii i wymagających wielu podstawień taki zapis jest dużo bardziej czytelny niż stosowanie po jednej instrukcji print na każdą linię lub formatowanie obszernej tupli elementów.

Przechowywanie obiektów Często okazuje się konieczne zapisanie jakiegoś obiektu w pliku, a następnie jego odtworzenie. Jednym ze sposobów jest utworzenie pary funkqi, służących odpowiednio do czytania i zapisywania danych w specjalnym formacie. Innym roz- wiązaniem jest skorzystanie z modułów piekle i shelve. Moduł piekle dokonuje serializacji obiektu na strumień bajtów, który można następnie zapisać w pliku. Oto przykład kodu, który to wykorzystuje: import piekle obiekt = jaki śObiekt() f = open(nazwapliku,'w') piekle.dump(obiekt, f) # Zapisanie obiektu Aby odtworzyć następnie ten obiekt, można użyć następującego kodu: import piekle f = open(nazwapliku,'r') obiekt = piekle.load(f) # Odtworzenie obiektu Moduł she lve służy temu samemu, ale zapisuje obiekty w bazie danych zbliżonej do słownika: import shelve obiekt = jaki śObiekt() dbase = shelve.open(nazwapliku) dbase['key'] = obiekt obiekt = dbase['key'] dbase.close() # Otwarcie bazy danych # Zapisanie obiektu w bazie danych # Odtworzenie obiektu # Zamkni ęcie bazy danych W obu przypadkach tylko obiekty nadające się do serializacji mogą być zapisywane w pliku. Większość obiektów Pythona spełnia ten warunek, ale obiekty specjalnego przeznaczenia, takie jak pliki, mają przypisany wewnętrzny stan, którego nie można zapisać ani odtworzyć w ten sposób. Bardziej szczegółowe informacje o modułach piekle i shelve znajdziesz w dodatku A, „Biblioteka Pythona".

Wejście/wyj ście z u życiem Unicode Napisy Unicode są reprezentowane wewnętrznie jako sekwencje 16-bitowych wartości całkowitych odpowiadających poszczególnym znakom. Tak jak w przypadku 8-bitowych napisów wszystkie znaki mają ten sam rozmiar, a większość podstawowych operacji jest po prostu rozszerzeniem ich wersji 8-bitowej w celu obsługi większego zakresu wartości znakowych. Jednak za każdym razem, gdy napis Unicode jest zamieniany na strumień bajtów, pojawia się kilka problemów. Rozdział 9: Wejście i wyjście Po pierwsze, aby zachować zgodność z istniejącym oprogramowaniem, możn rozważyć konwersję Unicode na reprezentację 8-bitową, która byłaby kompć tybilna z oprogramowaniem oczekującym kodu ASCII lub innych danych 8-bitowycl Po drugie, użycie 16-bitowych znaków niesie ze sobą problem kolejności bajtov W przypadku znaku Unicode U+HHLL kodowanie typu Little Endian na pierw szym miejscu umieszcza dolny bajt, jak w znaku LL HH, a kodowanie Big Endia górny bajt, jak w znaku HH LL. Z powodu tej różnicy nie jest ogólnie możliw zwykłe zapisywanie w pliku nie przetworzonych danych Unicode bez równe czesnego podania zastosowanej metody kodowania. Aby rozwiązać ten problem, dokonuje się zawsze zamiany napisów Unicode n zewnętrzną reprezentację zgodnie z konkretną regułą kodowania. Reguła t

określa dokładnie, jak należy reprezentować znaki Unicode w postaci sekwenc bajtów. Reguły kodowania zostały opisane po raz pierwszy w rozdziale 4 d] funkqi Unicode () i metody s . encode (). Oto przykład: a = u"M\u00feller" b = "Witaj świecie" c = a.encode('utf-8') d = Unicode(b) # Konwersja a na napis UTF-8 # Konwersja b na napis Unicode W przypadku operaqi wejścia/wyjścia z użyciem kodu Unicode podobna techn ka jest implementowana przy użyciu modułu wbudowanego codecs. Moduł te zawiera kolekcję funkcji do konwertowania danych typu bajtowego na napisy Un code (i odwrotnie) z użyciem różnych schematów kodowania. Konkretny schema jest wybierany za pomocą wywołania funkqi codecs . lookup (encoding) Funkqa ta zwraca czteroelementową tupię (enc_func, decode_func, stre am_reader, stream_wri ter). Na przykład: import codecs (utf8_encode, utf8_decode, utf8_reader, utf8_writer ) = \ codecs.lookup('utf-8 ') Funkcja enc_func(u [, errors]) pobiera napis Unicode u i zwraca tup] (s, len), gdzie s jest 8-bitowym napisem zawierającym fragment lub całoś napisu Unicode u przekonwertowanego zgodnie z żądanym schematem, ale liczbą znaków w s. Parametr errors określa sposób obsługi błędów i ma wai tość 'strict', 'ignore' lub ' replace ' .W trybie 'strict' błędy kodowć nia powodują zgłoszenie wyjątku UnicodeError. W trybie ' ignore ' błęd kodowania są ignorowane. Natomiast w trybie 'replace' znaki, których ni można przekonwertować, są zastępowane przez konkretny znak specjalny W Unicode jest nim znak U+FFFD, a w napisach 8-bitowych znak ' ? '. stream_reader to klasa, która implementuje zewnętrzny interfejs czytania d< nych Unicode z obiektu-pliku. Wywołanie stream_reader(file) zwrac obiekt, którego metody read (), readline () i readlines () czytają napis Unicode. Z kolei stream_wri ter to klasa, która implementuje zewnętrzny ii terfejs dla zapisywania danych Unicode w obiekcie-pliku. Wywołanie stre am_writer (file) zwraca obiekt, którego metody write () i writelines ( tłumaczą napisy Unicode na wybrany schemat kodowania i zapisują je w stri mieniu wyjściowym.

102 Python Oto przykład, który ilustruje wykorzystanie tych funkcji do czytania i pisania danych Unicode w kodzie UTF-8: # Zapisywanie danych Unicode w pliku ustr = u'M\uOOfcller' # Napis Unicode plikwy = utf8_writer (open ('pliki', 'w')) # Tworzy strumień wyjściowy UTF-8 plikwy.write(ustr) plikwy.close O # Czytanie danych Unicode z pliku plikwe = utf8_reader(open('plik2')) ustr = plikwe.read() plikwe.close O Podczas pracy z plikami Unicode kodowanie danych można zazwyczaj ustalić na podstawie samego pliku. Na przykład parser XML może sprawdzić najpierw kilka pierwszych bajtów napisu ' <?xml . . . >' i na tej podstawie wykryć rodzaj kodowania dokumentu. Jeśli pierwszymi czterema wartościami są3C 3F 78 6D (' <?xm'), wskazuje to na kodowanie UTF-8. Jeśli pierwszymi czterema warto- ściami są 00 3C 00 3Flub3C 00 3F 00, wskazuje to odpowiednio na kodowanie UTF-16 typu Big Endian lub Little Endian. Sposób kodowania dokumentu może być też podany w nagłówku MIME lub jako atrybut któregoś elementu dokumentu. Na przykład: <?xml ... encoding="ISO-8859-l" ... ?> Jeśli sposób kodowania daje się odczytać z dokumentu, można zastosować w programie następujący schemat czytania danych Unicode: f = open("pewienplik") # Ustalenie kodowania (encoder,decoder,reader,writer) = codecs.lookup(enc oding) f = reader(f) # Obudowanie pliku czytnikiem Unic ode data = f.read() # Wczytanie danych Unicode f. close () Kodowanie danych Unicode W tabeli 9.2 wymienione są wszystkie kodery dostępne aktualnie w module codecs. Tabela 9.2 Kodery występujące w module codecs Koder Opis 1ascii' Kodowanie ASCII 'latin-11, 'iso-8859-11 Kodowanie Latin-1 lub ISO-8859-1 •utf-81 Kodowanie 8-bitowe o zmiennej długości 'utf-161 Kodowanie 16-bitowe o zmiennej długości 'utf-16-le1 UTF-16 z jawnym kodowaniem Little Endian 'utf-16-be' UTF-16 z jawnym kodowaniem Big Endian 'unicode-escape' Ten sam format, co u" string" 'raw-unicode-escape' Ten sam format, co ur"string"

Rozaziat y: wejście i wy)$cie 103 W następnych akapitach omówimy szczegółowo każdy z tych koderów. Kodowanie 'ascii1 W kodowaniu 'ascii ' wartości znaków muszą pochodzić z przedziałów [0,0x7f] lub [U+0000, U+0 07 F]. Każdy znak o innej wartości jest niepra- widłowy. Kodowanie 'iso-8859-11 lub • latin-11 Znak może mieć dowolną wartość z przedziału [0,0xff] lub [U+0000, U+0 OFF]. Wartości z przedziału [0,0x7f] odpowiadają znakom zbioru ASCII. Wartości z przedziału [0x80, 0xff] odpowiadają znakom ISO-8859-1, inaczej rozszerzonego zbioru ASCII. Każdy znak o wartości spoza przedziału [ 0, 0xf f ] powoduje błąd. Kodowanie 'utf-8' UTF-8 to schemat kodowania o zmiennej długości, który pozwala reprezento- wać wszystkie znaki Unicode. Pojedynczy bajt służy do zapisywania znaków

ASCII z przedziału 0-127. Wszystkie pozostałe znaki są reprezentowane przez sekwencje złożone z dwóch lub trzech bajtów. Zawartość tych bajtów jest opisana w poniższej tabeli. Znaki Unicode Bajt 0 Bajtl Bajt 2 U+0000 -

- U+007F Onnnnnnn

U+007F -

- U+07FF HOnnnnn lOnnnnnn

U+0800 -

- U+FFFF lllOnnnn lOnnnnnn lOnnnnnn

W sekwencjach dwubajtowych pierwszy bajt rozpoczyna się zawsze od bitów 110, natomiast w sekwenqach trójbajtowych pierwszy bajt zaczyna się zawsze od bitów 1110. Wszystkie następne bajty danych w sekwencjach wielobajtowych zaczynają się od bitów 10. W ogólności format UTF-8 pozwala tworzyć sekwencje liczące maksymalnie 6 bajtów. W Pythonie czterobajtowe sekwencje UTF-8 są używane do kodowania par znaków Unicode zwanych parami zastępczymi (surrogate pair). Oba znaki mają wartości z przedziału [U+D800, U+DFFF] i służą do zakodowania 20-bitowej wartości znaku. Kodowanie zastępcze wygląda następująco: czterobajtowa sekwencja llllOOrjn lOnnnnnn 10nnmmmm 10mmmmmm jest kodowana jako paraU+D800 + A/,U+DC00 + M, gdzie N to 10 górnych, a M- 10 dolnych bitów 20-bitowego znaku zakodowanego w czterobajtowej sekwenqi UTF-8. Pięcio- i sześciobajtowe sekwencje UTF-8 (oznaczane odpowiednio przez początkowe sekwenqe bitów 111110 i 1111110) są używane do kodowania wartości zna- ków o maksymalnej długości 32 bitów. Wartości te nie są aktualnie obsługiwane przez Pythona i jeśli pojawią się w zakodowanym strumieniu danych, spowo- dują zgłoszenie wyjątku UnicodeError. Kodowanie UTF-8 ma wiele zalet, które umożliwiają korzystanie z niego w starszych programach. Po pierwsze, standardowe znaki ASCII są reprezentowane tradycyjnie. Oznacza to, że zakodowane w UTF-8 napisy ASCII niczym się nie

104 Python i różnią od zwykłych napisów ASCII. Po drugie, kodowanie UTF-8 nie wymaga wstawiania pustych bajtów do wielobajtowych sekwencji znakowych. W efekcie istniejące już oprogramowanie oparte na bibliotece C i programy oczekujące 8-bitowych napisów zakończonych pustym znakiem mogą prawidłowo działać na napisach UTF-8. I wreszcie kodowanie UTF-8 zachowuje leksykograficzny porządek napisów. To znaczy, jeśli a ib są napisami Unicode i a < b, to nierówność a < b zachodzi również po konwersji a i b na UTF-8. Dzięki temu wszystkie algorytmy sortujące i porządkujące, napisane dla napisów 8-bitowych, będą również działały prawidłowo na napisach zakodowanych w UTF-8. Kodowanie ' utf-16', ' utf-16be' i ' utf-161e' UTF-16 jest 16-bitowym kodowaniem zmiennej długości, w którym znaki Unicode są zapisywane w postaci 16-bitowych wartości. Jeśli nie jest podana kolejność bajtów, domyślnie stosowane jest kodowanie Big Endian. Ponadto można za pomocą specjalnego znacznika kolejności bajtów u+FEFF jawnie określić kolejność bajtów w strumieniu danych UTF-16. W kodowaniu Big En- dian wartość U+FEFE jest znakiem Unicode reprezentującym spację nieroz- dzielającą o zerowej szerokości. Natomiast wartość odwrotna, U+FFEF, nie odpowiada w ogóle żadnemu poprawnemu znakowi Unicode. W ten sposób koder może na podstawie sekwencji FE FF lub FF FE ustalić kolejność bajtów w strumieniu danych. Podczas czytania danych Unicode Python usuwa znaczniki kolejności bajtów z generowanego napisu Unicode. Kodowanie ' utf-16be ' jawnie wybiera wariant Big Endian formatu UTF-16, natomiast kodowanie 'utf-161eł jawnie wybiera wariant Little Endian. Chociaż istnieją rozszerzenia formatu UTF-16 dopuszczające znaki o wartościach większych niż 16-bitowe, aktualnie żadne z tych rozszerzeń nie jest obsługiwane przez Pythona. Kodowanie ' unicode-escape' i ' raw-unkode-escape' Obie te metody kodowania służą do konwertowania napisów Unicode na ten sam format, jaki jest używany przez Pythona w stałych napisowych Unicode i w nieprzetworzonych stałych napisowych Unicode. Na przykład: s = u'u\14a8\u0345\u2a34' t = s.encode('unicode-escape') #t = '\ul4a8\u0345\u2a34 Właściwo ści znaków Unicode Oprócz wykonywania operacji wejścia/wyjścia z użyciem znaków Unicode programy muszą czasem sprawdzać różne właściwości tych znaków, takie jak wiel- kość liter, przynależność do zbioru cyfr czy rodzaj odstępu (spacja, tabulaqa itd.). Cała baza danych właściwości znaków jest dostępna za pomocą modułu unicodedata. Ogólne właściwości znaku można poznać, wywołując funkcję unicodedata.category(c). Na przykład unicodedata.category(u"A") zwraca • Lu', co oznacza, że podany znak jest dużą literą. Bardziej szczegółowe informacje o bazie danych znaków Unicode i o module unicodedata można znaleźć w dodatku A. Rozdział 10

Środowisko wykonania programu

Tematem tego rozdziału jest środowisko, w którym są wykonywane programy napisane w Pythonie. Głównym celem jest opisanie konfiguraqi interpretera oraz sposobu jego działania od momentu uruchomienia programu, aż po jego zakończenie.

Opcje interpretera i środowisko Interpreter Pythona ma szereg opq'i, które decydują o jego działaniu i środowi- sku. W systemach Unix i Windows opcje interpretera są podawane w linii polecenia, tak jak to jest pokazane poniżej: python [options] [-c cmd | filename \ - ] [args] W Macintoshach opqe interpretera są ustawiane za pomocą oddzielnego programu EditPythonPrefs. Oto lista opq'i dostępnych w linii polecenia: Opcja Opis -d Włącza debugowanie interpretera. -h Podaje listę wszystkich opq'i dostępnych w linii polecenia. -i Włącza tryb interakcyjny po wykonaniu programu. -0 Włącza tryb optymalizaqi. -00 Włącza tryb optymalizaqi oraz usuwa napisy dokumentujące. -s Zapobiega wstawianiu modułu iniqalizujacego środowisko. -t Włącza ostrzeganie o niespójnym korzystaniu z tabulacji. -tt Powoduje zgłaszanie wyjątku TabError na skutek niespójnego używania tabulaqi. -u Ustawia stdout i stdin jako niebuforowane strumienie binarne. -U Wymusza traktowanie wszystkich stałych napisowych jako literałów

Unicode. -v Włącza tryb szczegółowy.

-V Wyświetla numer wersji i kończy działanie. -x Pomija pierwszą linię programu źródłowego. -c cmd Wykonuje cmd jako napis. -Wfilter Dodaje filtr ostrzegawczy.

106 tytnon Opcja -d włącza debugowanie interpretera i jest niezbyt przydatna dla większo- ści programistów. Opcja -i powoduje rozpoczęcie sesji interakcyjnej natychmiast po zakończeniu wykonania programu, co ułatwia debugowanie. Opcje -O i -00 powodują optymalizację plików z kodem bajtowym i zostały opisane w rozdziale 8, „Moduły i pakiety". Opcja -s zapobiega wstawieniu modułu ini- cjalizującego środowisko, opisanego w dalszej części tego rozdziału zatytułowa- nej „Pliki konfiguracyjne środowiska". Opcje -t, -tt i -v powodują generowanie dodatkowych ostrzeżeń i informacji o działaniu. Opcja -x zapobiega interpretacji pierwszej linii programu źródłowego na wypadek, gdyby to nie była poprawna instrukcja Pythona (może to być na przykład polecenie uruchamiające interpreter Pythona w skrypcie). Opcja -U zmusza interpreter do traktowania wszystkich literałów napisowych jako Unicode. Opcja - W umożliwia podanie filtru ostrzegawczego i jest opisana wraz z modułem warnings w dodatku A, „Biblioteka Pythona". Nazwa programu pojawia się po wszystkich opcjach interpretera. Jeśli jej nie ma lub jest zastąpiona łącznikiem (-), interpreter wczytuje program ze standardowego strumienia wejściowego. Jeśli strumieniem tym jest terminal interakcyjny, na ekranie pojawia się nagłówek i znak zgłoszenia. W przeciwnym wypadku interpreter otwiera plik o nazwie programu i wykonuje zawarte w nim instrukcje aż do napotkania znaku końca pliku. Opcja - c cmd może być używana do wykonywania krótkich programów przy użyciu składni opcji linii polecenia. Opcje linii polecenia występujące po nazwie programu lub łączniku (-) są przekazywane do programu na liście sys . argv, jak to zostało już opisane w podrozdziale „Czytanie opcji i zmiennych środowiskowych" rozdziału 9 „Wejście i wy- jście". Interpreter odczytuje ponadto następujące zmienne środowiskowe: Zmienna Opis PYTHONPATH Zawiera oddzieloną dwukropkami ścieżkę poszukiwań

modułu. PYTHONSTARTUP Wskazuje plik wykonywany po uruchomieniu Pythona w

trybie interakcyjnym. PYTHONHOME Podaje miejsce instalacji Pythona. PYTHONINSPECT Implikuje opcję -i. PYTHONUNBUFFERED Implikuje opqę -u. PYTHONCASEOK Powoduje ignorowanie wielkości liter w nazwach

importowanych modułów (Python 2.1).

i u. OIUUUWISKU wyKuimma programu Zmienna PYTHONPATH zawiera ścieżkę poszukiwań modułu wstawianą na ,^ początku zmiennej sys.path, opisanej wcześniej w rozdziale 8. Zmienna £ PYTHONSTARTUP wskazuje plik, który ma być wykonywany przy każdym uruchomieniu interpretera w trybie interakcyjnym. Zmienna PYTHONHOME służy do ustalania miejsca instalacji Pythona, ale rzadko kiedy jest potrzebna, gdyż interpreter wie, jak szukać swoich bibliotek i lokalnego katalogu pakietów, w którym normalnie są zainstalowane rozszerzenia. Jeśli jest podany tylko jeden katalog/ taki jak /usr/local, interpreter spodziewa się znaleźć w tym miejscu wszystkie swoje pliki. Jeśli są podane dwa katalogi, na przykład /usr/local:/usr/local/sparc-solaris-2 . 6, interpreter będzie szukać wszystkich plików niezależnych od platformy w pierwszym katalogu, a zależnycłi - w drugim. Zmienna PYTHONHOME nie ma znaczenia, jeśli w podanym miejscu nie ma poprawnie zainstalowanej wersji interpretera. W systemie Windows niektóre ze zmiennych środowiskowych, takie jak PYTHONPATH, są pobierane z pozycji Rejestru zapisanych w HKEY_LO-

CAL_MACHINE/Software/Python. W Macintoshach zmienne środowiskowe mogą być ustawiane za pomocą programu

Sesje interakcyjne Jeśli linia polecenia nie zawiera nazwy programu, a standardowy strumień wejś- ciowy Pythona jest przypisany do interakcyjnego terminala, interpreter jest uru- chamiany w trybie interakcyjnym. W trybie tym na ekranie pojawia się najpierw nagłówek informacyjny, a po nim znak zgłoszenia. Ponadto interpreter wykonuje skrypt zapisany na zmiennej PYTHONSTARTUP (jeśli jest ona ustawiana). Skrypt ten wykonuje się tak, jakby to była część programu (to znaczy, nie jest on ładowany przy użyciu instrukcji import). Jednym z zastosowań tego skryptu może być wczytywanie pliku konfiguracyjnego użytkownika, takiego jak . pythonrc. Podczas pracy w trybie interakcyjnym na ekranie użytkownika mogą pojawiać się dwa rodzaje znaków zgłoszenia. Znak >» występuje na początku nowej instrukcji, natomiast znak . . . oznacza jej kontynuację. Na przykład: Python 2.0 (#1, Oct 27 2000, 14:34:45) [GCC 2.95.2 19991024 (release)] on sunos5 Type "copyright", "credits" or "license" for more i nformation. >» for i in range(0,4): print i 0 1 2 3 >» Tworząc własne aplikacje możesz zmienić te znaki zgłoszenia, modyfikując po prostu wartości zmiennych sys . ps 1 i sys . ps2. W niektórych systemach Python może być tak skompilowany, aby korzystał z biblioteki GNU readline. Biblioteka ta (jeśli istnieje) umożliwia między innymi korzystanie w trybie interakcyjnym z historii poleceń i ich uzupełnianie. Znacze- nia speq'alnych kombinaqi klawiszy w bibliotece readline są opisane razem z nią w dodatku A. Standardowo strumień wyjściowy poleceń wydawanych w trybie interakcyjnym ma postać strumienia wyjściowego funkcji wbudowanej repr () wykonywanej

108 Python Rozdział 10: Środowisko wykonania programu 109 na wynikach tych poleceń. Począwszy od Pythona 2.1 można to zmienić usta- wiając samodzielnie zmienną sys . displayhook. Na przykład: >» def nowy_format (x) : ... print "wynik = %s" % repr(x) »> sys .displayhook = nowy_format >» 3+4 wynik = 7

Uruchamianie aplikacji napisanych w Pythonie W większości przypadków będziesz chciał, aby twoje programy automatycznie uruchamiały interpreter Pythona, bez potrzeby robienia tego własnoręcznie. W systemie Unix można to uzyskać za pomocą skryptu powłoki, którego pierwsza linia wygląda podobnie, jak to jest p.)kazane poniżej: #!/usr/local/bin/python # Od tego miejsca zaczyna si ę kod Pythona ... import string print "Witaj świecie" ag W systemie Windows dwukrotne kliknięcie pliku .py, .pyw, .wpy, .pyc lub-?*- . pyo automatycznie uruchamia interpreter. Standardowo programy wykonują Jg się w oknie konsoli, chyba że mają zmieniony przyrostek na .pyw (w takim przy- ^» padku program działa niejawnie). Jeśli trzeba dostarczyć opcje dla interpretera, jj można również uruchomić Pythona z poziomu pliku .bat. J| W Macintoshach kliknięcie pliku . py uruchamia zwykle edytor użyty do utwo- -g| rżenia tego pliku. W pakiecie dystrybucyjnym dla tego komputera są jednak do- *f; starczane specjalne dwa programy, które służą do budowania aplikacji. Upusz- || czenie pliku .py na ikonę programu BuildApplet konwertuje program J| źródłowy na plik, którego otwarcie powoduje automatyczne uruchomienie inter- ^ pretera Pythona. Program Build Application konwertuje z kolei program napisany h w Pythonie na samodzielną aplikację, którą można dystrubować i wykonywać w komputerach bez zainstalowanego w ni :h interpretera.

Pliki konfiguracyjne środowiska Typowa instalacja Pythona może obejmować szereg modułów i pakietów róż- _ nych producentów. Aby skonfigurować te pakiety, interpreter importuje naj- * pierw moduł site. Celem tego pakietu jest znalezienie plików pakietów i doda- % nie nowych katalogów do ścieżki poszukiwań modułu sys . path. Moduł site j| ustawia ponadto domyślne kodowanie dla konwersji napisów Unicode. Szcze- Jg| gółowe informacje o module site znajdziesz w dodatku A.

Udost ępnianie nowych mo żliwo ści Począwszy od Pythona 2.1 można blokować nowe możliwości języka, które mają wpływ na kompatybilność ze starszą wersją Pythona. Aby udostępnić te możli- wości, trzeba użyć instrukcji from__future__import możliwość. Na przykład: # Umożliwienie zagnie żdżania zasi ęgów w Pythonie 2.1 •a- from__future__import nested_scopes Instrukcja ta powinna być pierwszą instrukcją modułu lub programu. Należy pa- miętać, że celem modułu__future__jest udostępnianie możliwości, które z czasem staną się standardową częścią języka (i w takim przypadku korzystanie z__future__nie będzie już potrzebne).

Kończenie działania programu Zakończenie działania programu następuje w momencie, gdy w programie wejś- ciowym nie ma już żadnej instrukcji do wykonania, gdy zostaje zgłoszony i nie przechwycony wyjątek SystemExit (wygenerowany przez sys . exit ()) lub

gdy interpreter otrzyma sygnał SIGTERM lub SIGHUP (w Uniksie). Interpreter zmniejsza wówczas licznik odniesień każdego obiektu we wszystkich znanych aktualnie przestrzeniach nazw (i usuwa je). Jeśli wartość licznika odniesień obiektu wynosi zero, następuje usunięcie obiektu i wywołanie jego metody__del__(). Należy pamiętać, że w niektórych przypadkach w momencie zakończenia działania programu może nie dojść do wywołania metody__del__(). Może się tak stać, gdy między obiektami istnieje odniesienie cykliczne (w takim przypadku obiekty pozostaną w pamięci, ale nie będą dostępne z żadnej istniejącej przestrzeni nazw). Chociaż narzędzie Pythona do odzyskiwania pamięci może wykryć w trakcie działania programu nieużywane odniesienia cykliczne, normalnie nie jest ono wywoływane po zakończeniu programu. Ponieważ nie ma gwarancji, że metoda__del__() zostanie wywołana na za- kończenie programu, dobrym wyjściem może być jawne pousuwanie pewnych obiektów, takich jak otwarte pliki czy połączenia sieciowe. Aby to zrobić, należy dodać wyspecjalizowane metody „sprzątające" (na przykład close ()) do własnoręcznie zdefiniowanych obiektów. Inna możliwość to napisanie funkcji kończącej i zarejestrowanie jej w module at exit: import atexit poł ączenie = open_connection("krachdot.com") def koniec(): print "Rozł ączam si ę..." close_connection(poł ączenie) atexit.register(koniec) Aby uruchomić odzyskiwanie pamięci, można również napisać: import atexit, gc atexit.register(gc.collect)

110____________________________________________________________________Python Na koniec został nam jeszcze jeden specyficzny problem związany z usuwaniem obiektów po wyjściu z programu. Zdarza się, że jakaś metoda__de 1__próbuje dostać się do danych lub metod obiektów zdefiniowanych w innych modułach. Jeśli w tym momencie obiekty te już nie istnieją, zostanie zgłoszony wyjątek Na- rneError i na ekranie pojawi się komunikat typu Exception exceptions.NameError: 'c' in <method Co ś.__del__ W of Co ś instance at c0310> ignored Jeśli coś takiego nastąpi, oznacza to, że metoda__del__zakończyła swoje działanie przedwcześnie. Może to też oznaczać, że nie udało się wykonać jakie- goś ważnego działania (takiego, jak prawidłowe zamknięcie połączenia z serwerem). W takiej sytuacji lepszym rozwiązaniem może być jawne zapisanie w kodzie końcowych operacji, niż poleganie na mechanizmach interpretera uruchamianych w momencie wychodzenia z programu. Konkretny wyjątek NameEr- ror można również wyeliminować, deklarując domyślne argumenty metody del (): import co ś class Byleco: def__del__(self, coś.byleco() coś=coś): # U życie czego ś z modułu co ś W niektórych przypadkach może być korzystne zakończenie programu bez wykonywania jakiegokolwiek „sprzątania". Można to uzyskać wywołując funkcję os ._exit (status). Funkcja ta stanowi interfejs wywołania systemowego na niskim poziomie ex i t (), odpowiedzialnego za zabijanie procesu interpretera Py- thona. Z chwilą wywołania tej funkcji program zostanie natychmiast zakończony. Dodatek A

Biblioteka Pythona

Wraz z Pythonem dostarczana jest duża kolekcja modułów, które realizują wiele różnych działań, począwszy od komunikowania się z systemem operacyjnym, aż po usługi multimedialne. Moduły te nazywane są wspólnie biblioteką Pythona. Aktualnie składa się ona z około 200 modułów, nad którymi pracowały dziesiątki użytkowników. W tym dodatku znajdują się opisy większości najczęściej używanych modułów z biblioteki Pythona, ze szczególnym naciskiem na funkcje wbudowane, usługi, działania na napisach, interfejsy systemu operacyjnego, wątki i programowanie sieciowe. W razie konieczności podawany jest krótki przegląd elementarnych po- jęć, ale zasadniczo czytelnik powinien być obeznany z podstawami systemu operacyjnego i programowania. Co więcej, ponieważ większość tej biblioteki jest oparta na interfejsach programistycznych (API) w C, dobry podręcznik programowania w tym języku może pomóc w niektórych bardziej wyrafinowanych punktach różnych modułów. Obszerną dokumentację online biblioteki Pythona można również znaleźć w miejscu http: //www. python . org/doc/lib. Dodatek ten bazuje w dużym stopniu na zawartości dokumentacji online biblioteki Pythona w wersji 2.1. Poczyniono w niej jednak szereg istotnych modyfikacji: • Objaśnienia do biblioteki zostały skrócone, aby nadać im bardziej zwartą postać. • Dodano nowe objaśnienia, które lepiej opisują pewne moduły - zwłaszcza od- noszące się do interfejsów systemu operacyjnego i programowania sieciowego. • W przypadku modułów wymagających głębokiej wiedzy z dodatkowych dzie- dzin, takich jak protokoły sieciowe niskiego poziomu lub formaty danych, pozo- stawiono tylko krótkie opisy wraz z odsyłaczami do odpowiednich źródeł. • Pominięto wyspeqalizowane moduły nadające się do użytku tylko na jednej platformie (na przykład rozszerzenia multimedialne dla SGI).

• Pominięte zostały duże konstrukcje, takie jak rozszerzenia Win32, Tkinter czy przetwarzanie XML, gdyż wykraczają one poza zakres tej książki (istnieją oddzielne poświęcone im książki). • Pominięto też moduły przestarzałe, nawet jeśli są one nadal dołączane do standardowego pakietu dystrybucyjnego.

112 Python Dodatek A: Biblioteka Pythona 113 Warto pamiętać, że biblioteka Pythona jest przez cały czas ulepszana i wzbogaca- ^ na o nowe możliwości. Chociaż omawiane tutaj moduły należą do najbardziej ^ stabilnych, ich zawartość może ulegać niewielkim zmianom wraz z upływem * czasu. Gdyby pojawiły się wątpliwości, możesz zawsze zajrzeć do dokumentacji ,^ online. % Na koniec kilka słów o kompatybilności i dostępności. Jeśli nie ma żadnej informacji, każdy moduł jest dostępny na wszystkich platformach. Tam, gdzie jest mowa o zagadnieniach związanych z konkretną platformą, jest to zawsze wyraź- ~ nie zaznaczone.

Funkcje i wyj ątki wbudowane W tej części opiszemy funkcje i wyjątki wbudowane w Pythona. Większość z za- - wartego tu materiału została już omówiona mniej formalnie w kolejnych roz- działach tej książki. Teraz zajmiemy się dodatkowymi szczegółami i bardziej wy- rafinowanymi aspektami różnych funkcji wbudowanych. > Funkcje wbudowane ] Omawiane w tej części funkcje są zawsze dostępne dla interpretera i należą do modułu__built in__. Ponadto jest to moduł, do którego odnosi się zwykle - atrybut ~J^U i 11 i n s__każdego innego modułu (chyba że program jest wyko- — nywany w środowisku ograniczonym, co jest opisane pod koniec dodatku A, ._- w części zatytułowanej „Działanie w trybie ograniczonym"). ;i __ (podkreślenie) Gdy interpreter działa w trybie interakcyjnym, zmienna _ (podkreślenie) zawie- :

ra standardowo rezultat ostatnio obliczonego wyrażenia. r Zobacz także sys.displayhook (133) __import__(name [, globals [, locals [, fromlist]]]) ~ Funkcja ta jest wywoływana przez instrukcję import w celu załadowania modułu, name jest napisem zawierającym nazwę modułu, globals nieobo- : wiązkowym katalogiem definiującym globalną przestrzeń nazw, 1 o ca 1 s katalogiem definiującym lokalną przestrzeń nazw, a fromlist listą zawierającą miejsca źródłowe dla instrukcji from. Na przykład instrukcja import moje oznacza w efekcie wywołanie funkcji__import__('moje', globals ()/ locals () , [ ]), natomiast instrukcja from mo j e import coś - wywołanie funkcji__import__('moje'), globals (), locals (), [' coś ']) Jeśli nazwa modułu jest poprzedzona nazwą pakietu, typu mo j e. coś, a argument „. fromlist jest pusty, zwracany jest odpowiedni obiekt-moduł. Jeśli zaś argument fromlist nie jest pusty, zwracany jest tylko pakiet na najwyż- szym poziomie. Celem tej funkcji jest udostępnienie interfejsu niskiego poziomu do ładowa- nia modułów. Funkcja ta nie wykonuje wszystkich działań realizowanych przez instrukcję import (w szczególności lokalna przestrzeń nazw nie jest uzupełniana o nazwy odnoszące się do obiektów zawartych w ładowanym module). Przedefiniowując tę funkcję, użytkownik może zaimplementować nowe zachowanie instrukcji import. Standardowa wersja nie sprawdza nawet parametru locals, a parametr globals służy wyłącznie do ustalania kontekstu pakietu (parametry te występują po to, aby alternatywne implementacje funkcji__import__miały pełny dostęp do informaqi o globalnej i lokalnej przestrzeni nazw, gdy pojawi się instrukcja import). abs(x) Zwraca wartość bezwzględną x.

apply(func [, args [, keywords]]) Realizuje operację wywołania funkqi na wy woły walnym obiekcie func. args jest tupią zawierającą argumenty pozycyjne, a keywords słownikiem zawierającym argumenty hasłowe. Funkcja apply () może być również zapisana jako func(*args,**keywords). buffer(sequence [, offset [, size]]) Tworzy nowy obiekt-bufor. Buforem jest zazwyczaj bajtowa sekwencja na- leżąca do innej sekwencji, takiej jak napis. Bufory przypominają zwykle napisy, tyle że nie pozwalają stosować metod napisowych ani nie mogą być argumentami dla funkcji z modułu string. callable{object) Zwraca 1, jeśli obj ec t jest obiektem wywoływalnym, a 0 w przeciwnym wypadku. chr(i) Konwertuje wartość całkowitą lub długą wartość całkowitą i, gdzie 0 <= i <= 255, na jednoznakowy napis. cmp(x, y) Porównuje x z y i zwraca wartość ujemną, gdy x < y, zero, gdy x == y, a wartość dodatnią, gdy x > y. Można w ten sposób porównywać dowolne obiekty, chociaż w przypadku, gdy nie ma zdefiniowanej sensownej metody porównania dla podanych obiektów, wynik może być bezsensowny. W pewnych okolicznościach takie porównanie może również spowodować zgłosze- nie wyjątku. coerce (x, y) Zwraca tupię zawierającą wartości x i y przekonwertowane na wspólny typ numeryczny. Więcej informacji znajdziesz w podrozdziale „Operacje matematyczne" rozdziału 3, „Typy i obiekty". compile {string, filename, kind) Kompiluje napis string na obiekt typu kod, nadający się do wykorzystania przez instrukcję exec lub funkqe eval (). filename to napis zawierający na- zwę pliku, w którym został zdefiniowany napis string. Parametr Jcindokreśla rodzaj kompilowanego kodu: 'exec' oznacza sekwencję instrukq'i, 'eval' pojedyncze wyrażenie, a 'single' pojedynczą wykonywalną instrukcję. complex (real [, imag]) Tworzy liczbę zespoloną.

114 Python delattr {object, attr) Usuwa wskazany atrybut obiektu. Parametr attr jest napisem. To samo działanie wykonuje instrukcja de 1 obj e et. attr. dir ( [object]) Zwraca posortowaną listę nazw atrybutów. Nazwy te są pobierane z atrybu- tów obiektu diet__,__methods__i__members__. Bez podania argumentu funkcja zwraca nazwy z bieżącej lokalnej tablicy symboli. d±vmod(a, Jb) Zwraca tupię z ilorazem i resztą z dzielenia całkowitego. W przypadku liczb całkowitych zwracana jest wartość {alb, a % Jb), a w przypadku liczb zmiennoprzecinkowych wartość (math, floor (a / b) , a % b). eval(expr [, globals [, locals]]) Oblicza wartość wyrażenia zapisanego w expr-napisie lub obiekcie-kodzie utworzonym przez funkcję compile (). Parametry globals i locals defi- niują odpowiednio globalną i lokalną przestrzeń nazw dla obliczeń. Bez nich funkcja użyje przestrzeni nazw kodu, który ją wywołał. execfile(filename [, globals [, locals]]) Wykonuje instrukcje z pliku filename. Parametry globals i locals defi- niują odpowiednio globalną i lokalną przestrzeń nazw, w których mają być wykonane instrukcje. Bez nich zawartość pliku zostanie wykonana w przestrzeni nazw kodu, który wywołał execf ile (). Funkcja ta nie powinna być używana w treści innych funkcji, gdyż jest niekompatybilna z zagnieżdżany- mi zasięgami. filter(function, list) Tworzy nową listę składającą się z obiektów na liście list, dla których funkcja function daje wartość prawda. Jeśli parametr function ma wartość None, używana jest funkcja tożsamościowa i wszystkie elementy listo war- tości fałsz są usuwane. float(x) Konwertuje x na liczbę zmiennoprzecinkową. getattr(oJbject, name [, default]) Zwraca atrybut name obiektu object. Parametr name jest napisem. Parametr default jest nieobowiązkową wartością zwracaną, gdy podany atrybut nie istnieje. Działa tak samo jak object. name. globals() Zwraca słownik odpowiadający globalnej przestrzeni nazw kodu wywołującego. hasattr(object, name) Zwraca 1, jeśli obiekt object ma atrybut o nazwie name, a 0 w przeciwnym wypadku. Parametr name jest napisem. hash(object) Zwraca liczbę całkowitą będącą wynikiem funkcji haszującej dla podanego obiektu (jeśli to możliwe). Wynik ten jest identyczny dla każdych dwóch Dodatek A: bibiioteKa tytnona 115 obiektów, które przy porównywaniu okazują się równe. Funkcja haszująca nie działa na obiektach zmiennych. hex (x) Konwertuje liczbę całkowitą lub długą liczbę całkowitą x na napis szesnastkowy. id(object) Zwraca liczbę całkowitą będącą unikatowym identyfikatorem obiektu object. input ( [prompt]) Działa tak samo, jak eval (raw_input (prompt) ). int(x [, base]) Konwertuje liczbę lub napis x na wartość całkowitą. Nieobowiązkowy parametr base podaje bazę przy konwertowania napisu. intern (string) Sprawdza, czy parametr string należy do wewnętrznej tablicy napisów. Je- śli tak, funkcja zwraca kopię tego wewnętrznego napisu. Jeśli nie, parametr

s t ring jest dodawany do wewnętrznej tablicy napisów (internowany) i zwracany. Funkcja intern () używana jest przede wszystkim do usprawnienia działań związanych z przeszukiwaniem słowników. Internowane napisy nie są nigdy usuwane podczas pozyskiwania pamięci. Funkcja ta nie ma zastosowania do napisów Unicode. isinsta ńce(object, classobj) Zwraca wartość prawda, jeśli obiekt object jest instancją classobj lub podklasy classobj. Funkcja ta może być również używana do sprawdzania typów, jeśli classobj jest obiektem-typem. issubclass(classl, class2) Zwraca wartość prawda, jeśli classl jest podklasą (lub klasą pochodną) class2. Uwaga: issubclass (A, A) zwraca wartość prawda. len(s) Zwraca liczbę elementów sekwencji s. list(s) Zwraca nową listę składającą się z elementów sekwencji s. locals() Zwraca słownik odpowiadający lokalnej przestrzeni nazw kodu wywołującego tę funkcję. long(x [ , base]) Konwertuje liczbę lub napis x na długą wartość całkowitą. Nieobowiązkowy parametr base podaje bazę konwersji, gdy x jest napisem. map(function, list, ...) Wykonuje funkcję function dla każdego elementu listy list i zwraca listę wyników. Jeśli podasz więcej niż jedną listę, funkcja function będzie wywoływana z wieloma argumentami - po jednym z każdej listy. Jeśli parametr function ma wartość None, oznacza to funkqe tożsamościową.

116 Python W przypadku wielu list powoduje to zwrot listy tupli, z których każda zawiera po jednym elemencie z każdej listy. Krótkie listy są wówczas uzupełniane wartością None do zrównania z najdłuższą listą. Czasami zamiast funkcji map można próbować użyć wybierania listowego. Na przykład wywołanie map (funkcja, lista) można zastąpić przez [funkcja (x) for x in lista]. Zobacz także zip (119). max(s [, args, . . .]) Gdy jest tylko jeden argument s, zwraca maksymalną wartość w sekwencji s. Gdy jest wiele argumentów, zwraca największy z nich. min(s [, args, . . .]) Gdy jest tylko jeden argument s, zwraca minimalną wartość w sekwencji s. Gdy jest wiele argumentów, zwraca najmniejszy z nich. oct (x) Konwertuje wartość całkowitą lub długą wartość całkowitą x na napis ósem- kowy, open(filename [, mode [, bufsize]]) Otwiera plik filename i zwraca nowy obiekt-plik (zobacz rozdział 10 „Śro- dowisko wykonania programu"). Parametr mode określa sposób otwarcia pliku: ' r ' w trybie czytania, ' w' w trybie pisania lub ' a' w trybie dodawania. Obok symbolu trybu można podać również znak ' +', który powoduje otwarcie pliku w trybie aktualizacji (co umożliwia zarówno czytanie, jak i pisanie). Otwarcie istniejącego już pliku w trybie ' w+' powoduje skrócenie go do zerowej długości. Otwarcie pliku w trybie ' a+ ' lub ' r+ ' powoduje udostępnie- nie go zarówno do czytania, jak i pisania, ale z zachowaniem dotychczasowej zawartości. Użycie w parametrze mode litery ' b' oznacza tryb binarny, co jest przydatne w systemach takich jak Windows, które robią rozróżnienie mię- dzy plikami tekstowymi i binarnymi. Jeśli nie podasz mode, zostanie przyjęty domyślnie tryb ' r '. Parametr bufsize odnosi się do sposobu buforowania: wartość 0 oznacza brak buforowania, 1 buforowanie jednej linii, a dowolna inna liczba dodatnia określa rozmiar bufora w bajtach. Liczba ujemna powoduje zastosowanie standardowej w systemie metody buforowania (jest to działanie domyślne). ord(c) Zwraca kod całkowity pojedynczego znaku c. W przypadku zwykłych znaków jest to wartość z przedziału [ 0, 2 5 5 ], a w przypadku znaków Unicode wartość z przedziału [0,65535]. pow(x, y [, z]) Zwraca wartość x * * y. Jeśli wystąpi argument z, zwracana jest wartość (x * * y) % z. range([start,] stop [, step]) Tworzy listę wartości całkowitych odstartdostopz krokiem step (domy- ślnie jest to wartość 1). Jeśli nie podasz start (czyli wywołasz range O z jednym tylko argumentem), w jego miejsce zostanie przyjęta wartość 0. Dodatek A: Biblioteka Pythona 11 Ujemny krok (step) powoduje zwrot listy kolejnych liczb w porządku ma lejącym. Zobacz także xrange (118) raw__input ([prompt]) Wczytuje jedną linię ze standardowego strumienia wejściowego (sys. stdin) i zwraca ją jako napis. Jeśli podasz argument prompt, zostanie on naj pierw wysłany na standardowy strumień wyjściowy (sys.stdout). Wystę pujące na końcu znaki przejścia do nowej linii są obcinane, a w przypadki,

natrafienia na znak końca pliku (EOF), zgłaszany jest wyjątek EOFEr r o r. Jeśl jest załadowany moduł readline, funkcja raw_input () udostępnia zaawansowane techniki edycji linii i uzupełniania poleceń. reduce(func, seq [, initializer]) Wykonuje w sposób kumulujący dwuargumentową funkcję func dla kolejnych elementów sekwencji seg i zwraca na koniec pojedynczą wartość. NĆ początku wyznaczana jest wartość func dla dwóch pierwszych elementów seg, a następnie wywołuje się ją z użyciem ostatniego wyniku i kolejnego elementu sekwenqi seg, aż do jej wyczerpania. Argument initializer jesi nieobowiązkowy i zawiera wartość używaną przy pierwszym wywołaniu func lub gdy sekwencja seg jest pusta. reload(module) Ładuje moduł, który był już wcześniej importowany. Argument module musi odnosić się do istniejącego obiektu modułu. Nie zaleca się używania tej funkqi do innych celów niż debugowanie. Oto kilka dodatkowych uwag, o którydi warto pamiętać: • W trakcie ponownego ładowania modułu słownik definiujący globalną przestrzeń nazw tego modułu zostaje zachowany. Oznacza to, że definiqe pochodzące ze starego modułu, a nie występujące w nowym, będą nada] dostępne. Można to wykorzystać do sprawdzenia, czy moduł był już wcze- śniej ładowany. • Moduły ładowane dynamicznie napisane w C nie mogą być zwykle łado- wane ponownie. • Jeśli jakiś moduł dokonał wcześniej importu modułu module za pomocą instrukcji from, będzie on nadal używał definicji ze starej wersji modułu. Aby rozwiązać ten problem, można po przeładowaniu modułu ponownie wykonać instrukcję from lub stosować w pełni kwalifikowane nazwy, takie jak module. name. • Jeśli w programie istnieją instanqe obiektów utworzone za pomocą klas ze starego modułu, będą one nadal używały metod zdefiniowanych w poprzednio załadowanej wersji. repr(object) Zwraca napis reprezentujący object. Taki sam napis generuje operacja odwrotnych apostrofów (v obj ec t"). W większości przypadków zwracany napis jest wyrażeniem, które można przekazać do funkqi eval () w celu odtworze- nia obiektu.

118 Python round (x [, n]) Zwraca wynik zaokrąglenia liczby zmiennoprzecinkowej x do najbliższej wielokrotności liczby 10 podniesionej do potęgi minus n. Jeśli nie ma n, przyjmowana jest wartość 0. Jeśli x wypada dokładnie między dwoma kolejnymi wielokrotnościami, wybierane jest zaokrąglenie dalsze od zera (na przykład wartość 0 . 5 jest zaokrąglana do 1. 0, a -0 . 5 do -1. 0). setattr (object, name, value) Ustawia atrybut name obiektu obj ect na wartość value. Parametr name jest napisem. Powoduje to samo co obj ect. name = value. slice([start,] stop [, step]) Zwraca obiekt-wycinek reprezentujący liczby całkowite z podanego zakresu ([start, stop]). Obiekty tego typu mogą być też generowane przy użyciu rozszerzonej składni wycinka. Szczegółowe informacje można znaleźć w rozdziale 3 w podrozdziale zatytułowanym „Metody sekwencji i mapowania". str(object) Zwraca napis reprezentujący drukowalną postać obiektu. Jest to taki sam napis, jaki zostałby wygenerowany przez instrukqe print. tuple(s) Tworzy tupię, której elementy pochodzą z sekwencji s. Jeśli argument jest już tupią, funkcja zwraca go w oryginalnej postaci. type(object) Zwraca typ argumentu. Wartość powrotna ma postać obiektu-typu zdefiniowanego w module types. Zobacz także isinstance (115). unichr(i) Konwertuje wartość całkowitą lub długą całkowitą 1(0 <= i <= 65535) na pojedynczy znak Unicode. Unicode (string [, encoding [, errors] ]) Konwertuje napis s tring na napis Unicode. Parametr en coding określa rodzaj kodowania. Jeśli nie występuje w wywołaniu, funkcja stosuje kodowanie standardowe, czyli zwracane przez sys .getdefaultencoding (). Para- metr errors decyduje o sposobie reagowania na błędy i może mieć jedną z trzech wartości: ' strict', ' ignore ' lub ' replace '. Szczegółowe informaqe można znaleźć w rozdziale 9 „Wejście i wyjście" oraz 3 „Typy i obiekty". vars ([object]) Zwraca tablicę symboli argumentu object (znajdującą się zwykle w jego atrybucie__diet__). Bez podania argumentu funkcja zwraca słownik od- powiadający lokalnej przestrzeni nazw. xrange ([start, ] stop [, step]) Działa podobnie jak range (), tyle że zwraca obiekt XRangeType. Obiekt ten udostępnia te same wartości, co lista utworzona przez range (), ale w rzeczy- wistości nie są one nigdzie zapisane. Jest to korzystne w przypadku bardzo du- żych zakresów liczb całkowitych, które normalnie zajmowałyby wiele pamięci. Dodatek A: Biblioteka Pythona zip(sl [, s2 [, ...]]) Zwraca listę tupli, z których n-ta tupla ma postać (sl[n], s2[n], ...) Końcowa lista ma długość najkrótszej sekwencji podanej w argumentach. Wyjątki wbudowane Wyjątki wbudowane są zdefiniowane w module exceptions ładowanym zaw sze przed wykonaniem jakiegokolwiek programu. Definicje wyjątków mają pc stać klas. Oto lista wyjątków, które są wykorzystywane jako klasy bazowe dl wszystkich innych wyjątków: Exception

Klasa „korzeń". Jest to klasa bazowa wszystkich wyjątków wbudowanych Zaleca się, aby również wyjątki zdefiniowane przez użytkownika pochodził1

od tej klasy. S tandardError Klasa bazowa wszystkich wyjątków wbudowanych z wyjątkiem System- Exit. ArithmeticError Klasa bazowa wyjątków arytmetycznych, w tym Overf lowError, Zero- DivisionError i FloatingPointError. LookupError Klasa bazowa błędów związanych z kluczami i indeksowaniem, w tym In- dexError i KeyError. EnvironmentError Klasa bazowa błędów następujących poza Pythonem, w tym IOErroi iOSError. Żaden z dotychczas podanych wyjątków nie jest nigdy zgłaszany bezpośred- nio. Mogą one za to służyć do przechwytywania pewnych klas wyjątków. Otc na przykład kod, który przechwyci każdy błąd numeryczny: try: # Jakieś działania except ArithmeticError, e: # Błąd matematyczny Po zgłoszeniu wyjątku następuje utworzenie instancji klasy tego wyjątku. In- stancja ta jest umieszczana w nieobowiązkowej zmiennej podanej w instrukcji except. Na przykład: except IOError, e: # Obsługa bł ędu # Na zmiennej 'e' instancja IOError Z większością wyjątków jest skojarzona wartość, którą można znaleźć w atrybucie args instancji wyjątku (' e. args • w ostatnim przykładzie). W więk- szości przypadków jest to napis opisujący zaistniały błąd. Dla wyjątków opartych na EnvironmentError jest to podwójna lub potrójna tupla zawie- rająca numer całkowity błędu, napis z komunikatem o błędzie i nieobo-

120 Python Podatek A: Biblioteka Pythona 121 wiązkową nazwę pliku (wartości te są również dostępne w postaci atrybutów wyjątku opisanych w dalszej części). Oto wyjątki, które mogą być zgłaszane przez programy: AssertionError Błąd w instrukcji assert. AttributeError Błąd w odwołaniu do atrybutu lub w przypisaniu. EOFError Koniec pliku. Wyjątek generowany przez funkcję wbudowaną input () oraz raw__input (). Uwaga: niektóre metody wejścia/wyjścia, takie jak read () czy readlineO w momencie napotkania końca pliku zwracają pusty napis. FloatingPointError Błąd w operacji zmiennoprzecinkowej. Podklasa wyjątku Ar i t hme ticError. IOError Błąd w operacji wejścia/wyjścia. Zwracaną wartością jest instancja IOError z atrybutami errno, strerror i filename. Atrybut errno jest numerem całkowitym błędu, strerror napisem z komunikatem o błędzie, afilena- me nieobowiązkową nazwą pliku. Wyjątek ten jest podklasa Environment- Error. ImportError Wyjątek zgłaszany, gdy instrukcja import nie może znaleźć podanego modułu lub gdy instrukcja from nie może znaleźć w module podanej nazwy. IndentationError Błąd wcięcia. Podklasa wyjątku SyntaxError. IndexError Użyty indeks sekwencji wypada poza zakresem. Podklasa LookupError. KeyError Brak podanego klucza w słowniku. Podklasa LookupError. Keyboardlnterrupt Wyjątek zgłaszany w momencie naciśnięcia przez użytkownika klawisza przerwania (zazwyczaj [Ctrl+Cl). MemoryError Naprawialny błąd wyjścia poza pamięć. NameError Brak podanej nazwy w lokalnej lub w globalnej przestrzeni nazw. NotlmplementedError Nie zaimplementowana cecha. Wyjątek ten może być zgłaszany przez klasy bazowe, które wymagają klas pochodnych do zaimplementowania pewnych metod. Podklasa Runtime Error. OSError Błąd systemu operacyjnego. Wyjątek ten jest zgłaszany głównie przez funkcje z modułu os. Jest to ta sama wartość, co w przypadku IOError. Podklasa EnvironmentError. OverflowError Wynik operacji arytmetycznej zbyt duży, aby dało się go poprawnie przedsta- wić. Podklasa ArithmeticError. RuntimeError Ogólny błąd nie pasujący do żadnej innej kategorii. SyntaxError Błąd składni. Instancja tego wyjątku ma atrybuty filename, lineno, offset i text, za pomocą których można uzyskać dodatkowe informacje. SystemError Wewnętrzny błąd interpretera. Wartością jest napis wskazujący problem.

SystemExit Wyjątek zgłaszany przez funkcję sys . ex i t (). Wartością jest liczba całkowi- ta oznaczająca kod powrotu. Jeśli trzeba natychmiast wyjść z programu, mo- żna użyć os ._exit (). TabError Błąd oznaczający niespójne użycie tabulacji. Wyjątek generowany po uruchomieniu Pythona z opcją -tt. Podklasa SyntaxError. TypeError Nieprawidłowy typ obiektu użytego w działaniu lub wywołaniu funkcji. UnboundLocalError Odwołanie do niezwiązanej zmiennej lokalnej. Błąd ten następuje, gdy odwołanie do funkcji następuje przed zdefiniowaniem jej w funkcji. Podklasa NameError. UnicodeError Błąd kodowania lub dekodowania Unicode. Podklasa ValueError. ValueError Błąd generowany, gdy argument funkcji lub operacji ma prawidłowy typ, ale nieprawidłową wartość. WindowsError Błąd generowany w przypadku nieudanego wywołania systemowego w Windows. Podklasa OSError. ZeroDivisionError Błąd dzielenia przez zero. Podklasa ArithmeticError. Moduł exceptions definiuje także obiekty - wyjątki Warning, UserWar- ning, DeprecationWarning, RuntimeWarning i SyntaxWarning. Wyjątki te są używane jako część mechanizmu ostrzegającego Pythona i są opisane w dalszej części przy okazji modułu warnings. Zobacz także warnings (136).

122 Python Dodatek A: Biblioteka Pythona

Usługi Pythona Moduły opisane w tej części służą przede wszystkim do wpływania na pracę interpretera Pythona i jego środowisko. atexit Moduł atexit służy do rejestrowania funkcji wykonywanych w momencie zamykania interpretera Pythona. Dostępna jest tylko jedna funkcja: register(func [, args [, kwargs]) Dodaje ona funkcję fun c do listy funkcji, które mają być wykonywane w momencie kończenia pracy interpretera, args to tupla z argumentami pozycyjnymi przeznaczonymi dla tej funkcji, a kwargs to słownik z jej argumentami hasłowymi. Jej wywołanie będzie miało postać func (* args, ** kwargs). UWAGA • Zamiast ustawiać zmienną sys. exit func należy używać modułu atexit. Zobacz także sys (131). copy Moduł copy zawiera funkcje do tworzenia płytkich i głębokich kopii złożonych obiektów, takich jak listy, tupie, słowniki czy instancje klas. copy (x) Tworzy płytką kopię x. W rezultacie powstaje nowy obiekt ze składnikami w postaci odniesień do składników x. deepcopy(x [, visit]) Tworzy głęboką kopię x. W rezultacie powstaje nowy obiekt z powielonymi wszystkimi składnikami x. Parametr visit jest nieobowiązkowym słowni- kiem, używanym wewnętrznie do wykrywania i unikania zapętleń w rekurencyjnie zdefiniowanych strukturach danych. Tworząc klasę można w niej zaimplementować własne metody kopiowania w postaci__copy__(self) i__deepcopy__(self, visit). Każda z tych metod powinna zwracać kopię swojego obiektu. Ponadto metoda __deepcopy__() musi mieć wśród parametrów analogiczny do funkcji deepcopy () słownik vis i t. Wewnątrz__deepcopy__() nie trzeba koniecznie modyfikować tego słownika. Należy go za to przekazywać do wywoływanej w treści__deepcopy__() funkcji deepcopy (), o ile oczy- wiście takie wywołanie ma miejsce. UWAGI • Można używać tego modułu do obiektów prostych typów, takich jak liczby całkowite i napisy, ale nie ma za bardzo takiej potrzeby. • Funkcje kopiujące nie działają na modułach, klasach, funkcjach, metodach, śladach, ramkach stosu, plikach, gniazdach ani innych podobnych typach. Gdy nie można skopiować jakiegoś obiektu, zgłaszany jest wyjątek copy. error. • Moduł copy nie korzysta z modułu copy_reg. Zobacz także piekle (127). copyjeg Moduł copy_reg rozszerza możliwości modułów pickleicPicklew zakresie serializacji obiektów typów opisanych w rozszerzeniach (modułach rozsze- rzeń napisanych w C). Autorzy rozszerzeń mogą używać tego modułu do rejestrowania funkcji redukujących i konstruujących, wykorzystywanych odpowiednio do serializacji i deserializacji obiektów. constructor (cfunc) Deklaruje cfunc jako poprawną funkcję konstruującą, cfunc musi być wywoływalnym obiektem akceptującym tupię wartości zwracaną przez funkcję redukującą podaną w wywołaniu piekle (). piekle[type, rfunc [, cfunc]) Funkcja ta rejestruje rfunc jako funkcję redukującą dla obiektów typu type

rfunc pobiera obiekt podanego typu i zwraca tupię zawierającą funkcję kon- struującą oraz tupię argumentów, które należy przekazać do tej funkcji w celu ponownego złożenia z nich obiektu. Nieobowiązkowy argument cfun c prze kazuje funkcję konstruującą, zarejestrowaną przy użyciu funkcji constructor (). PRZYKŁAD Oto przykład, który pokazuje, jak można wykorzystać moduł copy_reg d( składowania (serializacji) liczb zespolonych. (Uwaga: ponieważ liczby zespolon< są standardowo składowane, celem tego przykładu jest wyłącznie ilustracja za stosowania omawianej metody). # Rejestracja metody składowania liczb zespolonych import copy_reg # Tworzenie liczb zespolonych z dwóch liczb rzeczyw istych def construct_complex(real,imag): return complex(real,imag) # Funkcja wbudowana # Zamiana liczby zespolonej 'c' na tupi ę liczb rzeczywistych def reduce_complex(c): return construct_complex, (c.real, c.imag) # Rejstracja obsługi składowania copy_reg.pickle(type(lj),reduce_complex, construct_ complex) W momencie serializacji liczby zespolonej wywoływana jest funkcja redu ce_complex (). Aby dokonać później deserializacji obiektu, trzeba z koi wywołać funkcję cons truct_complex (), podając w niej tupię z oryginalnym wartościami zwróconymi przez reduce_complex (). UWAGI # Nazwa copy_reg jest trochę myląca - moduł ten nie jest wykorzystywany przez moduł copy. # Nie trzeba używać tego modułu do składowania instancji klas zdefiniowanych przez użytkownika. Zobacz także piekle (12

124 Python Moduł gc stanowi interfejs służący do kontrolowania narzędzia pozyskującego pamięć, używanego w celu wykrywania zapętleń w takich obiektach jak listy, tupie, słowniki i instancje. W miarę tworzenia różnego typu obiektów kontenerów są one umieszczane na wewnętrznej liście interpretera. Każda dealokacja takiego obiektu powoduje również usunięcie go z tej listy. Gdy liczba alokacji przekracza liczbę dealokacji o wartość progową zdefiniowaną przez użytkownika, następuje wywołanie narzędzia pozyskującego pamięć. Jego działanie polega na przegląda- niu wspomnianej listy i wykrywaniu kolekcji obiektów, które nie są już używane, ale na skutek cyklicznej zależności nie zostały jeszcze dealokowane. Ponadto na- rzędzie do pozyskiwania pamięci wykorzystuje trzystopniowy schemat pokole- niowy, w którym obiekty nie zwolnione na wstępnym etapie pozyskiwania pa- mięci trafiają na listę obiektów rzadziej sprawdzanych. Przyśpiesza to wykonanie programów wykorzystujących dużą liczbę obiektów „długo żyjących". collect() Uruchamia pełną wersję pozyskiwania pamięci. Funkcja ta sprawdza wszystkie pokolenia obiektów i zwraca liczbę obiektów, do których nie ma dostępu. disable () Wyłącza pozyskiwanie pamięci. enable() Włącza pozyskiwanie pamięci. garbage Zmienna zawierająca listę (tylko do odczytu) nie pozyskanych obiektów, któ- re z pewnych powodów nie mogły zostać zwolnione. Przeczytaj uwagi. isenabled() Zwraca wartość prawda, jeśli pozyskiwanie pamięci jest włączone, s e t_debug{flags) Ustawia flagi debugowania pozyskiwania pamięci. Używając tych flag, mo- żna kontrolować zachowanie narzędzia do pozyskiwania pamięci. Argument flags jest sumą bitową stałych DEBUG_STATS, DEBUG_COLLECTABLE, DEBUGJJNCOLLECTABLE, DEBUGJNSTANCES, DEBUG_OBJECTS, DEBUG_SAVEALL i DEBUG_LEAK. get_debug() Zwraca aktualnie ustawione flagi debugowania. get_threshold() Zwraca w postaci tupli aktualną wartość progową pozyskiwania. set_threshold(thresholdO [, thresholdl [, threshold2]]) Ustawia częstotliwość pozyskiwania pamięci. Obiekty są dzielone na trzy pokolenia, z których pokolenie 0 składa się z najmłodszych obiektów, a pokolenie 2 - z najstarszych. Obiekty, które przeżyją kolejny etap pozyskiwania pamięci, przechodzą do następnego starszego pokolenia. Obiekt, który dojdzie w ten sposób do pokolenia 2, zostaje w nim już. Parametr thresholdO to różnica między liczbą alokowanych i dealokowanych obiektów, która musi zostać osiągnięta, aby odbyło się pozyskiwanie pamięci wśród obiektów pokolenia 0. Parametr thresholdl to z kolei liczba pozyskiwań pamięci na poziomie pokolenia 0, które muszą nastąpić, aby doszło do pozyskiwania pamięci w pokoleniu 1. Natomiast threshold2 jest liczbą pozyskiwań pa- mięci na poziomie pokolenia 1, które muszą nastąpić, aby doszło do pozyskiwania pamięci w pokoleniu 2. Standardowe wartości progowe wynoszą obecnie (700,10,10). Ustawienie thresholdO na zero powoduje zablokowanie pozyskiwania pamięci. UWAGI • Cykliczne odniesienia z udziałem obiektów dysponujących metodą___de 1___() nie są zwalniane przy po- zyskiwaniu pamięci i trafiają na listę gc. garbage (obiektów niepozyskiwalnych). Obiekty te nie są zwalniane na skutek trudności związanych ze „sprzątaniem" po nich i kolejnością wykonywania ich metody __del__(). • Aby prześledzić działanie programu z utratą pamięci, można użyć polecenia gc.set_de-

bug(gc.DEBUG_LEAK). • Moduł gc pojawił się po raz pierwszy w Pythonie 2.0. marshal Moduł marshal służy do serializacji obiektów Pythona. Przypomina moduł) piekle i shelve, ale daje mniejsze możliwości i jest przewidziany tylko dc działania na prostych obiektach. Nie powinno się go wykorzystywać do imple mentowania trwałych obiektów (trzeba wtedy użyć piekle). dump(value, file) Zapisuje obiekt value w otwartym obiekcie pliku file. Jeśli typ value ni jest obsługiwany, funkcja zgłasza wyjątek ValueError. dumps (value) Zwraca napis utworzony przez funkcję dump(). Jeśli typ value nie jes obsługiwany, funkcja zgłasza wyjątek ValueError. load(file) Wczytuje i zwraca następną wartość z otwartego obiektu pliku fi 1 e. Brak p< prawnej wartości powoduje zgłoszenie wyjątku EOFEr r or, ValueError lv TypeError. loads {string) Wczytuje i zwraca następną wartość z napisu string. UWAGI • Dane są zapisywane w formacie binarnym niezależnym od architektury systemu. • Dozwolone są tylko obiekty typu None, liczby całkowite, długie liczby całkowite, liczby zmiennoprzecin we, liczby zespolone, napisy, napisy Unicode, tupie, listy, słowniki i kod. Listy, tupie i słowniki mogą zawie wyłącznie obiekty wymienionych przed chwilą typów. Instancje klas i odniesienia rekurencyjne w listach, piach i słownikach nie są dozwolone. • Moduł marshal działa dużo szybciej niż piekle, ale nie jest tak elastyczny. Zobacz także piekle (127), shelve (li

new Moduł new służy do tworzenia różnego typu obiektów używanych przez interpreter. Z modułu tego korzystają przede wszystkim aplikaqe, które muszą tworzyć obiekty w sposób niestandardowy (na przykład podczas deserializaqi danych), instance(class, diet) Tworzy instancję klasy class ze słownikiem diet bez wywoływania meto- dy__init__(). instancemethod (function, instance, class) Tworzy obiekt metodę związany z instance. Argument function musi być wywoływalnym obiektem. Jeśli instance ma wartość None, tworzona jest niezwiązana instancja metody. function(code, globals [, name [, argdefs]]) Tworzy obiekt-funkcję z kodem zawartym w obiekcie code i globalną prze- strzenią nazw. Funkcja otrzymuje nazwę name (jeśli argument ten ma wartość None, nazwa pobierana jest z code. co_name). argdefs jest tupią zawie- rającą domyślne wartości parametrów. code(argcount, nlocals, stacksize, flags, codestring, constants, names, varnames, filename, name, firstlineno, lnotah) Tworzy nowy obiekt code. Objaśnienia argumentów podane są w podrozdziale „Typy wewnętrzne" rozdziału 3. module(name) Tworzy nowy obiekt moduł, name zawiera nazwę modułu, elassobj(name, baseclasses, diet) Tworzy nowy obiekt-klasę. name zawiera nazwę klasy, baseclasses jest tupią z klasami bazowymi, a diet jest słownikiem definiującym przestrzeń nazw tej klasy. Zobacz także rozdział 3. operator Moduł operator zawiera funkcje dostępu do wbudowanych operatorów i specjalnych metod interpretera opisanych w rozdziale 3. Na przykład funkcja add (3, 4) powoduje to samo, co 3 + 4. Gdy nazwa funkcji pokrywa się z naz- wą metody specjalnej, można ją wywoływać umieszczając po obu stronach nazwy dwa znaki podkreślenia - na przykład__add__(3, 4). Funkcja Opis add(a, b) Zwraca sumę liczb a + b

sub(a, b) Zwraca a - b mul (a, b) Zwraca iloczyn liczb a * b div(a, b) Zwraca alb mod(a, b) Zwraca a % b neg(a) Zwraca -a pos(a) Zwraca +a Funkcja Opis abs(a) Zwraca wartość bezwzględną a inv(a) Zwraca odwrotność a lshift(a, b) Zwraca a « b rshift(a, b) Zwraca a » b and (a, b) Zwraca a & Jb (koniunkcja bitowa) or_(a, jb) Zwraca a 1 b (alternatywa bitowa) xor(a, b) Zwraca a A b (rozłączna alternatywa bitowa) not_(a) Zwraca negację a truth(a) Zwraca 2, jeśli a ma wartość prawda, a 0 w przeciwnym wypadku concat(a, Jb) Zwraca a + b dla sekwencji repeat (a, jb) Zwraca a * b dla sekwencji a i liczby całkowitej b contains(a, b) Zwraca wynik testu, czy b należy do a sequencelncludes(a, b) Zwraca wynik testu, czy b należy do a (niezalecane)

countOf(a, b) Zwraca liczbę wystąpień bwa indexOf(a, b) Zwraca indeks pierwszego wystąpienia & w a getitem(a, b) Zwraca a [Jb] setitem(a, b, c) a[Jb] = c delitem(a, b) del a[b] getslice(a, Jb, c) Zwraca a[b:c] setslice(a, Jb, c, v) Ustawia a [b: c] = v delslice(a, b, c) del a[jb:c]

Moduł operator definiuje ponadto kilka funkcji do sprawdzania właściwość: obiektów. Uwaga: Funkcje te nie są do końca wiarygodne w przypadku instancj: zdefiniowanych przez użytkownika, gdyż nie przeprowadzają na tyle wyczer- pujących testów, aby przekonać się, czy wszystkie niezbędne funkcje są zaimple mentowane w obiekcie. Funkcja isMappingType(o) isNumberType(o) isSequenceType(o) Opis Sprawdza, czy o zapewnia interfejs mapowania Sprawdza, czy o zapewnia interfejs liczby Sprawdza, czy o zapewnia interfejs sekwencji Zobacz także „Metody specjalne" w rozdziale ć

piekle i cPickle Moduły piekle i cPickle służą do rozkładania obiektów Pythona na posta strumienia bajtów nadającego się do zapisania w pliku, przesłania przez sieć lui umieszczenia w bazie danych. Proces ten bywa nazywany różnie: składowa niem, serializacją, szeregowaniem lub spłaszczaniem. Uzyskany tą drogą stru mień bajtów można potem zamienić z powrotem na obiekty Pythona metod złożenia (deserializaqi).

128 Python Procesy rozkładania i składania są kontrolowane przy użyciu obiektów Pic- kler i Unpickler, tworzonych za pomocą następujących dwóch funkcji: Pickler(file [, bin]) Tworzy obiekt rozkładający, który zapisuje dane w obiekcie pliku fi 1 e. Para- metr bin umożliwia zapis danych w formacie binarnym. Standardowo uży- wany jest mniej efektywny - za to bardziej czytelny - format tekstowy. Unpickler(file) Tworzy obiekt składający, który wczytuje dane z obiektu pliku file. Obiekt ten automatycznie rozpoznaje, czy pobierane dane są w formacie binarnym, czy tekstowym. Do serializacji obiektu x w pliku / używa się metody dump () obiektu pickler. Na przykład: f = open('mójplik', 'w') p = piekle.Pickler (f) # Utworzenie obiektu skład uj ącego dane # w pliku f p.dump(x) # Zapisanie x Aby złożyć później taki obiekt, wystarczy napisać: f = open('mójplik') u = piekle.Unpickler(f) x = u.load() # Odtworzenie x z pliku f Używając tego samego pliku można wywołać wiele razy metody dump () i load () pod warunkiem, że sekwencja wywołań load () powodujących odtworzenie obiektów będzie odpowiadać sekwencji wywołań dump () użytych wcześniej do zapisania tych obiektów. Oto lista funkcji dostępnych w formie skrótów dla typowych operacji składo- wania: dump(oibject, file [, bin]) Zapisuje rozłożoną reprezentację obiektu object w obiekcie pliku file. Powoduje to samo, co Pickler (file, bin) .dump (object). dumps(object [, bin]) Działa tak samo jak dump (), tyle że zwraca napis zawierający rozłożone dane. load(file) Ładuje rozłożoną reprezentację obiektu z obiektu pliku fi 1 e. To samo co Unpickler(file) .load(). loads(string) Działa tak samo jak load(), tyle że wczytuje rozłożoną reprezentację obiektu z napisu string. Oto obiekty, które mogą być rozkładane: • None • Liczby całkowite, długie liczby całkowite, liczby zmiennoprzecinkowe i liczby zespolone • Tupie, listy i słowniki zawierające wyłącznie rozkładalne obiekty Dodatek A: Biblioteka Pythona 129 • Napisy zwykłe i Unicode • Klasy zdefiniowane na najwyższym poziomie modułu • Instancje klas zdefiniowanych na najwyższym poziomie modułu Aby można było rozłożyć instancję jakiejś klasy, definicja tej klasy musi występo- wać na najwyższym poziomie modułu (nie może to być klasa zagnieżdżona). Podczas składania takiej instancji następuje automatyczny import modułu z defi- nicją jej klasy. Ponadto w momencie odtwarzania instancji nie dochodzi do wywołania jej metody__i nit__(). Aby spowodować wywoływanie tej metody w momencie składania instancji, w jej klasie musi być zdefiniowana specjalna metoda__getinitargs__(), zwracająca tupię z argumentami przeznaczonymi dla__init__(). W takim przypadku piekle wywołuje tę metodę i koduje argumenty konstruktora w strumieniu bajtów używanym później do złoże- nia instancji. Warto również pamiętać, że przed przystąpieniem do składania instanqi klasy, której definiqa występowała w__ma i n__, trzeba ręcznie załadować tę definiqe

do__main__, gdyż interpreter w żaden sposób nie będzie wiedział, jak ma to zrobić automatycznie. Klasa może definiować niestandardowe metody zapisywania i odtwarzania swojego stanu, implementując specjalne metody__get state__() i__setsta- te__() .Metoda__get sta te__() musi zwracać rozkładalny obiekt (taki jak napis) reprezentujący stan obiektu klasy. Metoda__setstate__() musi z kolei przyjmować rozłożony obiekt i na jego podstawie odtwarzać stan klasy. W przypadku braku metody__getstate__() moduł piekle składuje po prostu atrybut__diet__obiektu klasy. Próba rozkładania obiektu o niedozwolonym typie powoduje zgłoszenie wyjątku piekle. PicklingError. Jeśli zaś nastąpi błąd podczas składania obiektu, zostanie zgłoszony wyjątek piekle . UnpicklingError. UWAGI • Obiekty rekurencyjne (zawierające odwołania do samych siebie) i obiekty dzielone są składowane pra- widłowo. Jeśli jednak ten sam obiekt jest przekazywany do obiektu Pickler więcej niż jeden raz, tylko jego pierwsza instancja zostanie zapisana (nawet, jeśli różnią się one między sobą). • Podczas rozkładania instancji klas definicje tych klas i związany z nimi kod oraz metody nie są zapisywane. Dzięki temu wolno modyfikować i unowocześniać klasy, zachowując nadal możliwość wczytywania danych pochodzących z ich starszych wersji. • Moduł piekle definiuje obiekty Pickler i Unpickler jako klasy, które umożliwiają w razie potrzeby tworzenie podklas. • Moduł cPiekle działa znacznie szybciej niż pi ckle, ale nie pozwala tworzyć podklas obiektów Pic- kler i Unpickler. • Format danych używany przez piekle jest specyficzny dla Pythona i nie należy zakładać jego kompaty- bilności z żadnym zewnętrznym standardem, takim jak XDR. • Zamiast pliku można użyć dowolnego obiektu udostępniającego metody write (), read () i readline(). • Do rejestrowania nowych typów w module piekle służy moduł copy_reg. Zobacz także shelve (169), marshal (125), copy_reg (123).

130 Python Dodatek A: Biblioteka Pythona 131 site Moduł site jest automatycznie importowany w momencie uruchamiania interpretera i służy do inicjalizowania pakietów oraz ustawiania domyślnego sposobu kodowania Unicode. Na początku tworzy on listę maksymalnie czterech nazw katalogów opartych na wartościach sys .prefix i sys .exec_prefix. W komputerach Macintosh i w systemach Windows lista ta składa się z nastę- pujących dwóch katalogów: t sys.prefix, sys.exec_prefix ] W systemie Unix na liście występują cztery katalogi: [ sys.prefix + '/lib/pythonvers/site-packages', sys.prefix + '/lib/site-python 1, sys.exec_prefix + '/lib/pythonvers/site-packages 1, sys.exec_prefix + '/lib/site-python 1 ] Moduł sprawdza po kolei wszystkie katalogi z listy i jeśli któryś istnieje, dodaje go do zmiennej sys .path. Następnie szukane są pliki konfiguracyjne ścieżek (z rozszerzeniem .pth). Plik konfiguracyjny ścieżki zawiera listę katalogów podanych względem lokalizacji pliku ścieżki, które również należy dodać do zmiennej sys .path. Na przykład: # Plik konfiguracyjny 'co ś.pth 1 pakietu co ś coś reszta Każdy katalog występujący w pliku konfiguracyjnym ścieżki musi zajmować od- dzielny wiersz. Komentarze i wiersze puste są ignorowane. Gdy moduł site ładuje ten plik, sprawdza, czy każdy z katalogów istnieje. Jeśli tak, dodaje go do zmiennej sys . path. Powtarzające się katalogi są dodawane do ścieżki tylko raz. Po dodaniu wszystkich ścieżek do sys . path następuje próba importu modułu 0 nazwie sitecustomize. Zadaniem tego modułu jest przeprowadzenie dodatkowego (dowolnego) dostosowania miejsca. Jeśli próba importu sitecustomize kończy się zgłoszeniem wyjątku ImportError, błąd ten jest ignorowany bez komunikatu. Moduł site jest również odpowiedzialny za ustawianie domyślnego sposobu kodowania Unicode. Standardowo stosuje się kodowanie ' ascii '. Można to jednak zmienić* wstawiając do pliku sitecustomize.py wywołanie sys .setdefaultencoding () z nowym sposobem kodowania, na przykład 1 utf-8 '. Można też samemu poeksperymentować, zmieniając kod źródłowy modułu site, tak aby automatycznie wybierał on sposób kodowania na podstawie lokalnych ustawień komputera. Zobacz także sys (131), rozdział 8, rozdział 10. sys Moduł sys zawiera zmienne i funkcje, które mają związek z działaniem interpretera i jego środowiskiem. Oto lista zdefiniowanych zmiennych: argv Lista opcji linii polecenia przekazanych do programu. Element argv [ 0 ] zawiera nazwę programu. buil tin_module_names Tupla zawierająca nazwy modułów wbudowanych w plik wykonywalny Py- thona. byteorder Naturalna kolejność bajtów w komputerze - 'little' oznacza kolejność Lit- tle-Endian, a 'big' -BigEndian. copyright

Zapis zawierający komunikat o prawach własności. __displayhook__ Oryginalna wartość funkcji displayhook(). __excepthook__ Oryginalna wartość funkcji excepthook(). dllhandle Liczba całkowita stanowiąca uchwyt pliku DLL Pythona (w Windows). exec_prefix Katalog, w którym są zainstalowane pliki Pythona zależne od platformy, executable Napis zawierający nazwę pliku wykonywalnego interpretera, exitfunc Funkcja (obiekt) wywoływana w momencie zamykania interpretera. Może to być również funkcja bez parametrów. Standardowo wartość exitfunc nie jest zdefiniowana. Bezpośrednie korzystanie z tej zmiennej nie jest zalecane -lepiej posługiwać się modułem at exit. Zobacz także atexit (122)

hexversion Liczba całkowita, której szesnastkowa reprezentacja jest zakodowaną infor- macją o wersji podanej w sys . version_inf o. Wartość ta jest zawsze coraz większa w kolejnych wydaniach interpretera. last_type, last_value, last_traceback Są to zmienne ustawiane w sytuacji, gdy interpreter napotyka nie obsługiwa- ny wyjątek i wyświetla komunikat o błędzie. Zmienna last_type zawiera typ ostatniego wyjątku, last_value jego wartość, a las t_traceback ślad na stosie. Uwaga: używanie tych zmiennych przy wielu wątkach nie jest bezpieczne. W takim przypadku należy korzystać z funkcji sys . exc_inf o (). maxint Największa liczba dozwolona dla typu całkowitego.

132 Python modules Słownik mapujący nazwy modułów na ich obiekty. path Lista napisów określających ścieżki poszukiwań modułów. Zobacz rozdział 8, „Moduły i pakiety". platform Napis identyfikujący platformę, na przykład f Iinux-i38 6 '. prefix Katalog, w którym są zainstalowane pliki Pythona niezależne od platformy. psi, ps2 Napisy zawierające tekst głównego i pomocniczego znaku zgłoszenia interpretera. Na początku wartością psi jest ' >» ', a ps2 - ' . . . '. Bez wzglę- du na rodzaj obiektu przypisanego do tych zmiennych, do generowania znaku zgłoszenia używana jest metoda str () tego obiektu. stdin, stdout, stderr Obiekty-pliki odpowiadające kolejno standardowemu strumieniowi wejścio- wemu, standardowemu strumieniowi wyjściowemu i standardowemu strumieniowi diagnostycznemu. Zmienna stdin jest używana przez funkcje raw_input () i input (). Zmienna stdout jest używana przez instrukcję print oraz przez funkcje raw_input () i input () do wyświetlania znaku zgłoszenia. Natomiast zmienna stderr jest używana do wyświetlania przez interpreter znaku zgłoszenia oraz komunikatów o błędach. Zmienne te mogą być przypisane do dowolnego obiektu, który dysponuje metodą write () z pojedynczym argumentem napisowym. __stdin__, __stdout__, __stderr__ Obiekty-pliki zawierające wartości stdin, stdout i stderr zaraz po uruchomieniu interpretera. tracebacklimit Maksymalna liczba poziomów śladu w momencie wyświetlania informacji o wystąpieniu nie obsługiwanego wyjątku. Standardową wartością jest 1000. Wartość 0 powoduje zablokowanie informacji o śladach i podawanie jedynie typu oraz wartości wyjątku. version Napis z wersją. version_info Informacja o wersji w postaci tupli (major, minor, micro, releaselevel, serial). Wszystkie wartości są liczbami całkowitymi z wyjątkiem elementu releaselevel (poziom wydania), który jest napisem ' alpha1/ 'beta', 'candidate' lub 'final'. warnoptions Lista opcji ostrzegania przekazanych do interpretera w linii polecenia za po- mocą opcji -w. UoaawK Ą: tnonowKa rymona winver Numer wersji używany podczas tworzenia kluczy rejestru w Windows. Lista funkcji zdefiniowanych w module sys wygląda następująco: displayhook ([value]) Jest to funkcja wywoływana w celu wyświetlenia wyniku wyrażenia, gdy in terpreter działa w trybie interakcyjnym. Domyślnie na standardowy stru mień wyjściowy kierowana jest wartość repr (value), a w zmienne __built in__zapisuje się wartość value. Jeśli trzeba zmienić to działanie można przedefiniować funkcję displayhook. excepthook(type,value,traceback) Jest to funkcja wywoływana w momencie wystąpienia nie przechwyconego wyjątku, type jest klasą wyjątku, value wartością podaną w instrukcji ra ise, a traceback obiektem - śladem. Standardowe działanie tej funkcji pc lega na skierowaniu komunikatu o wyjątku i śladzie w standardowy strumie: diagnostyczny. Można jednak przedefiniować tę funkcję i spowodować inn sposób obsługi nie przechwyconych wyjątków (co może być użyteczn

w przypadku wyspeqalizowanych aplikacji, takich jak debugery czy skrypt CGI). exc_info() Zwraca tupię (type, value, tracebac k) zawierającą informacje o wyjątki który jest aktualnie obsługiwany, type jest typem wyjątku, value parametrer użytym w raise, a traceback - obiektem zawierającym stos wywołań w mc mencie, w którym nastąpił wyjątek. Jeśli aktualnie nie jest obsługiwany żade wyjątek, funkcja exc_inf o () zwraca wartość None. exit ([u]) Kończy działanie Pythona przez zgłoszenie wyjątku SystemExit. Liczb całkowita n to kod wyjścia. Zero oznacza zwykłe zakończenie działania (wai tość domyślna), a wartość niezerowa - nieprawidłowe. Jeśli n ma wartość różn od liczby całkowitej, jest ona przesyłana na sys . stderr, a kod wyjścia ustć wiany jest na 1. getdefaultencoding() Zwraca domyślny sposób kodowania napisów w konwersjach z użyciem Unicc de. Może to być na przykład wartość ' ascii ' lub ' utf-8 '. Domyślny sposó kodowania jest ustawiany przez moduł site. getf ramę ([depth]) Zwraca obiekt-ramkę ze stosu wywołań. Jeśli argument depth jest pominięt lub wynosi zero, zwracana jest najwyżej położona ramka. W przeciwnym r< zie zwracana jest ramka o depth wywołań poniżej ramki bieżącej. N przykład _getframe(l) zwraca ramkę kodu wywołującego. Niepr. widłowa wartość depth powoduje zgłoszenie wyjątku ValueError. getrecursionlimit() Zwraca aktualny limit rekurencyjnych wywołań funkcji.

134 Python getrefcount(object) Zwraca licznik odwołań obiektu. setcheckinterval (n) Zwraca liczbę wirtualnych instrukcji maszynowych Pythona, które muszą być wykonane przez interpreter, zanim nastąpi sprawdzenie przez niego okresowego zdarzenia, takiego jak sygnał czy przełączenie kontekstu wątku. Wartością domyślną jest 10. setdefaultencoding (enc) Ustawia domyślny sposób kodowania. Parametr enc jest napisem takim jak 1 as cii ' lub ' utf -8 •. Funkcja ta jest zdefiniowana tylko wewnątrz modułu site. Można ją wywoływać ze zdefiniowanych przez użytkowników modułów sitecustomize. Zobacz także site (130). setprofile(pfunc) Ustawia systemową funkcję profilu, której można używać do implementowania profilera kodu źródłowego. Więcej informacji na ten temat znajdziesz w dalszej części zatytułowanej „Profiler Pythona". setrecursionlimit (xi) Zmienia limit rekurencyjnych wywołań funkcji. Wartością domyślną jest 1000. settrace( tfunc) Ustawia systemową funkcję śledzenia, której można używać do implementowania debugera. Więcej informacji o debugerze Pythona można znaleźć w dalszej części zatytułowanej „Debuger Pythona". traceback Moduł traceback służy do zbierania i wyświetlania śladów stosu po wystąpie- niu w programie wyjątku. Funkcje z tego modułu działają na obiektach typu ślad (traceback), takich jak trzeci element zwracany przez funkcję sys . exc_inf o (). print_tb( traceback [, limit [, file]]) Zapisuje w pliku file maksymalnie limit elementów śladu stosu traceback. Jeśli argument limi t jest pominięty, funkcja zapisuje wszystkie pozycje śladu. Jeśli plik file jest pominięty, funkcja kieruje strumień wyjściowy do sys.stderr. print_exception(type, value, traceback [, limit [, file]]) Zapisuje informacje o wyjątku i ślad stosu w pliku file, type jest typem wyjątku, a value jego wartością. Parametry limi t i f i 1 e zachowują się tak samo, jak w pr int_tb (). print_exc([limit [, file] ]) Działa tak samo jak funkcja pr int_except ion () zastosowana do informacji zwróconej przez funkcję sys . exc_inf o (). print_last( [limit [, file] ] ) Działa tak samo, jak print_exception {sys. last_type, sys. last value, sys.last_traceback, limit, file). Dodatek A: Biblioteka Pythona 135 print__stack ([frame [, limit [, file] ]) Zapisuje ślad stosu od miejsca, w którym została wywołana ta funkcja. Nie- obowiązkowy parametr frame pozwala wskazać ramkę stosu, od której ma się rozpocząć zapisywanie. Parametry limit i file zachowują się tak samo, jak w print_tb (). extract__tb (traceback [, limit] )

Pobiera ślad stosu używany przez print_tb (). extract_stack([frame [, limit] ]) Pobiera ślad stosu używany przez print_stack (). format_list (list) Formatuje informacje o śladzie stosu w celu ich wyświetlenia. format_exception_only( type, value) Formatuje informacje o wyjątku w celu ich wyświetlenia. format_exception (tj>pe, value, traceback [, limit]) Formatuje informacje o wyjątku i śladzie stosu w celu ich wyświetlenia. format_tb( traceback [, limit]) To samo co format_list(extract_tb(traceback, limit)). format_stack([frame [, limit] ) To samo co format_list (extract_stack (frame, limit) ). tb_lineno(traceback) Zwraca liczbę linii ustawioną w obiekcie traceback. Dodatkowe informacje można znaleźć w dokumentacji online. Zobacz także sys (131), „Debuger Pythona" (315), rozdział 3 oraz http://www.python.org/doc/lib/module-traceback.html. types Moduł types definiuje nazwy wszystkich wbudowanych typów obiektów. Za- wartość tego modułu jest często używana w wywołaniach funkcji wbudowanej isinstanceO oraz przy okazji różnych działań związanych z typami. Oto lista zmiennych zdefiniowanych w tym module: Zmienna Opis BufferType Obiekt-bufor BuiltinFunctionType Funkcja wbudowana CodeType Obiekt-kod ComplexType Liczby zespolone ClassType Klasa zdefiniowana przez użytkownika DictType Słowniki DictionaryType Nazwa alternatywna dla słowników EllipsisType Wielokropek FileType Obiekt-plik FloatType Liczby zmiennoprzecinkowe

136 Python Zmienna Opis FrameType Obiekt-ramka wykonania FunctionType Funkqe anonimowe i zdefiniowane przez użytkownika InstanceType Instanqa klasy zdefiniowanej przez użytkownika IntType Liczby całkowite LambdaType Alternatywna nazwa dla FunctionType ListType Listy LongType Długie liczby całkowite MethodType Metoda klasy zdefiniowana przez użytkownika ModuleType Moduły NoneType Typ None SliceType Wycinek rozszerzony-obiekt. Zwracany przez slice () StringType Napisy TracebackType Obiekty-ślady TupleType Tupie TypeType Typ obiektów typów UnboundMethodType Alternatywna nazwa dla MethodType UnicodeType Napis Unicode XRangeType Obiekt utworzony przy użyciu xrange () Dodatek A: Biblioteka Pythona 13/ PRZYKŁAD import types if isinstance (s, types.ListType) : print 'To jest lista' else: print 'To nie jest lista' Zobacz także rozdział 3. warnings Moduł warnings zawiera funkcje do generowania i filtrowania komunikatów ostrzegawczych. W odróżnieniu od wyjątków ostrzeżenia mają z założenia służyć informowaniu użytkownika o potencjalnych problemach, ale bez generowania wyjątków lub zatrzymywania wykonania. Jednym z głównych zastoso- wań modułu warnings jest ostrzeganie użytkowników przed korzystaniem z niezalecanych funkcji języka, które mogą nie być dostępne w przyszłych wersjach Pythona. Na przykład: >» import regex __main__:1: DeprecationWarning: the regex module is L+ deprecated; please use the re module »> Ostrzeżenia, podobnie jak wyjątki, tworzą hierarchię klas, które opisują podstawowe kategorie ostrzeżeń. Oto lista aktualnie dostępnych kategorii: Kategoria Opis Warning Klasa bazowa wszystkich typów ostrzeżeń UserWarning Ostrzeżenia zdefiniowane przez użytkownika DeprecationWarning Funkcje niezalecane SyntaxWarning Potenqalny problem składniowy RuntimeWarning Potenqalny problem wykonania

Każda z tych klas jest dostępna w module__built in__, jak również w module exceptions. Ponadto są one instancjami klasy Exception. Dzięki temu mo- żna łatwo konwertować ostrzeżenia na błędy. Ostrzeżenia są wydawane za pomocą funkcji warn (). Na przykład: warnings.warn("funkcja X jest niezalecana.") warnings.warn("funkcja Y mo że nie zadziała ć.", RuntimeWarning)

Ostrzeżenia mogą być również filtrowane, jeśli zajdzie taka potrzeba. Proces filtrowania daje się wykorzystać do zmiany zewnętrznej postaci ostrzeżeń, ignorowania ich lub zamiany na wyjątki. Aby dodać filtr dla ostrzeżeń konkretnego typu, trzeba użyć funkqi f ilterwarnings (). Na przykład: warnings.filterwarnings(action="ignore", message=".*regex.*", category=DeprecationWarning) import regex # Znikni ęcie ostrze żenia Ograniczone formy filtrowania można również uzyskać przy użyciu opcji -w interpretera. Na przykład: % python -Wignore:the\ regex:DeprecationWarning Oto lista funkcji zdefiniowanych w module warnings: warn {message [, category [, stacklevel]]) Wydaje ostrzeżenie. Argument message jest napisem zawierającym komunikat ostrzeżenia, category jest klasą ostrzeżenia, taką jak Deprecation- Warning. stacklevel to liczba całkowita wskazująca ramkę stosu, na podstawie której ma być wydane ostrzeżenie. Domyślną wartością category jest UserWarning, a stacklevel - 1. warn_explicit (message, category, filename, lineno [, module [, registry]]) Jest to wersja niskiego poziomu funkcji warn (). Argumenty message i category mają takie same znaczenia jak w warn (). filename, linenoimo- dule jawnie podają dane ostrzeżenia, registry to obiekt reprezentujący aktualnie aktywne filtry. Jeśli jest pominięty, nic nie blokuje ostrzeżeń. showwarning(message, category, filename, lineno [, file]) Zapisuje ostrzeżenie w pliku. Bez argumentu file ostrzeżenie jest kierowane do sys.stderr. formatwarning (message, category, filename, lineno) Tworzy sformatowany napis wyświetlany w momencie wydawania ostrzeżenia.

138 Python filterwarnings (action [, message [, category [, module [,lineno [, append]]]]]) Dodaje nowy element do listy filtrów ostrzeżeń. Argument action może mieć wartość 'error1, ' ignore', 'always', 'default', 'once' lub 'module '. Są one opisane w zamieszczonej niżej tabeli, message to napis z wyrażeniem regularnym porównywanym z komunikatami ostrzeżeń, category to klasa ostrzeżeń, taka jak DeprecationError. module to napis z wyrażeniem regularnym porównywanym z nazwą modułu, lineno podaje konkretny numer linii (wartość 0 oznacza wszystkie linie), append decyduje o dodaniu filtru na końcu listy wszystkich filtrów (będzie wówczas sprawdzany jako ostatni). Standardowo nowe filtry są umieszczane na początku tej listy. Brak któregoś argumentu powoduje przyjęcie w jego miejsce wartości domyślnej pasującej do wszystkich ostrzeżeń. Akcja 'error' 1 ignore' 'always' 'default' 'module' 1 once' Opis Konwersja ostrzeżenia na wyjątek Ignorowanie ostrzeżenia Bezwarunkowe wyświetlanie komunikatu ostrzeżenia Wyświetlanie po jednym ostrzeżeniu dla każdego miejsca, w którym nastąpiło Wyświetlanie po jednym ostrzeżeniu dla każdego modułu, w którym nastąpiło Wyświetlanie ostrzeżenia tylko raz, bez względu na to, gdzie nastąpiło resetwarnings() Cofa wszystkie filtry ostrzeżeń. Anuluje wszystkie wcześniejsze wywołania filterwarnings (), jak również opcje podane przy użyciu -w. UWAGI • Lista aktywnych w danej chwili filtrów znajduje się w zmiennej warnings. filters. • Moduł warnings pojawił się po raz pierwszy w Pythonie 2.1. • Po konwersji ostrzeżenia na wyjątek kategoria ostrzeżenia staje się typem wyjątku. Na przykład ostrzeżenie DeprecationWarning zgłasza po konwersji wyjątek DeprecationWarning. • Opcja -W może być używana do definiowania filtru ostrzeżeń w linii polecenia. Ogólny format tej opcji wygląda następująco: -Waction: message:category : module : lineno Każdy element ma to samo znaczenie co w funkcji filterwarning (). Jednakw tym przypadku pola message i module to podnapisy (zamiast wyrażeń regularnych) odnoszące się kolejno do pierwszej części komunikatu ostrzeżenia i nazwy modułu. weakref Moduł weakref służy do korzystania ze słabych odniesień. Utworzenie zwykłego odniesienia do obiektu powoduje zwiększenie jego licznika odniesień, co skutecznie zapobiega jego usunięciu, dopóki istnieje choć jedno odniesienie do Dodatek A: Biblioteka Pythona niego. Słabe odniesienie jest natomiast speq'alnym rodzajem odniesienia, ktć pozwala odwoływać się do obiektu bez zwiększania jego licznika odniesie Słabe odniesienie powstaje za pomocą wywołania funkcji weakref. ref (),: przykład: >» class A: pass >» a = A () >» ar = weakref.ref(a) # Utworzenie słabego o dniesienia do a >» print ar <weakref at 0xl35a24; to 'instance' at 0xl2ce0c> Aby sięgnąć do oryginalnego obiektu za pomocą jego słabego odniesienia, w

starczy wywołać je jako funkcję bez żadnych argumentów. Jeśli obiekt źródłom nadal istnieje, zostanie wówczas zwrócony przez to wywołanie. W przeciwny razie otrzymasz wartość None. Na przykład: # Wyświetlenie oryginalnego obiektu # Usuni ęcie oryginalnego obiektu # Poniewa ż a ju ż nie istnieje, ar() zwraca Non >» print ar () <__main__.A instance at 12ce0c> >» del a »> print ar () None Oto lista funkcji zdefiniowanych w module weakref: ref(object [, callback]) Tworzy słabe odniesienie do obiektu object. Argument callback to nit obowiązkowa funkcja, która ma zostać wywołana w momencie usuwani właściwego obiektu. Powinna to być funkcja, której jedynym argumentem je; odpowiadające jej słabe odniesienie do obiektu. Jeden obiekt może mieć zdef niowanych wiele słabych odniesień. W takim przypadku ich funkcje cali back będą wywoływane w kolejności od najnowszego zastosowaneg odniesienia do najstarszego. W każdej chwili można sięgnąć do oryginalneg obiektu object, wywołując obiekt słabego odniesienia jako bezargumer tową funkcję. Jeśli obiekt ten już nie istnieje, zostanie zwrócona wartość None proxy(object [, callback]) Używając słabego odniesienia, tworzy pośrednika obiektu object. Obiek zwracany przez tę funkcję jest tak naprawdę opakowaniem oryginalnego obiektu, które umożliwia dostęp do jego atrybutów i metod. Dopóki istniej obiekt oryginalny, jego pośrednik idealnie powiela jego zachowanie. Gdy jed nak ten pierwszy zostanie usunięty, wykonanie działania z użyciem pośred nika spowoduje zgłoszenie wyjątku weakref .Ref erenceError jedno znacznie wskazującego przyczynę. Argument callback jest funkcji wywoływaną zwrotnie, używaną do tego samego celu co w przypadki ref (). Obiekt-pośrednik jest typu ProxyType lub CallableProxyType w zależności od tego, czy oryginalny obiekt daje się wywoływać, czy nie. getweakrefcount (object) Zwraca liczbę słabych odniesień i pośredników obiektu object. getweakref s (object) Zwraca listę słabych odniesień i pośredników obiektu obj ect.

140 Python WeakKeyDictionary([diet]) Tworzy słownik ze słabymi odniesieniami do kluczy. Jeśli jakiś klucz utraci wszystkie swoje silne odniesienia, odpowiadający mu element słownika zostanie usunięty. Jeśli w wywołaniu podany jest argument diet, jego elementy są od razu dodawane przez funkcję do zwracanego przez nią obiektu WeakKeyDictionary. Ponieważ tylko niektóre typy obiektów dopuszczają stosowanie słabych odniesień, istnieje wiele ograniczeń dla wartości kluczy. W szczególności nie mogą być nimi napisy wbudowane. Można za to używać instancji klas zdefiniowanych przez użytkownika mających zdefiniowaną metodę__hash__(). WeakValueDictionary( [diet]) Tworzy słownik ze słabymi odniesieniami do wartości. Jeśli jakaś wartość utraci wszystkie swoje silne odniesienia, odpowiadający jej element słownika zostanie usunięty. Jeśli w wywołaniu podany jest argument diet, jego elementy są od razu dodawane przez funkcję do zwracanego przez nią obiektu WeakValueDictionary. PRZYKŁAD Jednym z zastosowań słabych odniesień jest tworzenie pamięci podręcznej z ostatnio obliczonymi wynikami. Na przykład, jeśli wykonanie jakiejś funkcji zajmuje bardzo dużo czasu, dobrym posunięciem może być zapisywanie jej wy- ników i przechowywanie dopóty, dopóki są wykorzystywane przez aplikację. Na przykład: _wyniki = { } def wynikifun(x): if _wyniki.has_key(x): r = _wyniki[x] () # Odszukanie słabego odniesienia i pobranie danych if r is not None: return r r = fun(x) _wyniki[x] = weakref.ref(r) return r UWAGI • Aktualnie jedynie instancje klas, funkcje i metody dopuszczają słabe odniesienia. Nie można ich stosować w przypadku funkcji wbudowanych i większości typów wbudowanych, takich jak listy, słowniki, napisy i liczby. • Słowniki zwracane przez funkcje WeakKeyDictionary i WeakValueDictionary są podklasami klasy UserDict Z modułu UserDict. WeakKeyDictionary i WeakValueDictio- nary również mogą posłużyć za klasy bazowe. • Jeśli zgłoszenie wyjątku nastąpi w czasie wykonania funkcji wywoływanej zwrotnie, zarejestrowanej przy użyciu ref () lub proxy (), wyjątek ten zostanie skierowany na standardowy strumień diagnostyczny i zignorowany. • Słabe odniesienia mogą być haszowane, o ile tylko haszowaniu podlega oryginalny obiekt. Co więcej, słabe odniesienia zachowują swoją wartość haszową również po usunięciu oryginalnego obiektu, o ile oryginalna wartość haszowa została obliczona, gdy obiekt jeszcze istniał. • Słabe odniesienia można sprawdzać pod kątem równości, ale nie kolejności. Jeśli istnieją oryginalne obiekty i ich wartości są równe, to również ich słabe odniesienia są równe. Jeśli nie ma oryginalnych obiektów, to słabe odniesienia są równe tylko wtedy, gdy jest to to samo odniesienie. • Słabe odniesienia pojawiły się po raz pierwszy w Pythonie 2.1 Dodatek A: Biblioteka tytnona UserDict, UserList i UserString Moduły UserDict, UserList i UserString zawierają klasy będące obudo- wami wskazywanych przez nie trzech typów wbudowanych: słowników, list i napisów. Obudowy te mogą służyć za klasy bazowe dla klas, które mają przesłonić wymienione typy lub wzbogacić je o nowe metody. Każdy z wymienionych modułów definiuje tylko jedną klasę o odpowiedniej dla siebie nazwie: UserDict, UserList i UserString: UserDict([initialdata]) Zwraca instancję klasy symulującej słownik. UserList([list]) Zwraca instancję klasy symulującej listę. Nieobowiązkowy argument list zawiera wartość początkową nowej listy. Jeśli zostanie pominięty, lista będzie pusta ([ ]).

UserString([sequence]) Zwraca instancję klasy symulującej napis. Początkową wartością nowego napisu jest str(sequence). W każdym z podanych przypadków można za pomocą atrybutu data instancji klasy dostać się do prawdziwego obiektu słownika, listy lub napisu. PRZYKŁAD # Słownik z kluczami nie rozró żniaj ącymi wielko ści liter from UserDict import UserDict import string class MójSłownik(UserDict): # Wyszukiwanie bez uwzgl ędniania wielko ści liter def__getitem__(self, key): return self.data[key.lower()] def__setitem__(self, key, value) : self.data[key.lower()] = value def__delitem__(self, key): del self.data[key.lower()] def has_key(self, key): return self.data.has_key(key.lower()) # U życie nowej klasy-słownika d = MójSłownik() d['Content-Type'] = 'text/html' print d['content-type'] # Zwraca 'text/html' Moduł UserString definiuje także klasę Mu tables t ring, która stanowi im plementację zmiennych napisów. Na przykład: a = UserString.MutableString("Witaj świecie!") a[4] 'm' a[6:] = 'was!' # a = "Witam świecie! # a = "Witam was!" Chociaż napisy zmienne są często wykorzystywane w Pythonie, ich implementa cja oferowana przez moduł MutableString ma kilka wad. Po pierwsze, stan dardowe metody napisowe, takie jak s . replace () czy s . upper (), zwracaj; nowe napisy zamiast modyfikować bezpośrednio „oryginały". Po drugie, napis;

142 Python zmienne nie mogą być używane jako klucze słowników. I na koniec implementacja napisów zmiennych nie korzysta zbyt efektywnie z pamięci i nie działa tak szybko, jak można by tego oczekiwać. Na przykład każda zmiana obiektu Mu- tableString powoduje skopiowanie całej pamięci zajmowanej przez napis, nawet jeśli wystarczyłaby prosta zmiana jego fragmentu w dotychczasowym miejscu. UWAGI J . . J . .tt w • Ogólnie rzecz biorąc nie powinno się korzystać z klasy MutableString, gdyż nie daje ona istotnych korzyści w porównaniu ze standardowymi napisami. W rzeczywistości przyczynia się nawet do wolniejszego działania aplikacji. • Podklasy klasy UserList powinny udostępniać konstruktor z co najwyżej jednym argumentem.

Matematyka Moduły opisane w tej części zawierają różne funkcje matematyczne. array Moduł array definiuje nowy typ obiektu ArrayType (typ tablicowy), który działa niemal identycznie, jak pozostałe typy sekwencyjne, z jednym wyjątkiem - wszystkie jego elementy muszą być tego samego typu. Typ tablicy jest ustalany w momencie jej tworzenia za pomocą jednego z następujących kodów: Typ Kod

Opis TypC Minimalny rozmiar (w bajtach)

'c' 8-bitowy znak char 1 •b1 8-bitowa liczba całkowita signed char 1 •B1 8-bitowa liczba całkowita bez znaku unsigned char 1 •h1 16-bitowa liczba całkowita short 2 ,H, 16-bitowa liczba całkowita bez znaku unsigned short 2 'i1 liczba całkowita int 4 lub 8 'I1 liczba całkowita bez znaku unsigned int 4 lub 8 '1' długa liczba całkowita long 4 lub 8 •L' długa liczba całkowita bez znaku unsigned long 4 lub 8 •f' liczba zmiennoprzecinkowa pojednyczej float 4 precyzji 'd' liczba zmiennoprzecinkowa podwójnej double 8 precyzji Reprezentacja liczb całkowitych i długich liczb całkowitych zależy od architektury komputera (czy jest 32-bitowa, czy 64-bitowa). Wartości zapisane jako ' L' lub ' I' są zwracane w postaci długich liczb całkowitych Pythona. Dodatek A: Biblioteka Pythona 14 Oto lista funkcji zdefiniowanych w module array: array(typecode [, Initializer]) Tworzy tablicę typu typecode. Nieobowiązkowy argument initialize, może być napisem lub listą wartości przeznaczonych do zainicjalizowania ta blicy. W zamieszczonej niżej tabeli wymienione są atrybuty i metody - obiekt] tablicy a: Element a.typecode a.itemsize a.append(x) a.buffer_info() a.byteswap() a.count(x) a. extend (b) a.fromfile (f, n) a. fromlist (list) a.fromstring (s)

a.index(x) a.insert(i, x) a.pop([i]) a.remove(x) a. reverse () a.tofile (f) a.tolist() a.tostring() Opis Jednoznakowy kod typu podany przy tworzeniu tablicy. Rozmiar elementu tablicy (w bajtach). Dodaje x na końcu tablicy. Zwraca (adres, długość), czyli miejsce w pamięci i rozmiar bufora służącego do przechowywania tablicy. Zmienia kolejność bajtów we wszystkich elementach tablicy z Big Endian na Little Endian lub odwrotnie. Działa tylko m wartościach całkowitych. Zwraca liczbę wystąpień x w a. Dodaje tablicę b na końcu tablicy a. Wczytuje n elementów (w formacie binarnym) z pliku f i dodaje je na końcu tablicy, f musi być obiektem-plikiem. Jeśli nie uda się wczytać n elementów, zgłaszany jest wyjątek EOFError. Dodaje na końcu tablicy elementy z listy list. Dodaje do tablicy elementy napisu s, interpretowanego jakc napis z wartościami binarnymi - takie samo wczytywanie, jak przy użyciu fromfile (). Zwraca indeks pierwszego wystąpienia x w a. Jeśli x nie występuje w a, zgłaszany jest wyjątek ValueError. Wstawia x przed i-tą pozyqa. Usuwa i-ty element tablicy i zwraca go. Bez podania i zwracany jest ostatni element a. Usuwa pierwsze wystąpienie x w tablicy a. Jeśli x nie występuje w a, zgłaszany jest wyjątek ValueError. Odwraca kolejność elementów w tablicy. Zapisuje wszystkie elementy a w pliku f. Dane są zapisywane w oryginalnym formacie binarnym. Konwertuje tablicę a na zwykłą listę wartości. Konwertuje tablicę na napis z danymi binarnymi - te same dane zostałyby zapisane przy użyciu tof ile (). Jeśli podczas wstawiania elementów do tablicy okazuje się, że któryś z nici nie jest zgodny z typem podanym w momencie tworzenia tablicy, następuj) zgłoszenie wyjątku TypeError.

144 Python UWAGI • Moduł ten służy do tworzenia długich list zapewniających efektywny sposób przechowywania. Tak skonstruowane tablice nie nadają się jednak do działań numerycznych. Na przykład operator dodawania nie oblicza sumy odpowiednich dwóch elementów tablicy, lecz dołącza jedną tablicę do drugiej. Aby móc tworzyć tablice efektywne zarówno pod względem dostępu, jak i obliczeń, trzeba użyć rozszerzenia Nume r i c, dostęp- nego pod adresem http: //numpy. sourcef orge .net/. Przekonasz się jednak, że API modułu Numeric wygląda zupełnie inaczej. • Typem obiektu tablicowego jest array. ArrayType. Zobacz także struct (160), xdrlib (302). cmath Moduł cmath zawiera funkcje matematyczne działające na liczbach zespolonych. Każda z tych funkcji akceptuje i zwraca liczbę całkowitą. Funkcja Opis acos(x) Zwraca arcus cosinus x. acosh(x) Zwraca arcus cosinus hiperboliczny x. asin(x) Zwraca arcus sinus x. asinh(x) Zwraca arcus sinus hiperboliczny x. atan(x) Zwraca arcus tangens x. atanh(x) Zwraca arcus tangens hiperboliczny x. cos(x) Zwraca cosinus x. cosh(x) Zwraca cosinus hiperboliczny x. exp(x) Zwraca e * * x. log(x) Zwraca logarytm naturalny x. loglO(x) Zwraca logarytm dziesiętny x. sin(x) Zwraca sinus x. sinh(x) Zwraca sinus hiperboliczny x. sqrt(x) Zwraca pierwiastek kwadratowy z x. tan(x) Zwraca tangens x. tanh(x) Zwraca tangens hiperboliczny x.

Są też zdefiniowane następujące stałe: Stała | Opis Stała matematyczna pi, jako liczba rzeczywista Stała matematyczna e, jako liczba rzeczywista Zobacz także math (144). math Moduł math definiuje standardowe funkcje matematyczne. Funkcje te działają na liczbach całkowitych i zmiennoprzecinkowych, ale nie na liczbach zespolonych. Dodatek A: Biblioteka Pythona Funkcja Opis acos(x) Zwraca arcus cosinus x. asin(x) Zwraca arcus sinus x. atan(x) Zwraca arcus tangens x. atan2(y, x) Zwraca atan (y / x). ceil(x) Zwraca górne zaokrąglenie x. cos(x) Zwraca cosinus x. cosh(x) Zwraca cosinus hiperboliczny x. exp(x) Zwraca e * * x. fabs(x) Zwraca wartość bezwzględną x. floor(x) Zwraca dolne zaokrąglenie x. fmod(x, y) Zwraca x % y. frexp(x) Zwraca dodatnią mantysę i wykładnik x. hypot(x, y) Zwraca odległość euklidesową, sqrt (x * x + y * y). ldexp(x, i) Zwraca x * (2 ** i). log(x) Zwraca logarytm naturalny x.

Iogl0(x) Zwraca logarytm dziesiętny x. modf(x) Zwraca część ułamkową i całkowitą x (obie mają ten sam znak co

x). pow(x, y) Zwraca x * * y. sin(x) Zwraca sinus x. sinh(x) Zwraca sinus hiperboliczny x. sqrt(x) Zwraca pierwiastek kwadratowy z x. tan(x) Zwraca tangens x. tanh(x) Zwraca tangens hiperboliczny x.

Są też zdefiniowane następujące stałe: Stała Opis Pi e

Stała matematyczna pi Stała matematyczna e

Zobacz tak że cmath(14 random Moduł random zawiera całą gamę funkcji do generowania liczb pseudolos wych, jak również funkcji do losowego generowania liczb rzeczywistych zgodn z różnymi rozkładami. Większość funkcji z tego modułu korzysta z funkcji ra\ dom (), która generuje zgodnie z rozkładem jednostajnym liczby z zakresu (0. 1.0), wykorzystując do tego standardowy generator Wichmanna - Hilla. Oto lista funkcji używanych do kontrolowania stanu zasadniczego generatoi liczb losowych: seed([x]) Inicjalizuje generator liczb losowych. Gdy nie ma argumentu x lub ma c

146 Python wartość None, do inicjalizacji generatora używany jest czas systemowy. W przeciwnym razie odbywa się to na podstawie wartości całkowitej lub długiej wartości całkowitej podanej w x. Jeśli x nie jest liczbą całkowitą, musi być haszowalnym obiektem i do uruchomienia generatora używana jest wówczas wartość hash (x). getstatę() Zwraca obiekt reprezentujący aktualny stan generatora. Obiekt ten można pó- źniej przekazać do funkcji set state () w celu przywrócenia starego stanu. setstate (state) Przywraca stary stan generatora liczb losowych na podstawie obiektu zwróconego przez funkcję getstate (). jumpahead(n) Szybko zmienia stan generatora na taki, jaki by nastąpił po n-krotnym z rzędu wywołaniu random (). n musi być nieujemną wartością całkowitą. randrange(start, stop [, step]) Zwraca losową liczbę całkowitą z zakresu range (start, stop, step). Nie obejmuje wartości końcowej. Oto lista funkcji, za pomocą których można wykonywać działania losowe na sekwencjach: choice(seg) Zwraca losowy element niepustej sekwencji seg. shuffle(x [, random]) Losowo przestawia elementy na liście x („w miejscu"). Nieobowiązkowy argument random podaje generator liczb losowych. Musi to być funkcja wołana bez argumentów i zwracająca liczby zmiennoprzecinkowe z zakresu (0.0, 1.0). Kolejne funkcje służą do generowania liczb losowych według różnych rozkładów liczb rzeczywistych. Nazwy parametrów tych funkcji pokrywają się z ich nazwami stosowanymi w standardowych równaniach matematycznych opisujących te rozkłady. betavariate (alpha, beta) Zwraca wartość między 0 a 1 zgodnie z rozkładem Beta. Wartości alpha i beta muszą być większe od -1. cunifvariate(mean, arc) Jednostajny rozkład kołowy, mean jest kątem średnim, a arc zakresem rozkładu (łukiem), którego środek stanowi kąt mean. Obie te wartości muszą być wyrażone w radianach i należeć do przedziału od 0 do pi. Funkcja zwraca wartości z przedziału {mean - arc/2, mean + ar cl 2). expovariate(lambd) Rozkład wykładniczy. Wartość lambd to liczba 1. 0 podzielona przez oczeki- waną wartość średnią. Funkcja zwraca wartości z przedziału (0, +oo). Dodatek A: Biblioteka Pythona 14 gamma(alpha, beta) Rozkład gamma. Wartość alpha ma być większa od -1, a wartość beta wię kszaod 0. gauss(mu, sigma) Rozkład Gaussa o wartości średniej mu i odchyleniu standardowym sigma Działa nieco szybciej niż funkqa norma lvariate (). lognormvariate (mu, sigma) Rozkład normalny logarytmiczny. Logarytm naturalny tego rozkładu daj rozkład normalny o wartości średniej mu i odchyleniu standardowym sigma, normalvariate(mu, sigma) Rozkład normalny o wartości średniej mu i odchyleniu standardowym sigma paretovariate (alpha)

Rozkład Pareto z parametrem kształtu alpha. vonmisesvariate(mu, kappa) Rozkład von Misesa, w którym mu jest średnim kątem (w radianach) między i 2 * pi, a ieappa jest nieujemnym współczynnikiem koncentracji. Jeśli kap pa ma wartość 0, rozkład redukuje się do jednostajnego rozkładu kołoweg z przedziału od 0 do 2 * pi. weibullvariate(alpha, beta) Rozkład Weibulla z parametrem wagi alpha i parametrem kształtu beta. UWAGI • Rozszerzenie Nume r i c zawiera kilka użytecznych generatorów dla dużych próbek oraz do tworzenia nii zależnych strumieni liczb losowych. • Funkcje z tego modułu nie są zabezpieczone przed działaniem wielowątkowym. Jeśli generujesz liczby li sowę w różnych wątkach, powinieneś nakładać olokady, aby uniknąć jednoczesnego dostępu. • Okres generatora liczb losowych (zanim jego wartości zaczną się znowu powtarzać) wynosi 6 953 607 & 644. Chociaż jest to więcej niż w wielu innych bibliotekach programowania, to jednak nie spełnia wymagć wszystkich aplikacji - w szczególności związanych z szyfrowaniem. • Moduł ten został istotnie zmieniony w Pythonie 2.1. Ponadto część jego funkcji występowała wcześniej w nie zal canym już module wh random. Więcej informacji o tych zmianach można znaleźć w dokumentacji online.

Obsługa napisów Moduły omawiane w tej części służą do przetwarzania napisów. codecs Moduł codecs stanowi interfejs umożliwiający dostęp do różnego rodzaju funl cji kodujących i dekodujących napisy (kodeków), jak również do zbioru klas baz< wych, które mogą posłużyć do definiowania nowych, własnych kodeków. Ol wykaz dostępnych funkcji: register(search_fwiction) Rejestruje funkqe szukującą nowego kodera. Funkcja ta powinna przyjmow. tylko jeden argument w postaci napisu kodowania (na przykład 'utf-8

148 Python i zwracać tupię z czterema funkcjami (encoder, decoder, streamreader, streamwriter). lookup(encoding) Szuka kodeka w rejestrze wszystkich kodeków. encoding jest napisem takim jak ' utf-8 '. Funkcja zwraca tupię z czterema funkcjami (encoder, decoder, streamreader, streamwriter) .W środku funkcja korzysta z pamięci podręcznej, w której przechowuje ostatnio używane sposoby kodowania. Jeśli żaden z nich nie pasuje do podanego w argumencie, wywoływane są po kolei wszystkie zarejestrowane funkcje szukające aż do skutku. Jeśli nie uda się znaleźć żądanej metody kodowania, zgłaszany jest wyjątek Lookup- Error. open (filename, mode [, encoding [, errors [, buffering]]]) Otwiera plik filename w trybie mode i stosuje w nim przezroczyste kodowanie i dekodowanie zgodnie z metodą podaną w encoding, errors może mieć jedną z następujących trzech wartości: 'strict1, 'ignore' lub 'replace '. Standardowo jest to ' strict'. Parametr buffering ma to samo znaczenie, co w przypadku funkcji wbudowanej open (). EncodedFile(file, Inputenc [, outputenc [, errors]]) Klasa stanowiąca interfejs kodowania w obiekcie pliku fi 1 e. Dane przeznaczone do zapisania w pliku są najpierw interpretowane zgodnie z typem kodowania wejścia inputenc, a następnie zapisywane w tym pliku przy użyciu typu kodowania wyjścia outputenc. Dane odczytywane z pliku są dekodowane przy użyciu typu kodowania wejścia inputenc. Jeśli argument outputenc jest pominięty, funkcja stosuje domyślnie metodę inputenc. Pa- rametr errors ma takie samo znaczenie, jak w funkcji open (), i domyślnie przyjmuje wartość 'strict'. Aby umożliwi ć tworzenie nowych kodeków, moduł codecs udostępnia klasę bazową Codec, z której w momencie definiowania koderów i dekoderów po- wstają odpowiednie podklasy. Interfejs obiektu c klasy Codec wygląda nastę- pująco: c.encode(self, input [, errors]) Koduje input i zwraca tupię (output, length), gdzie length jest długo- ścią danych w input, które zostały zakodowane, errors ma jedną z trzech następujących wartości: 'strict', 'ignore' lub 'replace' -standardowo 'strict'. c.decode(self, Input [, errors]) Dekoduje input i zwraca tupię (output, length), gdzie length jest długością danych w input, które zostały rozkodowane, errors ma jedną z trzech następujących wartości: 'strict', 'ignore' lub 'replace' - standardowo 'strict'. Ani metoda encode (), ani decode () nie powinny zapamiętywać wewnątrz swojego stanu. Ponadto obie te metody muszą sobie radzić z danymi wejściowy- mi zerowej długości, zwracając w takim przypadku zerowej długości obiekt wyj- ściowy odpowiedniego typu. Doóatek A: tsionoteKa rymona Oprócz wymienionych już klas moduł codecs zawiera także klasy bazowe dl czterech różnego typu interfejsów I/O. Wszystkie te klasy są podklasami Codec Streamwriter(stream [, errors]) Tworzy obudowę strumienia stream umożliwiającą generowanie zakodi

wanego strumienia wyjściowego. Instancja w klasy Streamwriter oferuje same metody co stream, a oprócz tego jeszcze parę innych: w.write (object) Zapisuje zakodowaną wersję object w w. w.writelines(list) Zapisuje konkatenowaną listę napisów w w. w.reset() Zrzuca zawartość buforów wyjściowych i resetuje wewnętrzny stan kod wania. StreamReader(stream [, errors]) Tworzy obudowę strumienia stream umożliwiającą wczytywanie zakod wanego strumienia wejściowego. Instancja r klasy StreamReader oferuje same metody co stream, a oprócz tego jeszcze parę innych: r.read([size]) Wczytuje rozkodowane dane z r. Argument size podaje orientacyj liczbę bajtów do wczytania. Dekoder może nieco zmienić tę wartość w ce dopasowania jej do konkretnego sposobu kodowania. Bez size następi wczytanie i rozkodowanie wszystkich danych. r. readline ( [size]) Wczytuje jedną linię wejściową przy użyciu metody readline () ory nalnego strumienia i zwraca ją w postaci rozkodowanych danych. Warte size jest po prostu przekazywana do metody readline(). r. readlines ( [size]) Wczytuje wszystkie linie i po rozkodowaniu zwraca je w postaci listy. r.reset() Resetuje bufory kodeka. Zazwyczaj ma to na celu powrót do normalne stanu po wystąpieniu błędu. StreaxnReaderWriter (stream, reader, writer [, errors]) Tworzy obudowę strumienia oferującego zarówno kodowanie, jak i dekoc wanie. stream może być dowolnym obiektem-plikiem. reader musi I funkcją fabrykującą lub klasą implementującą interfejs StreamRead< writer musi być funkcją fabrykującą lub klasą implementującą inter! Streamwriter. Instancja Streamwriter udostępnia połączenie interfejs StreamReader i StreamWriter. StreaznRecorder(stream, encode, decode, reader, writer [,errors]) Tworzy obudowę stream, która pozwala dokonywać konwersji mięć dwoma różnymi sposobami kodowania (na przykład z UTF-8 na UTF-16 i wrotnie). Argumentem stream może być dowolny obiekt-plik. Argume

150 Python encode i decode definiują odpowiednio funkcję kodującą i funkcję deko- dującą, które są zwracane lub akceptowane przez metodę read() iwrite(). Innymi słowy dane zwrócone przez read () są kodowane zgodnie z encode, a dane przekazywane do write () są dekodowane zgodnie z decode. Argu- menty reader i writer to klasy StreamReader i StrearnWriter używa- ne odpowiednio do wczytywania i zapisywania faktycznej zawartości strumienia danych. Obiekt StreamRecorder stanowi połączenie interfej- sów StreamReader i StreamWriter. Moduł codecs definiuje ponadto w postaci stałych następujące znaczniki ko- lejności bajtów, których można używać podczas interpretowania plików specyficznych dla platformy: Stała Opis BOM Znacznik rodzimej kolejności bajtów w

komputerze BOM_BE Znacznik kolejności bajtów big-endian BOM LE Znacznik kolejności bajtów little-endian BOM32_BE 32-bitowy znacznik big-endian BOM32_LE 32-bitowy znacznik little-endian BOM64_BE 64-bitowy znacznik big-endian BOM64 LE 64-bitowy znacznik little-endian PRZYKŁAD Oto przykład przedstawiający implementację nowego sposobu kodowania wy- korzystującego proste szyfrowanie oparte na alternatywie rozłącznej (XOR). Sposób ten działa tylko dla 8-bitowych napisów, ale daje się także rozszerzyć na znaki Unicode: # xor.py: Proste szyfrowanie z u życiem XOR import codecs # Funkcja koduj ąca/dekoduj ąca (działa w obie strony) def xor_encode(input, errors = 'strict 1, key=0xff): output = "".join ( [chr(ord(c) A key) for c in input]) return (output,len(input)) # Klasa kodeka XOR class Codec(codecs.Codec): key = Oxff def encode(self,input, errors='strict'): return xor_encode(input,errors, self.key) def decode(self,input, errors='strict'): return xor_encode(input,errors,self.key) # Klasy StreamWriter i StreamReader class StreamWriter(Codec,codecs.StreamWriter): pass class StreamReader(Codec,codecs.StreamReader): pass Dodatek A: Biblioteka Pythona # Funkcje fabrykuj ące do tworzenia obiektów StreamWriter # i StreamReader z podan ą warto ści ą klucza. def xor_writer_factory(stream,errors, key=0xff) : s = StreamWriter(stream,errors) s.key = key return s; def xor_reader_factory(stream,errors, key=0xff) : r = StreamReader(stream,errors) r.key = key return r # Funkcja rejestrowana w module codecs. Rozpoznaje dowolne # kodowanie postaci 'xor-hh', gdzie hh jest liczb ą szesnastkow ą. def lookup(s): if (s[:4] == 'xor-'): key = int(s[4:],16) # Utworzenie kilku funkcji z kluczem ustawionym na żądaną warto ść e = lambda x,err='strict',key=key:xor_encode(x,err, key) r = lambda x,err='strict',key=key:xor_reader_factor y(x,err,key) w = lambda x,err='strict',key=key:xor_writer_factor y(x,err,key) return (e,e,r,w) # Rejestracja w module codec

codecs.register(lookup) A oto krótki program, który wykorzystuje nowe kodowanie: import xor, codecs f = codecs.open("foo","w","xor-37") f.write("Hello World\n") # Zapisuje wersj ę "zakodowan ą" f.close ()

re (enc,dec,r,w) = codecs.lookup("xor-ae") a = enc("Hello World") # a = ('\346\313\302\302\301\216\371\301\334\302\31 21, 11) UWAGI • Więcej informacji o korzystaniu z modułu codecs jest podanych w rozdziale 9. • Większość wbudowanych sposobów kodowania ma służyć kodowaniu napisów Unicode. W ich przypa funkcje kodujące generują 8-bitowe napisy, a funkcje dekodujące - napisy Unicode. Zobacz także rozdzia Moduł re służy do sprawdzania i modyfikowania napisów przy użyciu wy: żeń regularnych. Pozwala operować zarówno na zwykłych napisach, jak i na i pisach Unicode. Wzorce wyrażeń regularnych mają postać napisów zaw rających kombinację tekstu i sekwenqi znaków specjalnych. Ponieważ wz< ce wykorzystują często dużą liczbę znaków specjalnych i odwrotnych ukoś ków, są zazwyczaj zapisywane w postaci „surowych" napisów, takich j r1 (?P<int>\d+)\. (\d*) '. Taka właśnie składnia będzie stosowana i wszystkich wyrażeniach regularnych używanych w dalszej części tego opisu.

152 Python Oto lista sekwencji znaków specjalnych rozpoznawanych we wzorcach wyrażeń regularnych: Znakti) Znaczenie tekst {m, n] {m, n}l r...] A\B (...) (?iLmsux) (?P<name> . . .) (?P=name) (?=...) (?<=. . •) Dosłowny napis tekst. Dowolny znak z wyjątkiem przejścia do nowej linii. 'oczątek napisu. Koniec napisu. Zero lub więcej powtórzeń poprzedniego wyrażenia (tyle, ile to tylko możliwe). edno lub więcej powtórzeń poprzedniego wyrażenia (tyle, ile to tylko możliwe). Zero lub jedno powtórzenie poprzedniego wyrażenia. Zero lub więcej powtórzeń poprzedniego wyrażenia (możliwie najmniej). Jedno lub więcej powtórzeń poprzedniego wyrażenia (możliwie najmniej). Zero lub jedno powtórzenie poprzedniego wyrażenia (możliwie najmniej). Od m do n powtórzeń poprzedniego wyrażenia (tyle, ile to tylko możliwe). Od m do n powtórzeń poprzedniego wyrażenia (możliwe najmniej). Zbiór znaków taki jak r' [abcdef] ' lubr' [a-zA-z] '. Znaki speqalne, takie jak *, są nieaktywne wewnątrz tego zbioru. Znaki spoza podanego zbioru, takie jak r' [A 0 - 9 ] '. A lub B, gdzie A i B są wyrażeniami regularnymi. Podnapis pasujący do wyrażenia regularnego wewnątrz nawiasów traktowanego jako grupa. Flagi "i", "L", "m", "s", "u" i "x" odpowiadające ustawieniom re. I, re.L, re.M, re.S, re.U oraz re.X w re.compile (). Usunięcie podnapisu pasującego do wyrażenia regularnego wewnątrz nawiasów traktowanego jako grupa. Grupa nazwana pasująca do wyrażenia regularnego w nawiasach. Nazwą tej grupy musi być poprawny identyfikator Pythona. Ten sam tekst, który pasował do wcześniejszej grupy nazwanej. Komentarz. Zawartość nawiasów jest ignorowana. Poprzednie wyrażenie, o ile następuje po nim wzorzec podany w nawiasach. Na przykład r'Witaj (?=świecie) ' oznacza'Witaj ' tylko wtedy, gdy dalej w napisie występuje 'świecie'. Poprzednie wyrażenie, o ile nie następuje po nim wzorzec podany w nawiasach. Na przykład r'Witaj (? !=świecie) ' oznacza'Witaj ' tylko wtedy, gdy dalej w napisie nie występuje 'świecie'. Podane wyrażenie, o ile występuje przed nim tekst pasujący do wzorca w nawiasach. Na przykład r' (?<=abc) def' oznacza ' def' tylko wtedy, gdy wcześniej w napisie występuje ' abc'. Podane wyrażenie, o ile nie występuje przed nim tekst pasujący do wzorca w nawiasach. Na przykład r' (?< ! abc) def' oznacza 'def tylko wtedy, gdy wcześniej w napisie nie występuje ' abc'. Dodatek A: Biblioteka Pythona Standardowe sekwencje znaków ucieczki, takie jak ' \n ' lub ' \t' są traktował w wyrażeniach regularnych jak zwykłe znaki; na przykład r • \n+ ' oznacza j den lub więcej znaków przejścia do nowej linii. Ponadto wstawienie odwrotne^

ukośnika przed symbolem, który normalnie ma speqalne znaczenie w wyraź niach regularnych, powoduje traktowanie go jak zwykłego znaku. Na przykła r' \ * ' oznacza znak *. Jest jednak kilka znaków, które poprzedzone odwrotny ukośnikiem nabierają specjalnego znaczenia: Znakd) Znaczenie \numer Tekst dopasowany wcześniej przez grupę o tym numerze. Grupy są numerowane od 1 do 99, zaczynając od lewej. \A Początek napisu. \b Pusty napis na początku lub na końcu wyrazu. Wyrazem jest sekwenqa znaków alfanumerycznych. \B Pusty napis nie na początku ani nie na końcu wyrazu. \d Dowolna cyfra dziesiętna. To samo, co r' [ 0-9 ] '. \D Dowolny znak różny od cyfry. To samo, co r' [A 0 - 9 ] '. \s Dowolny biały znak. To samo, co r' [ \t\n\r\f \v] '. \S Dowolny znak różny od białego znaku. To samo, cor' [A\t\n\r\f\v] \w Dowolny znak alfanumeryczny. \W Dowolny znak spoza zbioru zdefiniowanego przez \w. \z Koniec napisu. W Zwykły odwrotny ukośnik.

Oto funkq'e używane do sprawdzania i modyfikowania napisów przy użyci wzorców: compile(str [, flags]) Kompiluje napis z wzorcem wyrażenia regularnego na obiekt wyrażenia re gularnego. Obiekt ten można przekazać w postaci argumentu do wielu w) mienionych dalej funkcji. Argument flags zawiera alternatywę bitów następujących flag: Flaga Znaczenie I lub IGNORE CASE Dopasowywanie bez uwzględniania wielkości liter. L lub LOCALE Stosowanie lokalnych ustawień dla \w, \w, \bi\B. M lub MULTILINE Symbole A i $ odnoszą się nie tylko do początku i końca całego napisu, ale także do każdej linii. (Normalnie A i $ oznaczają wyłącznie początek i koniec całego napisu). S lub DOTALL Znak kropki (.) oznacza dowolny znak, łącznie ze znakiem przejścia do nowej linii. U lub UNICODE W przypadku \w, \W, \bi\B wykorzystywane są informaqe z bazy danych właściwości znaków Unicode. X lub VERBOSE Ignorowanie białych znaków i komentarzy nie poprzedzonych znakiem ucieczki.

154 Python search(pattern, string [, flags]) Szuka w s tring pierwszego podnapisu pasującego do wzorca przekazanego przez pa t tern. Parametr flags ma to samo znaczenie co w compi le (). Je- śli uda się dopasować wzorzec, funkcja zwraca MatchOb j ect, a w przeciwnym wypadku None. match(pattern, string [, flags]) Sprawdza, czy zero lub więcej znaków na początku s tring pasuje do wzorca podanego w pattern. Jeśli tak, zwraca instancję MatchObject, a w przeciwnym wypadku None. split (pattern, string [, maxsplit - 0]) Dzieli s tring w miejscach wystąpienia pa t tern i zwraca listę uzyskanych tą drogą napisów, łącznie z tekstami dopasowanymi na podstawie dowolnych grup we wzorcu. Wartość maxsplit określa maksymalną dozwoloną liczbę podziałów. Standardowo wykonywane są wszystkie możliwe po- działy. findall(pattern, string) Zwraca listę wszystkich nie zachodzących na siebie fragmentów string pa- sujących do wzorca pattern, łącznie z pustymi dopasowaniami. Jeśli wzorzec zawiera grupy, zwracana jest lista tekstów dopasowanych do tych grup. Jeśli jest używana więcej niż jedna grupa, funkcja zwraca listę tupli zawie- rających tekst dla każdej grupy. sub (pattern, repl, string [, count = 0]) Idąc od lewej zastępuje wartością repl nie zachodzące na siebie podnapisy s tring pasujące do wzorca pa ttern. Argument repl może być napisem lub funkcją. Jeśli jest to funkcja, musi być wywoływana dla instancji Ma- tchOb j ect i zwracać napis zastępujący. Jeśli repl jest napisem, do wskaza- nia grup w napisie używa się odwołań wstecznych, takich jak ' \ 6 '. Aby odwołać się do grupy nazwanej, stosuje się sekwencję '\q<nazwa>*. Argu- ment count podaje maksymalną liczbę wykonywanych zastąpień. Domy- ślnie zastępowane są wszystkie wystąpienia tekstu pasującego do wzorca. Cho- ciaż funkcja ta, w odróżnieniu od compile (), nie ma parametru flags, ten sam skutek można uzyskać stosując opisaną wcześniej notację (? iLmsux). subn(pattern, repl, string [, count = 0]) Taka sama jak sub (), tyle że zwraca tupię zawierającą nowy napis i liczbę zastąpień. escape(string) Zwraca napis z wszystkimi niealfanumerycznymi odwrotnymi ukośnikami. W wyniku kompilaqi wyrażenia regularnego funkq'a compile () tworzy obiekt r, który ma następujące metody i atrybuty: r.search(string [, pos [, endpos]]) Szuka wzorca w string. Argumenty pos i endpos określają początek i koniec przeszukiwanego fragmentu string. Gdy szukanie zakończy się pomyślnie, zwraca instancję MatchObj ect, a w przeciwnym wypadku None. uoaawK A: bionoteKa tytnona r. match (string [, pos [, endpos]]) Sprawdza, czy na początku string występuje zero lub więcej znaków sujących do wzorca. Argumenty pos i endpos określają początek i kor przeszukiwanego fragmentu string. Gdy sprawdzanie zakończy się ] myślnie, zwraca instancję MatchObj ect, a w przeciwnym wypad None. r. split (string [, maxsplit = 0]) To samo co funkcja split ().

r. findall (str±ngr) To samo co funkcja findall (). r. sub (repl, string [, count = 0]) To samo co funkcja sub (). r. subn (repl, string [, count - 0]) To samo co funkqa subn (). r.flags Argument flags użyty podczas kompilacji wyrażenia regularnego lub r .groupindex Słownik mapujący nazwy symboliczne grup zdefiniowanych pr2 r ' (? P< i d>) na numery tych grup. r.pattern Napis z wzorcem, którego kompilacja doprowadziła do utworzenia obie tu wyrażenia regularnego. Instancje MatchOb j ect zwracane przez funkqe search () i match () zaw rają informaqe o zawartości grup, jak również o miejscach, w których dopasovy nie zakończyło się sukcesem. Instancja MatchObj ect o nazwie m ma nas pujące metody i atrybuty: m. expand(template) Zwraca napis, który powstałby z napisu tempi a tew wyniku rozwinię< wstecznych odwołań wyrażenia regularnego. Wsteczne odwołar numeryczne, takie jak " \ 1" i " \ 2 " oraz symboliczne, takie jak " \ q<n> "\g<nazwa>" są zastępowane przez zawartość odpowiadających i grup. Uwaga: sekwencje te powinny być zapisywane w postaci surowy napisów lub przy użyciu nieinterpretowanego znaku odwrotne; ukośnika, czyli r' \ 1' lub ' \ \ 1'. m.group([groupl, group2, . . . ]) Zwraca jedną lub więcej podgrup dopasowania. Argumenty zawiera numery lub nazwy grup. Jeśli nie ma podanych grup, zwracane jest Cc dopasowanie. Jeśli jest podana tylko jedna grupa, zwracany jest napis z tekste pasującym tylko do tej grupy. W przeciwnym razie zwracana jest tup z tekstami pasującymi do każdej grupy z osobna. W przypadku użyć złego numeru lub złej nazwy grupy zgłaszany jest wyjątek IndexErro

156 Python JO.groups ([default]) Zwraca tupię zawierającą tekst pasujący do wszystkich grup we wzorcu. Argument default zawiera wartość zwracaną tym grupom, które nie brały udziału w dopasowaniu (standardowo jest to None). m.groupdict([default]) Zwraca słownik zawierający wszystkie nazwane podgrupy dopasowania. Argument default zawiera wartość zwracaną tym grupom, które nie brały udziału w dopasowaniu (standardowo jest to None). JD. start ( [group]) m. end ([ group]) Zwracają indeksy początku i końca podnapisu pasującego do podanej grupy. Bez podania group używany jest cały pasujący podnapis. Jeśli podana grupa istnieje, ale nie brała udziału w dopasowaniu, zwracana jest wartość None. m.span([group]) Zwraca dwuelementową tupię (m. start (group) , m. end (group) ). Jeśli podana grupa istnieje, ale nie brała udziału w dopasowaniu, zwracana jest tupla (None, None). Jeśli argument group zostanie pominięty, używany jest cały pasujący podnapis. m.pos Wartość pos przekazana do funkcji search () lub match (). m.endpos Wartość endpos przekazana do funkcji search () lub match (). m.re Obiekt-wyrażenie regularne, którego metoda search () lub match () utworzyła bieżącą instancję MatchObj ect. ID . string Napis przekazany do funkcji match () lub search (). Jeśli napis z wzorcem nie zawiera poprawnego wyrażenia regularnego, zgłaszany jest wyjątek re . error. m. lastindex Indeks całkowity ostatniej dopasowanej grupy. Jeśli nie nastąpiło dopasowanie, wartością jest None. m. lastgroup Nazwa ostatniej dopasowanej grupy. Jeśli grupa nie miała nazwy lub nie nastąpiło dopasowanie, wartością jest None. PRZYKŁADY import re s = open('plik').read() # Wczytanie jakiegoś tekstu # Zamiana wszystkich wystąpień 'nic' na 'coś' t = re.sub('nic','coś',s) # Pobranie tytułu dokumentu HTML tpas = re.search(r'<title>(.*?)</title>',s, re.IGNORECASE) Dodatek A: Biblioteka Pythona 75, if tpas: tytuł = tpas.group(1) # Pobranie z s listy potencjalnych adresów e-mail wzr = re.compile(r'([a-zA-Z][\w-]*@[\w-]+(?:\.t\w-] +)*)') adresy = re.findall(wzr,s) # Zamiana napisów podobnych do URL, takich jak 'htt p://www.python.org' # na znacznik HTML postaci # <a href='http://www.python.org'>http://www.python .org</a> wzr = re.compile(r'((ftplhttp)://[\w-]+(?:\.[\w-]+)*(?:/[\w-]*)*)') t = wzr.sub('<a href="\\l">\\K/a>' , s) UWAGI # Implementacja modułu re znajduje się tak naprawdę w module s re, który obsługuje zarówno napisy stan dardowe, jak i Unicode. Starsza implementacja modułu re, która obsługiwała tylko napisy standardowe znajduje się w module pre. # Szczegółowe informacje o teorii i implementacjach wyrażeń regularnych można znaleźć w podręcznikac

dotyczących budowy kompilatorów. Można też skorzystać z książki „Mastering Regular Expressions Jeffreya Friedla (O'Reilly & Associates, 1997). # Moduł re nie zmienia 8 bitu i może przetwarzać napisy, które zawierają puste bajty (null), jak i znaki z usta wionym górnym bitem. Wzorce wyrażeń regularnych nie mogą natomiast zawierać pustych bajtów, ale za t mogą ich szukać używając do tego celu sekwencji ucieczki ' \ 000 ■. Zobacz tak że string (157] string Moduł string zawiera kilka stałych ifunkcji użytecznych w czasie wykonywa nia działań na napisach. Większość tego, co potrafi ten moduł, można równie; zrealizować za pomocą metod napisu. Oto lista zdefiniowanych stałych: Stała Opis digits Napis '0123456789'. hexdigits Napis '01234567 89abcdefABCDEF'. letters Konkatenacja małych i dużych liter. lowercase Napis zawierający wszystkie małe litery. octdigits Napis '01234567'. punctuation Napis złożony ze znaków interpunkcyjnych ASCII. printable Napis złożony z drukowalnych znaków ASCII. uppercase Napis zawierający wszystkie duże litery. whitespace Napis zawierający wszystkie białe znaki. Są to zwykle: spacja, tabulaq'a, znak nowej linii, powrót karetki, znak wysuwu strony i tabulacja pionowa. Oto wykaz dostępnych funkcji: atof(s) Konwertuje napis s na liczbę zmiennoprzecinkową. Zobacz także funkcj float ().

158 Python atoi(s [, base]) Konwertuje napis s na liczbę całkowitą. Nieobowiązkowy argument base to podstawa systemu. Zobacz także funkcję int (). atol(s [, base]) Konwertuje napis s na długą liczbę całkowitą. Nieobowiązkowy argument base to podstawa systemu. Zobacz także funkcję int (). capitalize (s) Zamienia pierwszy znak s na dużą literę. To samo, cos.capitalize(). capwords(s) Zamienia pierwszy znak każdego wyrazu w s na dużą literę, zastępuje po- wtórzone białe znaki jedną spacją i usuwa białe znaki występujące na początku i na końcu s. count(s, sub [, start [, end]]) Znajduje liczbę nie zachodzących na siebie wystąpień sub w s [ start: end]. To samo, co s. count (sub, start, end). expandtabs(s [, tabs±ze=8]) Zastępuje tabulacje w napisie s spacjami, tabs i ze podaje liczbę znaków między kolejnymi tabulatorami. To samo, co s. expandtab (tabsize). find(s, sub [, start [, end]]) index(s, sub [, start [, end]]) Zwraca najmniejszy indeks w s[start: end], od którego zaczyna się podnapis s ub. Bez podania start i end przeszukiwany jest cały napis. Jeśli podnapis nie wy- stępuje w s, find () zwraca wartość -1, a index () zgłasza wyjątek ValueErr or. To samo, co s. find (sub, start, end) i s. index (sub, start, end). rfind(s, sub [, start [, end]]) rindex(s, sub [, start [, end]]) Podobne do find () i index (), tyle że szukają najwyższego indeksu. To samo co s.rfind(sub,start, end) i s.rindex(sub, start, end). lower(s) Konwertuje wszystkie duże litery w s na małe. To samo co s. lower (). maketrans(from, to) Tworzy tablicę translacji, która mapuje każdy znak z from na występujący w tym samym miejscu znak w to. from i to muszą być tej samej długości. split(s [, sep [, maxsplit]]) splitfields(s [, sep [, maxsplit]]) Zwraca listę wyrazów w s. Jeśli nie występuje sep lub ma wartość None, wyrazami są podnapisy oddzielone białymi znakami. W przeciwnym wypadku separatorem wyrazów jest sep. maxsplit podaje maksymalną liczbę po- działów, które mogą nastąpić. Reszta napisu jest zwracana w ostatnim elemencie, split () wykonuje to samo, co s. split (sep, maxsplit). Dodatek A: Biblioteka Pythona join (words [, sep]) joinfields(words [, sep]) Łączenie (konkatenacja) sekwencji wyrazów w napis z dodatkiem separato sep między tymi wyrazami. Bez sep wyrazy są oddzielane spacjami. 1 samo co s. j oin (words). lstrip(s) rstrip(s) sstrip(s) Usunięcie początkowych i końcowych białych znaków z s. To samo, < s.lstrip(), s.rstrip (),s.strip (). swapcase(s) Zamienia małe litery na duże i odwrotnie w całym napisie s. To samo < s.swapcase ().

translate(s, table [, delchars]) Usuwa z s wszystkie znaki występujące w delchars, a pozostałe tłumac: na podstawie table, table musi być 256-znakowym napisem mapujący jedne znaki na drugie, utworzonym przez maketrans(). To samo < s.translate(table,delchars). upper(s) Konwertuje wszystkie małe litery w s na duże. To samo co s. upper (). ljust(s, width) rjust(s, width) center(s, width) Kolejno wyrównanie do lewej, wyrównanie do prawej i wyśrodkowanie w polu o szerokości width. To samo co s. ljust (width), s.r just (wic th), s.center(width). zfill(s, width) Uzupełnia z lewej strony zerami napis numeryczny s do szerokości width replace (str, old, new [, max]) Zamienia max wystąpień podnapisu old w s tr na podnapis new. Bez max zami niane są wszystkie wystąpienia old. To samo, co s. replace (old, new, max] UWAGI • Wraz z pojawieniem się w Pythonie 2.0 metod napisowych moduł string został uznany oficjalnie za n aktualny, ale nadal jest powszechnie używany w istniejących programach. • Moduł obsługuje napisy zwykłe i Unicode, ale w razie konieczności te pierwsze są doprowadzane do post Unicode. Zobacz także re (151), rozdział

160 Python StringlO i cStringlO Moduły StringI O icStringlO definiują obiekt, który zachowuje się podobnie jak plik, ale czyta i zapisuje dane używając bufora znakowego. StringlO ( [buffer] ) Tworzy nowy obiekt StringlO. buffer zawiera początkową wartość bufora (standardowo jest to pusty napis). Obiekt StringlO udostępnia wszystkie standardowe operacje na plikach - read (), write () i tak dalej - a także następujące dodatkowe metody: s.getvalue() Zwraca zawartość bufora znakowego przed wywołaniem close (). s.close () Zwalnia pamięć bufora. UWAGA • Moduł stringio definiuje stringio jako klasę. Moduł cStringlO definiuje go z kolei jako typ rozszerzenia i zapewnia znacznie szybsze działanie. Zobacz także podrozdział „Pliki" rozdziału 9 (metody pliku). struct Moduł struct służy do konwertowania danych między Pythonem a binarnymi strukturami danych (reprezentowanymi przez napisy Pythona). Struktury te są często używane do pracy z funkcjami napisanymi w C lub z binarnymi proto- kołami sieciowymi. pack(fmt, vi, v2, ...) Pakuje wartości vl,v2i tak dalej do napisu zgodnie z napisem formatującym podanym w fmt. unpack (fmt, strlng) Rozpakowuje zawartość string zgodnie z napisem formatującym podanym w fmt. Rozpakowane wartości są zwracane w postaci tupli. calcsize(fmt) Oblicza rozmiar w bajtach struktury odpowiadającej napisowi forma- tującemu podanemu w fmt. Napis formatujący jest sekwencją znaków o następujących możliwych znaczeniach: Format Typ języka C Typ Pythona •x' pad byte Brak wartości 'c' char Napis o długości 1 ■b1 signed char Liczba całkowita •B1 unsigned char Liczba całkowita •h1 short Liczba całkowita •H1 unsigned short Liczba całkowita 'i' int Liczba całkowita 'I' unsigned int Liczba całkowita Dodatek A: Biblioteka Pythona Format Typ języka C Typ Pythona '1' long Liczba całkowita 'L' unsigned long Liczba całkowita •f float Liczba zmiennoprzecinkowa ■d1 double Liczba zmiennoprzecinkowa 's' char[] Napis 'P1 chart] Napis o długości zakodowanej w pierwszym

baje • pi void * Liczba całkowita Każdy znak formatujący może być poprzedzony liczbą całkowitą pełniącą rc licznika powtórzeń (na przykład Mi1 oznacza to samo co ' i i i i '). W przypa ku formatu s liczba ta reprezentuje maksymalną długość napisu. Tak więc ' ]

Os ' oznacza napis 10-bajtowy, a 'Os' oznacza napis zerowej długości. Form ' p' służy do kodowania napisów, których pierwszy bajt zawiera długość, a d piero następne dane. Jest to przydatne w czasie pracy z kodem Pascala, a w M cintoshach bywa czasem niezbędne. Uwaga: długość napisu jest w takiej sytua ograniczona do 255 znaków. W przypadku użycia formatów ' I' i ' L' do rozpakowywania wartości zwrac na jest długa liczba całkowita Pythona. Ponadto format ' P' może zwracać zar wno zwykłą liczbę całkowitą, jak i długą liczbę całkowitą - w zależności od ro miaru słowa w danym komputerze. Pierwszy znak każdego napisu formatującego może ponadto określać kolejność h tów i sposób wyrównania pakowanych danych, co jest opisane w poniższej tabel Format Kolejność bajtów Rozmiar i

wyrównanie •@- Rodzima Rodzime i _ i Rodzima Standardowe '<' Little-endian Standardowe •>' Big-endian Standardowe Sieciowa (big-endian) Standardowe Rodzima kolejność bajtów może być typu little-endian lub big-endian, w zależn ści od architektury komputera. Rodzimy rozmiar i rodzime wyrównanie odp wiadają wartościom używanym przez kompilator C i są specyficzne dla imp] mentacji. Standardowe wyrównanie oznacza, że żaden z typów nie wymaga w równania. Standardowy rozmiar oznacza, że typ short zajmuje 2 bajty, int bajty, long - 4 bajty, float -32 bity, a double - 64 bity. Format ' P' może uż wać tylko rodzimej kolejności bajtów. Czasem trzeba wyrównać koniec struktury danych zgodnie z wymaganiami ko kretnego typu. W tym celu wystarczy zakończyć napis formatujący kodem odp wiedniego typu z zerową liczbą powtórzeń. Na przykład format • 1 lhO 1' opisi strukturę, która kończy się na granicy czterobajtowej (zakładając, że długie liczi całkowite są wyrównywane do granicy czterobajtowej). W tym przypadku ]

162 Python krótkiej wartości, której dotyczy kod 'h' zostanie wstawione dwubajtowe wypełnienie. Ten mechanizm działa tylko wtedy, gdy jest używany rodzimy rozmiar i wyrównanie - standardowe formaty nie wymuszają wyrównania. Zobacz także array (142), xdrlib (302). unicodedata Moduł unicodedata umożliwia dostęp do bazy danych znaków Unicode, która zawiera właściwości wszystkich znaków Unicode. decimal (unichr [, default]) Zwraca wartość liczby całkowitej dziesiętnej przypisanej do znaku unichr. Jeśli znak unichr nie jest cyfrą dziesiętną, funkcja zwraca default lub zgłasza wyjątek ValueError. digit(unichr [, default]) Zwraca wartość cyfry przypisanej do znaku unichr. Jeśli znak unichr nie jest cyfrą, funkqa zwraca default lub zgłasza wyjątek ValueError. Funk- cja digit () tym się różni od funkqi decimal (), że działa dla znaków re- prezentujących cyfry, ale nie muszą to być cyfry dziesiętne. numeric (unichr [, default]) Zwraca wartość przypisaną do zneku Unicode unichr w postaci liczby zmiennoprzecinkowej. Jeśli nie ma zdefiniowanej wartości numerycznej dla znaku unichr, funkcja zwraca defaul t lub zgłasza wyjątek ValueError. Na przykład wartością numeryczną znaku U+2155 (znaku reprezentującego ułamek "1/5") jest 0.2. category (unichr) Zwraca napis podający ogólną kategorię unichr. Napis ten ma jedną z nastę- pujących wartości: Wartość Opis Lu Duża litera LI Mała litera Lt Litera jak w tytule Mn Znacznik; nierozdzielający Mc Znacznik; rozdzielający łączony Me Znacznik; obejmujący Nd Liczba; cyfra dziesiętna NI Liczba; litera No Liczba; inna Zs Separator; spacja Zl Separator; linia Zp Separator; akapit Cc Inny znak; sterujący Cf Inny znak; formatujący Cs Inny znak; zastępczy Dodatek A: Biblioteka Pythona Wartość Opis Co Inny znak; do użytku prywatnego Cn Inny znak; nie przypisany Lm Litera; modyfikator Lo Litera; inna Pc Znak interpunkcyjny; łącznik Pd Znak interpunkcyjny; pauza Ps Znak interpunkcyjny; początkowy Pe Znak interpunkcyjny; końcowy Pi Znak interpunkcyjny; cudzysłów otwierający

Pf Znak interpunkcyjny; cudzysłów zamykający Po Znak interpunkcyjny; inny Sm Symbol; matematyczny Sc Symbol; walutowy Sk Symbol; modyfikator So Symbol; inny bidirectional (unichr) Zwraca w postaci napisu dwukierunkową kategorię przypisaną do unich lub pusty napis, jeśli taka wartość nie jest zdefiniowana. Oto lista istniejącyc kategorii: Wartość Opis L Od lewej do prawej LRE Od lewej do prawej; wstawianie LRO Od lewej do prawej; zastępowanie R Od prawej do lewej AL Od prawej do lewej; arabski RLE Od prawej do lewej; wstawianie RLO Od prawej do lewej; zastępowanie PDF Przywrócenie kierunku EN Liczba europejska ES Separator liczby europejskiej ET Terminator liczby europejskiej AN Liczba arabska CS Wspólny separator liczby NSM Znacznik nierozdzielający BN Graniczny neutralny B Separator akapitu S Separator segementu WS Biały znak ON Inny znak neutralny

164 Python combining(unichr) Zwraca liczbę całkowitą wskazującą klasę łączenia dla znaku unichr lub 0, je- śli nie ma dla niego zdefiniowanej żadnej klasy. Oto lista możliwych wartości: Wartość Opis 0 Odstępy, dzielenie, obejmowanie, zmiana kolejności, załączniki

tybetańskie 1 Nakładane i wewnętrzne 7 Znaki Nukta 8 Znaczniki wymowy Hiragana/Katakana 9 Znaki Virama 10-199 Klasy znaków o stałym położeniu 200 Doczepiane z lewej u dołu 202 Doczepiane u dołu 204 Doczepiane z prawej u dołu 208 Doczepiane z lewej 210 Doczepiane z prawej 212 Doczepiane z lewej u góry 214 Doczepiane u góry 216 Doczepiane z prawej u góry 218 Poniżej z lewej 220 Poniżej 222 Poniżej z prawej 224 Z lewej 226 Z prawej 228 Powyżej z lewej 230 Powyżej 232 Powyżej z prawej 233 Dwukrotnie niżej 234 Dwukrotnie wyżej 240 Poniżej (indeks iota) _ mirrored( unichr) Zwraca 1, jeśli unichr jest „lustrzanym" znakiem w tekście dwukierunko- wym, a 0 w przeciwnym wypadku. decomposition {unichr) Zwraca napis zawierający mapowanie dekomponujące unichr lub pusty napis, jeśli takie mapowanie nie jest zdefiniowane. Znaki z symbolami akcentu są zazwyczaj dekomponowane na sekwencje wieloznakowe. Na przykład, decomposition (u"\u00fc"), czyli dekompozycja znaku ("u"), zwraca napis "0075 0308" odpowiadający literze i znakowi akcentu umlaut ("). Na- pis zwracany przez tę funkcję może również zawierać następujące napisy: Dodatek A: Biblioteka Pythona Wartość Opis <font> Odmiana czcionki <noBreak> Nierozdzielająca wersja spaqi lub łącznika <initial> Wstępna forma prezentaqi (arabski) <medial> Pośrednia forma prezentacji (arabski) <final> Końcowa forma prezentacji (arabski) <isolated> Izolowana forma prezentaqi (arabski) <circle> Forma otoczona <super> Forma indeksu górnego <sub> Forma indeksu dolnego <vertical> Poziomy układ prezentaqi

<wide> Szeroki znak (lub zenkaku) <narrow> Wąski znak (lub hankaku) <small> Mała odmiana znaku (kompatybilność z CNS) <square> Kwadratowa odmiana czcionki CJK <fraction> Zwykła postać ułamkowa <compat> Inny znak o nie podanej kompatybilności UWAGA • Więcej informacji o bazie danych znaków Unicode można znaleźć w miejscu http: //www .unico de. org.

Zarządzanie danymi i trwałe przechowywanie obiektów Omawiane w tej części moduły służą do zapisywania danych w formatach różnyc baz danych typu DBM. Bazy te działają podobnie do dużych asocjacyjnych tabli dyskowych, których elementy są zapisywane i odczytywane przy użyciu unike towych kluczy reprezentowanych przez standardowe napisy. Większość z tyc modułów to nieobowiązkowe rozszerzenia Pythona, wymagające bibliotek ir nych firm, dostępnych w momencie budowania interpretera Pythona. Więcej ir formacji o udostępnianiu nieobowiązkowych modułów znajdziesz w dodatku I zatytułowanym „Rozszerzanie i osadzanie Pythona". Wszystkie bazy danych są otwierane przy użyciu różnych wariantów funkc open () (zdefiniowanej w każdym module bazy danych): open {filename [, flag [, mode] ]) Otwiera plik bazy danych filename i zwraca obiekt-bazę danych. Argumer flag określa rodzaj dostępu do bazy danych i może mieć wartość": ' r' - tylk odczyt, ' w' - pisanie i czytanie, ' c' - utworzenie bazy danych, jeśli nie istnieje oraz ' n' - bezwarunkowe utworzenie nowej bazy danych. Argument mode pc daje tryb dostępu do pliku (w systemie Unix jest to standardowo wartość 0666). Obiekt zwracany przez funkqe open () pozwala wykonywać następujące podobne do wykonywanych na słownikach działania:

166 Python Działanie Opis d[key] = value Wstawienie wartości value do bazy danych value = d[key] Pobranie wartości z bazy danych del d[key] Usunięcie elementu bazy danych d. close () Zamknięcie bazy danych d.has key(key) Sprawdzenie istnienia klucza key d. keys () Uzyskanie listy kluczy

We wszystkich przypadkach key musi być napisem standardowym. Również value musi być we wszystkich modułach napisem standardowym, jedynie z wyjątkiem modułu she 1 ve. Napisy Unicode nie mogą być używane w żad- nym module jako klucze, a jako wartości tylko w module shelve. UWAGA • Większość opisanych pakietów baz danych jest opartych na dodatkowych zewnętrznych bibliotekach, które trzeba samodzielnie zainstalować w Pythonie. anydbm Moduł anydbm zapewnia ogólny interfejs, umożliwiający otwieranie baz danych bez informacji o tym, czy wyspecjalizowany pakiet niskiego poziomu dla danej bazy danych został zainstalowany i jest dostępny. Po wykonaniu importu modułu anydbm szuka on jednego z trzech modułów: bsddb, gdbm lub dbm, i jeśli nie znajdzie żadnego z nich (bo nie zostały zainstalowane), ładuje moduł dumb dbm. Obiekt-baza danych tworzony jest za pomocą wywołania funkcji open (): open(filename [, flag='r' [, mode]]) Funkcja open () otwiera plik bazy danych filename i zwraca obiekt-bazę danych. Jeśli podana baza danych już istnieje, moduł whichdb ustala jej typ oraz moduł, którego należy używać w tym przypadku. Jeśli baza danych nie istnieje, następuje próba jej utworzenia przy użyciu pierwszego zainstalowanego modułu z podanej wcześniej listy. Argumenty flags i mode zostały już wcześniej opisane, na samym początku tej części. error Tupla zawierająca wyjątki, które mogą być zgłaszane przez wszystkie modu- ły baz danych. Programy, które chcą przechwytywać błędy, powinny używać tej tupli jako argumentu instrukcji except. Na przykład: test: d = anydbm.open('baza','r') except anydbm.error: # Obsługa bł ędu UWAGA • Jeśli moduł dumbdbm jest jedynym zainstalowanym modułem bazy danych, w niektórych starszych wersjach Pythona próba ponownego otwarcia bazy danych przy użyciu anydbm może się nie udać. Lepiej jest wtedy używać dumbdbm. open (). Zobacz także dumbdbm (168), whichdb (170). Dodatek A: Biblioteka Pythona U bsddb Moduł bsddb stanowi interfejs biblioteki Berkeley DB. Używając odpowiednie wywołań jego funkcji open () , można tworzyć hasze, b-drzewa oraz pliki opai te na rekordach: hashopen (filename [, flag =' r' [, mode] ]) Otwiera plik w formacie hasza o nazwie filename. btopen(filename [, flag ='r • [, mode]]) Otwiera plik w formacie b-drzewa o nazwie filename. rnopen(filename [, flag ='r' [, mode]]) Otwiera plik w formacie rekordów DB o nazwie filename. Bazy danych tworzone za pomocą tego modułu zachowują się jak słowniki, o

zostało już opisane we wstępie do tej części („Zarządzanie danymi i trwałe prze chowywanie obiektów"). Moduł bsddb udostępnia również metody do przesu wania „kursora" w ramach rekordów: Metoda Opis d.set location(key) Ustawia kursor na elemencie wskazywanym przez klucz i zwraca go. d.firstO Ustawia kursor na pierwszym elemencie bazy danych i zwraca go. d.next () Ustawia kursor na następnym elemencie bazy danych i zwraca go. d.previous () Ustawia kursor na poprzednim elemencie pliku DB i

zwracć go. Nie działa dla baz danych w postaci tablic haszowych. d.last () Ustawia kursor na ostatnim elemencie pliku DB i zwraca

go Nie działa dla baz danych w postaci tablic haszowych. d.sync () Synchronizuje bazę danych na dysku. WYJĄTEK error Wyjątek zgłaszany w przypadku błędów w bazie danych nie związanycł z kluczem. UWAGI • Moduł ten korzysta z wersji 1.85 API pakietu Berkeley DB dostępnej pod adresem http://www.sle- epyca t. com. • Wszystkie funkcje open () mają dodatkowe, rzadko używane i nieobowiązkowe argumenty. Szczegółowi informacje na ten temat można znaleźć w dokumentacji online. • Dodatkowym źródłem może być książka Berkeley DB wydawnictwa New Riders (2001, ISBf 0-7357-1064-3). Zobacz także dbhash (168), http://www.python.org/doc/lib/module-bsddb.html

168 ryuiun dbhash Moduł dbhash służy do otwierania bazy danych za pomocą modułu bsddb, ale stosując interfejs bardzo zbliżony do interfejsu innych modułów baz danych. open(filename [, flag-'x1 [, mode]) Otwiera bazę danych DB i zwraca obiekt-bazę danych. Obiekt zwrócony przez open () zachowuje się podobnie, jak słownik. Oprócz metod wymienionych na wstępie tej części, udostępnia jeszcze następujące: Metoda Opis d. first() Zwraca pierwszy klucz w bazie danych. d.last() Zwraca ostatni klucz w bazie danych. d.next(key) Zwraca następny klucz w bazie danych po podanym. d.previous(key) Zwraca element bazy danych przed podanym kluczem (podczas przechodzenia bazy danych w przód). d. sync () Zapisuje dane przechowywane tylko w pamięci na dysku. WYJĄTEK error Wyjątek zgłaszany w wyniku błędu bazy danych innego niż KeyError. To samo co bsddb. error. UWAGA • Moduł bsddb musi być zainstalowany. Zobacz także bsddb (167). dbm Moduł dbm stanowi interfejs uniksowej biblioteki dbm. open {filename [, flag='r' [, mode]]) Otwiera bazę danych dbm i zwraca obiekt dbm. Argument f i 1 ename zawiera nazwę pliku bazy danych (bez rozszerzenia .dir lub .pag). Zwracany obiekt zachowuje się podobnie jak słownik i został już opisany we wstępie do tej części („Zarządzanie danymi i trwałe przechowywanie obiektów"). WYJĄTEK

erorr Wyjątek zgłaszany w przypadku błędu specyficznego dla dbm, innego niż KeyError. Zobacz także anydbm (166), gdbm (169). dumbdbm Moduł dumbdbm jest prostą bazą danych typu DBM zaimplementowaną w Py- thonie. Powinno się jej używać tylko wtedy, gdy nie jest dostępny żaden inny moduł bazy danych DBM. open {filename [, flag [, mode] ]) Otwiera plik bazy danych filename. Podana nazwa pliku nie powinna z wierać żadnych przyrostków, takich jak . dat czy . dir. Zwracany obiekt z chowuje się podobnie jak słownik i został już opisany we wstępie do tej częś („Zarządzanie danymi i trwałe przechowywanie obiektów"). WYJĄTEK erorr Wyjątek zgłaszany w przypadku błędów związanych z bazą danych, innyi niż KeyError. Zobacz także anydbm (166), wichdb (17 gdbm Moduł gdbm stanowi interfejs biblioteki GNU DBM.

open {filename [, flag=' r ' [, mode] ]) Otwiera plik filename z bazą danych gdbm. Użycie litery ' f ' w argumen< flag powoduje otwarcie bazy danych w trybie szybkiego dostępu. W tryl tym nie ma automatycznego zapisywania na dysku każdej zmiany danych, przyśpiesza działanie programu. W takim przypadku, aby wymusić skop wanie nie zapisanych danych na dysk w momencie zakończenia prograir trzeba użyć metody sync (). Obiekt d typu gdbm zachowuje się podobnie jak słownik. Oprócz metod wym nionych na wstępie tej części, udostępnia jeszcze następujące: Metoda Opis d. firstkey () Zwraca początkowy klucz bazy danych. d.nextkey(key) Zwraca następny klucz bazy danych po podanym. d. reorganize() Reorganizuje bazę danych i odzyskuje nieużywaną

przestrzeń. Można w ten sposób zmniejszyć rozmiar pliku gdbm po usunięciu wielu elementów z bazy danych. d.sync () Wymusza zapisanie zmienionych danych na dysku. WYJĄTEK erorr Wyjątek zgłaszany w przypadku błędów specyficznych dla gdbm. UWAGA • Biblioteka GNU DBM jest dostępna pod adresem www.gnu.org/software/gdi gdbm.html. Zobacz także anydbm (166), wichdb (1 shelve Moduł shelve pomaga trwale przechowywać obiekty za pomocą specjaln< obiektu - półki (ang. shelf). Obiekt ten zachowuje się podobnie jak słownik,: różnicą, że wszystkie zawarte w nim obiekty są przechowywane na dysku w

170 Python zie danych takiej jak dbm czy gdbm. Aby utworzyć „półkę", trzeba użyć funkcji shelve.open (). open(filename [, flag='c']) Otwiera podany plik bazy danych i zwraca obiekt-półkę. Jeśli podany plik nie istnieje, zostanie utworzony. Argument fi 1 ename powinien zawierać nazwę pliku, ale bez żadnego przyrostka. Argument flag ma to samo znaczenie co w pozostałych funkcjach open () i może przyjmować jedną z wartości: ' r ', 1 w', • c ' lub ' n •. Po otwarciu bazy danych obiekt-półka pozwala wykonywać następujące działania: Działanie Opis d[key] = data Zapisuje dane w miejscu key (usuwając już istniejące). data = d[key] Pobiera dane z miejsca key. del d[key] Usuwa dane z miejsca key. d.has key(A:ey) Sprawdza istnienie klucza. d.keys () Zwraca wszystkie klucze. d.close () Zamyka półkę. d.sync () Zapisuje nie zachowane dane na dysku.

Wartościami kluczy muszą być napisy. Obiekty przechowywane na półce muszą nadawać się do serializaq'i przy użyciu modułu piekle. Zobacz także open (116). shelf(diet) Klasa implementująca działanie półki. Argument di et jest istniejącym obiektem-słownikiem. Używając tej funkcji można utworzyć obiekt-półkę korzy- stający z wybranego aparatu bazy danych. Na przykład s = Shelf (dbm. open("baza","c")). UWAGA • Moduł shelve tym się różni od pozostałych modułów baz danych, że pozwala zapisać niemal każdy obiekt Pythona. Zobacz także piekle (127), rozdział 9. whichdb Moduł whichdb zawiera funkcję próbującą odgadnąć, który z kilku modułów prostych baz danych (dbm, gdbm czy dbhash) powinien zostać użyty do otwarcia pliku bazy danych. whichdb (filename) Argument filename powinien zawierać nazwę pliku bez żadnych przy- rostków. Jeśli plik nie daje się otworzyć, gdyż jest nieczytelny lub w ogóle nie istnieje, funkcja zwraca wartość None. Jeśli nie daje się rozpoznać formatu pliku, funkcja zwraca pusty napis. W przeciwnym wypadku zwracany jest napis zawierający nazwę odpowiedniego modułu, na przykład ' dbm' lub ' gdbm'. Zobacz tak że anydbm (166). Dodatek A: Biblioteka Pythona

Usługi systemu operacyjnego Moduły omawiane w tej części umożliwiają dostęp do różnego rodzaju us systemu operacyjnego, ze szczególnym uwzględnieniem zarządzania plika procesami i terminalami. Uwaga: Od czytelnika oczekuje się znajomości podstawowych pojęć syste operacyjnego. Ponadto kilka modułów zawiera zaawansowane funkcje, któr omówienie wykracza poza zakres tej książki, ale są zamieszczone z myślą o ty którzy będą wiedzieli, o co w nich chodzi. Większość modułów Pythona odnoszących się do systemu operacyjnego bazuje interfejsach POSIX-a. Jest to standard, który definiuje podstawowy zbiór inter sów systemu operacyjnego. Większość systemów Unix pozwala korzystać z I SIX-a, a pozostałe platformy, takie jak Windows i Macintosh, również obsług

dużą część tego standardu. W razie potrzeby czytelnicy mogą skorzystać z dodatkowych źródeł poświę nych omawianym tutaj tematom. Dobry przegląd plików, deskryptorów plik i interfejsów niskiego poziomu, na których opiera się wiele modułów z tej czę; można znaleźć w książce The C Programming Language, Second Edition Briana Kernighana i Dennisa M.Ritchie (Prentice Hall, 1989, ISBN 0-13-110362-8). B dziej zaawansowani mogą sięgnąć do książki W. Richarda Stevensa Advan Programming in the UNIX Environment (Addison-Wesley, 1992, IS! 0-201-56317-7). Dobrym materiałem uzupełniającym z dziedziny samego sys mu operacyjnego może być z kolei książka Operating Systems Concepts, 5th Edit Abrahama Silberschatza i Petera Galvina (John Wiley & Sons, 1998). Progran wanie dotyczące sieci i wątków zostanie natomiast przedstawione w oddzi nych częściach tego dodatku. commands Moduł commands służy do wykonywania poleceń systemowych (w postaci na su) i uzyskiwania ich wyników (także w postaci napisów). getoutput(cmd) Wykonuje w shellu polecenie cmd i zwraca napis zawierający oba standarc we strumienie tego polecenia: wyjściowy i diagnostyczny. getstatus(filename) Zwraca w postaci napisu strumień wyjściowy polecenia ' 1 s -Id filen, me'. Unix. getstatusoutput(cmd) Działa podobnie jak getoutput (), tyle że zwraca 2-elementową tupię (s t, tus, output), gdzie status jest kodem powrotu, jaki zwraca funk< os . wait (), a output jest napisem zwróconym przez getoutput (). mkarg(str) Zamienia s tr w argument, który można bezpiecznie umieścić w napisie po^ cenią (stosując reguły cytowania obowiązujące w shellu).

172 Python UWAGI Do wykonywania poleceń używane jest wywołanie funkcji os. popen2 (). Moduł commands jest do- stępny w większości systemów uniksowych, natomiast nie istnieje dla każdej wersji Windows. Zwracany napis ze strumieniem wyjściowym nie zawiera końcowego znaku przejścia do nowej linii. Zobacz także os (198), popen2 (215). crypt Moduł crypt stanowi interfejs uniksowej procedury crypt (), używanej w wielu systemach tego typu do szyfrowania haseł. crypt(word, salt) Szyfruje argument word przy użyciu zmodyfikowanego algorytmu DES. Ar- gument salt jest dwuznakową sekwencją służącą do zainicjalizowania algorytmu. Funkcja zwraca napis z zaszyfrowanym argumentem word. Tylko osiem pierwszych znaków word jest znaczących. PRZYKŁAD Oto fragment kodu, który wczytuje hasło użytkownika i porównuje je z warto- ścią zapisaną w systemowej bazie danych haseł: import getpass import pwd import crypt nazwa = getpass.getuser() hs = getpass.getpass() haslopraw = pwd.getpwnam (nazwa)[1] haslowprow = crypt.crypt (hs,haslopraw[ :2]) if haslopraw == haslowprow: # Pobranie ze środowiska # nazwy u żytkownika # Pobranie wprowadzonego hasła # Pobranie prawdziwego hasła # Szyfrowanie # Porównanie else: print 'Dobre hasło' print 'Złe hasło 1 UWAGA • Wiele nowoczesnych systemów Unix używa MD5 lub innego haszującego algorytmu szyfrowania do zapisywania haseł. Zobacz także pwd (216), getpass (184). errno

L

Moduł errno definiuje nazwy symboliczne dla całkowitych kodów błędów zwracanych przez wywołania różnych usług systemu operacyjnego. Kody te są zazwyczaj dostępne w atrybucie errno wyjątku OSError lub IOError. Uży- wając funkcji os.strerrorO można tłumaczyć kody błędów na tekstowe komunikaty o błędach. Aby zastąpić kod błędu jego nazwą symboliczną, można ró- wnież skorzystać ze słownika: errorcode Słownik ten mapuje liczby całkowite errno na takie nazwy, jak na przykład ■EPERM1. Zamieszczona niżej lista zawiera nazwy symboliczne wielu kodów błędów syst mowych występujące w standardzie POSIX. Nie wszystkie z tych nazw są d stępne w każdym komputerze. Niektóre platformy mogą też definiować dodć kowe kody. Kody U, W, M i K wskazują na dostępność poszczególnych kodów i

odpowiednich platformach: Unix, Windows, Macintosh i wszystkich innych. Kod błędu Platforma Opis E2BIG K Za długa lista argumentów EACCES K Odmowa dostępu EADDRINUSE K Adres już używany EADDRNOTAVAIL K Nie można przypisać żądanego adresu EADV U Błąd ogłaszania EAFNOSUPPORT K Rodzina adresów nie obsługiwana przez

protokół EAGAIN K Spróbuj ponownie EALREADY K Operaqa w toku EBADE U Niedozwolona wymiana EBADF K Zły numer pliku EBADFD U Zły stan deskryptora pliku EBADMSG U Zły komunikat EBADR u Deskryptor nieprawidłowego żądania EBADRQC u Kod nieprawidłowego żądania EBADSLT u Nieprawidłowe gniazdo EBFONT u Zły format pliku czcionki EBUSY K Zajęte urządzenie lub zasób ECHILD K Brak procesów potomnych ECHRNG U Numer kanału spoza zakresu ECOMM u Błąd komunikacji przy wysyłaniu ECONNABORTED K Przerwanie połączenia przez program ECONNREFUSED K Odmowa połączenia ECONNRESET K Zresetowanie połączenia przez uczestnika EDEADLK K Groźba zakleszczenia zasobów EDEADLOCK U, W Błąd zakleszczenia blokad pliku EDESTADDRREQ K Wymagany adres docelowy EDOM K Argument spoza domeny funkq'i matematycznej EDOTDOT U Błąd specyficzny dla RFS EDQUOT K Przekroczenie limitu (quota) EEXIST K Plik istnieje EFAULT K Zły adres EFBIG K Za duży plik EHOSTDOWN K Wyłączony host EHOSTUNREACH K Nie ma drogi do hosta

174 ryuiun Kod błędu Platforma Opis EIDRM U Usunięty identyfikator EILSEQ U, W Niedozwolona sekwencja bajtów EINPROGRESS u, w Działanie w toku EINTR K Przerwane wywołanie systemowe EINVAL K Nieprawidłowy argument EIO K Błąd wejścia/wyjścia EISCONN K Punkt docelowy jest już połączony EISDIR K To jest katalog EISNAM U To jest plik o nazwanym typie EL2HLT U Zatrzymanie na poziomie 2 EL2NSYNC U Brak synchronizacji na poziomie 2 EL3HLT U Zatrzymanie na poziomie 3 EL3RST U Resetowanie na poziomie 3 ELIBACC U Brak dostępu do biblioteki dzielonej ELIBBAD U ELIBEXEC U

Próba dostępu do uszkodzonej biblioteki dzielonej Nie można wykonać bezpośrednio exec

biblioteki dzielonej ELIBMAX U Próba dowiązania zbyt wielu bibliotek dzielonych ELIBSCN u Uszkodzona sekq'a lib w aout ELNRNG u Liczba dowiązań spoza zakresu ELOOP K Zbyt wiele dowiązań symbolicznych EMFILE K Zbyt wiele otwartych plików EMLINK U, W Zbyt wiele dowiązań EMSGSIZE U, W Za długa wiadomość EMULTIHOP U Próba połączenia „multihop" ENAMETOOLONG U Za długa nazwa pliku ENAVAIL U Brak semaforów XENIX-a ENETDOWN U, W Sieć nie działa ENETRESET U, W Przerwane połączenie sieciowe z powodu

resetowania ENETUNREACH U, W Brak dostępu do sieci ENFILE u, w Przepełnienie tablicy plików ENOANO u Brak węzła ENOBUFS K Brak miejsca w buforze ENOCSI U Brak struktury CSI ENODATA u Brak danych ENODEV K Nie ma takiego urządzenia ENOENT K Nie ma takiego pliku lub katalogu ENOEXEC K Zły format exec ENOLCK K Brak blokad rekordów uoaawK A: bioiiowKa tytnona Kod błędu Platforma Opis ENOLINK U Odcięte dowiązanie ENOMEM K Brak pamięci ENOMSG U Brak wiadomości żądanego typu ENONET U Komputer nie jest w sieci

ENOPKG u Nie zainstalowany pakiet ENOPROTOOPT K Niedostępny protokół ENOSPC K Brak miejsca w urządzeniu ENOSR U Brak strumieni ENOSTR U To nie strumień ENOSYS K Funkqa nie zaimplementowana ENOTBLK U,M Wymagane urządzenie blokowe ENOTCONN K Brak połączenia z punktem docelowym ENOTDIR K To nie jest katalog ENOTEMPTY K Katalog nie jest pusty ENOTNAM U To nie jest plik XENIX-a o nazwanym

typi( ENOTSOCK K Operaq'a „gniazdowa" nie na gnieździe ENOTTY K To nie jest terminal ENOTUNIQ U Ta nazwa nie jest unikatowa w sieci ENXIO K Nie ma takiego urządzenia lub adresu EOPNOTSUPP K Operaq'a nie obsługiwana przez odbiorcę EOVERFLOW U Za duża wartość dla zdefiniowanego typu

danych EPERM K Niedozwolone działanie EPFNOSUPPORT K Nie obsługiwana rodzina protokołów EPIPE K Przerwany potok EPROTO U Błąd protokołu EPROTONOSUPPORT K Protokół nie obsługiwany EPROTOTYPE K Nieodpowiedni protokół dla gniazda ERANGE K Nie można przedstawić wyniku matematycznego EREMCHG U Zmieniony zdalny adres EREMOTE K Zdalny obiekt EREMOTEIO U Zdalny błąd I/O ERESTART U Przerwane wywołanie systemowe

powinnc być powtórzone EROFS K System plików tylko do odczytu ESHUTDOWN K Nie można przesłać z powodu wyłączenia

odbiorcy ESOCKTNOSUPPORT K Nie obsługiwany typ gniazda ESPIPE K Niedozwolone szukanie ESRCH K Nie ma takiego procesu ESRMNT U Błąd srmount

176 Python Dodatek A: Biblioteka Pythona Kod błędu Platforma Opis ESTALE K Nieaktualny uchwyt pliku NFS ESTRPIPE U Błąd potoku strumieni ETIME U Przekroczenie czasu ETIMEDOUT K Przekroczenie czasu oczekiwania w trakcie połączenia ETOOMANYREFS K Zbyt wiele odwołań: nie można spleść ETXTBSY U,M Plik tekstowy zajęty EUCLEAN U Struktura wymaga uporządkowania EUNATCH U Nie dołączony sterownik protokołu EUSERS K Zbyt wielu użytkowników EWOULDBLOCK K Operacja może spowodować blokadę EXDEV K Dowiązanie między urządzeniami EXFULL U Pełne urządzenie wymienne WSAEACCES W Odmowa dostępu WSAEADDRINUSE w Adres w użyciu WSAEADDRNOTAVAIL w Nie można przypisać żądanego adresu WSAEAFNOSUPPORT w Rodzina adresów nie obsługiwana przez

rodzinę protokołów WSAEALREADY w Operacja w toku WSAEBADF w Nieprawidłowy uchwyt pliku WSAECONNABORTED w Przerwanie połączenia przez program WSAECONNREFUSED w Odmowa połączenia WSAECONNRESET w Zresetowanie połączenia przez uczestnika WSAEDESTADDRREQ w Wymagany adres docelowy WSAEDISCON w Wyłączenie zdalnego systemu WSAEDQUOT w Przekroczenie limitu miejsca na dysku

(quota] WSAEFAULT w Zły adres WSAEHOSTDOWN w Host jest wyłączony WSAEHOSTUNREACH w Brak drogi do hosta WSAEINPROGRESS w Operaqa w toku WSAEINTR w Przerwane wywołanie systemowe WSAEINVAL w Nieprawidłowy argument WSAEISCONN w Gniazdo już połączone WSAELOOP w Nie można przetłumaczyć nazwy WSAEMFILE w Zbyt wiele otwartych plików WSAEMSGSIZE w Za długa wiadomość WSAENAMETOOLONG w Za długa nazwa WSAENETDOWN w Sieć jest wyłączona WSAENETRESET w Przerwane połączenie z siecią z powodu

resetowania WSAENETUNREACH w Brak dostępu do sieci

Kod błędu Platforma Opis WSAENOBUFS W Brak miejsca w buforze WSAENOPROTOOPT W Zła opq'a protokołu WSAENOTCONN W Gniazdo nie jest połączone WSAENOTEMPTY w Nie można usunąć niepustego katalogu WSAENOTSOCK w Operaqa „gniazdowa" nie na gnieździe WSAEOPNOTSUPP w Nie obsługiwana operaqa WSAEPFNOSUPPORT w Nie obsługiwana rodzina protokołów WSAEPROCLIM w Zbyt wiele procesów WSAEPROTONOSUPPORT w Nie obsługiwany protokół WSAEPROTOTYPE w Typ protokołu nie pasuje do gniazda WSAEREMOTE w Obiekt niedostępny lokalnie WSAESHUTDOWN w Nie można wysłać z powodu zamknięcia

gniazda WSAESOCKTNOSUPPORT w Nie obsługiwany typ gniazda WSAESTALE w Uchwyt pliku jest już niedostępny WSAETIMEDOUT w Przekroczenie czasu oczekiwania w

trakd połączenia WSAETOOMANYREFS w Zbyt wiele dowiązań do obiektu jądra WSAEUSERS w Przekroczenie limitu (quota) WSAEWOULDBLOCK w Zasób chwilowo niedostępny WSANOTINITIALISED w Nieudane uruchomienie WSA WSASYSNOTREADY w Niedostępny podsystem sieci WSAVERNOTSUPPORTED w Wersja Winsock.dll spoza zakresu Zobacz także os ( fcntl Moduł fcntl pozwala sterować wejściem/wyjściem i plikami za pomocą ui sowych deskryptorów plików. Deskryptor pliku można uzyskać, korzyst. z metody fileno() obiektu pliku lub gniazda. Moduł fcntl używa wi stałych zdefiniowanych w module FCNTL (z tego względu należy go również portować). fcntl (fd, cmd [, arg]) Funkq'a ta wykonuje polecenie cmd na deskryptorze fd otwartego pliku, gument cmd zawiera kod całkowity polecenia, natomiast arg jest nieo wiązkowym argumentem w postaci liczby całkowitej lub napisu. Jeśli arg liczbą, wartość zwracana przez funkcję również jest liczbą. Jeśli arg jest na sem, jest on interpretowany jako binarna struktura danych i funkcja zw ca zawartość bufora przekonwertowaną z powrotem na obiekt-napis. < lista dostępnych poleceń (wymienione stałe są zdefiniowane w mod FCNTL):

rymon uoaaieK A: oiouowKa rytnona Polecenie F_DUPFD F_SETFD F_GETFD F SETFL F_GETFL F GETOWN F_SETOWN F_GETLK F_SETLK F SETLKW Opis Duplikuje deskryptor pliku, arg jest najmniejszą liczbą, którą można przypisać nowemu deskryptorowi pliku. Podobne do wywołania systemowego os. dup (). Ustawia flagę close-on-exec w arg (0 lub 1). Powoduje ona zamknięcie pliku na skutek wywołania systemowego exec (). Zwraca flagę close-on-exec. Ustawia flagi statusu w arg, używając alternatywy bitowej następujących stałych: O_NDELAY - Nieblokujący tryb I/O (System V). O_APPEND - Tryb dopisywania (System V). O_SYNC - Zapisywanie synchroniczne (System V). FNDELAY - Nieblokujący tryb I/O (BSD). FAPPEND - Tryb dopisywania (BSD). FASYNC - Wysyła sygnał SIGIO do grupy procesów, gdy jest możliwa operacja I/O (BSD). Pobiera flagi statusu ustawione przez F_SETFL. Pobiera ID procesu lub grupy procesów ustawionych na otrzymywanie sygnałów SIGIO i SIGURG (BSD). Ustawia ID procesu lub grupy procesów na otrzymywanie sygnałów SIGIO i SIGURG (BSD). Zwraca strukturę używaną do blokowania plików. Blokuje plik. Jeśli plik jest już zablokowany, zwraca wartość -1. Blokuje plik i czeka, jeśli nie jest to możliwe. Jeśli wywołanie funkcji fcntl() kończy się niepowodzeniem, następuje zgłoszenie wyjątku IOError. Polecenia F_GETLK i F_SETLK wykorzystują funkcję lockf (). ioctl(fd, op, arg) Funkcja ta jest podobna do fcntl (), tyle że jej działania są zdefiniowane w module IOCTL. Moduł IOCTL bywa niedostępny na niektórych platformach. flock(fd, op) Wykonuje operację blokowania op na deskryptorze pliku fd. Argument op zawiera alternatywę bitową następujących stałych zdefiniowanych w f net 1: Stała Opis LOCK EX Blokada wyłączna. LOCK NB Blokada bez blokowania. LOCK SH Blokada dzielona. LOCK_UN Odblokowanie.

Jeśli nie można nałożyć blokady w trybie nieblokującym, zgłaszany jest wyjątek IOError. lock(£d, op [, len [, start [, whence]]]) Funkqa ta blokuje jeden rekord lub cały fragment pliku. Argument op oz cza to samo, co w przypadku funkcji f lock (). Argument len podaje lic blokowanych bajtów, a start początek blokowanego miejsca względ wartości argumentu whence. Ten ostatni może mieć jedną z trzech warto 0 - początek pliku, 1 - miejsce bieżące, 2 - koniec pliku.

PRZYKŁADY import fcntl, FCNTL # Ustawienie bitu close-on-exec dla obiektu pliku f fcntl.fcntl(f.fileno(), FCNTL.F_SETFD, 1) # Zablokowanie pliku (tryb blokuj ący) fcntl.flock(f.fileno(), fcntl.LOCK_EX) # Zablokowanie pierwszych 8192 bajtów pliku (tryb n ieblokuj ący) try: fcntl.lockf(f.filenoO, fcntl.LOCK_EX | fcntl.LOCK_N B, 8192, 0, 0) except IOError,e: print "Nie mo żna nało żyć blokady", e UWAGI # Zbiór poleceń i opcji dostępnych w fcntl () zależy od systemu. Na niektórych platformach m FCNTL może zawierać ponad 100 stałych. # Wiele funkcji z tego modułu działa również na deskryptorach plików gniazd. Zobacz także os (198), socket (2S fileemp Moduł f i lecmp zawiera funkcje służące do porównywania plików i katalogó cmp(filel, f±le2 [, shallow [, use__statcache]]) Funkcja ta porównuje plik file Iz plikiem file2'\ jeśli są równe, zwracć a w przeciwnym wypadku 0. Standardowo pliki o identycznych atrybuta podawanych przez os . s tat (), są uznawane za równe. Jeśli występuje arj ment shadowi ma wartość fałsz, w celu ustalenia równości plików porówn się ich zawartość. W takim przypadku następne porównania tych sam) dwóch plików będą dawały wcześniejszy wynik, zapamiętany w parni podręcznej, chyba że zmienią się dla któregoś z nich dane os . stat (). J( jest podany argument use_statcache, funkcja zapisuje również w parni podręcznej wartości os . stat () i używa ich podczas kolejnych porówni Taka metoda przyśpiesza działanie, ale uniemożliwia modułowi wykrywaj zmian we wcześniej porównanych plikach. empfiles(dlr 1, dir2, common [, shallow [, use__statcache]] Porównuje zawartość plików z dwóch katalogów di rl i di r2 wymieniony na liście common. Funkcja zwraca tupię z trzema listami nazw plików (ma te mismatch, errors). Lista match zawiera pliki, które w obu katalogach identyczne, lista mismatch zawiera pliki, które są różne, a lista errors ;

180 Python wiera pliki, które z jakichś powodów nie mogły być porównane. Parametry shallowi use_s ta tea che mają to samo znaczenie, co w emp (). diremp(dirl, dir2 [, ignore [, hide]]) Tworzy obiekt, który może służyć do wykonywania różnych operacji porów- nawczych z udziałem katalogów dirl i dir2. Argument ignore zawiera li- stę nazw plików, które mają być ignorowane, i ma domyślną wartość [' RCS ', ' CVS ', ' tags ' ]. Argument hide zawiera listę nazw plików, które należy ukryć, i ma domyślną wartość [os.curdir, os.pardir] (w przypadku Uniksa jest to ['.','..']). Obiekt dzwracany przez di r emp () udostępnia następujące metody i atrybuty: d. report() Porównuje katalog dirl z dir2 i kieruje raport na sys . stdout. d. report__partial_closure () Porównuje dirl z dir2 oraz ich bezpośrednie jednakowe podkatalogi. d.report_full_closure() Porównuje dirl z dirl i wszystkie ich podkatalogi (rekurencyjne). d.left_list Podaje listę plików i podkatalogów występujących w dirl, przefiltro- waną na podstawie hide i ignore. d.right_list Podaje listę plików i podkatalogów występujących w dir2, przefiltro- waną na podstawie hide i ignore. d. common Podaje listę plików i podkatalogów występujących zarówno w dirl, jak i w dir2. d.left_only Podaje listę plików i podkatalogów występujących tylko w dirl. d.right_only Podaje listę plików i podkatalogów występujących tylko w dir2. d. common_dirs Podaje listę podkatalogów występujących zarówno w dirl, jak i w dir2. d. common_file ś Podaje listę plików występujących zarówno w dirl, jak i w dir2. d. common__f unny Podaje listę plików -w dirl i w dir2, które różnią się typem lub dla któ- rych nie można uzyskać informacji za pomocą os . stat (). d. same_f ile ś Podaje listę plików w dirl i w dir2 o identycznej zawartości. d.diff_files Podaje listę plików w dirl i w dir2 o różnej zawartości. Dodatek A: Biblioteka Pythona d. funny__f ileś Podaje listę plików występujących w dirl iw di r2, których nie moż porównać. d. subdirs Słownik mapujący nazwy z d.common_dirs na dodatkowe obiel diremp. UWAGA • Wartości atrybutów obiektu diremp są wyznaczane bardzo powoli i nie są znane od razu w momen utworzenia tego obiektu. fileinput Moduł fileinput przebiega listę plików wejściowych i odczytuje linia po lii ich zawartość. Głównym interfejsem tego modułu jest podana niżej funkcja: input( [files [, inplace [, backup]]]) Funkcja ta tworzy instancję klasy Fileinput. Argument files je

nieobowiązkową listą nazw plików wejściowych (dozwolona jest równi< pojedyncza nazwa). Jeśli jest pominięty, nazwy plików są pobierane z lii polecenia dostępnej za pomocą sys.argv[l: ]. Pusta lista powodu czytanie danych wejściowych z stdin (podobnie jak nazwa pliku ' - '). Jej wartością inplace jest 1, każdy plik wejściowy zostaje zamieniony na kop zapasową, a strumień sys.stdout jest przekierowywany do oryginalne^ pliku w celu jego nadpisania. Po zamknięciu strumienia wyjściowe^ następuje usunięcie kopii. Argument backup zawiera rozszerzenie pliku, r przykład .bak, dodawane do każdej nazwy pliku wejściowego w momenc tworzenia jego kopii. Jeśli argument ten wystąpi w wywołaniu funkc input (), kopie zapasowe plików wejściowych nie zostaną usunięt Standardową wartością backup jest pusty napis, a kopie zapasowe s usuwane z dysku. Wszystkie instancje Fileinput mają metody wymienione w poniższej tabt li. Metody te są również dostępne w postaci funkcji działających na ostatni* instancji utworzonej przez funkqe input (). Metoda Opis filename () Zwraca nazwę aktualnie czytanego pliku. lineno () Zwraca łączną liczbę wczytanych dotąd linii. filelineno() Zwraca liczbę linii wczytanych z bieżącego pliku. isfirstline () Zwraca prawdę, jeśli wczytana właśnie linia jest pierwszą w

pliku isstdin() Zwraca prawdę, jeśli plikiem wejściowym jest stdin. nextfile () Zamyka bieżący plik i przechodzi do następnego. close () Zamyka całą sekwencję plików.

Ponadto zwrócona przez input () instancja Fileinput może służyć jakc wyznacznik iteracji podczas czytania wszystkich linii pliku wejściowego.

182 Python Dodatek A: Biblioteka Pythona PRZYKŁAD Oto przykład kodu wczytującego i wyświetlającego wszystkie linie wejściowe plików wymienionych w linii polecenia: import fileinput for linia in fileinput.input (): print '%5d %s' % (fileinput.lineno(), linia), UWAGI • Wszystkie pliki otwierane przez ten moduł są otwierane w trybie tekstowym. • Jeśli nie można otworzyć jakiegoś pliku, następuje zgłoszenie wyjątku iOError. • Puste pliki są zaraz po otwarciu zamykane. • Wszystkie zwracane linie zawierają końcowe znaki przejścia do nowej linii, chyba że ostatnia linia pliku wejś- ciowego nie jest zakończona tym znakiem. • Krótkie nazwy plików MS-DOS/Windows (osiem znaków plus trójznakowe rozszerzenie) nie są obsługiwane. Zobacz także glob (187), f nmatch (182). findertools Moduł findertools umożliwia dostęp do niektórych funkcji Findera Macin- tosha. Wszystkie parametry pliku i folderu mogą być podawane w postaci napi- sów z pełną nazwą ścieżkową lub w postaci obiektów FSSpec tworzonych za po- mocą modułu macf s. launch(file) Uruchamia plik file traktując go jako aplikację lub otwierając go jako dokument w aplikacji macierzystej. print (file) Drukuje plik fi 1 e. copy(file, destdix) Kopiuje plik file do folderu destdir. move( file, destdir) Przenosi plik file do folderu destdir. sleep() Przełącza komputer w stan uśpienia (jeśli to możliwe). restart() Ponownie uruchamia komputer. shutdown() Wyłącza komputer. Zobacz także macf s (190), macostools (194). fnmatch Moduł fnmatch umożliwia dopasowywanie nazw plików przy użyciu symboli wieloznacznych typowych dla shella Uniksa. Znakti) Opis * Oznacza dowolną liczbę znaków. ■p Oznacza pojedynczy znak. [sec] Oznacza dowolny znak z seq. [ ! seq] Oznacza dowolny znak spoza seq. Oto lista funkcji, które pozwalają przeprowadzić dopasowanie symboli: fnmatch {filename, pattern) Zwraca wartość prawda, gdy nazwa filename pasuje do wzorca pa tte. Sprawdzanie wielkości liter zależy od systemu operacyjnego (niektóre p] formy, takie jak Windows, są obojętne na wielkość liter), fnmatchcase (filename, pattern) Porównuje filename z pattern uwzględniając wielkość liter. PRZYKŁADY fnmatch (' rys . gif , '*.gif') fnmatchCstr37.html1, 'str3[0-5] .html' Zwraca prawd ę Zwraca fałsz Zobacz także glob (1

getopt Moduł getopt umożliwia przeprowadzanie analizy składniowej opcji linii po cenią (zazwyczaj przekazywanych w sys . argv). getopt(args, options [, long_options]) Przeprowadza analizę składniową opcji linii polecenia występujących na 1 cie args. Argument options jest napisem składającym się z liter odpow dających jednoliterowym opcjom rozpoznawanym przez program ( przykład ' -x'). Gdy jakaś opcja wymaga podania wartości, po literow) symbolu tej opcji musi wystąpić dwukropek. Nieobowiązkowy argume long_options jest listą napisów odpowiadających długim nazwom op< Występujące na liście args nazwy tych opcji są zawsze poprzedzone dwoi łącznikami (--), na przykład '--exclude' (początkowe łączniki nie wys pują na liście long_options). Nazwy długich opcji wymagających podai wartości powinny być zakończone znakiem równości (=). Funkqa getopts zwraca listę dopasowanych par (option, value) oraz listę argumentć programu występujących po wszystkich opcjach. Opcje umieszczane są na liście w takiej samej kolejności, w jakiej zostały podane w linii poleceń Długie i krótkie opcje można łączyć ze sobą. Nazwy opcji są zwracane z je nym (-) lub dwoma łącznikami (—) na początku. WYJĄTEK error Wyjątek zgłaszany w przypadku wystąpienia nieznanej opcji lub braku arg mentu wymaganego przez opcję. Argumentem wyjątku jest napis podają przyczynę błędu.

184 Python PRZYKŁAD >» import getopt >» args = ['-a1, '-b', 'plikl1, '-cd1, 'akuku1, '-- oprócz1, Iplik2I, 'xl1

>» opts, pargs = getopt.getopt(args, 'ab:cd:', ['exclude=']) >» opts [('-a1, "), C-b1, 'plikl1), C-c',") >» pargs ['xl', 'x2'] 'x2 ('-d1, 'akuku'),('—oprócz', 'plik2')] UWAGI • Tylko jednoliterowe opcje linii polecenia mogą być rozpoznane na podstawie pojedynczego łącznika (-). Na przykład zapis ' -n 3 ■ jest poprawny, a ' -name 3 • - nie. • Jednoliterowe opcje można ze sobą łączyć pod warunkiem, że żadna z nich, z wyjątkiem ostatniej, nie ma argumentu. W podanym przykładzie ilustruje to zapis ' -cd akuku'. Zobacz także sys (131). getpass Moduł getpass umożliwia wczytywanie haseł i nazw użytkowników. getpass ([prompt]) Prosi o użytkownika o wpisanie hasła z wyłączonym echem. Standardowy tekst zachęty ma postać 'Password: '. Funkcja zwraca wprowadzone hasło jako napis. getuser() Zwraca nazwę użytkownika szukając jej najpierw w zmiennych środowisko- wych $LOGNAME, $USER, $LNAME i $USERNAME, a następnie sprawdzając systemową bazę danych haseł. Jeśli nazwa nie zostanie znaleziona, zgłaszany jest wyjątek KeyError. Systemy Unix i Windows. UWAGI • Przykład użycia getpas s pokazany jest w dokumentacji modułu crypt. • W systemie Unix moduł getpass jest uzależniony od modułu termios, który w pewnych systemach jest standardowo wyłączony. Zobacz także pwd (216), crypt (172). gettext Moduł gettext stanowi interfejs biblioteki GNU gettext, używanej do umię- dzynarodowiania oprogramowania (il8n). Podstawowym celem gettext jest stworzenie możliwości tłumaczenia wybranego tekstu programu w sposób łatwy do rozbudowy i możliwie najmniej widoczny dla programisty. Na przykład, jeśli piszesz program, który prosi użytkownika o podanie hasła, możesz sprawić, aby potrafił on wyświetlić na ekranie po angielsku password, po niemiecku passwort, po hiszpańsku contrasena i tak dalej. Działanie gettext polega na prostym podstawianiu napisów z wybranym tek- stem programu. W tym celu moduł korzysta z pomocy specjalnie skonstruowane] bazy danych ustawień regionalnych, zawierającej mapowanie oryginalnego tek- : tuDiiowKa tymona stu programu na jego wersje w różnych innych językach. Baza ta jest specyficz; dla aplikacji i musi być konstruowana przy użyciu specjalnego narzędzia (zosł nie opisane wkrótce). Standardowy interfejs gettext bazuje na podanych niżej funkcjach, które słu zarówno do lokalizowania bazy danych tłumaczeń, jak i do uzyskiwar przetłumaczonych napisów. bindtextdomain (domain [, localedir]) Ustala położenie katalogu ustawień regionalnych dla podanej domeny (dc main). Argument domain jest zwykle nazwą aplikacji, a localedir ścież] typu /usr/local/share/locale. Szukając tłumaczenia tekstu, gettext sprawdza najpierw plik binarny . r używając ścieżki localedir/ language/LC_MESSAGES/domain.vc\ gdzie language jest nazwą języka typu en, de, f r i tak dalej. Normalnie WĆ

tość language jest ustalana na podstawie jednej z następujących zmienny* Środowiskowych: $LANGUAGE, $LANG, $LC_MESSAGES i $LC_ALL. Arg ment language i wymienione zmienne środowiskowe mogą zawierać lis oddzielonych dwukropkami nazw akceptowanych języków. Bez argumen localedir funkcja zwraca aktualną nazwę domeny. textdomain([domain]) Ustawia wartość domain, która będzie używana w następnych tłumac2 niach tekstu. Bez podania domain funkcja zwraca bieżącą nazwę domeny. gettext {message) Zwraca przetłumaczoną wersję message na podstawie aktualnej nazwy d meny, lokalizaqi bazy danych ustawień regionalnych i języka. Jeśli nie uda s znaleźć odpowiedniego tłumaczenia, funkqa zwraca oryginalną warto message. Funkcja ta jest zwykle aliasem _ (), jak to jest opisane poniżej. dgettext(domain, message) Podobna do gettext (), ale szuka message w podanej domenie. PRZYKŁAD Zamieszczony fragment kodu pokazuje sposób użycia modułu gettext w ap kacji wraz z konstruowaniem bazy danych tłumaczeń. # myapp.py import getpass import gettext gettext. bindtextdomain ("mojaapl", "./locale") # K atalog ustawie ń regionalny gettext.textdomain("mojaapl") # Ustawienie domeny 'mojaap: _ = gettext.gettext # _() aliasem funkcji gettext pw = getpass.getpass(_("password:")) if pw != "sezam": print _("Authorization failed.\n"); raise SystemExit Użycie aliasu _ () jest bardzo istotnym elementem aplikacji. Po pierwsze, pozw la skrócić kod, który trzeba wpisać. Ważniejsze jest jednak to, że do konstruow

186 Python nia bazy danych tłumaczeń używane są automatyczne narzędzia, które wycinają tłumaczone teksty z programu źródłowego szukając w nim specjalnych sekwencji typu (" . . . "). W Pythonie służy do tego program pygettext.py (można go znaleźć w katalogu Tools/il8n pakietu dystrybucyjnego Pythona). Oto przykład użycia tego programu: % pygettext.py -o mojaapl.po mojaapl.py Na wyjściu pygettext. py powstaje czytelny dla użytkownika plik . po, który zawiera informacje o przetłumaczonych napisach oznaczonych w pliku źródłowym przez ("..."). Aby obsługiwać nowy język, trzeba dopisać w tym pliku przetłumaczone wersje napisów. Na przykład wersja mo j aapl. po po edycji może wyglądać następująco: #: myapp.py:8 msgid "Password:" msgstr "Passwort:" #: myapp.py:10 msgid "Authorization failed.\n" msgstr "Authorisierung fehlgeschlagen.\n" Po wprowadzeniu tłumaczenia na konkretny język trzeba przekonwertować plik mojaapl .po na postać binarną, używając specjalnego programu msgfmt .py (znajdującego się w tym samym katalogu co pygettext. py). Na przykład: % msgfmt.py mojaapl W wyniku tego polecenia powstaje plik mo j aapl. mo, który można skopiować do odpowiedniego podkatalogu katalogu ustawień regionalnych, na przykład locale/de/LC_MESSAGES/mojaapl .mo. W tym momencie można już wyko- nać test, ustawiając zmienną środowiskową $ LANGUAGE na napis " de " i urucha- miając aplikację. Na ekranie zamiast oryginalnego tekstu programu powinna się teraz pojawić jego wersja przetłumaczona. Interfejs oparty na klasach Oprócz standardowego interfejsu gettext Python udostępnia interfejs oparty na klasach, który lepiej pracuje z napisami Unicode i jest bardziej elastyczny. Oto lista funkcji występujących w tym interfejsie: find(domain [, localedir [, languages]]) Szuka odpowiedniego pliku tłumaczenia (. mo) dla podanej domeny, katalogu ustawień regionalnych i języków. Argumenty domain i localedir mają takie samo znaczenie, jak w funkcji bindtextdomain () .Argument languages jest listą napisów z językami, które należy znaleźć. Bez argumentów localedir i languages funkcja przyjmuje w ich miejsce te same wartości standardowe, co w bindtextdomain (). Jeśli zostanie znaleziony plik tłumaczenia, funkcja zwraca jego nazwę, a w przeciwnym razie obiekt None. install(domain [, localedir [, Unicode]]) Instaluje funkcję _ () we wbudowanej przestrzeni nazw, używając ustawień domain i localedir. Flaga Unicode powoduje zamianę zwracanego przetłumaczonego napisu na napis Unicode. uoaateKA: bioiiotena tytnona translation(domain [, localedir [, languages [, dass_]]]) Zwraca instancję obiektu tłumaczenia dla podanych wartości domain, loc lediri languages. Argumenty domain i localedirsą napisami, a la guages listą nazw języków. Argument class_ określa alternatyw implementaqe tłumaczenia i jest zarezerwowany głównie dla przyszłych r< szerzeń. Jego standardową wartością jest GNUTranslations. Obiekt tłumaczenia t zwracany przez funkqe translation () ma następuje metody i atrybuty: t. gettext (message) Zwraca przetłumaczoną wersję message w postaci napisu standardowegi t.ugettext(message) Zwraca przetłumaczoną wersję message w postaci napisu Unicode.

t.info() Zwraca słownik zawierający metadane tłumaczenia, w tym zbiór znaków, i tora, datę utworzenia i tak dalej. t.charset() Zwraca sposób kodowania zbioru znaków w tłumaczeniu, na przykł 'ISO-8859-11. PRZYKŁAD Zamieszczony tu przykład ilustruje użycie interfejsu opartego na klasie: # mojaapl.py import getpass import gettext gettext.install("mojaapl","./locale") pw = getpass.getpass(_("password:")) if pw != "hasło": print _("Authorization failed.\n"); raise SystemExit Alternatywą jest bezpośrednia kontrola nad instancją tłumaczenia: import gettext t = gettext.translation("mojaapl", "./locale", a = t.gettext("password:") ["de"] UWAGI • Aktualnie moduł ten obsługuje tylko format GNU gettext. Z czasem jednak moduł może ulec zmia i obsługiwać również inne sposoby kodowania tłumaczeń. • W trybie interakcyjnym Pythona używa się często zmiennej _, która zawiera wynik ostatnio obliczonego \ rażenia. Może to być źródłem konfliktów z funkcją _ (), instalowaną przez moduł get text. W prakt jednak prawdopodobieństwo tego typu problemów jest niewielkie. glob Moduł glob zwraca wszystkie nazwy plików w katalogu, który pasuje do wze ca podanego przy użyciu reguł uniksowego shella (opisanych przy oka modułu f nmatch).

188 Python Dodatek A: Biblioteka Pythona glob(pattern) Zwraca listę nazw ścieżkowych pasujących do pa t tern. PRZYKŁADY glob('*.html1) glob('obraz[0-5]*.gif') UWAGA • Nie działa rozwijanie znaku tyłdy (~) ani zmiennych środowiskowych shella. Aby to spowodować, trzeba przed wywołaniem globO użyć odpowiednio funkcji os. path. expanduser () i os. path. expandvars (). Zobacz także fnmatch (182), os .path (213). grp Moduł grp umożliwia dostęp do bazy danych grup Uniksa. getgrgid(gid) Zwraca pozycję bazy danych grup dla podanego identyfikatora grupy w postaci 4-elementowej tupli (gr_name, gr_passwd, gr_gid, gr_mem), gdzie: • gr_name jest nazwą grupy, • gr_pa sswd jest hasłem grupy (jeśli zostało zdefiniowane), • gr_ gi d jest identyfikatorem całkowitym grupy, • gr_mem jest listą nazw użytkowników należących do tej grupy. Jeśli grupa nie istnieje, funkcja zgłasza wyjątek KeyError. getgrnam (name) Działa tak samo jak getgrgid (), tyle że szuka grupy na podstawie nazwy. getgrall() Zwraca wszystkie zdefiniowane grupy w postaci listy tupli identycznych jak w przypadku getgrgid (). Zobacz także pwd (216). Moduł gz ip udostępnia klasę GzipFile, umożliwiającą odczytywanie i zapisywanie plików kompatybilnych z programem GNU gzip. Obiekty GzipFile działają podobnie jak zwykłe pliki. Różnica polega jedynie na tym, że powodują one automatyczną kompresję i dekompresję danych. GzipFile ([filename [, mode [, compresslevel [, fileoJbj] ] ] ]) Otwiera obiekt GzipFile. Argument filename jest nazwą pliku, a mode jedną z wartości ' r', 'rb1, ' a', ' ab', ' w' lub ' wb'. Standardowo jest to •rb'. Argument compresslevel jest liczbą całkowitą od 1 do 9, która ustala poziom kompresji. Na poziomie 1 moduł działa najszybciej, ale jednocze- śnie powoduje najmniejszą kompresję. Z kolei na poziomie 9 działanie jest najwolniejsze, ale kompresja największa (ustawienie standardowe). Nieobo- wiązkowy argument fileobj służy do przekazania obiektu pliku. Jeśli wymieniony w nim plik istnieje, zostanie użyty przez funkcję zamiast pliku o nazwie filename. open (filename [, mode [, compresslevel]]) Działa tak samo jak GzipFile (filename, mode, compresslev< Standardowym trybem jest ' rb', a poziomem kompresji 9. UWAGI • Wywołanie metody close () obiektu GzipFile nie zamyka pliku przekazanego w fileobj. I temu można na końcu skompresowanych danych umieścić dodatkowe informacje. • Pliki utworzone za pomocą uniksowego programu compres s nie są obsługiwane przez ten modu • Moduł gz ip wymaga modułu z i ib. Zobacz także zlib (238), zipf ile locale Moduł locale umożliwia dostęp do bazy danych ustawień regionali w standardzie POSIX. Dzięki tej bazie programiści mogą ustalać w aplikac pewne sprawy specyficzne dla danego kraju, nie wiedząc z góry, gdzie traf produkt. Baza danych ustawień regionalnych definiuje zbiory parametrów, Ł opisują reprezentaqe napisów, godzin, liczb i walut. Parametry te są pogrup< ne w kategorie o następujących kodach:

Kategoria LC_

_CTYPE

LC_

_COLLATE

LC_

_TIME

LC_

_MONETARY

LC_

_MESSAGES

LC_

_NUMERIC

LC

ALL

Opis Konwersja i porównywanie znaków. Sortowanie napisów. Wpływa nastrcollO i strxf rm (). Formatowanie godzin. Wpływa na time. strf time (). Formatowanie wartości walutowych. Wyświetlanie komunikatów. Może wpływać na komunikaty o błędach zwracane przez takie funkq'e, jak os.strerror() Formatowanie liczb. Wpływa na funkqe format (), atoi (), atof () istr (). Kombinacja wszystkich ustawień regionalnych. Oto lista funkcji dostępnych w module: setlocale(category [, locale]) Jeśli jest podany argument locale, funkcja zmienia ustawienia region dla podanej kategorii, locale jest napisem zawierającym nazwę ustawie gionalnych. W przypadku wartości ' C' wybierane są ustawienia przen (standard). Gdy jest to pusty napis, wybierane są domyślne ustawienia 1( ne ze środowiska użytkownika. Bez argumentu locale funkqa zwraca r reprezentujący bieżące ustawienia dla podanej kategorii. W przypadku b zgłaszany jest wyjątek locale. Error. localeconv() Zwraca bazę danych konwencji regionalnych w postaci słownika. strcoll(stringl, string2) Porównuje dwa napisy zgodnie z bieżącym ustawieniem LC_COLI i zwraca wartość ujemną, dodatnią lub zero w zależności od tego, stringl wypada przed, za, czy równo ze string2.

19U s trxfrm (s trlng) Przekształca string na napis nadający się do użycia w wywołaniu funkcji wbudowanej cmp (), gdzie będzie nadal dawał wyniki uwzględniające ustawienia regionalne. format (format, val [, grouping- 0]) Formatuje liczbę val zgodnie z bieżącym ustawieniem LC_NUMERIC. War- tość forma t wykorzystuje konwencję operatora %. W przypadku liczb zmiennoprzecinkowych modyfikowana jest również odpowiednio kropka dziesiętna. Jeśli wartością grouping jest prawda, funkcja uwzględnia ustawienia regionalne dotyczące grupowania. str(float) Formatuje liczbę zmiennoprzecinkową przy użyciu tego samego formatu, co funkcja wbudowana str(float),alez uwzględnieniem kropki dziesiętnej. atof(string) Konwertuje napis na liczbę zmiennoprzecinkową zgodnie z ustawieniami LC_NUMERIC. atol(string) Konwertuje napis na liczbę całkowitą zgodnie z ustawieniami LC_NUMERIC. WYJĄTEK Error Zgłaszany w przypadku niepowodzenia funkcji setlocale(). UWAGA • Dodatkowe informacje o tym module można znaleźć w dokumentacji online biblioteki. Zobacz także http://www.python.org/doc/lib/module-locale.html. macfs Moduł macfs służy do wykonywania działań na plikach i aliasach w komputerach Macintosh. W przypadku każdej funkcji i metody oczekującej argumentu w postaci pliku może nim być pełna lub częściowa nazwa ścieżkowa, obiekt FSSpec lub 3-elementowa tupla (wdRefNum, par ID, name). FSSpec(file) Tworzy obiekt FSSpec dla podanego pliku file. RawFSSpec(data) Tworzy obiekt FSSpec na podstawie napisu z surowymi danymi dla ukrytej pod FSSpec struktury danych w C. RawAlias (data) Tworzy obiekt Alias na podstawie napisu z surowymi danymi dla ukrytej pod Alias struktury danych w C. FInfo() Tworzy wypełniony zerami obiekt Flnf o. ResolveAliasFile (file) Rozwiązuje podany alias. Zwraca 3-elementową tupię (fsspec, isfolde. a liased), w której fsspec jest właściwym obiektem FSSpec, isfolderi wartość prawda, jeśli fsspec wskazuje folder, a a liased ma wartość pra da, jeśli podany plik jest aliasem. StandardGetFile ([ typel [, type2 [, ... ] ] ]) Wyświetla okno dialogowe „otwórz plik wejściowy" i prosi użytkowni o wybranie pliku. Można podać do czterech 4-znakowych typów plikć w celu ograniczenia listy plików, spośród których ma nastąpić wybór. Fur cja zwraca tupię zawierającą obiekt FSSpec i flagę wskazującą, czy użytko nik zamknął okno dialogowe bez anulowania operacji. PromptGetFile (prompt typel [, type2 [, ... ] ]) Działa podobnie jak StandardGetFile (), ale pozwala wybrać tekst proś do użytkownika. StandardPutFile(prompt [, default]) Wyświetla okno dialogowe „otwórz plik wyjściowy" i prosi użytkowni o wybranie pliku. Argument prompt zawiera tekst prośby do użytkowni] a default jest domyślną nazwą pliku. Funkcja zwraca tupię zawierają obiekt FSSpec i flagę wskazującą, czy użytkownik zamknął okno dialogo1

bez anulowania operaq'i. GetDirectory([prompt])

Wyświetla okno dialogowe „wybierz katalog". Argument prompt jest t( stem prośby do użytkownika. Funkcja zwraca tupię zawierającą obi( FSSpec i informację o powodzeniu całej operacji. SetFolder ([fsspec]) Ustawia folder wyświetlany domyślnie w momencie otwierania na ekrai okien dialogowych służących do wyboru pliku przez użytkownika. Ar£ ment fsspec powinien wskazywać jakiś plik w ustawianym folderze, a ] sam folder (ale nie musi to być plik istniejący). Bez podania argumentu fui cja ustawia folder na bieżący. FindFolder(where, which, create) Lokalizuje specjalny folder Macintosha, taki jak Trash czy Preferences. Ar£ ment where wskazuje dysk, który ma zostać przeszukany i zazwyczaj i wartość MACFS . kOnSystemDisk. Argument which jest czteroznakow} napisem definiującym szukany folder. (Napisy te są często podawane za j mocą symboli wymienionych na poniższej liście). Jeśli argument create ] wartość 1, a podany folder nie istnieje, zostanie utworzony. Funkcja zwn tupię (vrefn um, di rid). Zawartość tej tupli można wykorzystać jako d' pierwsze elementy 3-elementowej tupli (vrefn um, di ri d, name), rep zentującej nazwę pliku.

192 Python Zamieszczona niżej lista zawiera nazwy symboli używanych w module MACFS jako wartości argumentu which funkcji FindFolder (): kALMLocationsFolderType kALMModulesFolderType JcALMPreferencesFolderType kAppleExtrasFolderType kAppleMenuFolderType kApplicationAliasType kApplicationSupportFolderType kApplicationsFolderType kAssistantsFolderType kChewableltemsFolderType kColorSyncProfilesFolderType kContextualMenuItemsFolderType kControlPanelDisabledFolderType kControlPanelFolderType kControlStripModulesFolderType kDesktopFolderType kDocumentsFolderType kEditorsFolderType kExtensionDisabledFolderType kExtensionFolderType kFavoritesFolderType kFontsFolderType kGenEditorsFolderType kHelpFolderType klnternetPluglnFolderType kMacOSReadMesFolderType kModemScriptsFolderType kOpenDocEditorsFolderType kOpenDocFolderType kOpenDocLibrariesFolderType kOpenDocShellPluglnsFolderType kPreferencesFolderType kPrintMonitorDocsFolderType kPrinterDescriptionFolderType kPrinterDriverFolderType kScriptingAdditionsFolderType kSharedLibrariesFolderType kShutdownltemsDisabledFolderType kStartupFolderType kStartupItemsDisabledFolderType kStationeryFolderType kSystemExtensionDisabledFolderType kSystemFolderType kTemporaryFolderType kTextEncodingsFolderType kThemes Fo1de rType kTrashFolderType kUtilitiesFolderType kVoicesFolderType kVo1umeRo otFolderType kWhereToEmptyTrashFolderType NewAliasMinimalFromFullPath (pathname) Zwraca minimalny obiekt-alias wskazujący plik pa thname. Ten ostatni musi być podany w formie pełnej nazwy ścieżkowej. Jest to jedyny sposób utworzenia aliasu wskazującego plik nieistniejący. FindApplication(creator) Szuka aplikacji o czteroznakowym kodzie kreatora (creator). Funkcja zwraca obiekt FSSpec wskazujący aplikację. Instancja f obiektu FSSpec ma następujące atrybuty i metody: f.data Surowe dane kryjącego się pod f obiektu FSSpec. f. as_pathname() Zwraca pełną nazwę ścieżkową. f. as__tuple Zwraca tupię pliku (wdRefN urn, par ID, name). f.NewAlias([file] )

Tworzy obiekt Alias wskazujący plik opisany przez f. Jeśli jest podany nieobowiązkowy argument fi 1 e, tworzony jest alias względny, a w przeciwnym razie - bezwzględny. f. NewAliasMinimal () Tworzy minimalny alias wskazujący plik. Dodatek A: Biblioteka Pythona f. GetCreatorType() Zwraca czteroznakowy kod kreatora pliku. f .SetCreatorType (creator, type) Ustawia czteroznakowy kod kreatora oraz typ pliku. £.GetFInfo() Zwraca obiekt FInf o zawierający informacje Findera o pliku. f. SetFInfo(fanfo) Ustawia informacje Findera o pliku na wartości podane w obiekcie fir typu FInf o. £.GetDates() Zwraca tupię z trzema wartościami zmiennoprzecinkowymi reprez tującymi odpowiednio datę utworzenia, modyfikacji i archiwizaqi plil f.SetDates(crdate, moddate, backupdate) Ustawia datę utworzenia, modyfikaqi i archiwizacji pliku. Z kolei instanqa a obiektu Alias ma następujące metody i atrybuty: a. data Surowe dane rekordu Alias w postaci napisu binarnego. a. Resolve ([file]) Rozwiązuje alias i zwraca tupię zawierającą obiekt FSSpec dla pl wskazywanego przez alias oraz flagę informującą, czy obiekt Al i a s ZOJ zmodyfikowany w czasie procesu wyszukiwania. Jeśli plik nie istnieje, istnieje prowadząca do niego ścieżka, zwracany jest prawidłowy obi FSSpec. Nieobowiązkowy argument file jest plikiem, który trzeba ; dać, jeśli alias został utworzony pierwotnie w postaci względnej. a. Getlnf o (index) Zwraca informację o aliasie. Parametr indexzawiera kod całkowity ws żujący pobieraną informację i może mieć jedną z następujących wartoś Wartość Opis -3 Nazwa strefy -2 Nazwa serwera -1 Nazwa woluminu 0 Nazwa celu 1 Nazwa katalogu nadrzędnego

a.Update(file [, file2]) Zmienia wskazanie aliasu na plik file. Jeśli jest podany argunv file2, zostanie utworzony alias względny. Obiekt finfo typu FInf o ma następujące atrybuty: finfo .Creator Czteroznakowy kod kreatora pliku.

194 Python flnfo. Type Czteroznakowy kod typu pliku. flnfo.Flags Szesnastobitowa liczba całkowita z flagami Findera dla pliku. Wartości bitów w Flags są ustawiane za pomocą następujących stałych zdefiniowanych w module MACFS: kHasBeenlnited, kHasBundle, kHasCustomlcon, klsAlias, klslnvisible, klsOnDesk, klsShared, klsSt ationary i kNameLocked. flnfo. Location Wskaźnik podający pozycję ikony pliku w jego folderze. flnfo.Fldr Folder, w którym, jest plik (jako liczba całkowita). Zobacz także macostools (194), f indertools (182), http: //www.python.org/doc/mac (biblioteka dla Macintosha). macostools Moduł macostools zawiera funkcje do wykonywania operacji plikowych w Macintoshach. copy (src, dst [, createpath [, copytimes]]) Kopiuje plik src na dst. Jeśli wartość createpath jest różna od zera, dst musi być nazwą ścieżkową (w razie potrzeby funkcja tworzy brakujące foldery wymienione na ścieżce). Standardowo oprócz pewnych informacji Findera kopiowane są również dane i informacje dodatkowe (resource fork). Jeśli copytimes ma wartość niezerową, kopiowane są ponadto godziny utworzenia, modyfikacji i archiwizacji. Nie są natomiast kopiowane ikony niestandardowe, komentarze i pozycje ikon. Jeśli src jest aliasem, kopiowany jest oryginał wskazywany przez alias, a nie ten ostatni. copytree(src, dst) Rekurencyjnie kopiuje drzewo plików z miejsca src do dst, tworząc w razie potrzeby nieistniejące foldery, src i dst musza być napisami zawierającymi nazwy ścieżkowe. mkalias(src, dst) Tworzy alias Findera dst wskazujący src. touched(dst) Mówi Finderowi, że informacja o dst uległa zmianie i należy zaktualizować ikonę pliku oraz inne wyświetlane dla niego informacje. BUFSIZ Rozmiar bufora używanego do kopiowania (w bajtach). Standardowo jest to 1 megabajt. UWAGA • Z wyjątkiem copytree () nazwy plików mogą być przekazywane jako napisy lub obiekty FSSpec, utworzone za pomocą modułu macf s. Zobacz także macf s (190). Dodatek A: Biblioteka Pythona mmap Moduł mmap pozwala korzystać z obiektu pliku mapowanego w pamięci. Ob ten łączy w sobie cechy zarówno pliku, jak i napis, i nadaje się do użytku w w szóści przypadków, w których spodziewany jest zwykły plik lub zwykły na Co więcej, zawartość plików mapowanych w pamięci może być modyfikowi Oznacza to, że można je zmieniać za pomocą operatorów przypisania wart do indeksu, jak i wycinka. O ile nie zostało dokonane prywatne mapowanie ku, takie zmiany są przeprowadzane bezpośrednio w pliku kryjącym się ] obiektem. Pliki mapowane w pamięci są tworzone za pomocą funkqi mmap wyglądającej nieco inaczej w Uniksie i w Windows. mmap(flleno, length [, flags, prot])

(UNIX) Zwraca obiekt mmap, który mapuje length bajtów z pliku o deskr torze pliku fi len o (liczba całkowita). Parametr flags podaje sposób ma wania i ma postać alternatywy bitowej następujących wartości: Flaga MAP_PRIVATE MAP_SHARED MAP_AN0N MAP_DENYWRITE MAP EXECUTABLE Znaczenie Tworzy prywatne mapowanie z zapisywaniem w kopii. W te sposób zmiany obiektu będą widziane tylko przez bieżący proces. Mapowanie dzielone z wszystkimi innymi procesami mapującymi te same fragmenty pliku. W efekcie zmiany w obiekcie wpływają również na wszystkie pozostałe mapowar Używana podczas tworzenia anonimowego regionu pamięci dzielonej w systemie BSD. Uniemożliwia pisanie (flaga dostępna nie na wszystkich platformach). Mapowanie pamięci jako obiektu wykonywalnego (flaga dostępna nie na wszystkich platformach). Standardowo ustawiona jest flaga MAP_SHARED. Parametr prot określa bezpieczenia obiektu w pamięci i może być alternatywą bitową następując) pozycji: Ustawienie PROT_READ PROT_WRITE PROT EXEC Znaczenie Obiekt pozwala czytać dane. Obiekt pozwala modyfikować dane. Obiekt może zawierać instrukcje wykonywalne. Standardową wartością pro t jest PROT_READ | PROT_WRITE. Tryby wym nione w pro t muszą odpowiadać prawom dostępu użytym do otwarcia pli o deskryptorze f i len o. W większości przypadków oznacza to, że plik po\ nien być otwierany w trybie czytania/pisania (na przykład os . open (nam os. O RDWR)).

196 mmap(fileno, length [, tagname]) (Windows) Zwraca obiekt mmap, który mapuje length bajtów z pliku o deskryptorze pliku fileno (liczba całkowita). Plik powinien być otwarty za- równo do czytania, jak i pisania, gdyż inaczej zostanie wygenerowany błąd. Parametr tagname jest nieobowiązkowym napisem służącym do nadania nazwy mapowaniu. Jeśli tagname odnosi się do istniejącego już mapowania, zostanie ono otwarte. W przeciwnym wypadku funkcja utworzy nowe mapowanie. Jeśli tagname ma wartość None, powstanie mapowanie bez nazwy. Oto lista metod obiektu-pliku mapowanego w pamięci m: at. close () Zamyka plik. Dalsze działania będą powodowały zgłaszanie wyjątku. m.find{string [, start]) Zwraca indeks pierwszego wystąpienia napisu string. Nieobowiązkowy argument start określa miejsce rozpoczęcia poszukiwań. W przypadku nieznalezienia napisu funkcja zwraca wartość -1. m.flush([offset, size]) Zapisuje na dysku zmiany dokonane w kopii pliku trzymanej w pamięci. Nie- obowiązkowe argumenty offset i size wyznaczają zakres bajtów do zapisania. Bez nich metoda zapisuje całe mapowanie. m.move (dst, src, count) Kopiuje coun t bajtów zaczynając od indeksu src i zapisując od indeksu ds t. Kopiowanie odbywa się przy użyciu funkcji C memmove (), co gwarantuje poprawne działanie również w sytuacji, gdy obszar źródłowy i docelowy za- chodzą na siebie. at. read (n) Czyta do n bajtów zaczynając od bieżącej pozycji w pliku i zwraca dane w postaci napisu. m.read_byte() Wczytuje jeden bajt z bieżącej pozycji w pliku i zwraca go w postaci napisu o długości 1. m.readline() Wczytuje jedną linię zaczynając od bieżącego miejsca w pliku. at. resize {newsize) Zmienia wielkość obiektu mapowanego w pamięci na news i ze bajtów. m. seek (pos [, whence]) Ustawia nową pozycję bieżącą w pliku. Argumenty pos i whence mają to samo znaczenie, co w przypadku metody seek () obiektów-plików. m.size () Zwraca długość pliku. Wartość ta może być większa od rozmiaru obszaru mapowanego w pamięci. m. tell () Zwraca wartość wskaźnika pliku. at. write {string) Zapisuje bajty napisu string w miejscu pamięci zgodnym z bieżącym UJ wieniem wskaźnika pliku. at. write_byte {byte) Zapisuje pojedynczy bajt w miejscu pamięci zgodnym z bieżącym ustav niem wskaźnika pliku. UWAGI • Niektóre mapowania pamięci mogą działać tylko dla obszarów będących wielokrotnością strony pamięci, V rozmiar podaje stała mmap. PAGES I ZE. • W systemach Unix SVR4 anonimowe mapowania pamięci można uzyskać wywołując mmap () dla /dev/zero, otwartego z odpowiednimi uprawnieniami. • W systemach Unix BSD anonimowe mapowania pamięci można uzyskać wywołując mmap () z ujerr deskryptorem pliku i flagą mmap. MAP_ANON.

msvcrt Moduł msvcrt umożliwia dostęp do wielu przydatnych funkcji biblioteki ru me Microsoft Visual C. getch() Odczytuje naciśnięty klawisz i zwraca odpowiedni znak. Jeśli żaden klav nie został naciśnięty, funkcja blokuje dalsze wykonanie. Jeśli naciśnięty wisz jest specjalnym klawiszem funkcyjnym, wywołanie getch () zwi wartość ' \ O O O ' lub ' \ xe O ', a dopiero następne wywołanie zwraca kod wiszą. Odczytane znaki nie są wyświetlane na konsoli. Ponadto funkcja potrafi odczytać kombinacji klawiszy [Ctrl+C]. getche() Działa podobnie jak getch (), ale odczytany znak jest wyświetlany na e' nie (o ile jest drukowalny). ge t__os f handle (fd) Zwraca uchwyt pliku dla deskryptora podanego w fd. Nierozpoznany skryptor powoduje zgłoszenie wyjątku IOError. heapmin() Zmusza wewnętrznego menedżera pamięci Pythona do zwrócenia nieuży nych bloków pamięci systemowi operacyjnemu. Funkcja ta działa tylko w V dows NT i w przypadku niepowodzenia zgłasza wyjątek IOError. kbhit() Zwraca wartość prawda, jeśli został naciśnięty klawisz, i czeka na wczytar locking(£d, mode, nbytes) Blokuje fragment pliku dla podanego deskryptora fd z biblioteki runtim nbytes jest liczbą blokowanych bajtów zaczynając od bieżącej po2 wskaźnika pliku, mode może przyjmować jedną z następujących war! całkowitych:

198 ryinon OS Ustawienie Opis Odblokowuje region pliku (LKJJNLCK). Blokuje region pliku (LK_LOCK). Blokuje region pliku; wymaga braku blokady (LK_NBLCK). Blokuje przed zapisem (LK_RLCK). Blokuje przed zapisem; wymaga braku blokady (LK_NBRLCK). Jeśli próba nałożenia blokady przedłuża się do około dziesięciu sekund, powoduje to błąd. open__osfhandle (handle, flags) Tworzy deskryptor pliku typu „runtime" C z uchwytu pliku handle. Argu- ment flags jest alternatywą bitową wartości os . O_APPEND, os . O_RDONLY i os .O_TEXT. Funkcja zwraca całkowity deskryptor pliku, którego można użyć jako parametru os . f dopen () w celu utworzenia obiektu-pliku. putch(char) Wyświetla znak char na konsoli bez jego buforowania. setmode(fd, flags) Ustawia tryb tłumaczenia końca linii dla deskryptora pliku fd. flags ma war- tość os . O_TEXT dla trybu tekstowego, a os . O_BINARY dla trybu binarnego. ungetch( char) Powoduje wstawienie znaku char do bufora konsoli. Będzie on następnym znakiem odczytanym przez getch () lub getche (). UWAGI • Istnieje szeroka gama rozszerzeń Win32, które umożliwiają dostęp do Microsoft Foundation Classes, składników COM, graficznych interfejsów użytkownika i tak dalej. Tematy te wykraczają jednak poza zakres tej książki. Szczegółowe informacje o niektórych z nich można znaleźć w Python Programming on Win32 Marka Hammonda i Andy'ego Robinsona (O'Reilly & Associates, 1999). Ponadto obszerną listę stosownych modułów dla systemu Windows można znaleźć pod-adresem http: / /www. python. org. Zobacz także _winreg (232). Moduł os oferuje przenośny interfejs typowych usług systemu operacyjnego. Działanie modułu polega na szukaniu wbudowanego modułu zależnego od systemu operacyjnego, takiego jak mac czy po six, i eksportowaniu takich samych funkcji i danych, jak te, które tam występują. O ile nie jest zaznaczone inaczej, funkcje tego modułu są dostępne dla systemu Windows, MacOS i Unix. Oto lista zdefiniowanych zmiennych o charakterze ogólnym: environ Obiekt mapujący reprezentujący aktualne zmienne środowiskowe. Zmiany w tym obiekcie znajdują odbicie w środowisku. uoaateK A: bioiioteKa tytnona linesep Napis używany do oddzielania linii w bieżącym systemie. Może to być p dynczy znak, jak ' \n' w standardzie POSIX czy ' \r' w MacOS, albo k znaków, jak '\r\n' w Windows. name Nazwa importowanego modułu zależnego od systemu operacyjnego: ' six1, 'nt', 'dos', 'mac' lub 'os2'. path Standardowy moduł zależny od systemu operacyjnego do działania na śc kach. Moduł ten można również załadować przy użyciu os . path. ŚRODOWISKO PROCESU Podane w tej części funkcje umożliwiają dostęp (wraz z modyfikowaniem różnych parametrów związanych ze środowiskiem, w którym wykonuje się ces. Jeśli nie jest zaznaczone inaczej, identyfikatory (ID) procesu, grupy, gr procesów i sesji są liczbami całkowitymi. chdir (path)

Zmienia aktualny katalog roboczy na pa th. ctermidO Zwraca napis z nazwą pliku terminalu sterującego procesu. Unix. getcwd() Zwraca napis z aktualnym katalogiem roboczym. getegid() Zwraca efektywny identyfikator grupy. Unix. geteuid() Zwraca efektywny identyfikator użytkownika. Unix. getgid() Zwraca rzeczywisty identyfikator grupy procesu. Unix. getgroups() Zwraca listę całkowitych identyfikatorów grup, do których należy właśc procesu. Unix. getpgrpO Zwraca identyfikator bieżącej grupy procesów. Grupy procesów są używ zazwyczaj przy okazji kontroli zadań. Identyfikator grupy procesów jest koniecznie taki sam, jak ID grupy procesu. Unix. getpid() Zwraca rzeczywisty identyfikator grupy bieżącego procesu. Unix i Windo getppid() Zwraca identyfikator procesu nadrzędnego bieżącego procesu. Unix. getuid() Zwraca rzeczywisty identyfikator użytkownika bieżącego procesu. Unix

200 Python Dodatek A: Biblioteka Pythona putenv (vamame, value) Ustawia wartość zmiennej środowiskowej vamarne na value. Zmiany wpływają na podprocesy uruchomione za pomocą os . system (), popen (), fork () iexecv () .Przypisywanie wartości do elementów os. environ powoduje automatycznie wywołanie putenv (). Natomiast wywołania putenv () nie aktualizują os. environ. Unix i Windows. setgid(gid) Ustawia identyfikator grupy bieżącego procesu. Unix. setpgrp() Tworzy nową grupę procesów za pomocą wywołania systemowego setpgrp () lub setpgrp (0, 0), w zależności od tego, która wersja jest zaimplementowana (o ile są w ogóle dostępne). Funkcja zwraca identyfikator nowej grupy procesów. Unix. setpgid (pld, pgrp) Przypisuje proces o identyfikatorze pid do grupy procesów pgrp. Jeśli pid ma tę samą wartość co pgrp, proces dołącza do istniejącej grupy. Jeśli pi d ma wartość 0, używany jest identyfikator procesu wywołującego. Jeśli pgrp ma wartość 0, proces podany w pid staje się nadzorcą grupy procesów. Unix. setreuid(ruid, euid) Ustawia rzeczywisty (ruid) i efektywny (euid) identyfikator użytkownika procesu wywołującego. Unix. setregid(rgid, egid) Ustawia rzeczywisty (rgid) i efektywny (egid) identyfikator grupy procesu wywołującego. Unix. setsid() Tworzy nową sesję i zwraca jej identyfikator. Sesje są zazwyczaj związane z terminalami i kontrolą procesów uruchomionych w ich trakcie. Unix. setuid(uid) Ustawia rzeczywisty identyfikator użytkownika bieżącego procesu. Jest to funkcja uprzywilejowana i często może być wykonywana tylko przez proces uruchomiony na poziomie roota. Unix. strerror (code) Zwraca komunikat błędu odpowiadający wartości całkowitej kodu błędu code. Unix i Windows. Zobacz także errno (172) umask (mask) Ustawia wartość umask i zwraca poprzednie ustawienie tej maski. Służy ona do usuwania bitów uprawnień w plikach tworzonych przez proces. Unix i Windows. Zobacz także os. open (203) uname () Zwraca tupię napisów (sysname, nodename, release, version, machine) identyfikującą rodzaj systemu. Unix. TWORZENIE PLIKÓW IDESKRYPTORY PLIKÓW Podane tutaj funkcje stanowią interfejs niskiego poziomu do działań na plil i łączach. W funkqach tych pliki są identyfikowane za pomocą deskryptor. będącego liczbą całkowitą. Deskryptor pliku można uzyskać z obiektu pl wywołując jego metodę f ileno (). close(fd) Zamyka deskryptor pliku fd zwrócony uprzednio przez open () lub pipe dup(ftf)

Duplikuje deskryptor pliku fd. Zwraca nowy deskryptor pliku, który jest mniejszym deskryptorem pliku nieużywanym przez proces. Nowy i stary skryptor pliku mogą być używane zamiennie. Co więcej, współużytkują takie elementy, jak bieżący wskaźnik pliku i nałożone blokady. Unix i V dows. dup2(oldfd, newfd) Kopiuje deskryptor pliku oldfd na newfd. Jeśli newfd odpowiada uży nemu już deskryptorowi pliku, zostanie on najpierw zamknięty. Unix i V dows. fdopen(£d [, mode [, bufsize]]) Zwraca otwarty obiekt-plik odpowiadający deskryptorowi fd. Argurm mode i bufsize mają to samo znaczenie, co w przypadku funkcji wbudo nej open (). fpathconf(fd, name) Zwraca wartości konfigurowalnych zmiennych systemowych związar z otwartym plikiem o deskryptorze fd. Argument name jest napisem za^ rającym nazwę pobieranej wartości. Sama wartość pochodzi zazwyczaj od p metru zawartego w systemowym pliku nagłówkowym, takim jak <limits czy <unistd. h>. POSIX definiuje następujące nazwy dla name: Stała Opis "PC_ASYNC_IO" Wskazuje, czy można wykonywać asynchroniczne

operaqe I/O na fd. "PC_CHOWN_RESTRICTED"

Wskazuje, czy można używać funkcji chown (). Jeś

fd odnosi się do katalogu, dotyczy to wszystkich zawartych w nim plików. "PC_FILESIZEBITS" Maksymalny rozmiar pliku. "PC_LINK_MAX" Maksymalna liczba dowiązań do pliku. "PC_MAX_CANON" Maksymalna długość sformatowanej linii

wejściowe fd odnosi się do terminala. "PC_MAX_INPUT" Maksymalna długość linii wejściowej, fd odnosi

się terminala.

"PC_NAME_MAX" Maksymalna długość nazwy pliku w katalogu.

'PC_NO_TRUNC" Wskazuje, czy próba utworzenia w katalogu pliku o nazwie dłuższej niż PC NAME MAX

spowoduje błą ENAMETOOLONG.

202 Python Stała "PC_PATH_MAX" "PC_PIPE_BUF" "PC_PRIO_IO" "PC_SYNC_IO" "PC VDISABLE" Opis Maksymalna długość względnej nazwy ścieżkowej, gdy katalog fd jest bieżącym katalogiem roboczym. Rozmiar bufora łącza, gdy fd odnosi się do łącza lub FIFO. Wskazuje, czy można wykonywać na fd priorytetowe operacje I/O. Wskazuje, czy można wykonywać na fd synchroniczne operacje I/O. Wskazuje, czy fd pozwala blokować przetwarzanie znaków specjalnych, fd musi odnosić się do terminala. Nie wszystkie nazwy są dostępne na każdej platformie. Ponadto niektóre systemy mogą definiować własne, dodatkowe parametry. Listę nazw znanych systemowi operacyjnemu można znaleźć w katalogu os . pathconf_names. Jeśli jakaś nazwa konfiguracyjna nie występuje w os .pathconf_names, przez name można również przekazać jej wartość całkowitą. Nawet gdy nazwa jest znana Pythonowi, funkcja nadal może zgłaszać wyjątek OSError, je- śli rodzimy system operacyjny nie rozpozna parametru lub nie będzie mógł go skojarzyć z deskryptorem pliku fd. Funkcja ta jest dostępna tylko w nie- których wersjach Uniksa. fstat(£d) Zwraca status deskryptora pliku fd. Jest to taka sama wartość, jak w przypadku funkcji os . stat (). Unix i Windows. fstatvfs (fd) Zwraca informaqe o systemie plików zawierającym plik skojarzony z deskryptorem fd. Jest to taka sama wartość, jak w przypadku funkcji os.statvfs(). Unix. ftruncate(fd, length) Obcina plik skojarzony z deskryptorem fd, tak aby miał co najwyżej length bajtów. Unix. lseek (fd, pos, how) Ustawia bieżące położenie deskryptora pliku fd na pozycji pos. Argument ho w może mieć jedną z następujących wartości: 0 oznacza pozycję względem początku pliku, 1 oznacza pozycję względem bieżącego położenia, a 2 oznacza pozyqe względem końca pliku. open (file [, flags [, mode]]) Otwiera plik file. Argument flags jest alternatywą bitową następujących stałych: Stała Opis O_RDONLY Otwarcie pliku do czytania. O_WRONLY Otwarcie pliku do pisania. 0_RDWR Otwarcie pliku do czytania i pisania (aktualizacja). O_APPEND Dodawanie bajtów na końcu pliku. Dodatek A: Biblioteka Pythona Stała Opis O_CREAT Utworzenie pliku, jeśli nie istnieje. O_NONBLOCK Bez blokowania przy otwieraniu, czytaniu lub pisaniu (Unix). O_NDELAY To samo co 0 NONBLOCK (Unix). O_DSYNC Pisanie synchroniczne (Unix). O_NOCTTY Otwieranie urządzenia bez ustawiania terminalu sterującego

(Unix). OJTRUNC Skrócenie istniejącego pliku do zerowej długości. O_RSYNC Czytanie synchroniczne (Unix). O_SYNC Pisanie synchroniczne (Unix). O_EXCL Jeśli występuje stała O_CREAT i plik już istnieje, powoduje

to b O_TEXT Tryb tekstowy (Windows). O_BINARY Tryb binarny (Windows). Synchroniczne tryby I/O (O_SYNC, O_DSYNC, O_RSYNC) wymuszają t kowanie operacji wejścia/wyjścia aż do swojego zakończenia na pozioi sprzętowym (na przykład zapis synchroniczny nakłada blokadę do mome: fizycznego zapisania danych na dysku). Parametr mode zawiera prawa do! pu do pliku reprezentowane w postaci alternatywy bitowej następując wartości ósemkowych: Tryb Znaczenie 0100 Użytkownik ma prawo wykonywania. 0200 Użytkownik ma prawo pisania. 0400 Użytkownik ma prawo czytania. 0010 Grupa ma prawo wykonywania. 0020 Grupa ma prawo pisania. 0040 Grupa ma prawo czytania. 0001 Pozostali mają prawo wykonywania. 0002 Pozostali mają prawo pisania. 0004 Pozostali mają prawo czytania. Standardowym trybem pliku jest (0777 & -umask), gdzie ustawie umask służy do odbierania wybranych praw dostępu. Na przykład urna o wartości 0022 odbiera prawo pisania grupie i pozostałym. Wartość urna można zmienić za pomocą funkcji umask (). Ustawienie umask nie ma z czenia w Windows ani w Macintoshu. openptyO Otwiera pseudoterminal i zwraca parę deskryptorów pliku (maste slave) dla PTY i TTY. Funkcja dostępna w niektórych wersjach Unik pipe() Tworzy łącze umożliwiające nawiązanie jednokierunkowej łączności z nym procesem. Zwraca parę deskryptorów pliku (r, iv) służących od

204 Python wiednio do czytania i pisania. Funkcja pipe () jest zwykle wywoływana przed funkqa f ork (). Po wywołaniu tej ostatniej proces wysyłający zamyka koniec łącza do czytania, a proces odbierający zamyka koniec łącza do pisania. W tym momencie łącze jest już aktywne i można przesyłać nim dane z jednego procesu do drugiego za pomocą funkcji read () i write (). Unix. popen (command [, mode [, bufsize] ]) Otwiera łącze „do" lub „z" polecenia cmd. Wartością powrotną jest otwarty obiekt-plik przypisany do łącza, umożliwiający czytanie lub pisanie w zale- żności od tego, czy argument mode ma wartość ' r • (wartość domyślna), czy ' w'. bu fsize ma to samo znaczenie co w przypadku funkcji wbudowanej open (). Status wyjścia z polecenia jest zwracany przez metodę close () obiektu-pliku zwracanego przez funkqe popen (). Jedyny wyjątek stanowi status wyjścia równy 0, który powoduje zwrot obiektu None. popen2(cmd [, bufsize [, mode]]) Wykonuje polecenie cmd jako podproces i zwraca obiekty-pliki (child_stdin, child_stdout). bufsize podaje rozmiar bufora. mode ma wartość ' t' lub • b', oznaczającą odpowiednio tryb tekstowy lub binarny (jest to istotne w przypadku systemu Windows). popen3(cmd [, bufsize [, mode]]) Wykonuje polecenie cmd jako podproces i zwraca trzy obiekty-pliki (child_stdin, child_stdout, child_stderr). popen4(cmd [, bufsize [, mode]]) Wykonuje polecenie cmd jako podproces i zwraca dwa obiekty-pliki (child_stdin, child_stdout_stderr), w których standardowy strumień wyjściowy i standardowy strumień diagnostyczny są ze sobą połączone. read(fd, n) Wczytuje co najwyżej n bajtów z pliku o deskryptorze fd. Zwraca napis zawierający pobrane bajty. tcgetpgrp(£d) Zwraca grupę procesów skojarzoną z terminalem sterującym podanym w fd. Unix. tcsetpgrp(£d, pg) Ustawia grupę procesów skojarzoną z terminalem sterującym podanym w fd. Unix. ttyname(ird) Zwraca napis wskazujący terminal skojarzony z deskryptorem pliku fd. Jeśli podany deskryptor nie jest skojarzony z urządzeniem terminalowym, następuje zgłoszenie wyjątku. Unix. write (fd, str) Zapisuje napis str w pliku skojarzonym z deskryptorem fd. Zwraca licz- bę bajtów faktycznie zapisanych. Dodatek A: Biblioteka Pythona PLIKI I KATALOGI Omawiane w tej części funkcje i zmienne służą do wykonywania działań na kach i katalogach systemu plików. Aby można było sobie poradzić z różnj schematami nazw plików, dostępne są następujące zmienne zawierające im macje o konstruowaniu nazw ścieżkowych: Zmienna altsep curdir pardir pathsep sep

Opis Alternatywny znak używany przez system operacyjny do oddzielania składników nazwy ścieżkowej lub None, jeśli istnieje tylko jeden separator. W systemach DOS i Windows, gdzie sep jest odwrotnym ukośnikiem, jest to znak ' / '. Napis używany w celu odwołania się do bieżącego katalogu roboczego W systemach Unix i Windows jest to znak ' . ', a w Macintoshu ' : '. Napis używany w celu odwołania się do katalogu nadrzędnego. W systemach Unix i Windows jest to znak ' . . ', a w Macintoshu ' : : Znak używany do oddzielania składników ścieżki (występujący w zmiennej środowiskowej $PATH): ' : ' w Uniksie i '; ' w DOS-ie o: w Windows. Znak używany do oddzielania składników nazwy ścieżkowej: ' / ' w Uniksie i Windows, a ' : ' w Macintoshu. Oto wykaz funkcji służących do wykonywania działań na plikach: access(path, accessmode) Sprawdza, czy istnieje plik pa th lub czy bieżący proces ma do niego pra' dostępu czytaj/pisz/wykonuj. accessmode może mieć jedną z nas pujących wartości: R_OK, W_OK, X_OK lub F_OK, oznaczających odpowied] czytanie, pisanie, wykonywanie i istnienie. Jeśli wymienione prawo jest pr; znane, funkcja zwraca 1, a w przeciwnym wypadku 0. Unix. chmod(path, mode) Zmienia tryb pa th. mode może przyjmować te same wartości, co w przypć ku opisanej już funkcji open (). Unix i Windows. chown (path, uid, gid) Zmienia identyfikator właściciela i grupy pliku pa th na podane wartości r ^-_jneryczne uid i gid. Unix. getbootvol() Zwraca nazwę dysku startowego. Macintosh. link (src, dst) Tworzy dowiązanie „twarde" o nazwie dst wskazujące src. Unix. listdir(path) Zwraca listę zawierającą nazwy pozyq'i w katalogu path. Nazwy te uporządkowane w dowolny sposób i nie obejmują katalogów speq'alny • ' i ' '

206 Python Istat(path) Działa podobnie jak stat mi. Unix. , ale nie podąża za dowiązaniami symboliczny- mkf if o (path [, mode]) Tworzy plik FIFO (łącze nazwane) o nazwie pa th i numerycznie podanych prawach dostępu mode. Standardowe prawa dostępu to 0 6 6 6. Unix. mkdir (path [, mode]) Tworzy katalog o nazwie pa th i numerycznie podanych prawach dostępu mode. Standardowe prawa dostępu to 0777. W systemach nieuniksowych ustawienie mode może być ignorowane. makedirs (path [, mode]) Funkcja rekurencyjnie tworząca katalog. Podobna do mkdir (), ale potrafi utworzyć całą ścieżkę brakujących katalogów pośrednich. Jeśli ostatni na ście- żce katalog już istnieje lub nie można go utworzyć, funkcja zgłasza wyjątek OSError. pathconf(path, name) Zwraca konfigurowalne parametry systemu związane z nazwą ścieżkową path, name jest napisem zawierającym nazwę parametru i ma takie samo znaczenie, jak w opisanej już wcześniej funkcji f pathconf (). Unix. Zobacz także f pathconf (201). readlink (path) Zwraca napis reprezentujący ścieżkę do pliku wskazywanego przez dowiąza- nie symboliczne pa th. Unix. remove (path) Usuwa plik pa th. Działa identycznie jak funkcja unl ink (). removedirs (path) Funkcja rekurencyjnie usuwająca katalog. Podobna do rmdir (), tyle że po udanym usunięciu katalogu liścia idzie „w górę" i usuwa kolejne puste katalogi nadrzędne aż do usunięcia całej ścieżki lub wystąpienia błędu (ignorowa- nego, gdyż oznacza on w praktyce napotkanie katalogu niepustego). Nieudana próba usunięcia katalogu liścia powoduje zgłoszenie wyjątku OSError. rename(src, dst) Zmienia nazwę pliku lub katalogu src na dst. renames (old, new) Funkcja rekurencyjnie zmieniająca nazwy katalogów lub plików. Działa podobnie jak rename (), tyle że najpierw próbuje utworzyć wszystkie katalogi pośrednie, występujące w nazwie ścieżkowej new, a po zmianie nazw próbuje usunąć za pomocą removedirs () kolejne (idąc „od dołu") puste katalogi nazwy ścieżkowej old. rmdir (path) Usuwa katalog path. Dodatek A: Biblioteka Pytona stat(path) Wywołuje funkcję systemową stat () dla podanego pliku pa th, w celu uzy; nia informacji o nim. Wartością powrotną jest tupla przynajmniej 10 liczb ca witych w kolejności: st_mode, st_ino, st_dev, st_nlink, st_uid, st_c st_size, st_atime, st_mtime, st_ctime. Niektóre implementacje m dodawać jeszcze inne elementy na końcu tej listy, a platformy nieuniksowe sują w pewnych miejscach tej listy wartości fikcyjne. Standardowy moduł s definiuje funkcje i stałe ułatwiające pobieranie informaqi z tej tupli. statvfs(path) Wywołuje funkcję systemową statvf s () dla podanego pliku pa th, w ( uzyskania informacji o systemie plików. Wartością powrotną jest tupla p] najmniej 10 liczb całkowitych w kolejności: f_bsize, f_frs± ze, f_bl oc f_bfree, f_bavail, f_files, f__ffree, f_favail, f_flag, f_namen Standardowy moduł statvf s definiuje stałe ułatwiające pobieranie infor: qi z tej tupli. Unix.

symlink (src, dst) Tworzy dowiązanie symboliczne o nazwie dst wskazujące src. sync() Dokonuje synchronizacji systemu plików. Macintosh. unlink (path) Usuwa plik pa th. To samo co remove (). utime (path, (atime, mtime)) Ustawia datę ostatniego dostępu i modyfikacji pliku pa th na podane wa ści a time i mtime. (Drugi argument funkcji jest dwuelementową tupią). E mają postać liczb zwracanych przez funkcję time. time (). xstat (path) Działa podobnie jak stat (), ale zwraca tupię z trzema dodatkowymi poi zawierającymi wielkość resource fork, czteroznakowy kod kreatora i kod ty Macintosh. ZARZĄDZANIE PROCESAMI Oto lista funkcji i zmiennych używanych do tworzenia procesów, usuwania i zarządzania nimi: abort () Przesyła sygnał SIGABRT do procesu wywołującego. Jeśli nie zostanie przechwycony przez procedurę obsługi sygnału, wykonanie procesu zaŁ czy się standardowo błędem. defpath Zmienna ta zawiera domyślną ścieżkę poszukiwań używaną przez fun! exec*p* (), jeśli w środowisku nie ma zdefiniowanej zmiennej ' PATH'. execl(path, argO, argl, ...) Funkcja równoważna execv (path, (argO, argl, . . .) ) .UnixiWindo

208 Python execle (path, argO, argl, ..., env) Funkcja równoważna execve (path, (argO, argl, . . .) , env). Unix i Windows. execlp(path, argO, argl, ...) Funkcja równoważna execvp (path, (argO, argl, ...)). Unix i Win- dows. execv(path, args) Uruchamia program wykonywalny path z listą argumentów args, zastę- pując nim proces bieżący (czyli interpreter Pythona). Lista argumentów może być tupią lub listą napisów. Unix i Windows. execve (path, args, env) Uruchamia nowy program podobnie jak execv (), ale akceptuje dodatkowo słownik env definiujący środowisko, w którym wykonywany jest program. Słownik env musi mapować napisy na napisy. Unix i Windows. execvp (path, args) Funkqa podobna do execv (path, args), ale powiela działania shella w zakresie szukania pliku wykonywalnego na liście katalogów. Lista ta jest pobierana z environ [' PATH' ]. Unix i Windows. execvpe(pa th, args, env) Funkcja podobna do execv (path, args), ale korzysta z dodatkowej zmiennej środowiskowej, jak funkcja execve (). Unix i Windows. _exit(u) Powoduje natychmiastowy powrót do systemu ze statusem n, bez jakiegokolwiek „sprzątania". Uwaga: Standardowym sposobem wychodzenia z progra- mów Pythona jest wywołanie sys . exit (n). Unix i Windows. fork() Tworzy proces potomny. W nowo utworzonym procesie potomnym zwraca 0, a w procesie oryginalnym ID procesu potomnego. Proces potomny jest klo- nem oryginalnego procesu i dzieli z nim wiele zasobów, takich jak otwarte pliki. Unix. forkptyO Tworzy proces potomny, używając pseudoterminala jako terminala ste- rującego procesu potomnego. Zwraca parę (pid, f d), w której pid ma war- tość 0 w procesie potomnym, a fd jest deskryptorem pliku nadrzędnego końca pseudoterminala. Funkqa ta jest dostępna tylko w niektórych wersjach Uniksa. kill (pid, sig) Wysyła do procesu pid sygnał sig. Listę nazw sygnałów można znaleźć w module signal. Unix. nice (increment) Dodaje wartość incremen t do priorytetu wybierania procesu. Zwraca nową wartość priorytetu. Użytkownicy mogą zazwyczaj tylko zmniejszyć priorytet procesu, gdyż jego zwiększenie wymaga uprawnień roota. Unix. Dodatek A: Biblioteka Pythona plock (op) Blokuje segmenty programu w pamięci, zapobiegając ich przenoszeniu di szaru wymiany. Wartością op jest liczba całkowita wskazująca blokowane menty. Wartość op zależy od platformy, ale zazwyczaj jest to UNL PROCLOCK, TXTLOCK lub DATLOCK. Stałe te nie są definiowane przez Pytł ale można je znaleźć w pliku nagłówkowym <sys/lock. h>. Funkcja ta ni dostępna na wszystkich platformach i często może być wywoływana tylko j proces z efektywnym identyfikatorem użytkownika równym zero (roota). U spawnv(mode, path, args) Uruchamia program pa th w nowym procesie, przekazując argumenty p ne w args jako parametry linii polecenia, args może być listą lub ti Pierwszy element args powinien zawierać nazwę programu, mode może jedną z następujących stałych: Stała P_WAIT P_NOWAIT

P_NOWAITO P_OVERLAY P DETACH Opis Uruchamia program i czeka na jego zakończenie. Zwraca kod w] cia tego programu. Uruchamia program i zwraca uchwyt procesu. To samo co P_NOWAIT. Uruchamia program i usuwa proces wywołujący (to samo co fun exec). Uruchamia nowy program i odłącza się od niego. Proces wywołu wykonuje się dalej, ale nie może czekać na proces utworzony prz siebie. Funkcja spawnv () jest dostępna w Windows i w niektórych wersjach Uni" spawnve(mode, path, args, env) Uruchamia program pa th w nowym procesie, przekazując argumenty pc ne w args jako parametry linii polecenia i zawartość słownika mapując env jako środowisko, args może być listą lub tupią, mode ma to samo i czenie co w spawnv (). Windows i Unix. startfile (path) Uruchamia aplikację z pliku path. Jest to to samo, co dwukrotne klikni< pliku w Eksploratorze Windows. Powrót z funkqi następuje zaraz po wys towaniu aplikaqi. Co więcej, nie ma sposobu, aby zaczekać na zakończeni ostatniej lub uzyskanie jej kodu wyjścia. Ścieżka pa th jest podana względ katalogu bieżącego. Windows. sys tern( command) Wykonuje polecenie command (napis) w podshellu. W Uniksie funkcja zw ca status wyjścia procesu taki jak w a i t (). W systemie Windows kodem w; cia jest zawsze 0. Unix i Windows. times () Zwraca pięcioelementową tupię z liczbami zmiennoprzecinkowymi, ; dającymi kumulowane czasy wykonania w sekundach. W przypadku Uni]

210 Python tupla zawiera czas wykonania procesu w trybie użytkownika, w trybie systemu, potomków w trybie użytkownika i systemu oraz cały miniony czas. W przypadku Windows tupla zawiera czas wykonania w trybie użytkowni- ka, systemu oraz zera w miejsce trzech pozostałych wartości. Unix i Windows. Nie działa w systemach Windows 95 i Windows 98. wait ([pid]) Czeka na zakończenie procesu potomnego i zwraca tupię zawierającą status wyjścia i identyfikator tego procesu. Status wyjścia jest 16-bitową liczbą z dol- nym bajtem reprezentującym numer sygnału, który zabił proces, i górnym bajtem reprezentującym status wyjścia (jeśli numerem sygnału jest zero). Gó- rny bit dolnego bajtu ma wartość 1, jeśli doszło do utworzenia pliku core. Ar- gument pid, jeśli występuje, podaje identyfikator procesu, na który ma czekać funkcja. Bez niego powrót z wai t () następuje po zakończeniu dowolnego procesu potomnego. Unix. waitpid (pid, options) Czeka na zmianę stanu procesu potomnego wskazanego za pomocą jego identyfikatora pid. Funkcja zwraca tupię zawierającą ID procesu i wskazanie statusu wyjścia, zakodowane tak samo, jak w przypadku wait (). Argument options powinien mieć wartość 0 (zwykłe działanie) lub WNOHANG (pozwala uniknąć zawieszenia, gdy nie można natychmiast uzyskać statusu żadnego procesu potomnego). Funkcja waitpidO może być również używana do zbierania informacji o procesach potomnych, które przestały się wykonywać z jakiegoś powodu (szczegółowe informacje można znaleźć w dokumentacji online Uniksa pod hasłem wai tpid). Unix. Oto lista funkqi pobierających kod statusu procesu, taki jaki zwraca waitpidO, umożliwiających sprawdzanie stanu procesu (tylko Unix): WIFSTOPPED{status) Zwraca wartość prawda, jeśli proces się zatrzymał. WIFSIGNALED{status) Zwraca wartość prawda, jeśli proces zakończył się z powodu sygnału. WIFEXITED(status) Zwraca wartość prawda, jeśli proces zakończył się na skutek wywołania systemowego exit (). WEXITSTATUS (status) Jeśli WIFEXITED () jest prawdą, funkcja zwraca parametr całkowity wywołania systemowego exit (). W przeciwnym razie funkcja zwraca nic nie znaczącą wartość. WSTOPSIG(status) Zwraca sygnał, który spowodował zatrzymanie procesu. WTERMSIG(status) Zwraca sygnał, który spowodował wyjście z procesu. Dodatek A: Biblioteka Pythona KONFIGURACJA SYSTEMU Oto funkcje używane do pobierania informacji o konfiguracji systemu: confstr(name) Zwraca napis będący wartością systemowej zmiennej konfiguracyjnej. n, jest napisem zawierającym nazwę zmiennej. Dopuszczalne nazwy zaleźć konkretnej platformy. Nazwy znane lokalnemu systemowi operacyjne można znaleźć w słowniku os . conf str_names. Jeśli nie ma zdefiniowi wartości dla podanej zmiennej konfiguracyjnej, funkq'a zwraca pusty na Jeśli zmienna name jest nieznana, funkcja zgłasza wyjątek ValueErr Może również dojść do zgłoszenia OSEr ror, jeśli rodzimy system operac) nie udostępnia podanej zmiennej konfiguracyjnej. Parametry zwracane pi funkcję odnoszą się głównie do roboczego środowiska danego kompu

i obejmują ścieżki narzędzi systemowych, opcje kompilatorów dla różn konfiguracji programów (na przykład 32-bitowych lub 64-bitowych, obs! dużych plików i tak dalej) oraz opq'e programu łączącego (linkera). Unix sysconf(name) Zwraca całkowitą wartość systemowej zmiennej konfiguracyjnej. name napisem zawierającym nazwę zmiennej. Dopuszczalne nazwy zależą od 1 kretnej platformy. Nazwy znane lokalnemu systemowi operacyjnemu mo znaleźć w słowniku os . sysconf_names. Jeśli nie ma zdefiniowanej wa ści dla podanej zmiennej konfiguracyjnej, funkcja zwraca wartość -l.Wpi padku innych błędów może dojść do zgłoszenia OSError lub ValueEri W niektórych systemach może być zdefiniowanych ponad 10 różnych p, metrów. Zamieszczona niżej tabela zawiera parametry zdefiniowane pi POSIX.1, które powinny być dostępne w większości systemów uniksowy Parametr Opis "SC_ARG_MAX" Maksymalna długość argumentów, których można użyć w exec(). "SC_CHILD_MAX" Maksymalna liczba procesów z tym samym

identyfikato użytkownika. "SC_CLK_TCK" Liczba taktów zegara na sekundę. "SC_NGROUPS_MAX" Maksymalna liczba równoczesnych identyfikatorów

gru dodatkowych.

"SC STREAM MAX" Maksymalna liczba strumieni otwartych jednocześnie pr

proces. "SC_TZNAME_MAX" Maksymalna liczba bajtów w nazwie strefy czasowej. "SC_OPEN_MAX" Maksymalna liczba plików otwartych jednocześnie

przei proces. "SC_JOB_CONTROL" System umożliwia kontrolę zadań. "SC_SAVED_IDS" Wskazuje, czy każdy proces ma zachowywane SUID i

SC

212 Python WYJĄTEK error Wyjątek zgłaszany w przypadku zwrócenia przez funkcję błędu związanego z systemem. Jest to to samo co wbudowany wyjątek OSError. Wyjątek dostar- cza dwie wartości: er r no i s t re r r. Pierwsza z nich zawiera wartość całkowitą błędu, opisaną przy okazji modułu errno, a druga napis z komunikatem o błędzie. W przypadku błędów związanych z systemem pliku dochodzi do tego jeszcze jeden atrybut, filename, który jest nazwą pliku przekazaną do funkcji. PRZYKŁAD Zamieszczony przykład używa modułu os do implementacji minimalnego shella Uniksa, uruchamiającego programy i wykonującego przekierowania wejścia/ wyjścia: import os, sys, string print 'Witaj w shellu Pythona! 1 while 1: poi = string.split(raw_input('pysh % ')) if not pol: continue nazwaprog = pol[0] plikwy = None plikwe = None arg = [nazwaprog] for c in pol[1:]: if c[0] == •>': plikwy = c[1: ] elif c[0] == '<': plikwe = c[1:] else: arg.append(c) # Czy jest to zmiana katalogu roboczego? if nazwaprog == 'cd 1: if len(arg) > 1: try: os.chdir(arg[l]) except OSError,e: print e continue # Wyj ście z shella if nazwaprog == 'exit': sys.exit(0) # Utworzenie procesu wykonuj ącego polecenie pid = os.fork() if not pid: # Otwarcie pliku wej ściowego (przekierowanie) if plikwe: ifd = os.open(plikwe,os.O_RDONLY) os.dup2(ifd,sys.stdin.fileno()) # Otwarcie pliku wyj ściowego (przekierowanie) if plikwy: ofd = os.open(plikwy,os.O_WRONLY | os.O_CREAT | os. OJTRUNC) os.dup2(ofd,sys.stdout.fileno()) # Wykonanie polecenia os.execvp(nazwaprog, arg) else: childpid,ec = os.wait(pid) if ec: print 'Kod wyj ścia ' , ec Dodatek A: Biblioteka Pythona Uwaga • Funkcje os. popen2 (),os.popen3 () ios.popen4() występują również w module poj Kolejność zwracanych przez nie obiektów plików jest jednak nieco inna. Zobacz tak że os.path (213), stat (2 statvfs (224), time (229), popen2 (215), signal (220), fcntl I os.path Moduł os.path służy do wykonywania działań na nazwach ścieżkov w sposób niezależny od platformy. Jest on importowany przez moduł os. abspath(path) Zwraca bezwzględną postać nazwy ścieżkowej pa th, opierając się na ak

nym katalogu roboczym. Na przykład abspath ('../Python/pli może dawać wynik ' /home/beai ley/Python/plik'. basename (path) Zwraca ostatni składnik nazwy ścieżkowej path. Na przykład base me (' /UST/ local /python ') zwraca wartość 'python'. commonprefix(list) Zwraca najdłuższy napis będący prefiksem wszystkich napisów na 1 list. Jeśli lista jest pusta, funkcja zwraca pusty napis. dirname (path) Zwraca nazwę katalogu w nazwie ścieżkowej path. Na przykład dir me('/usr/local/python') zwraca '/usr/local'. exists(path) Zwraca prawdę, jeśli pa th zawiera istniejącą nazwę ścieżkową. expanduser (path) Zamienia nazwę ścieżkową postaci '-użytkownik' na katalog dom< podanego użytkownika. Jeśli rozwinięcie jest niemożliwe lub pa th nie zai na się od ' ~ ', funkcja zwraca niezmieniony argument. expandvars (path) Rozwija występujące w path zmienne środowiskowe postaci '$naz i ' $ {na z wa} '. Źle podane lub nieistniejące nazwy są pozostawiane bez zm ge ta time (path) Zwraca moment ostatniego dostępu do path w postaci liczby sekund początku epoki (zobacz moduł time). getmtime (path) Zwraca moment ostatniej modyfikacji path w postaci liczby sekund początku epoki (zobacz moduł time). getsize (path) Zwraca rozmiar pliku path w bajtach. isabs (path) Zwraca prawdę, jeśli pa th jest bezwzględną nazwą ścieżkową (zaczynaj się od ukośnika).

214 Python isfile(path) Zwraca prawdę, jeśli path jest zwykłym plikiem. Funkcja ta podąża za dowiązaniami symbolicznymi, tak więc ten sam plik może dawać prawdę zarówno w przypadku isf ile (), jaki islink (). isdir (path) Zwraca prawdę, jeśli pa th jest katalogiem. Podąża za dowiązaniami symbolicznymi. islink (path) Zwraca prawdę, jeśli pa th jest dowiązaniem symbolicznym, a fałsz w przeciwnym wypadku. Wartość fałsz zwracana jest także wtedy, gdy system nie obsługuje dowiązań symbolicznych. ismount (path) Zwraca prawdę, gdy pa th jest punktem montowania. join (pathl [, Path2 [, ...]]) Inteligentnie łączy jeden lub kilka składników w nazwę ścieżkową. Na przykład join ('/home1, 'beazley', 'Python') daje w Uniksie '/home/beazley/Python'. normcase (path) Normalizuje wielkość liter w nazwie ścieżkowej. W systemach plików igno- rujących wielkość liter oznacza to konwersję pa th na same małe litery. Po- nadto w Windows ukośniki „zwykłe" są zamieniane na ukośniki odwrotne. normpath (path) Normalizuje nazwę ścieżkową. Powoduje redukcję niepotrzebnych separa- torów i odwołań do katalogów nadrzędnych. Na przykład zapisy 'A//B\ ' A/ . /B' i ' A/coś / . . /B ' są wszystkie zamieniane na ' A/B'. W Windows ukośniki „zwykłe" są zamieniane na ukośniki odwrotne. samefile (pathl, path2) Zwraca prawdę, jeśli pathl i pa th2 wskazują ten sam plik. Macintosh i Unix. sameopenfile (fpl, fp2) Zwraca prawdę, jeśli obiekty otwartych plików fl i f2 odnoszą się do tego samego pliku. Macintosh i Unix. samestat (statl, stat2) Zwraca prawdę, jeśli tupie statl i stat2, takie jakie zwraca fstatO/ lstat () lub stat (), odnoszą się do tego samego pliku. Macintosh i Unix. split(path) Rozbija pa th na parę (head, tail), gdzie tail jest ostatnim składnikiem nazwy ścieżkowej, a head wszystkim, co go poprzedza w nazwie ścieżkowej. Na przykład split (' /home/user/coś') daje w wyniku (' /home/user' / 1 coś '). Taką samą tupię można uzyskać pisząc (dirname () , basename ()). Dodatek A: Biblioteka Pythona splitdrive (path) Rozbija path na parę (drive, filename), gdzie drive jest nazwą nap< lub napisem pustym, a f i 1 ename resztą argumentu. W systemach, w któr nie stosuje się nazw napędów, dr i ve jest zawsze napisem pustym. splittext(path) Rozbija path na bazową nazwę pliku i przyrostek. Na przykład sp: text('plik.txt') zwraca ('plik', '.txt'). walk(path, visitfunc, azg) Rekurencyjnie przechodzi wszystkie katalogi poddrzewa zaczynającego w path i wywołuje dla każdego z nich funkcję visitfunc (arg, diri

me, names), gdzie dirname jest nazwą odwiedzonego podkatalogu, a J mes listą zawartych w nim plików, taką, jaką zwraca os . 1 istdir (diri me). Funkqa visi tfunc może zmieniać zawartość names, aby wpłyną< zbiór katalogów odwiedzanych poniżej dirname. Zobacz także fumatch (182), glob (187), os I popen2 Moduł popen2 jest używany w systemach Windows i Unix do tworzenia procef i podłączania się do ich standardowych strumieni: wejściowego, wyjściow i diagnostycznego. Opisane tutaj funkcje są również dostępne w module os, zwracają tam nieco inne wartości. popen2(cmd [, bufsize [, mode]]) Wykonuje polecenie cmd jako podproces i zwraca parę obiektów pliŁ (child_stdout, child_stdin), odpowiadających strumieniowi w ciowemu i wyjściowemu podprocesu. bufsize określa wielkość bufora łączy I/O. mode ma wartość ' t' dla pliku tekstowego lub ' b ', dla pliku narnego, co jest konieczne w przypadku Windows. popen3(cmd [, bufsize [, mode]]) Podobnie jak popen2 () wykonuje cmd jako podproces, ale zwraca trzy obie (child_stdout, child_stdin, child_stderr), zawierające doda! wo standardowy strumień diagnostyczny. popen4(cmd [, bufsize [, mode]]) Podobnie jak popen2 () wykonuje cmd jako podproces, ale zwraca d obiekty (child_stdout_stderr, chi 1 d_stdin), w którychstandar we strumienie wyjściowy i diagnostyczny są połączone w jeden. Oprócz wymienionych już funkcji uniksowa wersja tego modułu udostępnia stepujące klasy, umożliwiające kontrolowanie procesów: Popen3(cmd [, capturestderr [, bufsize]]) Jest to klasa reprezentująca proces potomny, cmd jest poleceniem shella wy nywanym jako podproces. Jeśli flaga capturestderr ma wartość praw obiekt Popen3 ma przechwytywać standardowy strumień diagnostyce procesu potomnego, bufsize podaje wielkość buforów I/O.

216 Python Popen4(cmd [, bufsize]) Klasa podobna do Popen3, tyle że łączy standardowe strumienie wyjściowy i diagnostyczny. Instancja p klasy Popen3 lub Popen4 ma następujące metody i atrybuty: p.poll () Zwraca kod wyjścia procesu potomnego lub wartość -1, jeśli proces ten nie zakończył się jeszcze. p. wait () Czeka na zakończenie procesu potomnego i zwraca jego kod wyjścia. p.fromchild Obiekt-plik przechwytujący strumień wyjściowy procesu potomnego. p.tochild Obiekt-plik przesyłający strumień wejściowy do procesu potomnego. p.childerr Obiekt-plik przechwytujący standardowy strumień diagnostyczny procesu potomnego. Może mieć wartość None. p.pid Identyfikator procesu potomnego. UWAGA • Kolejność obiektów-plików zwracanych przez popen2 (), popen3 () ipopen4 () różni się od standardowej kolejności s t di n, s t do u t i s t de r r w Uniksie. Wersje funkcji zawarte w module o s poprawiają to. Zobacz także commands (171), os . popen (204). pwd Moduł pwd umożliwia dostęp do bazy danych haseł Uniksa. getpwuid(uid) Zwraca pozycję bazy danych użytkownika o identyfikatorze numerycznym uid. Zwraca 7-elementową tupię (pw_name, pw_passwd, pw_uid, pw_gid, pw_gecos, pw_dir, pw_shell). Elementy pw_uidipw_gid są liczbami całkowitymi. Wszystkie pozostałe to napisy. Jeśli podana pozycja nie istnieje, zgłaszany jest wyjątek KeyEr ror. getpwnam (name) Zwraca pozycję bazy danych haseł dla podanej nazwy użytkownika. getpwall() Zwraca listę wszystkich dostępnych pozycji bazy danych haseł. Każda pozycja ma postać tupli zwracanej przez getpwuid (). PRZYKŁAD »> import pwd >» pwd.getpwnam('beazley') ('beazley', 'x', 100, 1, 'David M. Beazley', '/home/beazley', 1/usr/local/bin/tcsh') Zobacz także grp (188), getpass (184), crypt (172). uuucucn, n. muuvicna ryuiwia readline Moduł readline udostępnia w Uniksie interfejs biblioteki GNU readline blioteka ta rozszerza możliwości Pythona w trybie interakcyjnym o mechai historii oraz uzupełnianie i edycję poleceń. Dotyczy to również funkcji takie] raw_input() i input(). Moduł readline udostępnia następujące specjalne kombinacje klawiszy w cie pracy interakcyjnej: Klawisz(e) Ctrl+a Ctrl+b Esc b Esc c Ctrl+d Esc d Del

Esc Del Ctrl+e Ctrl+f Esc f Ctrl+k Ctrl+1 Esc 1 Ctrl+n Ctrl+p Ctrl+r Ctrl+t Esc t Esc u Ctrl+w Ctrl+y Esc y Esc < Esc > Działanie Przejście na początek linii Cofnięcie się o jeden znak Cofnięcie się o jlden wyraz Rozpoczęcie bieżącego wyrazu dużą literą Usunięcie znaku w miejscu kursora Usunięcie znaków do końca bieżącego wyrazu Usunięcie znaku na lewo od kursora Usunięcie znaków do początku poprzedniego wyrazu Przejście na koniec linii Przejście do przodu o jeden znak Przejście do przodu o jeden wyraz Usunięcie tekstu do końca linii Wyczyszczenie ekranu Konwersja bieżącego wyrazu na małe litery Przejście w dół listy historii Przejście w górę listy historii Zmiana kierunku przeszukiwania historii Przestawienie znaków Przestawienie wyrazów Konwersja bieżącego wyrazu na duże litery Usunięcie znaków od kursc ra do poprzedniego białego znaku Wstawienie ostatnio usuniętego tekstu Odwrócenie cyklu usunięć i wklejenie nowego „lidera" Przejście do pierwszej linii historii Przejście do ostatniej linii historii UWAGI • Kombinacje klawiszy z użyciem [Esc] są czasem dostępne przy użyciu klawisza [Meta]. • Wiele wymienionych kombinacji klawiszy może być poprzedzonych argumentem numerycznym wprowadzć pomocą sekwencji [Esc] [nnn]. Na przykład wpisanie [Esc] [5] [0] [Ctrl+f] powoduje przejście do przodu o 50 zi • Moduł readline nie jest standardowym składnikiem Pythona. Jeśli instalujesz interpreter i chce wać modułu readline, musisz zastosować się do wskazówek podanych w pakiecie dystrybu (różnią się w zależności od wersji Pythona). Zobacz tak żerlcompleter (http://www.python.org/doc/lib/module-r lcompleter.

resource Moduł resource służy do pomiarów i kontroli zasobów systemu używanych przez program działający w Uniksie. Zużycie zasobów można ograniczyć za po- mocą funkcji setrlimit (). Każdy zasób jest kontrolowany za pomocą dwóch ograniczeń: słabego i silnego. Słabe ograniczenie jest ograniczeniem bieżącym, które można zaostrzyć lub osłabić. Silne ograniczenie może zostać zaostrzone do dowolnej wartości większej od słabego ograniczenia, ale nie można go nigdy osłabić (chyba że robi to superużytkownik). getrlimit (resource) Zwraca tupię {soft, hard) z bieżącymi ograniczeniami: słabym (soft) i silnym (hard), resource jest jedną z następujących stałych: Stała RLIMIT _CORE RLIMIT_

_CPU

RLIMIT_

_FSIZE

RLIMIT _DATA RLIMIT _STACK RLIMIT_

_RSS

RLIMIT_

_NPROC

RLIMIT_

_NOFILE

RLIMIT_

_OFILE

RLIMIT_

_MEMLOC

RLIMIT_

_VMEM

RLIMIT AS Opis Maksymalny rozmiar pliku core (w bajtach) Maksymalny czas CPU (w sekundach). Przekroczenie go powoduje przesłanie do procesu sygnału SIGXCPU Maksymalny rozmiar tworzonego pliku Maksymalny rozmiar stogu procesu (w bajtach) Maksymalny rozmiar stosu procesu (w bajtach) Maksymalny rozmiar zbioru rezydującego Maksymalna liczba procesów, które można utworzyć Maksymalna liczba deskryptorów otwartych plików Nazwa BSD dla RUMIT_NOFILE Maksymalny rozmiar obszaru pamięci, który można zablokować. Największy obszar mapowanej pamięci, którego można użyć Maksymalny obszar przestrzeni adresowej, którego można użyć (w bajtach) setrlimit (resource, limits) Ustawia nowe ograniczenia dla zasobu resource, limi ts jest tupią (soft, hard) dwóch liczb całkowitych wyznaczających odpowiednio nowe ograniczenie słabe i silne. Wartość -1 może posłużyć do podania maksymalnego do- puszczalnego górnego ograniczenia. getruśage(who) Funkcja ta zwraca obszerną tupię opisującą zasoby używane albo przez proces bieżący, albo przez jego procesy potomne, who ma jedną z następujących wartości: Wartość Opis RUSAGE_SELF Informacje o procesie bieżącym RUSAGE_CHILDREN Informacje o procesach potomnych RUSAGE BOTH Informaqe zarówno o procesie bieżącym, jak i o procesach

potomnych Zwracana tupla zawiera dane o zużyciu zasobów systemowych w n pującej kolejności: Przesunięcie Zasób 0 Czas w trybie użytkownika (liczba zmiennoprzecinkowa) 1 Czas w trybie systemu (liczba zmiennoprzecinkowa) 2 Maksymalny rozmiar zbioru rezydującego (strony) 3 Rozmiar pamięci dzielonej (strony) 4 Rozmiar pamięci indywidualnej (strony) 5 Rozmiar stosu indywidualnego (strony) 6 Błędy strony nie wymagające I/O 7 Błędy strony wymagające I/O 8 Liczba usunięć z pamięci 9 Operaqe blokowe na wejściu 10 Operacje blokowe na wyjściu 11 Wiadomości wysłane 12 Wiadomości odebrane 13 Sygnały odebrane 14 Niewymuszone zmiany kontekstu 15 Wymuszone zmiany kontekstu getpagesize() Zwraca liczbę bajtów na stronie systemowej. WYJĄTEK error Wyjątek zgłaszany w przypadku niespodziewanych błędów w wywoła systemowych getrlimit () i setrlimit (). UWAGA • Nie wszystkie nazwy zasobów są dostępne we wszystkich systemach. Zobacz także w dokumentacji online Uniksa getrlim shutil Moduł shutil służy do wykonywania operacji plikowych wysokiego poz takich jak kopiowanie, usuwanie czy przemianowywanie. copyfile(src, dst) Kopiuje zawartość src do dst. copymode(src, dst) Kopiuje bity praw dostępu z src do dst. copystat(src, dst) Kopiuje bity praw dostępu, datę ostatniego dostępu oraz datę ostatniej r fikacji z src do dst. Zawartość, właściciel i grupa dst pozostają bez z

ZA) Hython copy (src, dst) Kopiuje plik src do pliku lub katalogu dst, zachowując oryginalne prawa dostępu. copy2(src, dst) Działa podobnie jak copy (), ale dodatkowo zachowuje oryginalne daty do- stępu i modyfikacji. copytree(src, dst [, symllnks]) Rekurencyjnie kopiuje całe drzewo katalogów zaczynające się w src. Funkcja sama tworzy katalog docelowy ds t (nie powinien wcześniej istnieć). Poszcze- gólne pliki są kopiowane przy użyciu copy2 (). Jeśli symlinks ma wartość prawda, dowiązania symboliczne w drzewie źródłowym są w drzewie docelowym reprezentowane także w postaci dowiązań symbolicznych. Jeśli argument symlinks ma wartość fałsz lub w ogóle nie występuje, do nowego drzewa katalogów jest kopiowana zawartość plików wskazywanych przez te dowiązania. Komunikaty o błędach są kierowane na standardowy strumień wyjściowy. raitree (path [, ±gnore_errors [, onerror]]) Usuwa całe drzewo katalogów. Jeśli ignore_errors jest prawdą, błędy są ignorowane. W przeciwnym razie ich obsługą zajmuje się funkcja onerror (o ile jest podana). Funkqa ta musi mieć trzy parametry (func, path, excinfo), gdzie func wskazuje funkcję, która spowodowała błąd (os . remove () lub os. rmdir ()),pa th jest nazwą ścieżkową przekazaną do tej funkcji, a excinfo jest informaq'a o wyjątku zwróconą przez sys . exc_inf o (). Jeśli nastąpi błąd, a nie ma argumentu onerror, następuje zwykłe zgłoszenie tego błędu. UWAGA • W systemie MacOS część resource fork\es\ ignorowana przy kopiowaniu plików. Zobacz także os .path (213), macostools (194). Dodatek A: Biblioteka Pythona signal Moduł signal jest używany do pisania procedur obsługi sygnałów w Pythonie. Sygnały odpowiadają zwykle zdarzeniom asynchronicznym i są przesyłane do programów w wyniku upływu zadanego czasu, pojawienia się danych wejścio- wych lub jakiejś akcji wykonanej przez użytkownika. Moduł signal emuluje uniksowy interfejs sygnałów, chociaż może być używany także na innych platformach. alarm (time) Jeśli time ma wartość różną od zera, funkqa ustawia wysłanie sygnału SIGALRM do programu za time sekund. Wszystkie wcześniej ustawione alarmy są anulowane. Jeśli time ma wartość 0, anulowane są tylko wcześniejsze alarmy, bez ustawiania nowego. Funkcja zwraca liczbę sekund do najbliższe- go ustawionego alarmu lub zero, jeśli żaden nie został ustawiony. Unix. get signal {signalman) Zwraca procedurę obsługi sygnału signalnum. Zwracany obiekt jest w ływalnym obiektem Pythona. Funkcja ta może również zwracać S IG_IGN w padku ignorowania sygnału, SIG_DFL w przypadku domyślnej proce obsługi sygnału lub None, jeśli procedury obsługi sygnału nie ma w Python pause() Powoduje przejście w stan uśpienia aż do momentu otrzymania następ sygnału. Unix. signal(signalnum, handler) Ustawia procedurę obsługi sygnału signalnumna. funkqe handler. Ta < nia musi być wywoływalnym obiektem Pythona przyjmującym dwa par

try: numer sygnału i obiekt-ramkę. Można też użyć SIG_IGN lub SIG_ aby zignorować sygnał lub użyć domyślnej procedury jego obsługi. Wart powrotną jest poprzednia procedura obsługi sygnału, SIG_IGN SIG_DFL. Jeśli są dozwolone wątki, funkcja ta może być wywoływana w głównym wątku. W przeciwnym razie następuje zgłoszenie wyjątku lueError. Poszczególne sygnały są identyfikowane przy użyciu stałych symbolicz postaci SIG*. Nazwy te odpowiadają liczbom całkowitym specyficznyi konkretnego systemu. Typowe wartości wyglądają następująco: Nazwa sygnału Opis SIGABRT Zakończenie nieprawidłowe SIGALRM Alarm SIGBUS Błąd szyny SIGCHLD Zmiana statusu procesu potomnego SIGCLD Zmiana statusu procesu potomnego SIGCONT Kontynuaqa SIGFPE Błąd zmiennoprzecinkowy SIGHUP Zawieszenie SIGILL Nieprawidłowa instrukcja SIGINT Terminalowy znak przerwania SIGIO Asynchroniczne wejście/wyjście SIGIOT Błąd sprzętowy SIGKILL Zakończenie SIGPIPE Pisanie w łączu bez „czytelników" SIGPOLL Zdarzenie odpytywane SIGPROF Alarm profilowania SIGPWR Błąd zasilania SIGQUIT Terminalowy znak wyjścia SIGSEGV Błąd segmentaqi SIGSTOP Zatrzymanie SIGTERM Zakończenie

222 rytnon Nazwa sygnału Opis SIGTRAP Błąd sprzętowy SIGTSTP Terminalowy znak zatrzymania SIGTTIN Terminal sterujący SIGTTOU Terminal sterujący SIGURG Pilny warunek SIGUSR1 Zdefiniowany przez użytkownika SIGUSR2 Zdefiniowany przez użytkownika SIGVTALRM Alarm czasu wirtualnego SIGWINCH Zmiana rozmiaru okna SIGXCPU Przekroczenie limitu CPU SIGXFSZ Przekroczenie limitu rozmiaru pliku uoaateKA: biblioteka Fythona Stosując w jednym programie wątki i sygnały, trzeba zachować maksimum ostrożności. Aktualn główny wątek wykonania może ustawiać nowe procedury obsługi sygnałów lub odbierać sygnały. Obsługa sygnałów w środowiskach Windows i Macintosha ma niewielkie zastosowanie. Liczba sy występujących na tych platformach jest bardzo okrojona. Zobacz także thread (241), errnc Ponadto moduł definiuje następujące zmienne: Zmienna Opis SIG_DFL SIG_IGN NSIG Wywołanie domyślnej procedury obsługi sygnału Wywołanie procedury obsługi ignorującej sygnał Wartość o jeden większa od najwyższego numeru sygnału PRZYKŁAD Oto przykład ustawienia czasu przerwania dla zakładania połączenia sieciowego: import signal, socket def obsługa(signum, frame): print 'Przekroczenie czasu oczekiwania!' raise IOError, 'Host nie odpowiada. 1 sock = socket.socket(socket.AF_INET, socket.SOCK_ST REAM) signal.signal(signal.SIGALRM, obsługa) signal.alarm(5) # alarm za 5 sekund sock.connect ('www.python.org', 80) # Poł ączenie signal.alarm(0) # Usuni ęcie alarmu UWAGI • Raz ustawione procedury obsługi sygnałów pozostają zainstalowane aż do ich jawnego usunięcia. Wyjątek stanowi procedura obsługi sygnału SIGCHLD (jej zachowanie zależy od konkretnej implementacji). • Nie można okresowo zablokować sygnałów. • Sygnały są obsługiwane jedynie pomiędzy atomowymi („nierozkładalnymi") poleceniami interpretera Pytho- na. Doręczenie sygnału może się opóźnić na skutek długotrwałych obliczeń zapisanych w C (na przykład w module rozszerzenia). • Jeśli przesłanie sygnału następuje w momencie operacji wejścia/wyjścia, ta ostatnia może się nie udać i zgłosić wyjątek. W takim przypadku wartość err no jest ustawiana na err no. EINTR, aby wskazać przerwane wywołanie systemowe. • Pewne sygnały, takie jak SIGSEGV, nie mogą być obsługiwane z poziomu Pythona. • Python instaluje standardowo niewielką liczbę procedur obsługi sygnałów. Sygnał s iGPI PE jest ignorowany, SIGINT zamieniany na wyjątek Keyboardinterrupt, a SIGTERM przechwytywany w celu wykonania „sprzątania" i wywołania sys. exitf unc. stat Moduł stat definiuje stałe i funkcje służące do interpretowania wartości z nych os . stat (), os . f stat () i os . lstat (). Funkqe te zwracają 10-' entową tupię zawierającą informacje o pliku. Oto lista zmiennych definiuj, indeksy tupli, pod którymi można znaleźć odpowiednie informaqe: Zmienna Opis ST_MODE Tryb ochrony i-węzła ST_IN0 Numer i-węzła ST_DEV Urządzenie, na którym jest i-węzeł ST_NLINK Liczba dowiązań do i-węzła

ST_UID Identyfikator UID właściciela ST_GID Identyfikator GID grupy ST_SIZE Rozmiar pliku w bajtach ST ATIME Data ostatniego dostępu ST_MTIME Data ostatniej modyfikacji ST_CTIME Data ostatniej zmiany statusu Oto lista funkcji, które pomagają sprawdzać właściwości podane w trybie o ny zwróconym przez os. stat {path) [stat. ST_M0DE]: Funkcja S_ISDIR (mode) S_ISCHR (/node) S_ISBLK (mode) S_ISREG(mode) S_ISFIFO (mode) S_ISLNK(mode) S_ISSOCK(mode) S_IM0DE(mode) S IFMT(mode) Opis Zwraca wartość różną od zera, jeśli mode dotyczy katalogu. Zwraca wartość różną od zera, jeśli mode dotyczy pliku specjalnego urządzenia znakowego. Zwraca wartość różną od zera, jeśli mode dotyczy pliku speqalnego urządzenia blokowego. Zwraca wartość różną od zera, jeśli mode dotyczy pliku zwy] Zwraca wartość różną od zera, jeśli mode dotyczy FIFO (łącz, nazwanego). Zwraca wartość różną od zera, jeśli mode dotyczy dowiązani symbolicznego. Zwraca wartość różną od zera, jeśli mode dotyczy gniazda. Zwraca fragment mode, który można ustawić za pomocą os . chmod (). Są to bity praw dostępu do pliku, bit lepkości i bity SUID i SGID. Zwraca fragment mode, który określa typ pliku (używany pr wymienione wcześniej funkcje S_IS* ()).

224 rymon UWAGA • Większość możliwości tego modułu oferuje również bardziej przenośna jego wersja - moduł os. path. Zobacz także os (198), os . path (213), statvf s (224). statvfs Moduł statvfs definiuje stałe używane do interpretowania w Uniksie wyni- ków funkcji os. statvfs (). Stałe wyznaczają odpowiednie indeksy w tupli zwracanej przez tę funkcję. Stała Opis F_BSIZE Preferowany przez system plików rozmiar bloku. F FRSIZE Podstawowy rozmiar bloku systemu plików. F_BLOCKS Całkowita liczba bloków w systemie plików. F_BFREE Całkowita liczba wolnych bloków. F_BAVAIL Liczba bloków dostępnych dla wszystkich oprócz superużytkownika. F_FILES Całkowita liczba i-węzłów. F_FFREE Całkowita liczba wolnych i-węzłów. F_FAVAIL Liczba wolnych i-węzłów dostępnych dla wszystkich oprócz superużyt- kownika. F FLAG Flagi (zależne od systemu) F NAMEMAX Maksymalna długość nazwy pliku. Zobacz także os (198), stat (223). tempfile Moduł tempfile służy do tworzenia plików tymczasowych i generowania ich nazw: mktemp ([suffix] ) Zwraca unikatową nazwę pliku tymczasowego, suffix jest nieobowiązko- wym przyrostkiem pliku, który ma być dodany na końcu nazwy pliku. Funk- cja ta generuje samą nazwę, ale nie tworzy ani nie otwiera samego pliku. gettempprefix() Zwraca przedrostek używany do generowania plików tymczasowych. Nie zawiera on katalogu, w którym bezpośrednio rezydują pliki tymczasowe. TemporaryFile([mode [, bufsize [, suffix]]]) Tworzy plik tymczasowy i zwraca obiekt podobny do pliku, udostępniający te same metody, co zwykły obiekt-plik. Argument mode ma domyślną war- tość ' w+b'. bufsize ma to samo znaczenie, co w funkcji open (). suffix jest przyrostkiem dołączanym do nazwy pliku (o ile jest podany). Obiekt zwracany przez tę funkcję stanowi jedynie obudowę wbudowanego obiektu- pliku, dostępnego za pomocą atrybutu. Utworzony w ten sposób plik jest automatycznie usuwany w momencie likwidacji obiektu pliku tymczasowego. n. oiunuicna ryuiuiia Do konstruowania nazw tymczasowych używane są dwie zmienne globć W razie potrzeby można im przypisać nowe wartości. Ich standardowe wari zależą od systemu. Zmienna tempdir template Opis Katalog, w którym rezydują pliki o nazwach zwracanych przez mktemp(). Przedrostek nazw plików generowanych przez mktemp (). Napis złóż z cyfr dziesiętnych, dodawany do template podczas generowania ur towych nazw plików. termios Moduł termios udostępnia interfejs (w stylu POSIX-a) do kontrolowania za

wania terminali (TTY) i innych szeregowych urządzeń komunikacyjnych w temach typu Unix. Wszystkie funkqe tego modułu operują na całkowitych skryptorach plików, takich jakie zwraca funkcja os . open () lub metoda f i no () obiektu pliku. Ponadto moduł ten korzysta z dużej kolekcji stałych ze niowanych w module TERMIOS, który także należy załadować. tcgetattr(£d) Zwraca listę [i flag, oflag, cflag, lflag, ispeed, ospeed, atrybutów TTY o deskryptorze pliku f d. Znaczenie poszczególnych pól \ jest następujące: Pole Opis if lag Tryby wejściowe (liczba całkowita). oflag Tryby wyjściowe (liczba całkowita). cflag Tryby sterujące (liczba całkowita). lflag Tryby lokalne (liczba całkowita). ispeed Prędkość wyjściowa (liczba

całkowita) ospeed Prędkość wyjściowa (liczba

całkowita) cc Lista znaków sterujących (napisy). Pola i flag, oflag, cflag i lflag są polami bitowymi interpretowan przy użyciu stałych z modułu TERMIOS. TRYBY WEJŚCIOWE Tryb Opis TERMIOS.IGNBRK Ignoruje warunki przerwania na wejściu. TERMIOS.BRKINT Generuje sygnał SIGINT na skutek przerwania, o ile

nie ustawiony tryb IGNBRK. TERMIOS.IGNPAR Ignoruje błędy parzystości i synchronizaqi. TERMIOS.PARMRK Zaznacza błędy parzystości. TERMIOS.INPCK Włącza kontrolę parzystości na wejściu.

226 rjuivn Tryb Opis TERMIOS.ISTRIP Obcina ósmy bit. TERMIOS.INLCR Zamienia przejścia do nowej linii na powroty karetki. TERMIOS.IGNCR Ignoruje powroty karetki. TERMIOS.ICRNL Zamienia powroty karetki na przejścia do nowej linii. TERMIOS.IUCLC Zamienia duże litery na małe. TERMIOS.IXON Włącza kontrolę przepływu XON/XOFF na wyjściu. TERMIOS.IXANY Włącza restartowanie wyjścia przez dowolny znak. TERMIOS.IXOFF Włącza kontrolę przepływu XON/XOFF na wejściu. TERMIOS.IMAXBEL Sygnalizuje dźwiękiem zapełnienie kolejki wejściowej.

n. utunuici\d ryiuuiid TRYBY WYJŚCIOWE Tryb Opis TERMIOS .OPOST Przetwarzanie wyjścia zdefiniowane przez implementaq'e. TERMIOS .OLCUC Zamiana małych liter na duże na wyjściu. TERMIOS .ONLCR Zamiana przejść do nowej linii na powroty karetki. TERMIOS .OCRNL Zamiana powrotów karetki na przejścia do nowej linii. TERMIOS .ONLRET Niewysyłanie powrotów karetki. TERMIOS .OFILL Wysyłanie znaków wypełniających dla opóźnienia. TERMIOS .OFDEL Ustawienie znaku wypełnienia na ASCII [DEL]. TERMIOS .NLDLY Maska opóźnienia dla nowej linii. Wartość NLO lub NL1. TERMIOS .CRDLY Maska opóźnienia dla powrotu karetki. Wartość CRO, CR1, CR2 lub CR3. TERMIOS .TABDLY Maska opóźnienia dla tabulacji poziomej: TABO, TAB1,

TAB2, TAB3lubXTABS. TERMIOS .BSDLY Maska opóźnienia dla znaku Backspace: BSO lub BS1. TERMIOS .VTDLY Maska opóźnienia dla tabulacji poziomej: VT0 lub VT1. TERMIOS .FFDLY Maska opóźnienia dla wysunięcia strony: FFO lub FF1. TRYBY STERUJĄCE Tryb Opis TERMIOS.CSIZE Maska rozmiaru znaku: CS5, CS6, CS7 lub CS8. TERMIOS.CSTOPB Ustawia dwa bity stopu. TERMIOS.CREAD Umożliwia odbieranie wejścia. TERMIOS.PARENB Włącza generowanie bitów parzystości i ich sprawdzanie. TERMIOS.PARODD Włącza parzystość „nieparzystą". TERMIOS.HUPCL „Odwieszanie" modemu po zamknięciu połączenia. TERMIOS.CLOCAL Ignoruje sygnały kontroli modemu. TERMIOS.CRTSCTS Kontrola przepływu (potwierdzanie RTS/CTS). TRYBY LOKALNE Tryb TERMIOS.ISIG TERMIOS.ICANON TERMIOS.XCASE TERMIOS.ECHO TERMIOS.ECHOE TERMIOS TERMIOS TERMIOS. TERMIOS. TERMIOS. TERMIOS. TERMIOS. TERMIOS. TERMIOS.

TERMIOS. .ECHOK .ECHONL .ECHOCTL ECHOPRT ECHOKE FLUSHO NOFLSH TOSTOP PENDIN IEXTEN Opis Generuje odpowiednie sygnały po otrzymaniu znaku II QUIT, SUSP lub DSUSP. Włącza tryb kanoniczny. Wykonuje konwersję wielkości liter, jeśli jest ustawiony I CANON. Echo znaków wejściowych. Jeśli jest ustawiony tryb I CANON, znak ERASE usuwa poprzedzający znak wejściowy. WERASE usuwa poprzed wyraz. Jeśli jest ustawiony tryb I CANON, znak KILL usuwa bież linię. Jeśli jest ustawiony tryb I CANON, zachodzi echo znaków przejścia do nowej linii (NL). Jeśli jest ustawiony tryb ECHO, zachodzi echo znaków sterujących, takich jak AX. Echo usuwanych znaków. Echo znaku KILL przez usuwanie wszystkich znaków p< jednym na raz. Opróżnianie kolejki wyjściowej. Blokada opróżniania kolejek wejścia/wyjścia po wygenerowaniu sygnałów SIGINT i SIGQUIT. Wysłanie sygnału SIGTTOU do grupy procesów procesu działającego w tle i piszącego na swoim terminalu sterując Przedrukowuje wszystkie znaki w kolejce wejściowej po wpisaniu kolejnego znaku. Włącza przetwarzanie wejścia specyficzne dla implemen PRĘDKOŚCI Prędkości są zdefiniowane przez takie stałe, jak TERMIOS. BO, TERMIOS . ] TERMIOS. B75 czy TERMIOS. B230400, wskazujące szybkość transmisji, stępne wartości są specyficzne dla implementacji i zdefiniowane w mo< TERMIOS. ZNAKI STERUJĄCE Oto lista symboli zdefiniowanych w TERMIOS i wskazujących indeksy 1 cc. Używając ich można zmieniać przypisania klawiszy. Znak Opis TERMIOS.VINTR Znak przerwania (zazwyczaj [Ctrl+C]). TERMIOS.VQUIT Powoduje zakończenie. TERMIOS.VERASE Usuwa poprzedni znak (zazwyczaj [Del]) TERMIOS.VWERASE Usuwa poprzedni wyraz ([Ctrl+w]) TERMIOS.VKILL Usuwa całą linię.

228 rymon Znak Opis TERMIOS.VREPRINT Przedrukowuje wszystkie znaki, które nie zostały jeszcze wczytane. TERMIOS.VEOF Koniec pliku ([Ctrl+D]) TERMIOS.VNL Ogranicznik linii (linefeed) TERMIOS.VSUSP Zawieszenie ([Ctrl+Z]) TERMIOS.VSTOP Zatrzymanie wyjścia ([Ctrl+S]) TERMIOS.VSTART Wznowienie wyjścia ([Ctrl+Q])

tcsetattr{fd, when, attributes) Ustawia atrybuty terminala o deskryptorze pliku fd. attributes jest taką samą listą, jaką zwraca tcgetattr (). Argument when decyduje o tym, kiedy ma nastąpić zmiana atrybutów: Argument

Opis

TERMIOS. TCSANÓW Natychmiast. TERMIOS. TCSADRAIN Po przesłaniu kolejki wyjściowej. TERMIOS. TCSAFLUSH Po przesłaniu kolejki wyjściowej i odrzuceniu kolejki wejściowej. tcsendbreak(£d, duration) Wysyła sygnał przerwania dla deskryptora pliku fd. Wartość duration ró- wna 0 powoduje wysyłanie przerwania przez około 0,25-0,5 sekundy. Defini- cja wartości niezerowej zależy od implementacji. tcdrain (fd) Czeka, aż skończy się zapisywanie całego wyjścia w pliku o deskryptorze fd. tcflush(fd, queue) Odrzuca zawartość kolejki dla deskryptora pliku fd. Argument queue decyduje, które dane mają być odrzucone: Kolejka TERMIOS.TCIFLUSH TERMIOS.TCOFLUSH TERMIOS.TCIOFLUSH Opis Kolejka wejściowa. Kolejka wyjściowa. Obie kolejki. tcflow(fd, action) Zawiesza lub wznawia korzystanie z wejścia albo wyjścia deskryptora pliku fd. Argument action może mieć jedną z następujących wartości: Dodatek A: Biblioteka Pythona Akcja TERMIOS.TCOOFF TERMIOS.TCOON TERMIOS.TCIOFF TERMIOS.TCION Opis Zawiesza wyjście. Restartuje wyjście. Zawiesza wejście. Restartuje wejście. time PRZYKŁAD Podana niżej funkcja prosi o wpisanie hasła i wyłącza na ten czas lokalne e< def czythaslo(): import termios, TERMIOS, sys fd = sys.stdin.filenoO

te = termios.tcgetattr(fd) stare = te[3] & TERMIOS.ECHO te[3] = te[3] & -TERMIOS.ECHO # Wył ączenie echa try: termios.tcsetattr(fd, TERMIOS.TCSADRAIN, te) passwd = raw_input('Hasło: ') finally: te [3] = te [3] I stare # Powrót do starego u stawienia e termios.tcsetattr(fd, TERMIOS.TCSADRAIN, te) return passwd Zobacz tak że tty (232), getpass (185), signal Moduł t ime zawiera różne funkcje związane z czasem. W Pythonie czas jest rzony w postaci liczby sekund, jakie upłynęły w ramach „epoki". Początek e jest początkiem mierzenia czasu (momentu, w którym czas = 0 sekund). Pocz ten wypada 1 stycznia 1970 roku dla Uniksa i Windows, a 1 stycznia 1900 i dla Macintosha. Moduł definiuje następujące zmienne: accept2dyear Wartość boolowska wskazująca, czy są akceptowane dwucyfrowe nun lat. Standardowo jest to prawda, ale staje się fałszem po ustawieniu zmie $PYTHONY2K na niepusty napis, altzone Strefa czasowa używana w przypadku przechodzenia na czas letni (dayi saving time - DST). O ile ma to miejsce, daylight Ma wartość niezerową, jeśli jest zdefiniowany czas letni (DST). timezone Lokalna strefa czasowa (nie-DST). t z name Tupla zawierająca nazwę lokalnej strefy czasowej i nazwę lokalnej strefy i su letniego (jeśli jest zdefiniowany). Oto lista dostępnych funkcji: asetime ([ tupie]) Konwertuje tupię reprezentującą czas, jaki zwraca gmtime () lub ; cal time (), na napis postaci 'Mon Jul 16 14:45:23 2 0 01'. Bez argurr tów funkcja zwraca bieżący czas. clock() Zwraca bieżący czas CPU w sekundach jako liczbę zmiennoprzecinkową.

230 rymon uuumtm H. Diuuuitma ryinona ctime([sees]) . Konwertuje czas wyrażony w sekundach, które minęły od początku epoki, na napis reprezentujący czas lokalny, etime (sees) daje to samo co asctime (localtime (sees) ). Bez sees używany jest czas bieżący. gmtime ([sees]) . Konwertuje czas wyrażony w sekundach, które minęły od początku epoki, na tupię reprezentującą czas UTC (Coordinated Universal Time, znany jako Gre- enwich Mean Time). Zwracana tupla składa się z dziewięciu liczb (year, month, day, hour, minute, second, weekday, day, dst) ozna- czających kolejno: rok, miesiąc, dzień, godzinę, minutę, sekundę, dzień tygodnia, dzień i czas letni. Oto numeryczne zakresy dla każdego elementu tupli: Element Wartość year Czterocyfrowa wartość, taka jak

2002 month 1-12 day 1-31 hour 0-23 minute 0-59 second 0-61 weekday 0-6 (0=Monday) day 1-366 dst -1, 0, 1 Pole ds t ma wartość 1, jeśli obowiązuje właśnie czas letni, 0, jeśli nie, a -1, jeśli brak na ten temat informacji. Bez sees używany jest czas bieżący. localtime([sees]) Zwraca tupię „czasową" taką jak gmtime (), ale odpowiadającą lokalnej strefie czasowej. Bez sees używany jest czas bieżący. mktime ( tupie) Pobiera tupię reprezentującą czas w lokalnej strefie czasowej (w tym samym formacie jak localtime ()) i zwraca liczbę zmiennoprzecinkową zawie- rającą liczbę sekund od początku epoki. Jeśli argument nie zawiera wartości poprawnej dla czasu, zgłaszany jest wyjątek Over f lowError. sleep {sees) Usypia bieżący proces na podaną w sees liczbę sekund, sees zawiera war- tość zmiennoprzecinkową. strftime {format [, tuple]) Konwertuje tupię reprezentującą czas, jaką zwraca gmtime () lub localtime (), na napis, forma t jest napisem formatującym, w którym można stoso- wać następujące kody: Kod Znaczenie Regionalny skrót nazwy dnia tygodnia. Regionalna pełna nazwa dnia tygodnia. %b %B %c %d %H %m %M %p %S %u %w

%W %x %X %y %Y %Z Regionalny skrót nazwy miesiąca. Regionalna pełna nazwa miesiąca. Regionalna poprawna reprezentaqa daty i godziny Dzień miesiąca w postaci liczby dziesiętnej [01-31] Godzina (zegar 24-godzinny) jako liczba całkowita [00-23] Godzina (zegar 12-godzinny) jako liczba dziesiętna [01-12] Dzień roku jako liczba dziesiętna [001-366] Miesiąc jako liczba dziesiętna [01-12] Minuta jako liczba dziesiętna [00-59] Regionalny odpowiednik AM lub PM Sekunda jako liczba dziesiętna [00-61] Numer tygodnia w roku [00-53] (pierwszym dniem jest niedziela) Dzień tygodnia jako liczba dziesiętna [0 (niedziela)-6] Numer tygodnia w roku (pierwszym dniem jest poniedziałek) Regionalna reprezentacja daty Regionalna reprezentaqa godziny Rok bez stulecia jako liczba dziesiętna [00-99] Rok ze stuleciem jako liczba dziesiętna Nazwa strefy czasowej (lub pusty napis, jeśli strefa nie istnieje) Znak % Kody formatujące mogą zawierać taką samą specyfikację szerokości i do ności, jak w przypadku operatora % i znaków formatujących napisy. Bez i mentu tupie używana jest tupla zawierająca wskazanie bieżącego czaj strptime {string [, format]) Dokonuje rozkładu napisu string reprezentującego czas i zwraca tupię \ mej postaci co funkcje localtime () i gmtime (). Argument format: zawierać takie same kody, jakich używa strf time (), i ma standardową tość'%a %b %d %H:%M:%S %Y' Jest to ten sam format, co w przypadku cji etime (). Jeśli podany napis zawiera błędy składniowe, zgłaszan1

wyjątek ValueError. time () Zwraca bieżący czas UTC (Coordinated Universal Time), jako liczbę se od początku epoki. UWAGI • Jeśli wolno stosować dwucyfrową postać roku, jest ona konwertowana na wersję czterocyfrowa, zgo standardem POSIX X/Open, gdzie wartości 69-99 mapuje się na 1969-1999, a wartości 0- 2000-2068. • Funkcje z tego modułu nie są przeznaczone do obsługi dat i godzin odległych w przeszłości lub przyj W szczególności nie wolno posługiwać się datami sprzed epoki, jak również datami przekraczającyr maksymalny (na wielu maszynach jest to 231 sekund od początku epoki).

232 rytnon W wersjach Pythona wcześniejszych niż 2.1 trzeba było podawać nieobowiązkowe obecnie argumenty funkcji asctime (), ctime (), gmtime (), localtime () i strf time (). Jeśli więc zależy ci na kompatybilności ze starszymi wersjami interpretera, pamiętaj o podawaniu tych argumentów. Zakres wartości dla funkcji sees obejmuje liczby od o do 61, w celu uwzględnienia sekund przestępnych. Zobacz także locale (189). tty Moduł tty zawiera funkcje do ustawiania terminali uniksowych w trybach cbreak i raw. Tryb raw powoduje odbieranie przez proces każdego znaku z terminala bez interpretowania go przez system. Tryb cbreak włącza przetwarzanie przez system specjalnych klawiszy generujących sygnały, takich jak klawisze przerwań i wyjścia. setraw(£d, [, when]) Ustawia tryb raw dla deskryptora pliku fd. Argument when podaje, kiedy ma nastąpić ta zmiana i może mieć wartość TERMIOS. TCSANOW, TERMIOS. TCSADRAIN lub TERMIOS . TCSAFLUSH (domyślna). setebreak(fd [, when]) Zmienia tryb deskryptora /dna cbreak. Argument when ma takie samo znaczenie jak w setraw (). UWAGA • Wymaga modułu termios. Zobacz także termios (225). jwinreg Moduł _winreg stanowi interfejs niskiego poziomu Rejestru Windows. Rejestr jest obszernym hierarchicznym drzewem, którego poszczególne węzły nazywane są kluczami. Klucze leżące poniżej danego klucza są określane mianem jego podkluczy i mogą zawierać dodatkowe podklucze lub wartości. Na przykład ustawienie zmiennej Pythona s y s . pa th jest zwykle zawarte w Rejestrze jako klucz: \HKEY_LOCAL_MACHINE\Software\Python\PythonCore\2.0\ PythonPath W tym przypadku Software jest podkluczem HKEY_LOCAL_MACHINE, Py- thon jest podkluczem Software i tak dalej. Wartością klucza PythonPath jest faktyczne ustawienie ścieżki. Aby skorzystać z klucza, trzeba go najpierw otworzyć, a potem zamknąć. Otwar- ty klucz jest reprezentowany przez specjalny uchwyt, będący obudową całkowi- tego identyfikatora uchwytu używanego standardowo przez system Windows. CloseKey (key) Zamyka otwarty wcześniej klucz rejestru o uchwycie key. ConnectRegistry(compuetr_name, key) Zwraca uchwyt predefiniowanego klucza rejestru na innym komputerze, com- puter_name jest nazwą zdalnego komputera w formie napisu \ \nazwakom- putera. Jeśli computer_name ma wartość None, funkcja używa lokalnego rejestru, key jest predefmiowanym kluczem, takim jak HKEY_ CURRENT_USER uoaateK A: tnoiioteKa Hytnona lub HKEY_USERS. W przypadku niepowodzenia funkcja zgłasza wyjątek E ronmentError. CreateKey (key, sub__key) Tworzy lub otwiera klucz i zwraca jego uchwyt, key jest wcześniej otwa kluczem lub kluczem predefiniowanym w postaci stałej HKEY_*. sub_ jest nazwą klucza, który ma zostać otwarty lub utworzony. Jeśli key jes czem predefiniowanym, sub_key może mieć wartość None, co powc zwrot wartości key. DeleteKey (key, sub__key) Usuwa sub_key. Key jest otwartym kluczem lub jedną z predefiniowa stałych postaci HKEY_*. sub_key jest napisem wskazującym usuwany Ł Nie może on mieć żadnych podkluczy, gdyż inaczej zostanie zgłoś wyjątek EnvironmentError.

DeleteValue (key, value) Usuwa wartość value z klucza rejestru key. key jest otwartym kluczer jedną z predefiniowanych stałych postaci HKE Y_* .value jest napisem z« rającym nazwę usuwanej wartości. EnumKey (Jfcey, index) Zwraca nazwę podklucza o podanym indeksie, key jest otwartym klu lub jedną z predefiniowanych stałych postaci HKEY_*. index jest 1 całkowitą wyznaczającą położenie szukanego podklucza. Jeśli wartość i. jest spoza zakresu, funkcja zgłasza wyjątek EnvironmentError. EnumValue (key, index) Zwraca wartość otwartego klucza, key jest otwartym kluczem lub j z predefiniowanych stałych postaci HKEY_*. index jest liczbą całkowiti znaczającą położenie szukanej wartości. Funkcja zwraca tupię (n, data, type), gdzie name jest nazwą wartości, data jest obiektem z< rającym szukaną wartość, a type jest liczbą całkowitą wskazującą typ tej tości. Aktualnie są zdefiniowane następujące kody typów: Kod Opis REG_BINARY Dane binarne REG_DWORD Liczba 32-bitowa REG_DWORD_LITTLE_ENDIAN Liczba 32-bitowa w formacie little-endian REG_DWORD_BIG_ENDIAN Liczba 32-bitowa w formacie big-endian REG_EXPAND_SZ Napis zakończony znakiem pustym z nierozwiniętymi odniesieniami do

zmienny środowiskowych REG_LINK Dowiązanie symboliczne Unicode REG_MULTI_SZ Sekwenqa napisów zakończonych znakiem

pi REG_NONE Niezdefiniowany typ wartości REG_RESOURCE_LIST Lista zasobów sterownika urządzenia REG_SZ Napis zakończony znakiem pustym

Python FlushKey (key) Wymusza zapis atrybutów klucza key Rejestru na dysku. Funkcja ta powinna być wywoływana tylko wtedy, gdy aplikacja musi mieć pewność, że dane Re- jestru są zabezpieczone przed utratą. Powrót z funkcji następuje dopiero po dokończeniu zapisu. W normalnych warunkach nie ma potrzeby korzystania z tej funkcji. RegLoadKey{key, sub_key, filename) Tworzy podklucz i zapisuje w nim informacje rejestracyjne z podanego pliku. key jest otwartym kluczem lub jedną z predefiniowanych stałych postaci HKE Y_*. s ub_key jest napisem identyfikującym ładowany podklucz. filename jest nazwą pliku, z którego należy pobrać dane. Zawartość tego pliku musi być utworzona za pomocą funkcji SaveKey (), a wołający proces musi mieć uprawnienia SE_RESTORE_PRIVILEGE. Jeśli key jest wartością zwróconą przez ConnectRegistry (), nazwa pliku powinna być ścieżką względną prowadzącą do zdalnego komputera. OpenKey(key, sub_key [, res [, sam]]) Otwiera klucz, key jest otwartym kluczem lub jedną z predefiniowanych stałych postaci HKEY_*. res jest zarezerwowaną liczbą całkowitą i musi mieć wartość zero. sam jest liczbą całkowitą definiującą chroniącą maskę dostępu do klucza. Standardowo jest to KEY_READ. A oto inne dopuszczalne wartości: • KEY_ALL_ACCESS • KEY_CREATE_LINK • KEY_CREATE_SUB_KEY • KEY_ENUMERATE_SUB_KEYS • KEY_EXECUTE • KEY_NOTIFY • KEY_QUERY_VALUE • KEY_READ • KEY_SET_VALUE • KEY_WRITE OpenKeyEx() To samo co OpenKey (). Query InfoKey (key) Zwraca informacje o kluczu key w postaci tupli (n um_s ubkeys, n um_va - lues, last_modified), gdzie num_subkeys jest liczbą podkluczy, num_values liczbą wartości, a la st_modified długą liczbą całkowitą za- wierającą czas ostatniej modyfikacji. Czas jest mierzony od 1 stycznia 1601 roku w jednostkach równych 100 nanosekundom. Query Value (key, sub_key) Zwraca w postaci napisu nienazwaną wartość klucza, key jest otwartym kluczem lub jedną z predefiniowanych stałych postaci HKEY_*. sub_key jest nazwą podklucza, z którym jest skojarzona wartość. Jeśli sub_key zawiera Dodatek A: Biblioteka Pythona None lub jest napisem pustym, funkcja zwraca wartość skojarzoną z Zwracana jest pierwsza nienazwana wartość, ale bez podania typu (dl lepiej jest używać QueryValueEx). QueryValueEx(key, value_name) Zwraca tupię (value, type) zawierającą dane i typ dla klucza key jest otwartym kluczem lub jedną z predefiniowanych stałych postaci HKE value_name jest nazwą zwracanej wartości, type jest jednym z kc całkowitych opisanych przy okazji funkcji En urn Value (). SaveKey (key, filename) Zapisuje podany klucz i wszystkie jego podklucze w pliku filename. jest otwartym kluczem lub jedną z predefiniowanych stałych postaci HKE Argument filename nie może wskazywać istniejącego pliku i nie pow:

zawierać rozszerzenia. Co więcej, proces wywołujący funkcję musi uprawnienia do wykonywania kopii zapasowych (SeBackupPrivilec SetValue(key, sub_key, type, value) Ustawia wartość podanego klucza, key jest otwartym kluczem lub j< z predefiniowanych stałych postaci HKEY_*. sub_key jest nazwą podkh z którym skojarzona jest wartość, type jest kodem typu całkowitego ogi czonym aktualnie do wartości REG_SZ. value jest napisem zawierają dane. Jeśli sub_key nie istnieje, zostanie utworzony. Aby funkcja zadzia key musi być otwarty z kodem dostępu KEY_SET_VALUE. SetValueEx(key, value_name, reserved, type, value) Ustawia wartość klucza, key jest otwartym kluczem lub jedną z predefi wanych stałych postaci HKEY_*. val ue_name jest nazwą wartości, type jednym z kodów typu całkowitego opisanych przy okazji funkqi Enum lue (), a value jest napisem zawierającym nową wartość. Przy ustawi; wartości typów numerycznych (na przykład REG_DWORD), value musi nadal napisem, tyle że zawierającym surowe dane. Napis taki można ut rzyć przy użyciu modułu struct. Argument reserved jest aktualnie i^ rowany i może mieć dowolną wartość (nie zostanie w ogóle użyta). zipfile Moduł zipfile służy do operowania na plikach zakodowanych w popularr formacie ZIP. Oto lista dostępnych funkcji: is_zipfile(filename) Sprawdza, czy filename jest poprawnym plikiem ZIP. Jeśli tak, zwrac a w przeciwnym razie None. ZipFile(filename [, mode [, compression]]) Otwiera plik ZIP filename i zwraca instancję ZipFile. Argument try mode może mieć jedną z następujących wartości: ' r ' oznacza czytanie niejącego pliku, ' a ' oznacza dodawanie do istniejącego pliku, a ' w' ozna usunięcie zawartości pliku i pisanie w nim od początku. W trybie ' a ', j filename jest istniejącym plikiem ZIP, nowe pliki zostaną dodane do nie Jeśli zaś fi 1 ename nie jest plikiem ZIP, archiwum zostanie po prostu dopi

236 Pyfoor, ne na jego końcu, compression określa metodę kompresji ZIP używaną przy pisaniu w archiwum i może mieć jedną z dwóch wartości: ZI P_STORED lub ZIP_DEFLATED (standardowo ZIP_STORED). PyZipFile(filename [, mode [, compression]]) Podobnie jak Z ipFi 1 e () otwiera plik ZIP, ale zwraca specjalną instancję Py- ZipFile, z dodatkową metodą writepy (), używaną do zapisywania w archiwum plików źródłowych Pythona. Ziplnfo( [filename [, date_time]]) Ręcznie tworzy nową instanqe Ziplnfo, używaną do przechowywania informacji o składnikach archiwum. Zazwyczaj nie ma potrzeby korzystania z tej funkqi, chyba że w połączeniu z metodą z. writestr () instancji Zip- File (opisaną poniżej). Instancja z obiektu ZipFi 1 e lub PyZipFi 1 e dysponuje następującymi metodami i atrybutami: z.close () Zamyka plik archiwum. Musi być wywołana, aby nastąpił zrzut rekordów do pliku ZIP przed zakończeniem programu. z.getinfo(name) Zwraca w postaci instancji Ziplnfo informaqe o składniku name archiwum (opisane poniżej). z.infolist() Zwraca listę obiektów Ziplnfo dla wszystkich składników archiwum. z.namelist() Zwraca listę nazw składników archiwum. z.printdir () Kieruje wykaz zawartości archiwum nasys.stdout. z. read (name) Wczytuje zawartość archiwum dotyczącą składnika name i zwraca te dane w postaci napisu. z. testzipO Wczytuje wszystkie pliki archiwum i sprawdza ich sumy kontrolne CRC. Zwraca nazwę pierwszego uszkodzonego pliku lub None, jeśli wszystko jest w porządku. z.write(filename [, arcname [, compress__type]]) Zapisuje plik filename w archiwum o nazwie arcname. compress_type podaje rodzaj kompresji i ma jedną z dwóch wartości: ZIP_STORED lub ZIP_DEFLATED. Standardowo funkcja stosuje wartość użytą w ZipFile () lub PyZipFile (). Archiwum musi być otwarte w trybie ' w • lub • a '. z. writepy (pathname [, basename]) Jest to metoda dostępna tylko w przypadku instancji PyZipFile i służy do zapisywania w archiwum ZIP plików źródłowych Pythona (* . py). Pozwala łatwo tworzyć pakiety dystrybucyjne aplikacji. Jeśli pathname jest plikiem, musi on mieć rozszerzenie . py. W takim przypadku do archiwum zostaną ta- DodatekA: Biblioteka Pythona kże dodane odpowiadające mu pliki . pyo, . pyc lub . py (w podanej kc ści). Jeśli pathname jest katalogiem i nie jest to pakiet Pythona, wsz odpowiadające mu pliki .pyo, .pyc lub .py są dodawane na najwyi poziomie archiwum. Jeśli katalog jest pakietem, pliki są dodawane pod r pakietu jako ścieżką. Jeśli jakieś podkatalogi również są pakietami, ze dodane rekurencyjnie. Wartość basename służy do celów wewnętr: i normalnie nie trzeba jej podawać. z.writestr(zinfo, bytes) Zapisuje łańcuch bajtów w archiwum. Informacja o tych bajtach jest za w instanqi zinfo obiektu Ziplnfo i musi obejmować przynajmniej r

pliku, datę i godzinę. Do utworzenia instanqi Ziplnfo można użyć fi Ziplnfo (). z.debug Poziom debugowania z zakresu od 0 (brak informaqi) do 3 (najwięcej macji). Instancje Ziplnfo zwracane przez funkcje Ziplnfo (), z .get info () i z f olist () mają następujące atrybuty: zinfo. filename Nazwa składnika archiwum. zinfo. date_time Tupla (year, month, day, hours, minutes, seconds) zawiei czas ostatniej modyfikacji (rok, miesiąc, dzień, godzina, minuta, sęku mon th i day są liczbami z zakresu l-12il-31 odpowiednio. Wszystk: zostałe wartości zaczynają się od 0. zinfo . compress_type Rodzaj kompresji zastosowany w składniku archiwum. Aktualnie modi puszcza tylko dwie wartości: ZIP_STORED i ZIP_DEFLATED. zinfo. comment Komentarz do składnika archiwum. zinfo.extra Dodatkowe pole do przechowywania danych zależnych od systemu, w rym został utworzony plik. zinfo. create__system Kod typu całkowitego wskazujący system, w którym powstało archiwurr powe wartości są wymienione w poniższej tabeli: Wartość 0 3 7 10 Opis MS-DOS (systemy plików FAT/VFAT/FAT32) UNIX Macintosh Windows NTFS

238 rymon zinfo.create_version Kod typu całkowitego wersji PKZIP użytej do utworzenia archiwum ZIP. zinfo .extract_version Minimalna wersja potrzebna do rozpakowania archiwum. z info. reserved Pole zarezerwowane. Aktualnie ustawione na wartość zero. zinfo.flag_bits Bity z flagami ZIP opisującymi kodowanie danych, łącznie z szyfrowaniem i kompresją. zinfo . volume Numer woluminu nagłówka pliku. zinfo .internal_attr Opis wewnętrznej struktury zawartości archiwum. Jeśli dolny bit ma wartość 1, oznacza to dane tekstowe (ASCII). W przeciwnym razie przyjmuje się dane binarne. zinfo. external_attr Zewnętrzne atrybuty pliku. Zależne od systemu operacyjnego. zinfo. header_of f set Odległość w bajtach do nagłówka pliku. zinfo.file_offset Odległość w bajtach do początku danych pliku. zinfo.CRC Suma kontrolna CRC-32 nierozpakowanego pliku. zinfo .compress_size Rozmiar pliku ze spakowanymi danymi. zinfo. file_size Rozmiar pliku z nierozpakowanymi danymi. UWAGI • Moduł ten wymaga użycia także modułu z l ib. • Szczegółowa dokumentacja wewnętrznej struktury plików ZIP jest dostępna w PKZIP Application Note pod adresem http: //www.pkware. com/appnote. html. Dodatek A: Biblioteka Pythona zlib Moduł zlib umożliwia kompresję danych za pomocą biblioteki zlib. adler32(string [, value]) Oblicza sumę kontrolną Adler-32 napisu string, value służy za wartość początkową (co pozwala obliczyć sumę kontrolną kilkunastu skonkatenowa- nych napisów). Bez tego argumentu używana jest domyślna stała wartość. compress(string [, level]) Upakowuje dane ze string, level jest liczbą całkowitą od 1 do 9 decy- dującą o stopniu kompresji. Wartośt 1 oznacza najgorszą (za to najszybszą) kompresję, a 9 najlepszą (ale najwolniejszą) kompresję. Domyślnym p< mem jest 6. Funkcja zwraca napis zawierający upakowane dane, a wystąpi błąd, zgłasza wyjątek error. compressobj([level]) Zwraca obiekt kompresji używany do upakowywania strumieni danycl mieszczących się w całości w pamięci, level ma to samo znaczenie w funkcji compress (). crc32(string [, value]) Oblicza sumę kontrolną CRC napisu string. Jeśli jest podany argument lue, służy za wartość początkową sumy. Bez niego używana jest stała tość domyślna. decompress(string [, wbits [, buffsize]]) Rozpakowuje zawartość napisu string, wbi ts decyduje o rozmiarze bu okna, a buff size jest wstępnym rozmiarem bufora wyjścia. W przypa błędu funkqa zgłasza wyjątek error.

decompressobj([wbits]) Zwraca obiekt dekompresji, wbi ts decyduje o rozmiarze bufora okna. Obiekt kompresji c ma następujące metody: c. compress (string) Wykonuje kompresję string. Zwraca napis zawierający upakowane c będące przynajmniej częścią string. Dane te powinny być dołączone do jścia wygenerowanego przez wcześniejsze wywołania c. compress (), utworzyć razem z nimi strumień wyjściowy. Pewna część danych weji wych może pozostać w wewnętrznych buforach do dalszego przetwarza c. flush ([mode]) Upakowuje całą pozostałą część danych wejściowych i zwraca napis za rający resztę upakowanych danych wyjściowych, mode może mieć wai Z_SYNC_FLUSH, Z_FULL_FLUSHlub Z_FINISH (domyślna). Z_SYNC_FL i Z_FULL_FLUSH umożliwiają dalszą kompresję i są używane w celu um< wienia częściowej naprawy błędu podczas dekompresji. Z_FINISH oznć koniec upakowanego strumienia. Obiekt dekompresji d ma następujące metody: d. decompress(string) Wykonuje dekompresję string i zwraca napis zawierający rozpakow dane będące przynajmniej częścią string. Dane te powinny być dołączoni wyjścia wygenerowanego przez wcześniejsze wywołania c. decompress aby utworzyć razem z nimi strumień wyjściowy. Pewna część danych wejs wych może pozostać w wewnętrznych buforach do dalszego przetwarzań d. flush () Wykonuje dekompresję pozostałej części danych wejściowych i zwraca ni zawierający resztę rozpakowanych danych wyjściowych. Po wywołanii metody nie można już użyć ponownie obiektu dekompresji.

240 Python 1 WYJĄTEK error Wyjątek zgłaszany w przypadku błędów podczas wykonywania kompresji lub dekompresji. UWAGA • Biblioteka zlib jest dostępna pod adresem http: //www. cdrom. com/pub/inf ozip/zlib. Zobacz także gzip (188).

Wątki W tej części są opisane moduły używane do programowania aplikacji wie- lowątkowych. Na początku znajduje się krótkie wprowadzenie i wyjaśnienie ter- minów. Podstawy w ątków Wykonujący się program nosi nazwę procesu. Z każdym procesem skojarzony jest stan systemu obejmujący pamięć, listę otwartych plików, licznik programu wskazujący wykonywaną instrukcję oraz stos wywołań używany do przechowywania funkcji i zmiennych lokalnych. Normalnie proces wykonuje instrukcje w formie pojedynczej sekwencji przepływu sterowania. Taka sekwencja jest czasem nazywana wątkiem (lub głównym wątkiem). Gdy program tworzy nowe procesy za pomocą wywołania systemowego, takiego jak os . system (), os . fork () czy os . spawnv (), procesy te wykonują się jako niezależne programy, z których każdy ma własny zbiór zasobów systemowych i główny wątek wykonania. Istnieje jednak możliwość utworzenia przez program dodatkowych wątków wykonania, istniejących wewnątrz tego samego procesu i dzielących dane oraz zasoby systemowe z wątkiem głównym. Wątki są użyteczne szczególnie wtedy, gdy aplikacja chce wykonać jakieś działania ró- wnolegle, nie tworząc nowych procesów potomnych lub gdy któreś z podzadań musi wczytać lub zapisać współużytko\ /ane dane. Program wielowątkowy wykonuje się, dzieląc swój czas przetwarzania między wszystkie aktywne wątki. Na przykład program z 10 aktywnymi wątkami wykonania będzie przydzielał około 1/10 czasu CPU każdemu wątkowi, przechodząc cyklicznie od jednego do drugiego. Ponieważ wątki dzielą te same dane, trzeba zachować maksimum ostrożności podczas aktualizowania w wątku struktur danych wykorzystywanych również przez inne wątki. W szczególności próba aktualizacji jakiejś struktury danych przez wiele wątków prawie jednocześnie może doprowadzić do uszkodzenia i niespójności stanu programu (jest to problem nazywany formalnie stanem wyści- gu). Aby radzić sobie z tego typu problemami, programy wielowątkowe muszą zamykać dostęp do krytycznych fragmentów kodu za pomocą wzajemnie wy- kluczających się blokad i innych narzędzi synchronizujących. Więcej informacji na temat teorii i implementacji wątków oraz blokad można znaleźć w większości książek poświęconych systemom operacyjnym. Diuiiuiei\a ryuiunu Wątki w Pythonie Python dopuszcza stosowanie wątków w Windows, Solaris i innych systerr współpracujących z biblioteką wątków POSIX (pthreads). Często jednak i wanie wątków jest standardowo wyłączone. Dlatego, aby dało się użyć modu omawianych w tej części, może być konieczne ponowne zbudowanie interpre z dodaną obsługą wątków (poczynając od wersji Pythona 2.1 obsługa wąt] jest już standardowo włączona). Szeregowanie wątków i przełączanie się między nimi jest ściśle kontrolowane p globalny mechanizm blokujący interpretera, który pozwala działać tylko jedni wątkowi w danym momencie. Co więcej, przełączanie się z jednego wątku na d może następować jedynie pomiędzy wykonaniami poszczególnych kodów b

wych w interpreterze. Częstotliwość, z jaką interpreter sprawdza koniecz przełączenia się na inny wątek, jest ustawiana za pomocą funkcji sys. set check terval (). Standardowo interpreter robi to co 10 instrukcji kodu bajtowego. W czasie pracy z modułami rozszerzeń interpreter może wywoływać funkcje pisane w języku C. Jeśli nie zostały one napisane specjalnie z myślą o współp z wielowątkową wersją interpretera Pythona, do swojego zakończenia funkc blokują wykonanie wszystkich innych wątków. W efekcie długotrwałe obli nia w module rozszerzenia mogą zmniejszać przydatność stosowania wątl Za to większość funkcji we/wy z biblioteki standardowej napisano z uwzg nieniem pracy w środowisku wielowątkowym. Na koniec programiści powinni być świadomi możliwości dziwnego reagow wątków na sygnały i przerwania. Na przykład wyjątek Keyboardlnterr może zostać odebrany przez dowolny wątek, a z kolei sygnały użyv w połączeniu z modułem signal są odbierane tylko przez główny wątek. thread Moduł thread zawiera funkcje służące do pracy z wątkami na niskim pozio Moduł ten jest dostępny w wersji dla Uniksa i dla Windows. allocate^lock() Tworzy nowy obiekt blokady typu LockType. Obiekt ten jest na pocz w stanie odblokowanym. exit () Zgłasza wyjątek SystemExit. Zmusza wątek do wyjścia. get_ident() Zwraca liczbę całkowitą będącą identyfikatorem bieżącego wątku. start_new_thread(func, args [, kwargs]) Wykonuje funkcję func w nowym wątku. Funkcja ta jest wywoływana ZĆ mocą apply (fun c, args, k wa r gs). Jeśli się uda, sterowanie jest nat miast przekazywane do jednostki wywołującej. Po wyjściu z funkqi i wątek kończy cicho swoje działanie. W przypadku zakończenia funkc skutek nieobsługiwanego wyjątku, następuje wyświetlenie śladu stosu i v cie z wątku (pozostałe wątki nadal jednak się wykonują).

242 _̂____________________________________________________________________________________' '"""' Obiekt blokady 1 ck, zwracany przez a 1 locateJLock (), ma następujące metody: lek. acquire ([waitflag]) Nakłada blokadę, czekając w razie potrzeby, aż inny wątek ją zwolni. Bez wa - it flag-po nałożeniu blokady funkcja zwraca N o n e. Jeśli w a i t fl a g ma war- tość 0, blokada jest nakładana tylko wtedy, gdy jest to możliwe natychmiast, bez czekania. Jeśli wait flag ma. wartość różną od zera, metoda przejmuje sterowanie do momentu, aż blokada zostanie zwolniona. Gdy jest podany argument wait flag, funkcja zwraca 1 po nałożeniu blokady, a 0 w przeciwnym wypadku. lek.release() Zwalnia blokadę. lek.locked() Zwraca status blokady: 1 - nałożona, 0 - nie. PRZYKŁAD Oto przykład prostego wątku wyświetlającego co pięć sekund bieżący czas: import thread import time def podaj_czas(odst ęp): while 1: time.sleep(odst ęp) print time.ctime(time.time()) • Uruchomienie nowego w ątku thread.start_new_thread(podaj_czas,(5,)) • Teraz, gdy działa ju ż w ątek podaj ący czas, mo żna zaj ąć si ę czym ś innym while 1: pass WYJĄTEK error Wyjątek zgłaszany na skutek błędów specyficznych dla wątków. UWAGI • Wywołanie sys . exit () lub zgłoszenie wyjątku SystemExit jest równoważne wywołaniu thread.exit (). • Metoda blokady acquire () nie może zostać przerwana. • To, czy inne wątki przetrwają po wyjściu z głównego wątku, zależy od systemu operacyjnego. W większości przypadków wątki te są natychmiast zabijane, bez żadnego sprzątania. Co więcej, możliwości sprzątania po wątku głównym są nieco ograniczone. W szczególności nie dochodzi do opróżnienia buforów standardowych plików we/wy, ani do wywołania destruktorów obiektów. Zobacz także threading (242). threading Moduł threading udostępnia interfejs wątków wysokiego poziomu, w tym klasę Thread oraz klasy różnych narzędzi pierwotnych do synchronizacji wątków. Moduł ten korzysta z zawartości modułu niskiego poziomu thread. Oto lista dostępnych funkcji narzędziowych: activeCount() Zwraca liczbę aktywnych w tym momencie obiektów Thread. currentThread() Zwraca obiekt Thread odpowiadający wątkowi wywołującemu tę funk enumerate() Zwraca listę wszystkich aktywnych w tym momencie obiektów Thread OBIEKTY THREAD Klasa Thread służy do reprezentowania poszczególnych wątków wykon Nowy wątek można utworzyć w sposób następujący: Thread(group=None, targe t=None, name=None, args=(), kwargs={}) Tworzy nową instancję Thread. Argument group ma wartość None i jest ] widziany do wykorzystania w przyszłości, target jest obiektem wywofy nym, uruchamianym przez metodę run () w momencie startowania wi Standardowo targe t ma wartość None, co oznacza, że nic nie jest wywoływ name jest nazwą wątku. Domyślnie tworzona jest unikatowa nazwa pc "Thread- N". a rgs jest tupią argumentów przekazywanych do funkcji tar a kwargs słownikiem argumentów hasłowych dla tej funkqi. Instancja t obiektu Thread ma następujące metody: t.start() Uruchamia wątek przez wywołanie metody run () w oddzielnym wątki:

konania. Metodę tę można wywołać tylko raz. t.run() Jest to metoda wywoływana w momencie startowania wątku. Standard wykonuje ona docelową funkcję przekazaną przez konstruktor. Metoc może zostać również przedefinio\ 'ana w podklasie Thread. t. join ([ timeout]) Czeka na zakończenie wątku lub upływ czasu podanego w timeout. A ment ten jest liczbą zmiennoprzecinkową wyrażającą czas oczekiwania i kundach. Wątek nie może wywoływać metody join () dla samego si Ponadto wywołanie jej dla wątku jeszcze nie uruchomionego powoduje b t.getName() Zwraca nazwę wątku. t. setName (name) Ustawia nazwę wątku. t.isAlive() Zwraca 1, jeśli wątek „żyje", a 0 w przeciwnym wypadku. Wątek żyje od mentu powrotu z metody start () aż do zakończenia jego metody rur t.isDaemon() Zwraca ustawienie flagi demon wątku.

t. setDaemon (daemonic) Ustawia flagę demon wątku na wartość boolowską da emonic. Trzeba to zro- bić przed wywołaniem start (). Wartość początkowa jest dziedziczona po wątku tworzącym. Cały program Pythona kończy działanie, gdy zabraknie żyjących wątków nie będących demonami. Aby wątek stał się demonem, trzeba użyć metody setDaemon (). Gdy zostają już tylko wątki-demony, program kończy działanie. Wszystkie programy mają główny wątek, który reprezentuje początkowy wątek wykonania. Nie jest on wątkiem-demonem. W niektórych przypadkach powstają sztuczne obiekty-wątki. Są to wątki wykonania uruchamiane poza modułem threading, na przykład w module rozszerzenia napisanym w C. Sztuczne wątki są zawsze traktowane jako żyjące i aktywne demony i nie można wywoływać dla nich metody j oin (). Co wię- cej, nigdy nie są usuwane, dlatego wykrycie ich zakończenia jest niemożliwe. Alternatywą dla jawnego skorzystania z obiektu Thread jest utworzenie podklasy klasy Thread. Przy takim podejściu można zastąpić metodę run () własną. To samo można zrobić z konstruktorem, ale wówczas trzeba koniecznie pamiętać o wywołaniu konstruktora klasy bazowej Thread.__init__(). Zastąpienie każdej innej metody klasy Thread powoduje błąd. OBIEKTY LOCK Podstawowym narzędziem blokady (lub narzędziem blokady wzajemnie się wy- kluczającej) jest prosty element synchronizujący, który może być w stanie „zablokowanym" lub „odblokowanym". Do zmiany stanu blokady służą dwie metody: acquire () irelease().W stanie zablokowanym próby nałożenia blokady są blokowane aż do zwolnienia blokady. Jeśli wi ęcej niż jeden wątek czeka na nałożenie blokady, tylko jeden z nich zdoła to zrobić, gdy blokada zostanie zwolniona. Kolejność, w jakiej są obsługiwane czekające wątki, jest nieustalona. Do utworzenia nowej instancji obiektu Lock służy następujący konstruktor: Lock() Tworzy nowy obiekt synchronizujący, początkowo w stanie odblokowanym. Instancja lek obiektu blokady ma następujące metody: lek . acquire ( [blocking = 1]) Nakłada blokadę, czekając w razie potrzeby, aż blokada będzie możliwa. Jeśli jest podany argument blocking i ma wartość zero, funkcja zwraca natychmiast 0, jeśli blokada się nie udała, a 1 w przeciwnym wypadku. lek.release() Zwalnia blokadę. Wywołanie tej metody w sytuacji, gdy blokada jest w stanie odblokowanym, powoduje błąd. BLOKADA WIELOKROTNA Blokada wielokrotna (ang. reentrant lock) jest podstawowym elementem synchroni- zującym, podobnym do Lock, ale umożliwiającym parokrotne nakładanie blokady przez ten sam wątek. W ten sposób wątek, który nałożył blokadę, może za- Diouoisna ryinona gnieżdżąc operacje acquire () i release (). W takim przypadku tylko na dziej zewnętrzna operacja release () ustawia element synchronizujący 7 wrotem w stanie odblokowanym. RLock() Tworzy nowy obiekt blokady wielokrotnej. Instancja rlck obiektu blokady wielokrotnej ma następujące metody: rick. acquire( [blocking - 1]) Nakłada blokadę, czekając w razie potrzeby, aż blokada będzie n\oż. Jeśli żaden wątek nie nałożył blokady, jest ona włączana, a poziom i rencji ustawiany na 1. Jeśli wątek wywołujący tę metodę nałożył już b] dę, poziom rekurencji tej blokady jest zwiększany o 1 i nastę natychmiastowy powrót z funkcji. rlck .release() Zwalnia blokadę, zmniejszając o jeden jej poziom rekurencji. Jeśli w ef< poziom rekurencji staje się równy zero, blokada jest ustawiana w nie odblokowanym. W przeciwnym razie nadal obowiązuje stan zab] wany. Funkqa ta powinna być wywoływana tylko w wątku, do ktć aktualnie należy blokada.

ZMIENNE STANU Zmienna stanu (ang. condition variable) jest elementem synchronizującym, ( tym na innym elemencie blokady i używanym wtedy, gdy wątek jest zainte wany konkretną zmianą stanu lub jakimś zdarzeniem. Typowym przykłs jest problem producent-konsument, w którym jeden wątek generuje dane, a gi je odbiera. Nowa instancja zmiennej stanu powstaje w wyniku użycia n pującego konstruktora: Condition([lock]) lock jest nieobowiązkową instanq'a Lock lub RLock. Bez tego argurr konstruktor tworzy nową instancję RLock przeznaczoną do używania r« ze zmienną stanu. Zmienna stanu cv udostępnia następujące metody: cv. acquire(*args) Nakłada blokadę na kryjący się pod nią element. Wywołuje odpowiedni, todę acquire (* args) tego elementu i zwraca jej wartość powrotną. cv. release() Zwalnia blokadę nałożoną przez kryjący się pod nią element. Wywołuj powiednią metodę release (* args) tego elementu i zwraca jej wartoś wrotną. cv. wait (t timeout]) Czeka do momentu powiadomienia jej przez inny wątek lub upływu ( timeout. Jest to metoda używana już po nałożeniu blokady przez v wywołujący. Powoduje zwolnienie kryjącej się pod nią blokady i uśpienie v aż do obudzenia go przez wywołanie metody notify () lub notif yAll samej zmiennej stanu w innym wątku. Po obudzeniu metoda pono

246 Python nakłada blokadę i przekazuje sterowanie do wątku. Argument timeout jest liczbą zmiennoprzecinkową podającą czas oczekiwania w sekundach. Po upływie tego czasu następuje obudzenie wątku, ponowne nałożenie blokady i powrót z metody. cv. notify([n] ) Budzi jeden lub więcej wątków czekających na zmienną stanu. Jest to metoda wywoływana tylko wtedy, gdy wywołujący ją wątek nałożył już blokadę, i ma sens, jeśli istnieją wątki czekające na powiadomienie. Argument n okre- śla liczbę wątków, które należy obudzić, i ma domyślnie wartość 1. Obudzone wątki nie wracają z metody wait () aż do uzyskania blokady. cv. notifyAll () Budzi wszystkie wątki czekające na tę zmienną stanu. PRZYKŁAD Oto przykład rozwiązania problemu producent-konsument przy użyciu zmiennych stanu: # Pobranie jednego elementu def konsument(): cv.acquire() while not element_jest_dost ępny(): cv.wait() # Czekanie na element cv.release() konsumuj_element() # Pobranie elementu # Wygenerowanie jednego elementu def producent(): generuj_element() cv.acquire() udost ępnij_element() cv.notify() cv.release() # Wygenerowanie elementu # Powiadomienie konsumenta SEMAFOR Semafor (ang. semaphore) jest narzędziem synchronizującym opartym na liczniku zmniejszanym przez każde wywołanie acquire () i zwiększanym przez każde wywołanie release (). Gdy licznik osiągnie wartość zero, metoda acquire () blokuje się aż do momentu wywołania przez inny wątek metody release (). Semaphore ([value]) Tworzy nowy semafor, value jest początkową wartością licznika. Bez niej licznik ustawiony jest standardowo na wartość 1. Instancja s semafora ma następujące metody: s.acquire([blocking]) Ustawia semafor. Jeśli wewnętrzny licznik ma wartość większą od zera, metoda zmniejsza ją o jeden i wraca natychmiast do wątku. Jeśli jest to zero, metoda blokuje się do momentu, aż inny wątek wywoła release () dla tego semafora. Argument blocking zachowuje się tak samo, jak w przypadku obiektów Lock i RLock. Dodatek A: Biblioteka Pythona s.release () Zwalnia semafor, zwiększając wartość jego wewnętrznego licznika o jeden było to zero i jakiś wątek czekał na ten semafor, zostanie on obudzony. Jeśl kało kilka wątków, tylko w jednym z nich nastąpi powrót z metody a cqu i i Wybór wątku, który zostanie w ten sposób wznowiony, jest nieokreślony. ZDARZENIA Zdarzenia (ang. events) służą do komunikowania się wątków ze sobą. Komui cja odbywa się poprzez sygnalizowanie „zdarzenia" przez jeden wątek i C2 nie na niego przez drugi (lub nawet kilka). Instancja obiektu Event zarządzi wnętrzną flagą, którą można ustawiać na prawdę lub fałsz, używając odpov nio metody set () lub clear (). Za pomocą metody wait () blokuje się z wykonanie wątku do momentu ustawienia flagi na prawdę.

Event() Tworzy nową instancję Event z wewnętrzną flagą ustawioną na fałsz. Instancja e zdarzenia ma następujące metody: e.isSet() Zwraca prawdę tylko wtedy, gdy wewnętrzna flaga jest ustawiona na prav e.set() Ustawia wewnętrzną flagę na prawdę. Wszystkie wątki czekające na to rżenie są budzone. e.clear() Ustawia wewnętrzną flagę na fałsz. e. wait ([ timeout]) Blokuje wątek aż do ustawienia wewnętrznej flagi zdarzenia na prawdę, w momencie wywołania wewnętrzna flaga jest ustawiona na prawdę, n; puje natychmiastowy powrót z metody. W przeciwnym wypadku czeka aż inny wątek za pomocą set () ustawi tę flagę na prawdę lub upłynie timeout, timeout jest liczbą rzeczywistą podającą liczbę sekund. PRZYKŁAD Oto przykład wykorzystania modułu threading do pobrania kolekcji U w oddzielnych wątkach. W przykładzie tym wątki są definiowane za pon podklasy klasy Thread. import threading import urllib class W ątekPobierzURL(threading.Thread): def__init__(self, url, nazwapliku) : threading. Thread.__init__(self) self.url = url self.nazwapliku = nazwapliku def run (self) : print self.getName(), 'Pobiera ', self.url urllib.urlretrieve(self.url,self.nazwapliku) print self.getName(), 'Zapisany w ', self.nazwaplik u urle = [ ('http://www.python.org','/tmp/index.html' ), (' ftp://ftp.python.Org/pub/python/2.l/Python-2.l.t gz', '/tmp/py21.tg: ('http://www.petaflop.org/p.png','/tmp/p.png'),

248 Python ('http://www.pud.com','/tmp/pud.html') ] # Pobranie kilku URL-i w oddzielnych w ątkach for url,plik in urle: t = W ątekPobierzURL(url,plik) t.start() Zobacz tak że thread (241), Queue (248). Queue Moduł Queue implementuje kolejkę FIFO wielu producentów /wielu kon- sumentów, za pomocą której można bezpiecznie wymieniać informacje między wieloma wątkami wykonania. Aby móc skorzystać z tego modułu, trzeba dyspo- nować interpreterem Pythona z włączoną obsługą wątków. Moduł Queue definiuje następujące klasy: Queue(maxslze) Tworzy nową kolejkę, w której można umieścić maksymalnie max size elementów. Jeśli wartość maxsize jest mniejsza lub równa 0, kolejka ma rozmiar nieskończony. Instancja q klasy Queue ma następujące metody: q.qsize() Zwraca przybliżony rozmiar kolejki. Ponieważ kolejka może być aktualizo- wana przez inne wątki, podawana liczba nie jest dokładna. g. empty() Zwraca 1, jeśli kolejka jest pusta, a 0 w przeciwnym wypadku. g. fuli () Zwraca 1, jeśli kolejka jest pełna, a 0 w przeciwnym wypadku. q.put(item [, block]) Wstawia i tern do kolejki. Jeśli nieobowiązkowy argument block jest podany i ma wartość 1 (wartość domyślna), kod wywołujący zostaje zablokowany do momentu zwolnienia jakiegoś miejsca w kolejce. W przeciwnym razie (gdy block ma wartość 0), jeśli kolejka jest pełna, zgłaszany jest wyjątek Fuli. g.put_nowait (item) To samo co q.put (item, 0). g. get ([block] ) Usuwa i zwraca i tern z kolejki. Jeśli nieobowiązkowy argument block jest podany i ma wartość 1 (wartość domyślna), kod wywołujący zostaje zablokowany do momentu uzyskania dostępu do i te/n. W przeciwnym razie (gdy block ma wartość 0), jeśli kolejka jest pusta, zgłaszany jest wyjątek Empty. q. get_nowait () To samo co g. get (0). WYJĄTKI Empty Wyjątek zgłaszany w przypadku nieblokującego wywołania get() lub get_nowait () dla obiektu Queue pustego lub zablokowanego. Dodatek A: Biblioteka Pythona Fuli Wyjątek zgłaszany w przypadku nieblokującego wywołania put () put_nowait () dla obiektu Queue pełnego lub zablokowanego. Zobacz także thread (241), threading

Programowanie sieciowe W tej części opiszemy moduły używane do implementowania serwerów i k tów sieciowych. Python udostępnia szeroką gamę narzędzi z tej dziedziny czynając od interfejsów sieciowych niskiego poziomu aż po klienty wysol poziomu i środowiska pisania aplikacji sieciowych. Zanim jednak do tego p dziemy, przedstawimy krótki wstęp do programowania sieciowego. Bar

szczegółowe i zaawansowane wyjaśnienia można znaleźć w książkach takicł na przykład UNIX Network Programming, Volume 1: Networking APIs - Socket XTI Richarda Stevensa (Prentice Hall, 1997, ISBN 0-13-490012-X). Moduły Pythona do pisania programów sieciowych współpracują głó1

z dwoma protokołami internetowymi: TCP I UDP. Protokół TCP jest nieza^ nym protokołem kontroli transmisji używanym do nawiązywania dwukieru wych połączeń między komputerami. UDP jest niskiego poziomu protok< pakietowym (bezpołączeniowym), w którym komputery wysyłają i odbii dyskretne pakiety informacji bez formalnego nawiązywania połączenia. Kc nikacja UDP, w odróżnieniu od TCP, jest niepewna i z tego względu zdecyd< nie bardziej skomplikowana do zarządzania w komunikacjach wymagają niezawodnych połączeń. W konsekwencji większość protokołów internekrv wykorzystuje połączenia TCP. Oba protokoły sieciowe są realizowane za pomocą abstrakcyjnych obiektów gramistycznych zwanych gniazdami. Gniazdo jest obiektem podobnym do p który pozwala programowi odebrać połączenie, zgłosić chęć nawiązania połć nia innemu komputerowi oraz nadawać i odbierać dane. Zanim dwa kompi będą w stanie nawiązać połączenie, muszą utworzyć u siebie obiekty-gniazd. Co więcej, komputer odbierający połączenie (serwer) musi związać i obiekt-gniazdo z odpowiednim portem. Port jest 16-bitową liczbą z zak: 0 - 65535, zarządzaną przez system operacyjny i używaną przez klientów dc noznacznego identyfikowania serwerów. Porty od 0 do 1023 są zarezerwov przez system operacyjny i wykorzystywane przez popularne protokoły siecii Oto tabela z listą portów przypisanych do najczęściej używanych protokołów ciowych: Usługa Numer portu

FTP-dane 20 FTP-sterowanie 21 Telnet 23 SMTP (poczta) 25 Finger 79

250 Python Usługa Numer portu HTTP (WWW) NNTP (wiadomości) HTTPS (bezpieczne WWW)

80 119 443

Proces nawiązywania połączenia TCP obejmuje dokładną sekwencję działań za- równo po stronie serwera, jak i klienta, co jest pokazane na rysunku A.l. Serwer Klient socket () socket()

r bind () > r listen () r accept() czekanie na

> f

V połączenie nawiązanie połączenia

connect () > r

A f \ ^ żądanie

write ()

1 przetworzenie żądania

1

r

odpowiedz w

te()

read ()

Dodatek A: Biblioteka Pythona Rysunek A.1 Protokół połączenia TCP W przypadku serwerów TCP obiekt-gniazdo używany do odbioru połączenia nie jest tym samym gniazdem, które służy następnie do komunikaqi z klientem. Mówiąc konkretnie, wywołanie systemowe accept () zwraca nowy obiekt- gniazdo, który będzie dalej służyć do komunikacji. Dzięki temu serwer może zarządzać połączeniami z wieloma klientami jednocześnie. Komunikaqa UDP przebiega w podobny sposób, tyle że bez nawiązywania połączenia między klientami i serwerami, jak to jest pokazane na rysunku A.2. Serwer Klient socket () socket() \ r

r

bind()

bind ()

r reevfrom () czekanie r \

a dane żądanie >

sendto ()

1 przetworze

r nie żądania r

r

sen odpowiedź

dto()

w reevfrom ()

Rysunek A.2 Protokół połączenia UDP Oto przykład ilustrujący działanie protokołu TCP, w którym klient i serwer do siebie przy użyciu modułu socket. W tym przypadku serwer przekazi klienta bieżący czas w postaci napisu. # Serwer czasu from socket import * import time s = socket(AF_INET, SOCK_STREAM) s.bindU1 ',8888)) s.listen (5) while 1: client,addr = s.accept () print 'Poł ączenie z ',addr client.send(time.ctime(time.time())) client.close () # Utworzenie gniazda TCP # Dowi ązanie do portu 8888 # Oczekiwanie, ale z limite # 5 poł ącze ń w kolejce. # Odebranie poł ączenia # Wysłanie danych do klient A oto program klient: # Klient czasu from socket import * s = socket (AF_INET,SOCK_STREAM) s.connect(('gdzies.tam.com', 8888)) tm = s.recv(1024) s.close () print 'Czas serwera: ', tm # Utworzenie gniazda TCP # Poł ączenie z serwerem # Odbiór nie wi ęcej ni ż 1024 ba Reszta tego dodatku poświęcona jest opisowi modułów należących do dwóc tegorii. Pierwszą z nich stanowią moduły i narzędzia związane z program niem gniazd. Druga kategoria obejmuje różne moduły implementujące int klienta dla popularnych protokołów internetowych. Z wyjątkiem HTTP nie dziesz tu szczegółowych informaqi o samych protokołach. Jeśli są ci potrz

252 Python zajrzyj do dokumentacji online lub odpowiedniego internetowego dokumentu RFC (Request for Comments) w miejscu http: //www. ietf . org. Odsyłacze do tych dokumentów oraz innych źródeł informacji znajdziesz także w dalszej czę- ści tekstu. asyncore Moduł asyncore służy do budowania aplikacji sieciowych, w których aktyw- ność sieciowa przebiega asynchronicznie, w postaci serii zdarzeń rozdzielanych w pętli opartej na wywołaniu systemowym select (). Takie podejście jest wy- godne w przypadku programów, które chcą zapewnić współbieżność bez korzystania z wątków lub procesów. Może też okazać się najbardziej wydajne dla krót- kich transakcji. Całe działanie tego modułu jest realizowane przez klasę dispatcher, stanowiącą cienką obudowę zwykłego obiektu-gniazda. dispatcher ([socle]) Klasa bazowa definiująca sterowany zdarzeniami nieblokujący obiekt-gniazdo. sock jest istniejącym już obiektem-gniazdem. Bez niego następuje utworzenie gniazda za pomocą opisanej dalej metody create_socket (). Kiedy już istnieje, zdarzenia sieciowe są obsługiwane za pomocą specjalnych metod, o których powiemy później. Ponadto wszystkie otwarte obiekty typu dispatcher są zapisane na wewnętrznej liście używanej przez kilka funkcji odpy- tujących. Oto metody klasy dispatcher wywoływane w celu obsługi zdarzeń sieciowych. Powinny być również zdefiniowane w klasach pochodnych od dispatcher. d.handle_read() Wywoływana, gdy są gotowe nowe dane do wczytania z gniazda. d.handle_write() Wywoływana w momencie próby zapisu danych. d.handle_expt() Wywoływana po otrzymaniu przez gniazdo dodatkowych danych (out of band). d. handle_connect() Wywoływana w momencie tworzenia połączenia. d.handle_close() Wywoływana w momencie zamykania gniazda. d.handle_accept() Wywoływana dla nasłuchującego gniazda w momencie odbioru nowego połączenia. d.readable() Używana przez pętlę select () w celu sprawdzenia, czy obiekt chce wczytać dane. Jeśli tak, zwraca 1, a w przeciwnym wypadku 0. Na podstawie rezultatu tej metody ustala się, czy należy wczytać nowe dane za po- mocą metody handle_read (). Dodatek A: Biblioteka Pythona d. writable() Wywoływana przez pętlę select () w celu sprawdzenia, czy obie zapisać dane. Jeśli tak, zwraca 1, a w przeciwnym wypadku 0. Na { wie rezultatu tej metody ustala się, czy należy wygenerować dane w we za pomocą metody handle_write (). Oprócz wymienionych już metod używa się również innych, wykom operaqe niskiego poziomu na gniazdach. Są one podobne do metod uc nianych przez obiekt-gniazdo. Oto one: d.create_socket(family, type) Tworzy nowe gniazdo. Argumenty są takie same, jak w przy socket.socket(). d.connect(address) Tworzy połączenie. Argument address jest tupią postaci (host, p d.send(data) Wysyła dane data.

d.recv(size) Odbiera co najwyżej size bajtów. d. listen([backlog]) Słucha nadchodzących połączeń. d.bind(address) Wiąże gniazdo z podanym adresem. Argument address jest z tupią postaci (host, port). d.accept() Akceptuje połączenie. Zwraca parę (client, addr), gdzie clie obiektem-gniazdem używanym do przesyłania i odbierania danyd mach połączenia, a addr adresem klienta. d.close () Zamyka gniazdo. Oto funkcje używane do obsługi zdarzeń: poll([timeout [, ignore_exception]]) Przegląda cyklicznie za pomocą select () wszystkie otwarte obiekty d: tcher pod kątem zdarzeń sieciowych i jeśli trzeba, wywołuje odpow procedurę obsługi, timeout jest nieobowiązkowym czasem oczekiwań: myślnie ma wartość 0.0). Jeśli jest ustawiony argument i gnore excep wszystkie wyjątki zgłoszone w procedurach obsługi zdarzeń będą ignon (ustawienie domyślne). loop ([ timeout]) Sprawdza bez końca zdarzenia. W praktyce wywołuje jedynie co pewie funkcję poll (). timeout jest okresem oczekiwania, ustawionym stć dowo na 30 sekund.

254 Python PRZYKŁAD Oto przykład implementacji minimalnego serwera WWW przy użyciu modułu asyncore. Występują w nim dwie klasy: asynhttp do odbierania połączeń oraz asynklient do przetwarzania żądań klienta. # Minimalny serwer HTTP bez kontroli bł ędów, import asyncore, socket import string, os, stat, mimetypes # Klasa, która tylko akceptuje poł ączenia class asynhttp(asyncore.dispatcher): def__init__(self, port): asyncore. dispatcher.__init__(self) self.create_socket(socket.AF_INET,socket.SOCK_STREA M) self.bind(('',port)) self.listen(5) # Akceptacja poł ączenia i utworzenie klienta def handle_accept(self): klient,adr = self.accept() print 'Poł ączenie z ', adr return asynklient(klient) # Obsługa klientów class asynklient(asyncore.dispatcher): def__init__(self, sock = None) : asyncore. dispatcher.__init__(self, sock) self.got_request =0 # Wczyta ć żądanie HTTP? self.request_data = [] self.responsef = None # Plik odpowiedzi self.sent_headers =0 # Wysła ć nagłówki HTTP? self.clientf = sock.makefile('r+',0) # Plik żądania # Czeka na czytanie, je śli nie jest wczytany nagłówek żądania def readable(self): if not self.got_request: return 1 # Wczytanie nagłówka żądania (do pustej linii) def handle_read(self): data = string.strip(self.clientf.readline()) if data: self.request_data.append(data) return self.got_request = 1 request = string.split(self.request_data[0]) if request[0] == 'GET': filename = request[1][1:] self.responsef = open(filename) self.content_type,enc = mimetypes.guess_type(filena me) self.content_length = os.stat(filename)[stat.ST_SIZ E] else: self.close() # Czeka na pisanie, je śli jest gotowa odpowied ź def writable(self) : if self.responsef: return 1 return 0 # Zapisanie danych odpowiedzi def handle_write(self) : # Wysłanie nagłówków HTTP, je śli jeszcze nie nast ąpiło if not self.sent_headers: self.send('HTTP/1.0 200 OK\n') if not self.content_type: self.content_type = 'text/plain' self.send('Content-type: %s\n' % (self.content_type ,)) self send('Content-length: %d\n\n' % (self.content_ length,)) uoaateK A: biblioteka Pythona self.sent_headers = 1 # Wczytanie danych i wysłanie ich data = self.responsef.read(8192) if data: sent = self.send(data) # Dostosowanie niewysłanych danych self.responsef.seek(sent-len(data),1) else: self.responsef.close() self.close() # Utworzenie serwera a = asynhttp(80) # Niesko ńczona p ętla sprawdzaj ąca

asyncore.loop() UWAGA # Moduł ten wymaga modułu select. Zobacz także socket (275), oelect (273), httplib (266), SocketServe BaseHTTPServer Moduł BaseHTTPServer definiuje dwie klasy bazowe używane do impL towania serwerów HTTP. HTTPServer (server_address, requ.es t_handler) Tworzy nowy obiekt HTTPServer. server_address jest tupią postaci (i port) używaną przez serwer do nasłuchiwania. request_handler jest tem klasy używanym do obsługi żądań (zostanie wkrótce omówiony). Klasa HTTPServer jest pochodną klasy SocketServer. TCPServer i same metody. W szczególności udostępnia następujące istotne funkcje: Funkcja h. handle_request( h. serve forever() Opis Przetwarza pojedyncze żądanie. Obsługuje nieskończoną liczbę żądań. W celu obsługi żądań definiuje się klasy pochodne od następującej: BaseHTTPRequestHandler(request, cl±ent_address, server Klasa ta jest używana do obsługi żądań HTTP. Po odebraniu połączeń stępuje analiza składniowa żądania i nagłówków HTTP. Potem dokom próby wykonania metody postaci do_REQUEST opartej na typie żądań przykład żądanie 'GET1 spowoduje wywołanie metody do_G a ' POST' - do_POST (). Standardowo klasa ta nie potrafi nic zrobić, d trzeba zdefiniować te metody w podklasie. Oto lista zmiennych klasy zdefiniowanych wBaseHTTPRequestHanc BaseHTTPRequestHandler.server_version Zawiera napis z wersją oprogramowania serwera - na prz 'NazwaSerwera/1.2'. BaseHTTPRequestHandler.sys_version Napis z wersją Pythona, na przykład 'Python/2.0'.

256 Python BaseHTTPRequestHandler. error_message_f ontiat Napis formatujący używany do generowania komunikatów o błędach przesyłanych klientowi. Napis formatujący odnosi się do słownika zawie- rającego atrybuty code, message i explain (kod, komunikat i wyjaśnie- nie). Na przykład: 1 ''<head> <title>Informacja o bł ędzie</title> </head> <body> <hl>Informacja o bł ędzie</hl> <p>Kod bł ędu %(code)d. <p>Komunikat: %(message)s. <p>Wyja śnienie kodu bł ędu: %(code)s = %(explain)s. </body>''' BaseHTTPRequestHandler . protocol_version Wersja protokołu HTTP używanego w odpowiedziach. Standardowo jest to ' HTTP/1.0'. BaseHTTPRequestHandler.MessageClass Klasa używana do analizy składniowej nagłówków HTTP. Standardowo jest nią mimetools .Message. BaseHTTPRequestHandler.responses Mapowanie kodów błędów (liczb całkowitych) na dwuelementowe tupie (message, explain), opisujące problemy. Instancja b klasy BaseHTTPRequestHandler ma następujące atrybuty: Atrybut Opis b.client_address Adres klienta w postaci tupli (hos t, port). b. command Typ żądania, taki jak ' GET', ' POST', ' HEAD' i tak dalej. i).path Zawiera ścieżkę żądania. b.request version Napis z wersją HTTP żądania, na przykład ' HTTP/1. 0 '. b. headers Nagłówki HTTP, reprezentowane zazwyczaj jako obiekt mimetools.Message. jb.rfile Strumień z nieobowiązkowymi danymi wejściowymi. b.wfile Strumień wyjściowy do zapisywania odpowiedzi dla klienta. Dodatek A: Biblioteka Pythona Oto lista dostępnych metod: Jb.handle () Dyspozytor żądań. Analizuje żądania i wywołuje odpowiednie metody postaci do_*(). b.send_error(code [, message]) Wysyła do klienta komunikat o błędzie, code jest liczbowym kodem błędu HTTP, message jest nieobowiązkowym komunikatem. ł>.send_response (code [, message]) Wysyła nagłówek odpowiedzi. Po linii odpowiedzi HTTP następują nagłówki Server i Date. b.send_header( keyword, value) Zapisuje element nagłówka MIME w strumieniu wyjściowym, keywoz słowem kluczowym nagłówka, a value jego wartością. b.end_headers() Wysyła pustą linię na znak końca nagłówków MIME. b.log_request([code [, size]) Zapisuje w dzienniku pomyślne żądanie, code jest kodem HTTP, a si z< miarem odpowiedzi w bajtach (jeśli jest znany). b.log_error(format, . . .) Zapisuje w dzienniku komunikat o błędzie. Standardowo wywoływań metoda b. log_message (). b. log_message (format, . . .)

Zapisuje dowolny komunikat w sys . stderr. forma t jest napisem fc tującym, odnoszącym się do wszystkich dodatkowych argumentów j nych w wywołaniu. Adres klienta i bieżący czas są dodawane na poc; każdej wiadomości. b.version_string() Zwraca napis z wersją oprogramowania serwera - kombinację zmień server_versioni sys version. b. date_time_s tring () Zwraca bieżącą datę i godzinę, sformatowane dla nagłówka. Jb. log_date_time_s tring () Zwraca bieżącą datę i godzinę, sformatowane dla zapisu w dzienniku. 23. address_s tring () Na podstawie IP klienta szuka jego adresu symbolicznego i zwraca nazw sta sformatowaną pod kątem zapisu w dzienniku. PRZYKŁAD Oto przykład obsługi żądań typu GET i odsyłania ich w niezmienionej posta klienta na stronie WWW. import BaseHTTPServer class EchoHandler(BaseHTTPServer.BaseHTTPRequestHan dler): # Odsyła kopi ę żądania z powrotem do strony WWW def do_GET(self): self.send_response(200) self.send_header('Content-type' , 'text/html') self.end_headers() self.wfile.write(''' <html><headxtitle>Twoje żądanie</title></head> <body> <pre> Twoje żądanie wygl ąda nast ępuj ąco : %s Oto nagłówki żądania : %s </prex/body></html> 111 % (self.path, self.headers)) server = BaseHTTPServer.HTTPServer(('',80),EchoHand ler) server.serve forever()

258 tymon UWAGA • Zawartość tego modułu jest rzadko kiedy używana bezpośrednio. Zajrzyj do modułów simple- HTTPServer i CGIHTTPServer. Zobacz tak że SimpleHTTPServer (274), CGIHTTPServer (262), Socket Server (282), httplib (266), mimetools (290). cgi Dodatek A: Biblioteka Pythona Moduł cgi służy do implementowania skryptów CGI w aplikacjach WWW. Skrypty CGI są programami wykonywanymi przez serwer WWW, gdy chce on przetworzyć dane użytkownika doręczone za pomocą ' '-----TTPr11" ---- ^EV\DM jr"PTn»l-l /oni -V-ln /»1/ r r,~i t MPTB <FORM ACTION='/cgi-bin/skr.cgi' METHOD='GET'> Nazwisko : <INPUT type='Text' narae='name' size='30 '> Adres e-mail: <INPUT type='Text' name='email' size= '30'> <INPUT type='Submit' name='submit-button' value =l Subscribe'> </FORM> Po przedłożeniu tego formularza przez użytkownika serwer WWW uruchamia program CGI s kr. eg i, który otrzymuje dane wejściowe z dwóch źródeł: sys. stdin oraz zmiennych środowiskowych ustawionych przez serwer. Za- mieszczona niżej tabela zawiera listę typowych zmiennych środowiskowych ustawianych przez serwer: Zmienna Opis AUTH_TYPE Metoda uwiarygodniania CONTENT_LENGTH Długość danych przekazanych wsys.stdin CONTENTJTYPE Typ danych kwerendy DOCUMENT_ROOT Katalog główny dokumentu GATEWAY_INTERFACE Napis kontrolny CGI HTTP_ACCEPT Typy MIME akceptowane przez klienta HTTP_COOKIE Stała wartość cookie Netscape'a HTTP_FROM Adres email klienta (często niedostępny) HTTP_REFERER URL zleceniodawcy HTTP_USER_AGENT Przeglądarka klienta PATH_INFO Dodatkowe infonnaqe o ścieżce PATH_TRANSLATED Przetłumaczona wersja PAT H IN FO QUERY_STRING Napis kwerendy REMOTE_ADDR Zdalny adres IP klienta REMOTE_HOST Zdalna nazwa hosta klienta REMOTE_IDENT Użytkownik zgłaszający żądanie REMOTE_USER Uwiarygodniona nazwa użytkownika REQUEST_METHOD Metoda (' GET' lub ' POST') SCRIPT_NAME Nazwa programu SERVER NAME Nazwa hosta serwera SERVER_PORT Numer portu serwera SERVER_PROTOCOL Protokół serwera SERVER_SOFTWARE Nazwa i wersja oprogramowania serwera

Program CGI zapisuje dane wyjściowe w standardowym strumieniu sys out. Szczegółowe informacje o programowaniu CGI można znaleźć w ] Programowanie CGlwPerlu Shishira Gundavarama (Wydawnictwo RM, 20 naszych celów wystarczy znajomość tylko dwóch rzeczy. Po pierwsze, zav formularza HTML jest przekazywana do programu CGI w postaci sekwer stu zwanej napisem kwerendy. W Pythonie zawartość napisu kwerendy j stępna za pomocą klasy FieldStorage. Na przykład: import cgi form = cgi.FieldStorage() name = form['name'].value email = form['email'].value

# Pobranie z formularza pola 'name # Pobranie z formularza pola 'emai Po drugie, wyjście programu CGI składa się z dwóch części: nagłówka HT rowych danych (zazwyczaj HTML). Prosty nagłówek HTTP wygląda pująco: print 'Content-type: text/html' print # Wyj ście HTML # Pusta linia (konieczna!) Resztę wyjścia stanowią surowe dane. Na przykład: print *<TITLE>Mój skrypt CGK/TITLE>' print '<Hl>Witaj świecie!</Hl>' print 'Jeste ś %s (%s)' % (name, email) Większość pracy wykonywanej przez moduł cgi polega na utworzeniu i klasy FieldStorage. Klasa ta pobiera zawartość formularza przez we i analizę składniową napisu kwerendy przekazanego przez zmienną śi skową lub standardowe wejście. Ponieważ dane mogą być czytane ze stai wego strumienia wejściowego, należy tworzyć tylko jedną instancję kl stancja f klasy FieldStorage ma następujące atrybuty: Atrybut Opis .f .name Nazwa pola, o ile występuje f.filename Nazwa przysyłanego pliku po stronie klienta f. value Wartość jako napis f.file Obiekt podobny do pliku, z którego są czytane

c f. type Typ zawartości f. type options Słownik opcji podanych w linii typu

zawartości HTTP

f.disposition Pole ' content-disposition';None, jeślinii

występuje f.disposition options Słownik opcji dyspozycji f.headers Obiekt podobny do słownika, zawierający

wszy nagłówki HTTP Ponadto moduł cgi definiuje klasę MiniFieldStorage, która zawi< nazwę i wartość atrybutu. Klasa ta jest używana do reprezentowania in alnych pól formularza przekazanego w napisie kwerendy, a nie wielu p tości, jak w przypadku klasy FieldStorage.

260 Python Instancje FieldStor age są używane podobnie jak słowniki Pythona, a rolę kluczy pełnią w nich nazwy pól formularza. Uzyskane tą drogą obiekty są w przypadku wieloczęściowych danych lub nadesłanych plików kolejnymi instancjami FieldStorage, w przypadku prostych pól instancjami MiniFieldStorage, a w przypadku wielu identycznie nazwanych pól formularza - listami tych instancji. Jeśli pole reprezentuje nadesłany plik, sięgnięcie do atrybutu value powoduje wczytanie całego tego pliku do pamięci jako napisu. Ponieważ taki plik może zająć dużą część pamięci serwera, lepszym wyjściem może być czytanie jego danych w mniejszych porcjach, bezpośrednio z atrybutu file. Oto przykład pobierania nadesłanych danych linia po linii: fileitem = form['pliku żytkownika'] if fileitem.file: # To jest ładowany plik; zliczanie linii liczbalinii = 0 while 1: linia = fileitem.file.readline () if not linia: break liczbalinii = liczbalinii + 1 Oto lista funkcji stanowiących interfejs CGI na niższym poziomie: escape(s [, quote]) Konwertuje znaki '&', '<' i '>' w napisie s na sekwencje bezpieczne w HTML, czyli ' &amp', '&lt' i '&gt'. Jeśli nieobowiązkowa flaga quote ma wartość prawda, znak podwójnego cudzysłowu (") również jest tłuma- czony. parse([fp [, environ [, keep_blank_values [, strict_jparsing\ ]]]) Dokonuje rozbioru formularza i zwraca wynik w postaci słownika, fp jest obiektem-plikiem, z którego są czytane dane (domyślnie stdin). environ jest słownikiem zawierającym zmienne środowiskowe (domyślnie os.environ). Jeśli keep_blank_values ma wartość 1, puste elementy są mapowane na puste napisy. W przeciwnym wypadku puste elementy są ignorowane (ustawienie domyślne). Opcja strict_parsing decyduje o sposobie reagowania na błędy. Standardowo są one ignorowane. Ustawienie tej opcji powoduje w przypadku błędu zgłoszenie wyjątku ValueError. Funkcja zwraca słownik mapujący nazwy pól na listy wartości. parse_header (string) Analizuje dane dostarczone po polu nagłówka HTTP takim jak 'content-type1. Dane są rozbijane na wartość podstawową i słownik pa- rametrów podrzędnych, zwracanych w postaci tupli. Na przykład polecenie: parse_header("text/html; a =l witaj 1; b= ' świecie'") daje wynik w postaci: ('text/html', {'a':'witaj', 'b':' świecie'}). parse_multipart (fp, pdict) Analizuje dane wejściowe typu ' multipart/ form-data', używanego czę- sto w przypadku ładowania pliku do serwera, fp jest plikiem wejściowym, Dodatek A: Biblioteka Pythona a pdict słownikiem zawierającym parametry nagłówka content Funkcja zwraca słownik mapujący nazwy pól na listy wartości. Nie jednak dla zagnieżdżonych wieloczęściowych danych. Zamiast niej należy w używać klasy FieldStorage. parse_qs(gs [, keep_blank_values [, strict_parsing]]) Analizuje napis kwerendy qs. Argumenty keep_blank_v i strict_parsing mają to samo znaczenie co w przypadku pa: Funkcja zwraca słownik mapujący nazwy pól na listy wartości. parse_qsl (qs [, keep_blank_values [, strict_parsing] ] ) Działa podobnie jak pars e_qs (), tyle że zwraca listę par (nazwa, war print_directory ()

Formatuje zawartość bieżącego katalogu roboczego HTML. Funkcja ui podczas debugowania. print_environ () Formatuje zmienną środowiskową HTML. Funkcja używana podcza; gowania. print_environ_usage() Wyświetla listę przydatnych zmiennych środowiskowych HTML. I używana podczas debugowania. print_form (form) Formatuje dane dostarczone w formularzu HTML. form musi być ir FieldStorage. Funkcja używana podczas debugowania. test () Zapisuje minimalny nagłówek HTML i wyświetla wszystkie informs starczone skryptowi w formacie HTML. Funkcja używana podczas d wania. UWAGI • Proces instalowania programu CGI zależy w dużym stopniu od typu serwera, który jest używany. Progn zwyczaj umieszczane w specjalnym katalogu cgi-bin. Serwer może wymagać także dodatko guracji. • W Uniksie programy CGI napisane w Pythonie mogą wymagać umieszczenia na początku następi #!/usr/local/bin/python import cgi • Aby uprościć debugowanie, dobrze jest czasem ustawić zmienną sys.stderrnasys.: Spowoduje to przesyłanie pythonowych komunikatów o błędach na standardowy strumień wyjści samym umieszczenie ich w tekście wysyłanym do przeglądarki). • Wywołując program zewnętrzny - na przykład za pomocą funkcji os. system () lub os. po trzeba uważać, aby nie przekazać niesprawdzonego napisu od klienta do sheila. Jest to znana luk mie bezpieczeństwa, wykorzystywana przez hakerów do wykonywania różnych poleceń shella w (gdyż polecenia przekazywane do tych funkcji są interpretowane przez shell Uniksa, a nie wykony pośrednio). W szczególności nie należy nigdy przekazywać żadnego fragmentu URL-a ani danyc rza do polecenia shella, zanim nie sprawdzi się dokładnie, czy taki napis zawiera wyłąa alfanumeryczne, łączniki, podkreślenia i kropki.

262 Python Dodatek A: Biblioteka Pythona • Nie należy nigdy w Uniksie nadawać uprawnień SUID programowi CGI. Jest to element zabezpieczeń wy- stępujący nie we wszystkich systemach. • Nie należy używać instrukcji' from eg i import *', gdyż moduł ten definiuje całą masę nazw i symboli, które z reguły nie muszą występować w przestrzeni nazw. • Oryginalną specyfikację CGI można znaleźć pod adresem http://hoohoo.ncsa.uiuc. edu/egi/interface.html. Zobacz także CGIHTTPServer (262). CGIHTTPServer Moduł CGIHTTPServer udostępnia prosty program serwerowy HTTP, na- dający się do uruchamiania skryptów CGI. Serwer jest definiowany przez nastę- pującą klasę obsługi żądań, przewidzianą do współpracy z modułem Base- HTTPServer: CGIHTTPRequestHandler (request, cl±ent_address, server) Obsługuje pliki z katalogu bieżącego i wszystkich jego podkatalogów. Ponad- to potrafi uruchamiać w formie skryptów CGI pliki ulokowane w specjalnym katalogu CGI. Dozwolone metody to GET i POST. Lista dozwolonych katalogów CGI jest zawarta w następującym atrybucie: CGIHTTPRequestHandler.cgi_directories Standardową wartością tego atrybutu jest [' /egi-bin', ' /htbin' ]. PRZYKŁAD from BaseHTTPServer import HTTPServer from CGIHTTPServer import CGIHTTPRequestHandler import os • Przej ście do katalogu głównego os.chdir('/home/httpd/html') • Uruchomienie serwera CGI serv = HTTPServer(('',80),CGIHTTPRequestHandler) serv.serve_forever() UWAG! • Ze względów bezpieczeństwa skrypty CGI są wykonywane z UID użytkownika nobody. • Problemy ze skryptami CGI są reprezentowane przez błąd HTTP 403. • Żądania są obsługiwane za pomocą metod do_GET i do_POST, które można przedefiniować w podklasie. • Aby uniknąć problemów podczas wykonywania skryptów CGI, z reguły dobrze jest używać nazw katalogów CGI nie zawierających w środku żadnych białych znaków. Zobacz tak że BaseHTTPServer (255), SimpleHTTPServer (274), egi (258), httplib (266). Cookie Moduł Cookie zawiera narzędzia do zarządzania plikami cookie. Pliki cookie pozwalają udostępniać skryptom CGI informacje o kliencie, umożliwiające implementowanie sesji, logowań użytkownika, kart zakupowych i tak dalej. Aby dostarczyć plik cookie do przeglądarki klienta, server HTTP dodaje zazwyczaj do odpowiedzi HTTP (zobacz moduł httplib) nagłówek HTTP typu: Set-Cookie: session=8273612; expires=Sun, 18-Feb-20 01 15:00:00 GMT; \ path=/; domain=cs.uchicago.edu Alternatywnym sposobem ustawienia cookie jest osadzenie JavaScript w mencie HTML: <SCRIPT LANGUAGE="JavaScript"> document.cookie = "session=8273612; expires=Sun, 18 -Feb-2001 15:00:00 < Path=/; Domain=cs.uchicago.edu;" </SCRIPT> Moduł Cookie upraszcza generowanie wartości cookie, udostępniając spe obiekt w stylu słownika do przechowywania i nadzorowania kolekcji w< cookie zwanych odrobinami (ang. morsles). Każda odrobina ma swoją nazw< tość i zbiór nieobowiązkowych argumentów zawierających metadane, ktc leży dostarczyć do przeglądarki {expires, path, comment, domain, ma: secure, version). Nazwa jest zwykle prostym identyfikatorem typu "nazw i musi być inna niż nazwy metadanych, takie jak "expires " czy "path" tością jest z reguły krótki napis. Aby utworzyć plik cookie, wystarczy utv najpierw prosty obiekt cookie: c = Cookie.SimpleCookie() Gdy już istnieje, można przystąpić do ustawiania wartości (odrobin) pliku

za pomocą zwykłego przypisania słownikowego: cfsession"] = 8273612 c["user"] = "beazley" Ustawianie dodatkowych atrybutów konkretnej odrobiny wygląda następ c ["session"] ["path"] = "/" c["session"]["domain"] = "cs.uchicago.edu" c["session"]["expires"] = "18-Feb-2001 15:00:00 GMT " Aby przesłać dane pliku cookie w postaci zbioru nagłówków HTTP, możri metody c. output (). Na przykład: print c.output() # Produkuje dwie linie na wyj ściu # Set-Cookie: session=8273612; expires^...; path=/; domain=... # Set-Cookie: user=beazley Gdy przeglądarka przesyła plik cookie z powrotem do serwera HTTP, ma on napisu złożonego z par klucz=wartość, na przykład "session=827 user=beazley". Atrybuty nieobowiązkowe, takie jak expires, path i d nie są zwracane. Napis cookie jest z reguły przechowywany w zmiennej śr skowej HTTP_COOKIE, skąd można go pobrać do aplikaqi CGI. Aby odczyto tości cookie, wystarczy użyć następującego fragmentu kodu: c = Cookie. SimpleCookie (os .environ [ "HTTP__COOK IE" ] ) session = c["session"].value user = c ["user"].value W powyższym przykładzie instancja cookie c pochodzi od klasy BaseCc udostępniającej następujące metody: c. value__decode (val) Pobiera napis val i zwraca zakodowaną wartość cookie. Funkcja ta je wana do interpretowania wartości cookie zwróconej przez przegląda serwera.

264 Python c. value_encode (val) Pobiera obiekt val i zwraca go w postaci zakodowanego napisu, nadającego się do użycia w nagłówku HTTP. Serwer wykorzystuje tę funkcję do kodowania wartości funkcji przesyłanych do przeglądarki. c.output([attrs [, header [, sep]]]) Generuje napis nadający się do użycia podczas ustawiania wartości cookie w nagłówkach HTTP. attrs jest nieobowiązkową listą nieobowiązkowych ar- gumentów, które należy dołączyć ("expires", "path", "domain" i tak dalej), header jest używanym nagłówkiem HTTP (domyślnie ' Set-Cookie'), a sep znakiem służącym do łączenia nagłówków (domyślnie znakiem przejś- cia do nowej linii). c. js_output([attrs]) Generuje napis zawierający kod JavaScript, którego wykonanie w przeglądar- ce (obsługującej kod JavaScript) ustawi w niej wartość cookie, a t trs jest nie- obowiązkową listą dołączanych atrybutów. c.load(rawdata) Ładuje do c dane zawarte w rawda ta. Jeśli argument jest napisem, zakłada się, że ma on ten sam format, co zmienna środowiskowa HTTP__COOKIE w programie CGI. Jeśli argument jest słownikiem, każda para klucz-war- tość jest interpretowana jako ustawienie c[ klucz] =wartość. Podane niżej klasy są wyspecjalizowanymi implementacjami obiektów cookie. Każda z tych klas pochodzi od klasy BaseCookie. SimpleCookie([input] ) Definiuje obiekt cookie, w którym wartości cookie są interpretowane jako pojedyncze napisy. Metoda c.value_decode () jest funkcją tożsamościową, a metoda c.value_encode () funkcją generującą zakodowane wartości przy użyciu funkcji str (). SerialCookie([input] ) Definiuje obiekt cookie, w którym wartości cookie są interpretowane przy użyciu modułu piekle. Metoda c.value_decode () używa metody piekle . loads (), a metoda c. value_encode () metody piekle . dumps (). Przeczytaj dalej uwagę dotyczącą bezpieczeństwa. SmartCookie([input]) Działa podobnie, jak SerialCookie (), ale zostawia napisy niezmodyfikowane. Jeśli nie można pomyślnie złożyć z powrotem wartości cookie, c. value_deco- de () zwraca ją w postaci napisu. Ponadto, jeśli wartość nie jest napisem, metoda c. value_encode () wywołuje jedynie metodę piekle. dumps (). Przeczytaj dalej uwagę dotyczącą bezpieczeństwa. Wewnętrznie pary klucz/wartość używane do przechowywania wartości cookie są instancjami klasy Morsel. Instancja m tej klasy zachowuje się podobnie jak słownik i pozwala ustawiać nieobowiązkowe klucze "expires", "path", "comment", "domain", "max-age", "secure" i "version".Po- nadto instancja m dysponuje następującymi metodami i atrybutami: Dodatek A: Biblioteka Pythona m.value Surowa wartość cookie. m.coded_value Zakodowana wartość cookie, wysyłana do przeglądarki lub odebrana o m.key Nazwa cookie. m.set(Jtcey, value, coded_value) Ustawia wartości m. key, m.value i m. coded_value. m. isReservedKey (k) Sprawdza, czy k jest zarezerwowanym słowem kluczowym, tak

"expires", "path", "domain" i tak dalej. m.output([attrs [, header]]) Generuje napis z nagłówkiem HTTP dla tej instancji, attrs jest r wiązkową listą dodatkowych atrybutów, które należy dołączyć (" exp i "path" i tak dalej), header jest napisem z używanym nagłówkiem (domyślnie 'Set-Cookie'). m. js_ouput([attrs]) Zwraca kod JavaScript, którego wykonanie ustawi cookie. m.OutputString( [attrs]) Zwraca napis cookie bez żadnych nagłówków HTTP i kodu JavaSa Wystąpienie błędu podczas analizowania lub generowania wartości cool woduje zgłoszenie wyjątku CookieError. UWAGI • Więcej informacji o plikach cookie można znaleźć w niemal każdej książce o programowaniu CGI. specyfikacja jest dostępna w RFC-2109. • Klasy SerialCookie () i SmartCookie () są źródłem znanych zagrożeń, gdyż moduł F pozwala wykonać podczas składania cookie dowolny kod klienta. Dlatego nie należy używać tych I aplikacja nie ma sposobu sprawdzenia poprawności wartości cookie przez jej złożeniem. • Większość przeglądarek nakłada ograniczenia na wielkość i liczbę plików cookie. Z tego względ ograniczać rozmiar danych cookie do kilkuset bajtów. Zobacz także egi (258), httpli ftplib Moduł ftplib służy do implementowania klientów protokołu FTP. Rząd] dy zachodzi konieczność bezpośredniego skorzystania z niego, gdyż i moduł urllib, który zapewnia interfejs na wyższym poziomie. Przykład sowania tego modułu ilustruje następujący fragment kodu: >» import ftplib >» ftp = ftplib. FTP ('ftp.python.org') >» ftp.login() >» ftp.retrlines ('LIST') drwxrwxr-x 12 root 4127 512 Apr 6 19:57 . drwxrwxr-x 12 root 4127 512 Apr 6 19:57 .. drwxrwxr-x 2 root 4127 512 Aug 25 1998 RCS

266 rjuajn lrwxrwxrwx drwxr-xr-x 1 root bin 11 Jun 29 18:34 README -> welcome.msg 3 root wheel 512 May 19 1998 bin 1wb1).write) >» ftp.retrbinary ('RETR README 1, open ('README' '226 Transfer complete. 1

>» ftp.quit() Pełny opis działania tego modułu znajdziesz w dokumentacji online. Zobacz także urllib (284), Internet RFC 959, http://www.python.org/doc/lib/module-ftplib.html. httplib Moduł httplib implementuje klienta HTTP (Hypertext Transfer Protocol) uży- wanego w aplikacjach WWW. Obsługiwane są dwie wersje tego protokołu: HTTP/1.0 i HTTP/1.1. Ponadto, jeśli podczas konfigurowania Pythona została dodana obsługa OpenSSL, można nawiązywać połączenia korzystające z bezpiecznych gniazd. Protokół HTTP/1.0 jest prostym protokołem opartym na tekś- cie, działającym w następujący sposób: 1. Klient tworzy połączenie z serwerem WWW i wysyła do niego nagłówek żądania następującej postaci: GET /document.html HTTP/1.0 Connection: Keep-Alive User-Agent: Mozilla/4.61 [en] (Xli; U; SunOS 5.6 su n4u) Host: rustler.cs.uchicago.edu:8000 Accept: image/gif, image/x-xbitmap, image/jpeg, ima ge/pjpeg, image/png, */* Accept-Encoding: gzip Accept-Language: en Accept-Charset: iso-8859-1,*,utf-8 Dane (nieobowi ązkowe) Pierwsza linia definiuje typ żądania, dokument (selektor) i wersję protokołu. Po niej następuje szereg linii nagłówkowych, zawierających różne informacje o kliencie, na przykład o haśle, plikach cookie, ustawieniach pamięci podręcz- nej czy oprogramowaniu klienta. Koniec linii nagłówkowych jest oznaczony pojedynczą pustą linią. Dalej mogą występować dane, jeżeli żądanie dotyczy formularza lub ładowanego pliku. Każda z linii nagłówka powinna się koń- czyć znakami powrotu karetki i przejścia do nowej linii (' \r\n '). 2. Serwer wysyła odpowiedź następującej postaci: HTTP/1.0 200 OK Content-type: text/html Content-length: 72883 bytes Nagłówek: dane uoaaien M: oiouoiena rymona Dane Pierwsza linia odpowiedzi serwera podaje wersję protokołu HTTP, kod uda- nej operacji i wiadomość zwrotną. Po linii odpowiedzi następuje szereg pól nagłówka, zawierających informacje o typie zwracanego dokumentu, jego rozmiarze, oprogramowaniu serwera WWW, plikach cookie i tak dalej, główek kończy się pojedynczą pustą linią, po której następują surowe < żądanego dokumentu. Do metod najczęściej używanych w żądaniach należą: Metoda Opis GET Pobranie dokumentu POST Zgłoszenie danych do formularza HEAD Zwrot samego nagłówka PUT Załadowanie danych do serwera A oto kody odpowiedzi zwracane przez serwery: Kod Opis Kody udanych operacji (2xx) 200 OK

201 Utworzono 202 Zaakceptowano 204 Brak zawartości Kody przekierowań (3xx) 300 Wiele możliwości 301 Przeniesiono na stałe 302 Przeniesiono

tymczasowo 303 Bez zmian Błędy klienta (4xx) 400 Złe żądanie 401 Brak autoryzaqi 403 Zakaz 404 Nie znaleziono Błędy serwera (5xx) 500 Wewnętrzny błąd

serwera 501 Nie zaimplementowano 502 Zła brama 503 Usługa niedostępna

Nagłówki żądań i odpowiedzi mogą zawierać również całą gamę dod< wych pól. Są one podawane w formacie znanym jako RFC 822, w którym dy nagłówek ma postać Nagłówek: dane. Na przykład: Date: Fri, 16 Jul 1999 17:09:33 GMT Server: Apache/1.3.6 (Unix) Last-Modified: Mon, 12 Jul 1999 19:08:14 GMT ETag: "741d3-44ec-378a3dle" Accept-Ranges: bytes Content-Length: 17644

268 Python Connection: close Content-Type: text/html Oto wykaz klas używanych do tworzenia połączeń HTTP/1.0 z serwerem WWW: HTTP ([host [, port]]) Zakłada połączenie HTTP/1.0 z serwerem HTTP, host jest nazwą hosta, aport nieobowiązkowym numerem hosta. Bez drugiego argumentu numer portu jest pobierany z nazwy hosta, o ile ma ona postać 'host:port'. W przeciwnym wypadku używany jest port 80. Bez hosta nie dochodzi do utworzenia połączenia i należy założyć je ręcznie przy użyciu metody connect (). HTTPS([host [, port [, *ey_£ile=kfile [, cert_file=cfile]]) Zakłada bezpieczne połączenie HTTP/1.0. Działa podobnie jak HTTP (), tyle że wykorzystuje domyślnie port 443 i pozwala za pomocą parametrów hasłowych podać nazwy plików z prywatnym kluczem oraz certyfikatem klienta, które należy dostarczyć do serwera. Instancja h klasy HTTP lub HTTPS ma następujące metody: h.connect(host [, port]) Zakłada połączenie z serwerem wskazanym przez nazwę hosta i numer portu. Metodę tę należy wywoływać tylko wtedy, gdy instancja została utworzona bez połączenia z hostem. h.send(data) Wysyła dane do serwera. Metody tej należy używać dopiero po wywołaniu endheaders (). h.putrequest(request, selector) Wysyła do serwera linię zawierającą napis żądania, napis selektora i wer- sję HTTP (HTTP/1.0). h.putheader(header, argument [, ...]) Wysyła do serwera nagłówek w fermacie RFC 822. Jest to linia składająca się z nagłówka, dwukropka, spacji oraz pierwszego argumentu. Jeśli jest podanych więcej argumentów, wysyłane są linie kontynuacji, z których każda zawiera znak tabulacji i jeden argument. h.endheaders() Wysyła do serwera pustą linię oznaczającą koniec nagłówków. h.getreply () Zamyka nadający koniec połączenia, wczytuje odpowiedź serwera i zwraca trójkę (replycode, message, headers), gdzie replycode jest liczbą całkowitą będącą kodem odpowiedzi (na przykład 200 oznacza pomyślne zrealizowanie żądania), message jest napisem z komunikatem przypisa- nym do kodu odpowiedzi, a headers jest instancją klasy mimetools . Message, zawierającą nagłówki HTTP otrzymane z serwera. Dodatek A: Biblioteka Pythona h.getfile() Zwraca obiekt-plik z danymi dostarczonymi przez serwer, które rr odczytać za pomocą metody read (), readline () lub readlines PRZYKŁAD import httplib h = httplib.HTTP('www.python.org') h.putrequest('GET', '/index.html') h.putheader('Accept', 'text/html') h.putheader('Accept', 'text/plain') h.endheaders() errcode, errmsg, headers = h.getreply() print errcode # Powinno by ć 200 f = h.getfile() data = f.readO # Surowy HTML f.close() HTTP/1.1 jest rozszerzeniem protokołu HTTP/1.0. Umożliwia multipleks

nie wielu strumieni danych żądanie/odpowiedź w jednym połączeniu s wym. Aby obsłużyć wiele połączeń jednocześnie, HTTP/1.1 przypisuje po] niom sieciowym jeden z trzech stanów: Stan Opis _cs

IDLE Połączenie bezczynne

es REQ STARTED Początek żądania _cs

_REQ_

SENT Żądanie wysłane

Nowe żądania mogą być wysyłane tylko wtedy, gdy połączenie jest w s _CS_IDLE. Po wysłaniu żądania HTTP połączenie nie wraca do stanu bez ności, aż klient otrzyma i wczyta odpowiedź serwera. Oto lista klas udostępnianych przez moduł httplib do pracy z protoŁ HTTP/1.1: HTTPConnection(host [ ,port] ) Tworzy połączenie HTTP/1.1, host jest nazwą hosta, a port- num zdalnego portu. Standardowo jest to port 80. Funkcja ta zwraca insl HTTPConnection. HTTPSConnection(host [, port [, key_file=kfile [, cert_f±le=cf±le ]]]) Działa podobnie jak HTTPConnection (), ale tworzy połączenie z użj bezpiecznego gniazda. Standardowym numerem portu jest 443. key_ icert_fileto nieobowiązkowe argumenty hasłowe wskazujące pliki; watnym kluczem i certyfikatem klienta. Funkcja zwraca insl HTTPSConnection. Instancja h klasy HTTPConnection lub HTTPSConnection ma następ metody: h.connect() Iniqalizuje połączenie z hostem i portem podanym w HTTPConnect i lub HTTPSConnection() .

270 Python Dodatek A: Biblioteka Pythona h. close () Zamyka połączenie. h. send(str) Wysyła do serwera napis str. Bezpośrednie korzystanie z tej funkcji w HTTP/1.1 nie jest wskazane, gdyż może wprowadzić niespójność w obo- wiązującym formacie żądania /odpowiedzi. Najczęściej używa się jej do wysyłania danych do serwera po wywołaniu metody h.endhaedersO. h.putrequest(method, url) Wysyła żądanie do serwera, method jest metodą HTTP, taką jak ' GET' lub ' POST', a url wskazuje obiekt, który należy zwrócić, na przykład ' /index .html '. Jeśli h nie jest w stanie _CS_IDLE, generowany jest wyjątek CannotSendRequest. W przeciwnym razie h przechodzi do stanu _CS_REQ_STARTED, w którym można dodać do żądania inne nagłówki. h.putheader {header, value) Wysyła do serwera nagłówek w formacie RFC 822. Jest to linia składająca się z nagłówka, dwukropka, spacji i wartości. Jeśli h nie jest w stanie _CS_REQ_STARTED, metoda zgłasza wyjątek CannotSendHeader. h.endheaders() Wysyła do serwera pustą linię oznaczającą koniec nagłówków. Zmienia stan połączenia na _CS_REQ_SENT. h.request(method, url [, body [, headers]]) Wysyła do serwera kompletne żądanie HTTP. Argumenty met hod i url mają to samo znaczenie, co w metodzie h.putrequest (). body jest nieobo- wiązkowym napisem zawierającym dane ładowane do serwera po wysłaniu żądania, headers jest słownikiem z parami nagłówek: wartość, które na- leży dostarczyć metodzie h .putheader (). h.getresponse() Pobiera odpowiedź z serwera i zwraca instancję HTTPResponse, której mo- żna użyć do wczytania danych. Jeśli h nie jest w stanie _CS_REQ_SENT, zgłasza wyjątek ResponseNotReady. Instancja r klasy HTTPResponse udostępnia następujące metody: r.close () Zamyka połączenie. Nie jest jednak zamykane kryjące się pod nim połączenie HTTP. Tylko obiekt-plik używany do czytania danych z serwera jest zamykany. r.isclosed() Zwraca prawdę, jeśli połączenie zostało zamknięte. r.read([size]) Wczytuje maksymalnie size bajtów z serwera. Bez argumentu wczytywane są wszystkie dane należące do odpowiedzi. r .getheader(name [, default]) Pobiera nagłówek odpowiedzi, name jest nazwą nagłówka, a default do- myślną wartością zwracaną w przypadku nieznalezienia podanej nazwy. r.version Wersja HTTP używana przez serwer, r. status Kod stanu HTTP zwracany przez serwer, r. reason Komunikat błędu HTTP zwracany przez serwer, r.length Liczba bajtów pozostałych w odpowiedzi. r.will_close Wskazuje, czy serwer zamknie połączenie po wysłaniu odpowiedzi. PRZYKŁAD

Oto przykład ilustrujący wykorzystanie klasy HTTPConnection do otwa połączenia HTTP/1.1 i pobrania kilku plików. import httplib pliki = [ '/index.html', '/doc/index.html', '/News. html' ] h = httplib.HTTPConnection("www.python.org",80) h.connect() for f in pliki: h.putrequest('GET','f') h.putheader('Accept','text/html') h.putheader('Accept','text/plain') h.endheaders() r = h.getresponse() if r.status == 200: dane = r.read() print ": : : : %s : : : :" % f print dane r.close() h.close() UWAGI • Moduł ten jest używany przez moduł url lib, który zawiera wysokiego poziomu interfejs dostęi URL-i. • Aby można było korzystać z HTTP, trzeba podczas kompilacji Pythona dodać obsługę OpenSSL. Zobacz tak że urllib (284), mimetools (290), asyncore (252), Base HTTPServer I SimpleHTTPServer (274), CGIHTTPServer I imaplib Moduł imaplib zawiera niskiego poziomu interfejs klienta połączeń z sei rem pocztowym IMAP4 przy użyciu protokołu IMAP4revl. Dokumenty sujące ten protokół, jak również pliki źródłowe i binarne implementującyd serwerów można znaleźć w Centrum Informacyjnym IMAP Uniwersytetu szyngtońskiego pod adresem http: //www. cac .washington.edu/imap

272 Python Dodatek A: Biblioteka Pythona Oto przykład ilustrujący wykorzystanie tego modułu do otwarcia skrzynki pocztowej i wyświetlenia wszystkich zapisanych w niej wiadomości: import getpass, imaplib, string m = imaplib.IMAP4() m.login(getpass.getuser(), getpass.getpass()) m.select () typ, dane = m.search(None, 'ALL') for num in string.split(dane[0]): typ, dane = m.fetch(num, '(RFC822)') print 'Message %s\n%s\n' % (num, dane[0][l]) m.logout() Zobacz także poplib (272), http: //www.python.org/doc/lib/module-imaplib.html, http: / /www. cac. Washington. edu/ imap, Internet RFC 1730, RFC 2060. nntplib Moduł nntplib zawiera niskiego poziomu interfejs klienta protokołu NNTP (Network News Transfer Protocol). Szczegółowe informacje o korzystaniu z tego modułu można znaleźć w dokumentacji online (http: //www.python. org/ doc/lib/module-nntplib.html). Oto przykład ilustrujący wykorzystanie modułu do zamieszczenia wiadomości trzymanej w pliku z prawidłowymi nagłówkami: s = NNTP('news.miejsce.com') f = open ('artykuł') s.post(f) s .quit () Zobacz także http: //www.python. org/doc/lib/module-nntplib. html, Internet RFC 977. poplib Moduł poplib zawiera niskiego poziomu interfejs klienta połączeń z serwerem pocztowym POP3. Szczegółowe informacje o korzystaniu z tego modułu można znaleźć w dokumentacji online (http: //www.python.org/doc/lib/module-pop lib.html). Oto przykład ilustrujący otwarcie skrzynki pocztowej i pobranie wszystkich wiadomości: import getpass, poplib M = poplib.P0P3('localhost') M.user (getpass.getuser()) M.pass_(getpass.getpass()) liczbaWiad = len(M.list()[1]) for i in range(liczbaWiad): for j in M.retr(i+1)[1]: print j Zobacz także http: //www. python .org/doc/lib/module-poplib.html, Internet RFC 1725. robotparser Moduł robotparser zawiera klasę, której można używać do pobierania i przeszukiwania informacji zawartych w plikach robots . txt, używanych przez wi- tryny WWW do informowania „pająków" i „gąsienic" o nowych zasobach Sieci. Oto przykład typowej zawartości takiego pliku: # robots.txt User-agent: * Disallow: /warheads/designs # Zakaz wst ępu robotom RobotFileParser() Tworzy obiekt umożliwiający wczytanie i analizę zawartości pojedyn pliku robots . txt. Instanqa r klasy RobotFileParser udostępnia następujące atrybuty im< r .set_url(url) Ustawia URL pliku robots, txt. r.read() Wczytuje zawartość pliku robots . txt i przekazuje ją do parsera. r. parse(lines) Dokonuje analizy linii uzyskanych z pliku robots . txt. r . can_fe tch (useragen t, url )

Zwraca prawdę, jeśli podany agent użytkownika (useragent) moi bierać robots . txt z wskazanego url. r.mtime () Zwraca czas ostatniego pobrania zrobots.txt. r.modified() Ustawia na bieżący czas ostatniego pobrania robots, txt. UWAGA • Szczegółowe informacje o formacie pliku robots. txt można znaleźć pod adresem http: / / i webcrawler.com/mak/projects/robots/norobots.html. select Moduł select umożliwia dostęp do funkcji systemowej select (). Funk jest zazwyczaj używana w implementacjach odpytywania lub przetwarzania tipleksowego wielu strumieni wyjścia/wejścia bez pomocy wątków i podp sów. W Uniksach i Macintoshach obejmuje to pliki, gniazda, łącza i większoś zostałych typów plików. W systemach Windows dotyczy zaś tylko gniazd, select(iwtd, owtd, ewtd [, timeout]) Sprawdza status wejścia, wyjścia i wyjątków dla podanych grup ( ryptorów plików. Pierwsze trzy argumenty są listami zawierającymi wartości całkowite deskryptorów plików, albo obiekty dysponujące mc fileno(), zwracającą wartość deskryptora. iwtd wskazuje obiekty kające na dane wejściowe, owtd wskazuje obiekty czekające na dane wyj we, a ewtd wskazuje obiekty czekające na określone wyjątki. Każda może być pusta, timeout jest liczbą zmiennoprzecinkową podającą oczekiwania w sekundach. Bez niej funkqa czeka do momentu, aż pojaw dane przynajmniej dla jednego deskryptora pliku. Jeśli timeout ma wa zero, funkcja odpytuje deskryptory i natychmiast kończy swoje dział Wartością powrotną jest trójka list zawierających obiekty gotowe do prze rzania. Są to podzbiory trzech pierwszych argumentów funkqi. Jeśli ż,

274 Python Dodatek A: Biblioteka Pythona obiekt nie otrzyma danych przed upływem czasu oczekiwania, funkcja zwraca same puste listy. W przypadku błędu następuje zgłoszenie wyjątku select . error. Jest to ta sama wartość, co w przypadku IOError i OSError. PRZYKŁAD Oto fragment kodu przedstawiający wykorzystania select () do cyklicznego sprawdzania zbioru gniazd wewnątrz pętli zdarzeń i wykrywania zgłaszanych połączeń: import socket, select # Utworzenie nowych gniazd sl = socket.socket(socket.AF_INET, socket.SOCK_STRE AM) si.bind(("",8888)) sl.listen(5) s2 = socket.socket(socket.AF_INET, socket.SOCK_STRE AM) s2.bind(("",8889)) s2.1isten(5) # P ętla zdarze ń while 1: . .. przetwarzanie . . . # Odpytywanie gniazd input,output,exc = select.select ( [sl,s2],[],[],0) # P ętla przebiegaj ąca wszystkie gniazda z nie przetworzonymi # danymi wej ściowymi for gniazdo in input: # Zaakceptowanie poł ączenia przychodz ącego klient = gniazdo.accept() ... działania po stronie klienta ... klient.close() # Koniec. Mo żna przej ść dalej. ... dalsze działania ... UWAGA # Zazwyczaj istnieje górne ograniczenie liczby deskryptorów plików podawanych w funkcji select (). W przypadku Windows wynosi ono zwykle 64, a Uniksa - 256. Zobacz także asyncore (252), socket (275), os (199). SimpleHTTPServer Moduł SimpleHTTPServer zawiera prostą wersję serwera HTTP udostęp- niającego pliki z bieżącego katalogu. Moduł definiuje następującą klasę obsługi, wykorzystującą moduł BaseHTTPServer: SimpleHTTPRequestHandler(request, cl±ent_address, server) Udostępnia pliki z bieżącego katalogu i wszystkich jego podkatalogów. Klasa ta implementuje metody do_HEAD () i do_GET (), obsługujące odpowiednio żądanie HEAD i GET. Wszystkie wyjątki IOError dają w efekcie błąd 404 File not found (nie ma takiego pliku). Próba dostępu do katalogu powo- dujebłąd403 Directory listing not supported (niemożna listować katalogów). Oto lista atrybutów udostępnianych przez tę klasę: SimpleHTTPRequestHandler.server_version Napis z wersją serwera. SimpleHTTPRequestHandler.extensions_map Słownik mapujący przyrostki plików na typy MIME. Nierozpoznane plików są traktowane jako 'text/plain'. PRZYKŁAD from BaseHTTPServer import HTTPServer from SimpleHTTPServer import SimpleHTTPRequestHandl er import os # Przej ście do katalogu startowego os.chdir("/home/httpd/html") # Uruchomienie serwera SimpleHTTP serv = HTTPServer(("",80),SimpleHTTPRequestHandler) serv.serve_forever() Zobacz tak że BaseHTTPServer (255), CGIHTTPServer (262), httplib smtplib Moduł smtplib udostępnia niskiego poziomu interfejs klienta SMTP, um

wiający wysyłanie poczty. Szczegółowe informacje o tym module można zn< w dokumentaq'i online pod adresem http://www.python.org/doc/] module-smtplib.html. Zamieszczony tu przykład ilustruje wykorzysi modułu do pobrania od użytkownika adresu i treści wiadomości, a nastę wysłania jej do odbiorcy: import string, sys import smtplib def prompt(prompt): sys.stdout.write(prompt + ": ") return string.strip(sys.stdin.readline()) adresod = prompt("Od") adresdo = string.splitfields(prompt("Do"), ',') print "Wpisz wiadomo ść i zako ńcz j ą [ AD]:" wiad = "" while 1: linia = sys.stdin.readline() if not linia: break wiad = wiad + linia print "Długo ść wiadomo ści:_" + 'len. (wiad) ' server = smtplib.SMTP('localhost') server.sendmail(adresod, adresdo, wiad) server.quit() Zobacz tak że poplib (272), http: //www.python.org/doc/lib/module-smtplib.l: imaplib (271), Internet RFC 821 (Simple Mail Transf er Prol Internet RFC 1869 (SMTP Service Extens

socket Moduł socket umożliwia korzystanie z interfejsu gniazd BSD. Chociaż oj na Uniksie, moduł ten jest dostępny na wszystkich platformach. fromfd (fd, family, type [, pro to]) Tworzy obiekt - gniazdo na podstawie całkowitego deskryptora pliku fo dzina adresów (family), rodzaj gniazda (type) i numer protokołu (pr mają takie samo znaczenie, jak w przypadku socket (). Deskryptor { musi się odnosić do wcześniej utworzonego gniazda. Funkcja zwraca in: cję SocketType.

276 Python getf qdn ([name]) Zwraca w pełni kwalifikowaną nazwę argumentu name. Bez niego funkcja uży- wa nazwy lokalnego komputera. Na przykład getf qdn ("stonecrusher") może zwrócić wartość "stonecrusher. es . uchicago. edu". gethostbyname(hostname) Tłumaczy nazwę hosta, taką jak ' www. python. org', na adres IP. Adres ten jest zwracany w postaci napisu, na przykład '132.151.1.90'. gethostbyname_ex(hostname) Tłumaczy nazwę hosta na adres IP, ale zwraca trójkę (hostname, aliaslist, ipaddrlist), gdzie hostname jest podstawową nazwą hosta, aliaslist listą alternatywnych nazw tego hosta, a ipaddrlist listą adresów IP tego samego interfejsu na tym samym hoście. Na przykład gethostbyname_ex ('www.python, org') zwraca Cparrot.python.org', ['www.python.org'1 ['132.151.1.90']). gethostnameO Zwraca nazwę lokalnego komputera. gethostbyaddr{ip_address) Zwraca tę samą informaqe co gethostbyname_ex (), ale na podstawie adresu IP, na przykład ' 132 .151.1. 90 '. getprotobyname(protocolname) Tłumaczy nazwę protokołu internetowego, taką jak ' iemp', na jego numer (na przykład wartość IPPROTO_ICMP), który można przekazać do trzeciego argumentu funkcji s oc ke t (). getservbyname (servicename, protocolname) Tłumaczy nazwę usługi internetowej i nazwę protokołu na numer portu tej usługi. Na przykład getservbyname (' f tp', ' tcp') zwraca liczbę 21. Protokół powinien mieć nazwę 'tcp1 lub 'udp'. ntohl (x) Zmienia kolejność bajtów 32-bitowej liczby całkowitej z formatu sieciowego (big-endian) na obowiązujący w hoście. ntohs (x) Zmienia kolejność bajtów 16-bitowej liczby całkowitej z formatu sieciowego na obowiązujący w hoście. htonl (x) Zmienia kolejność bajtów 32-bitowej liczby całkowitej z obowiązującej w ho- ście na format sieciowy. htons(x) Zmienia kolejność bajtów 16-bitowej liczby całkowitej z obowiązującej w ho- ście na format sieciowy. ssl(sock, key^file, cert_file) Tworzy bezpieczne gniazdo po stronie klienta, sock jest instancją istniejącego gniazda z nawiązanym już połączeniem za pomocą metody connect (). key_file jest nazwą pliku z prywatnym kluczem klienta, a cert_file Dodatek A: Biblioteka Pytona nazwą pliku z jego certyfikatem. Oba argumenty muszą wskazywać istnie pliki w formacie PEM lub mieć jednocześnie wartość None. Funkcja ta jest stępna tylko wtedy, gdy podczas konfigurowania Pythona została dod obsługa OpenSSL. Ponadto nie można jej używać do tworzenia bezpieczr gniazd po stronie serwera. Przeczytaj uwagi. socket (family, type [, proto]) Tworzy nowe gniazdo używając podanej rodziny adresów (fami ly), rod: gniazda (type) i numeru protokołu. Argument fami ly może być jedną 2 stepujących stałych:

Stała AF_INET AF UNIX Opis Protokoły IPv4 (TCP, UDP) Protokoły domeny Uniksa Typ gniazda może być wskazywany przez jedną z następujących wartoś Stała Opis SOCK STREAM Gniazdo strumienia (TCP) SOCK_DGRAM Gniazdo datagramów (UDP) SOCK_RAW Surowe gniazdo (dostępne tylko z AF_INET) SOCK_SEQPACKET Sekwencyjny transfer rekordów w trybie

połączeniowym Numer protokołu jest zazwyczaj pomijany (wartość domyślna to 0). Używ go zwykle tylko w przypadku surowych gniazd (S0CK_RAW) i ma wówczas tość ustawioną na jedną z następujących stałych: I PPROTO_I CMP, IPPROTO IPPR0T0_RAW, IPPROTOJTCP lub IPPROTOJJDP. Aby otworzyć połączenie TCP, należy użyć wywołania socket (AF_I1 SOCKJSTREAM). Aby otworzyć połączenie UDP, należy użyć wywołania ; ket (AF_INET, SOCK_DGRAM). Dostęp do surowych gniazd jest uprzyw wany i w systemach uniksowych wymaga efektywnego UID roota (0). Fu zwraca instancję typu SocketType (opisanego poniżej). Gniazda są reprezentowane przez instancje typu SocketType. Oto lista n udostępnianych przez gniazdo s: s.accept() Akceptuje połączenie i zwraca parę (conn, address), gdzie conn jej wym obiektem-gniazdem, umożliwiającym wysyłanie i odbieranie de w ramach połączenia, a address jest adresem gniazda na drugim I połączenia. s.bind( address) Wiąże gniazdo z adresem address. Format adresu zależy od rodziny sów. W większości przypadków jest to tupla postaci (hostname, port adresów IP pusty napis reprezentuje INADDR_ANY, a napis ' <broadca

278 Python Dodatek A: Biblioteka Pythona reprezentuje INADDR_BROADCAST. Nazwa hosta INADDR_ANY (pusty napis) wskazuje, że serwer pozwala łączyć się z dowolnym interfejsem interneto- wym w systemie. Dotyczy to często serwera typu multihomed. Nazwa hosta INADDR_BROADCAST (' <broadcast>') jest używana wtedy, gdy gniazdo służy do rozgłaszania wiadomości. s.close() Zamyka gniazdo. Gniazda są zamykane także w momencie pozyskiwania pa- mięci. s.connect(address) Łączy ze zdalnym gniazdem o adresie address. Format adresu zależy od rodziny adresów, ale zwykle ma postać (hostname, port). W przypadku błędu zgłasza wyjątek socket. error. W przypadku łączenia się z serwerem w tym samym komputerze można uży- wać nazwy ' localhost' jako pierwszego argumentu s. connect (). s. connect__ex (address) Działa podobnie jak connect (address), ale w przypadku powodzenia zwraca 0, a niepowodzenia - wartość errno. s.fileno() Zwraca deskryptor pliku gniazda. s.getpeername () Zwraca zdalny adres, z którym jest połączone gniazdo, w postaci pary (ipad- drs, port). Metoda dostępna nie we wszystkich systemach. s.getsockname () Zwraca własny adres gniazda w postaci pary (ipaddr, port). s.getsockopt(level, optname [, buflen]) Zwraca wartość opcji gniazda, level określa poziom opcji i jest to stała SOL_SOCKET dla opcji poziomu gniazda albo numer protokołu, taki jak IPPROTO_IP, dla opcji związanych z protokołem, optname wskazuje kon- kretną opcję. Bez buflen metoda zakłada, że chodzi o opcję typu całkowitego i zwraca jej wartość numeryczną. Jeśli jest podana wartość buflen, oznacza ona maksymalną długość bufora przeznaczonego na wartość opcji. Metoda zwraca ten bufor w postaci napisu, który można następnie rozkodować przy użyciu modułu struct lub innych narzędzi. Oto lista typowych nazw opcji poziomu SOL_SOCKET: Nazwa opcji Wartość Opis SO_KEEPALIVE 0, 1 Okresowo sprawdza drugi koniec połączenia

i zamyka je, gdy jest otwarte jednostronnie. SO_RCVBUF int Rozmiar bufora odbiorczego (w bajtach). SO_SNDBUF int Rozmiar bufora nadawczego (w bajtach). SO REUSEADDR 0, 1 Zezwala na ponowne użycie lokalnego adresu. SO RCVLOWAT int Liczba bajtów wczytanych przed zwróceniem gniazda przez socket () jako gotowego do czytania. Nazwa opcji Wartość Opis SO_SNDLOWAT int Liczba bajtów umieszczonych w buforze nadawczym przed zwróceniem gniazda

prze socket () jako gotowego do pisania. SO_RCVTIMEO tvalue Czas oczekiwania na odbiór (w sekundach). SO_SNDTIMEO tvalue Czas oczekiwania na wysłanie (w

sekundach SO_OOBINLINE 0, 1 Wstawienie dodatkowych danych do

kolejki

wejściowej. SO_LINGER linger Opóźnia close (), jeśli bufor nadawczy za w dane. SO_DONTROUTE 0, 1 Pomija wyszukiwanie w tablicach

rutowania SO_ERROR int Pobiera status błędu. SO_BROADCAST 0, 1 Zezwala na rozgłaszanie datagramów. SO TYPE int Pobiera typ gniazda. SO USELOOPBACK 0, 1 Gniazdo rutujące otrzymuje kopię

wysłanych danych. tvalue jest strukturą binarną dekodowaną jako (second, microsec) = struct.unpack("11", tvalue). linger jest strukturą binarną dekodowaną jako ( linger_onoff, linger__sec) = struct .unpack ("ii", linger). A oto lista opcji dostępnych dla poziomu IPPROTO_IP: Nazwa opcji Wartość Opis IP_ADD_MEMBERSHIP ipmreg Dodaje gniazdo do grupy

multicast. IP_DROP_MEMBERSHIP ipmreg Usuwa gniazdo z grupy multicast. IP_HDRINCL int Nagłówek IP dołączony do

danych. IP_MULTICAST_IF inaddr Ustawia gniazdo jako multicast. IP MULTICAST LOOP uchar Zwraca pakiety grupowe do

lokalnego gniazda. IP_MULTICAST_TTL uchar Czas życia. IP_OPTIONS char[44] Opqe nagłówka IP. IP_TOS int Rodzaj usługi. IPJTTL int Czas życia. i na ddr jest 32-bitową strukturą binarną zawierającą adres IP (struct, pack (' bbbb', inaddr) ). ipmreg jest 64-bitową strukturą binarną za rającą dwa adresy IP w tym samym formacie co inaddr. uchar jednobajtową liczbą całkowitą bez znaku, jaką tworzy struct. pack (' uvalue). char [44] jest napisem zawierającym co najwyżej 44 bajty. Nie wszystkie opcje są dostępne na każdym komputerze. Szczegółowe ii macje o tych opcjach można znaleźć w speqalistycznych książkach sieciow)

280 Python s.listen(backlog) Rozpoczyna nasłuchiwanie połączeń przychodzących, backlog określa maksymalną liczbę połączeń oczekujących, które system operacyjny powinien kolejkować, zanim zacznie odrzucać następne. Argument ten powinien mieć przynajmniej wartość 1, a w większości przypadków odpowiednim ustawieniem jest liczba 5. s.makefile ([mode [, bufslze] ]) Tworzy obiekt-plik związany z gniazdem, mode i bufsize mają to samo znaczenie co w przypadku wbudowanej funkcji open (). Obiekt-plik używa zdwo- jonej wersji deskryptora pliku gniazda, utworzonej za pomocą metody os . dup (), dzięki której obiekt-plik i obiekt-gniazdo mogą być zamykane i zwalniane niezależnie. s. recv (bufslze [, flags]) Pobiera dane z gniazda. Dane są zwracane w postaci napisu, bufsize okre- śla maksymalną ilość tych danych, a flags zawiera dodatkowe informacje o traktowaniu nadchodzących komunikatów. Bez flags przyjmowana jest w to miejsce domyślnie wartość 0. W przeciwnym razie można użyć jednej z następujących stałych (zależą od systemu): Dodatek A: Biblioteka Pythona Stała MSG_PEEK MSG_WAITALL MSGJDOB MSG DONTROUTE Opis „Podglądanie" danych bez ich usuwania (tylko odbiór)). Czekanie do momentu wczytania żądanej liczby bajtów (tylko odbiór). Odbieranie/wysyłanie dodatkowych danych (OOBD). Brak wyszukiwania w tablicach rutowania (tylko wysyłanie). s.recvfrom(bufsize [, flags]) Działa podobnie jak metoda recv(), ale zwraca parę (data, address), gdzie da ta jest napisem zawierającym otrzymane dane, a address jest adresem gniazda, które wysłało te dane. Nieobowiązkowy argument flags ma to samo znaczenie co w metodzie recv (). Metoda ta służy głównie do pracy z protokołem UDP. s.send(string [, flags]) Wysyła dane zawarte w napisie string do połączonego gniazda i zwraca liczbę wysłanych bajtów. Nieobowiązkowy argument fl a gs ma to samo znaczenie, co w opisanej wcześniej metodzie recv (). s.sendto(string [, flags], address) Wysyła dane do gniazda i zwraca liczbę wysłanych bajtów, flags ma to samo znaczenie co w metodzie recv (). address jest tupią postaci (host, port), zawierającą zdalny adres. Gniazdo nie powinno być jeszcze połączo- ne. Metoda ta służy głównie do pracy z protokołem UDP. s.setblocking(flag) Jeśli flag ma wartość zero, metoda ustawia gniazdo w trybie nieblokującym- W przeciwnym wypadku ustawiany jest tryb blokujący (domyślny). Jeśli w trybie nieblokującym recv () nie znajdzie żadnych danych albo send O nie wyśle natychmiast danych, zgłaszany jest wyjątek socket.er W trybie blokującym wywołania tych metod powodują zawieszenie wyl nia do momentu spełnienia podanych warunków. s.setsockopt (level , optname, value) Ustawia wartość podanej opcji gniazda, level i optname mają to samo czenie co w metodzie getsockopt (). value może być liczbą całkowit. napisem reprezentującym zawartość bufora. W tym drugim przypadku te

wywołujący metodę musi upewnić się, czy napis zawiera prawidłowe c Nazwy, wartości i opisy opq'i są podane przy okazji metody getsockopi s.shutdown(how) Zamyka jedną lub obie strony połączenia, how może mieć jedną z trzech tości: 0 blokuje dalsze odbieranie danych, 1 blokuje dalsze wysyłanie dan a 2 blokuje jedno i drugie. WYJĄTEK error Wyjątek zgłaszany w przypadku błędów związanych z gniazdem lub a sem. Zwraca parę (error, mesg) zawierającą błąd pochodzący z użyteg niższym poziomie wywołania systemowego. PRZYKŁAD Prosty przykład połączenia TCP został pokazany wcześniej we wstępie do ] gramowania sieciowego. Oto inny przykład, ilustrujący użycie modułu soc do utworzenia prostego klienta i serwera UDP: # Serwer komunikatów UDP # Odbiera małe pakiety z dowolnego miejsca i wy świetla je import socket s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM ) s.bind(("",10000)) while 1: dane, adres = s.recvfrom(256) print adres[0], "nadesłał : ", dane # Klient komunikatów UDP # Wysyła pakiet komunikatu do serwera import socket s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM ) while 1: msg = raw_input("powiedz co ś : ") if msg: s.sendto(msg, ("nazwaserwera",10000)) else: break s .close () UWAGI • Nie wszystkie wymienione stałe i opcje gniazda są dostępne na każdej platformie. • Moduł socket nie obsługuje aktualnie wielu protokołów, miedzy innymi IPX i IPv6. W przyszłych w; niach Pythona moduł ten zostanie jednak najprawdopodobniej rozszerzony. Zobacz tak że SocketServer (282), asyncore (252), select (2

282 Python Dodatek A: Biblioteka Pythona SocketServer Moduł SocketServer służy do pisania serwerów gniazd domen TCP, UDP i Uniksa. Zamiast implementować je za pomocą modułu gniazd na niskim poziomie, można użyć jednej z następujących czterech klas: TCPServer( address, handler) Serwer implementujący protokół TCP. address jest dwuelementową tupią postaci (host, port), gdzie host jest nazwą hosta, a port numerem portu. host jest zazwyczaj pustym napisem, handler to instanqa podklasy opisanej wcześniej klasy BaseRequestHandler. UDPServer(address, handler) Serwer implementujący protokół UDP. address i handler mają to samo znaczenie, co w TCPServer (). UnixStreamServer (address, handler) Serwer implementujący protokół strumieniowy wykorzystujący gniazda domeny uniksowej. UnixDatagramServer( address, handler) Serwer implementujący protokół datagramowy wykorzystujący gniazda domeny uniksowej. Instancje wszystkich tych czterech klas mają następujące metody i atrybuty: s.fileno() Zwraca deskryptor pliku (typu całkowitego) gniazda serwera. s.handle_request() Czeka na żądanie i obsługuje je tworząc instancję klasy handler (opisanej nieco dalej) i wywołując jej metodę handle (). s.serve_forever() Obsługuje nieskończoną liczbę żądań. s. address_family Rodzina protokołów serwera: socekt. AF_INET lub socket. AF_UNIX. s.RequestHandlerClass Zdefiniowana przez użytkownika klasa obsługi żądań, przekazana do konstruktora serwera. s.server_address Adres nasłuchiwany przez serwer, na przykład ('127.0.0.1', 80). s.socket Obiekt-gniazdo używany do odbioru żądań. Klasy serwerów definiują ponadto następujące atrybuty (<ServerClass> nale- ży zastąpić nazwą jednej z czterech dostępnych klas): <ServerClass>. request__queue_size Wielkość kolejki żądań przekazywana do metody gniazda listen (). Stan- dardowo wynosi 5. <ServerClass> .socket_type Typ gniazda używanego przez serwer, na przykład socket. SOCK_S lub socket.SOCK_DGRAM. ~ Żądania są obsługiwane za pomocą definiowanych w tym celu podklas BaseRequestHandler. Gdy serwer odbiera połączenie, tworzy instanqc sy handler i wywołuje następujące jej metody: h.finish() Ma za zadanie „posprzątać" po zakończeniu metody handle (). Stan wo nic nie powoduje. Aby doszło do wywołania tej metody, żadna z setup () i handle () nie może zgłosić wyjątku. h.handle() Metoda wywoływana w celu wykonania zadania podanego w żądań:

ma żadnych argumentów, natomiast korzysta z kilku zmiennych in; h.request zawiera żądanie, h.client_address zawiera adres 1 a h. server zawiera instancję serwera, który wywołał klasę har W przypadku usług strumieniowych takich jak TCP, atrybut h. reque obiektem-gniazdem, a w przypadku usług datagramowych napisem rającym otrzymane dane. h.setup () Jest to metoda wywoływana przed metodą handle () w celu przepro\ nia inicjalizacji. Standardowo nic nie powoduje. Proces tworzenia serwera obejmuje następujące działania: 1. Zdefiniowanie klasy obsługującej żądania (w postaci podklasy Base estHandler). 2. Utworzenie instancji jednej z klas serwerów na podstawie przekazane resu serwera i klasy obsługującej żądania. 3. Wywołanie metody serwera handle_request () lub serve_fore w celu obsługi połączenia. Oto fragment kodu ilustrujący ten proces na przykładzie bardzo prostego ra HTTP, wyświetlającego otrzymane żądania HTTP na stronie WWW kli import SocketServer import socket import string # Pobranie żądania HTTP od klienta i odesłanie go z powrotem # na stron ę WWW class EchoHandler(SocketServer.BaseRequestHandler): def handle(self): f = self.request.makefile() self.request.send("HTTP/1.0 200 0K\r\n") self.request.send("Content-type: text/plain\r\n\r\n ") self.request.send("Odebrano poł ączenie z %s\r\n\r\n" % (self.client_address,)) while 1: linia = f.readlineO self.request.send(linia) if not string.strip(linia): break

284 Python Dodatek A: Biblioteka Pythona f.close () • Utworzenie serwera i uruchomienie obsługi serv = SocketServer.TCPServer(("",80),EchoHandler) serv.serve_forever() Standardowo klasy procesów przetwarzają żądania po jednym na raz, w trybie synchronicznym. Innym rozwiązaniem jest obsługiwanie żądań w podprocesach za pomocą wywołania os . f ork (), lub w oddzielnych wątkach, poprzez utworzenie instancji jednej z następujących klas (zamiast czterech klas wymienionych wcześniej): • ForkingUDPServer (address, handler) • ForkingTCPServer (address, handler) • ThreadingUDPServer (address, handler) • ThreadingTCPServer (address, handler) Istnieją też dwie inne klasy, których można używać jako klas bazowych do obsługi żądań: StreamRequestHandler i DatagramRequestHandler. Kla- sy te przesłaniają metody setupO ifinish(), udostępniając dwa atrybuty plikowe, self.rfileiself.wfile, umożliwiające odpowiednio pobieranie danych od klienta i kierowanie ich do niego. Na przykład: • Pobieranie żądań HTTP od klienta i dosylanie ich z powrotem class EchoHandler(SocketServer.StreamRequestHandler ): def handle(self): self.wfile.write("HTTP/1.0 200 OK\r\n") self.wfile.write("Content-type: text/plain\r\n\r\n" ) self.wfile.write("Odebrano poł ączenie z %s\r\n\r\n" % (self.client_address,)) while 1: linia = self.rfile.readline() self.wfile.write(linia) if not string.strip(linia): break UWAGA • Wszystkie klasy serwerów umożliwiają tworzenie podklas. Więcej informacji na ten temat można znaleźć w dokumentacji online. Zobacz tak że socket (275), BaseHTTPServer (255), SimpleHTTPServe r (274), CGIHTTPServer (262), thread (241), os (198). urllib Moduł urllib służy do pobierania danych z sieci WWW. urlopen(url [, data]) Na podstawie jednolitego wskaźnika zasobu (url), takiego jak http:// www.python.org lub ftp://byleco.com/pub/byleco.tar, otwiera połączenie sieciowe i zwraca obiekt w stylu pliku. Jeśli URL nie zawiera wskaźni- ka schematu dokumentu, takiego jak ftp: czy http:, lub ma on postać f ile:, funkqa otwiera lokalny plik. Jeśli nie można utworzyć połączenia lub kończy się to błędem, funkcja zgłasza wyjątek IOE r r o r. Jeśli URL jest żądaniem HTTP, nie- obowiązkowy argument data może powodować obsługę żądania za pomocą metody POST, co oznacza wówczas załadowanie danych do serwera. W przypadku muszą one być zakodowane w formacie ' application/x -f orm-urlencoded', takim jaki generuje funkcja urlencode (). urlretrieve(url [, filename [, hook]]) Otwiera podany URL i w razie potrzeby kopiuje jego dane do lokalnegc Jeśli url jest plikiem lokalnym lub istnieje podręczna kopia danych, jest kopiowane, filename podaje nazwę pliku lokalnego, w którym z zapisane dane. Bez tego argumentu funkcja sama wygeneruje nazwę t) sowego pliku, hook jest funkcją wywoływaną po utworzeniu połączer odczytaniu każdego bloku danych. Funkcja ta jest wywoływana z trze gumentami: liczbą otrzymanych dotąd bloków, rozmiarem bloku w 1 i całkowitym rozmiarem pliku w bajtach. Funkcja zwraca tupię (filt

headers), gdzie fi 1 ename jest nazwą pliku lokalnego, w którym zost pisane dane, a headers zawiera informacje zwrócone przez metodę i obiektu w wyniku urlopen (). Jeśli URL odnosi się do pliku lokalne funkcja korzysta z kopii podręcznej danych, argument headers ma v None. W przypadku wystąpienia błędu funkqa zgłasza wyjątek iOEr urlcleanup () Wymazuje lokalną pamięć podręczną utworzoną przez urlretrieve quote(string [, safe]) Zamienia znaki specjalne w napisie string na sekwencje ucieczki na się do umieszczenia w URL. Litery, cyfry, podkreślenia (_), przecir kropki (.) i łączniki (-) pozostają bez zmian. Wszystkie inne znaki są k< towane na postać ' %xx'. safe zawiera dodatkowe znaki, które nie pc być cytowane i jest to standardowo ukośnik (/). quo te_j?lus (string [, safe]) Wywołuje quote () i zamienia dodatkowo wszystkie spacje na plusy unquote(string) Zamienia sekwencje ucieczki postaci ' %xx' na odpowiadające im pojec znaki. unquote_plus (string) Działa podobnie jak unquote (), ale dodatkowo zamienia plusy na sj urlencode(diet) Konwertuje słownik diet na napis w stylu URL, nadający się do użyć argument data funkcji urlopen (). Generowany napis jest sei 'klucz=wartość ' oddzielonych znakami ' & ', gdzie klucz i wart zacytowane przy użyciu funkcji quote_plus (). Obiekt typu plik zwrócony przez funkcję urlopen () udostępnia pujące metody: Metoda u.read( [nbytes] u. readline() Opis Wczytuje nbytes danych. Wczytuje jedną linię tekstu.

286 Python Dodatek A: Biblioteka Pythona Metoda u.readlines() u.fileno() u.close() u. info () u.geturl () Opis Wczytuje wszystkie linie wejściowe i zwraca ich listę. Zwraca całkowity deskryptor pliku. Zamyka połączenie. Zwraca obiekt mime tools .Message zawierający meta- informacje związane z wskaźnikiem URL. W przypadku HTTP metoda zwraca nagłówki HTTP dołączone do odpowiedzi serwera, a w przypadku FTP - nagłówki 1 content-length'. W przypadku plików lokalnych nagłówki obejmują datę oraz pola typu 'content-length'i 'content-type1. Podaje rzeczywisty wskaźnik URL zwróconych danych, biorąc pod uwagę wszystkie ewentualne przekierowania. UWAGI • Jedyne protokoły obsługiwane przez moduł to: HTTP, FTP, Gopher i pliki lokalne. Chociaż moduł htt- pl ib obsługuje protokół HTTP/1.1, ten moduł używa dokumentów HTTP/1.0. • Jeśli Python został skonfigurowany z obsługą OpenSSL, można również używać bezpiecznego HTTP (https://nazwa). • Funkcja urlopen () radzi sobie w sposób przezroczysty z serwerami proxy nie wymagającymi uwiarygodniania. W Uniksie i Windows serwery proxy powinny być ustawione za pomocą zmiennych środowisko- wych $http_proxy, $ftp_proxy i $gopher_proxy. • Nie ma aktualnie implementacji pamięci podręcznej. • Jeśli URL wskazuje plik lokalny, ale nie można go otworzyć, następuje próba otwarcia go z użyciem proto- kołu FTP. • Moduł urllib2 (dostępny w Pythonie 2.1) udostępnia bardziej zaawansowane metody sięgania do URL-i, obsługi przekierowań i uwiarygodniania. Szczegółowe informacje o tym module można znaleźć pod adresem http: //www.python. org/doc/current/lib/module-urllib2 . html. Zobacz także httplib (266), f tplib (265), urlparse (286), mimetools (290). urlparse Moduł urlparse służy do wykonywania działań na napisach URL, takich jak "http: //www.python. org". Ogólna postać wskaźnika URL wygląda nastę- pująco: "schemat:/'/miej seesieciowe/ścieżka;parametery?kwerenda#fragment" urlparse (urlstring [, default__scheme [, allow_fragments] ]) Dokonuje rozbioru wskaźnika URL podanego w urlstring i zwraca tupię (schemat, miejscesieciowe, ścieżka, parametry, kwerenda, fragment). default_scheme określa schemat ("http", "ftp" i tak dalej) uży- wany w przypadku niepodania go w URL. Jeśli allow_fragments ma wartość 0, identyfikatory fragmentów są niedozwolone. urlunparse ( tupie) Składa napis URL z tupli zwróconej przez urlparse(). url join (base, url [, allow__fragments]) Składa absolutny wskaźnik URL łącząc podstawę wskaźnika (base) z częścią względną (url). allow_fragments ma to samo znaczenie co w urlparse (). Jeśli ostatni składnik base nie jest katalogiem, zostaje obcięty. PRZYKŁADY >» urlparse("http://www.python.org/index.html") ('http 1, 'www.python.org 1, '/index.html', '', '', '') >» urlunparse(('http', 'www.python.org 1, '/index.html', '', '*, '•) 'http://www.python.org/index.html' >» urljoin("http://www.python.org/index.html", "Hel p.html") 1http://www.python.org/Help.html' Zobacz także urllib (284), Internet RFC 1738, Internet R] webbrowser

Moduł webbrowser zawiera funkcje umożliwiające otwieranie dokum w przeglądarce WWW w sposób niezależny od platformy. Moduł ten p ustalić rodzaj przeglądarki na podstawie środowiska lokalnego komputer open (url [, new]) Wyświetla url w domyślnej przeglądarce. Ustawienie new powoduje < cie nowego okna przeglądarki. open_new (url) Wyświetla url w nowym oknie domyślnej przeglądarki, get ([name]) Zwraca obiekt-kontroler umożliwiający sterowanie przeglądarką. Argi name jest nazwą typu przeglądarki i zazwyczaj ma jedną z następu wartości: 'netscape1, 'kfm1, 'grail1, 'windows-default', ' ir net-config' lub 'command-line'. register(name, constructor [, controller]) Rejestruje nowy typ przeglądarki do wykorzystania przez funkqe get (). jest nazwą typu przeglądarki, a constructor konstruktorem wywoływ bez argumentów w celu utworzenia obiektu - kontrolera do stero przeglądarką, con tr oiler jest instanqa zastępczego kontrolera. Jeśli ten ment występuje, constructor jest ignorowany i może mieć wartość NOJ Instancja c kontrolera zwracana przez funkqe get () ma następujące met c. open (url [, new]) To samo co funkcja open (). c. open__new (url) To samo co funkcja open_new (). UWAGA • Jeśli jest ustawiona zmienna środowiskowa $BROWSER, zawiera ona nazwę domyślnej przegląd

Obsługa i kodowanie danych internetowych Moduły omawiane w tej części są używane do kodowania i dekodowania d< w formatach szeroko rozpowszechnionych w Internecie.

288 Pyihon base64 Moduł base 64 służy do kodowania i dekodowania danych z użyciem metody kodowania base64. Metoda ta jest powszechnie wykorzystywana do kodowania danych binarnych w załącznikach poczty. decode (Input, output) Dekoduje dane zakodowane w formacie base64. input jest nazwą pliku lub obiektem-plikiem otwartym do czytania, output jest nazwą pliku lub obiektem-plikiem otwartym do pisania. decodestring( s) Dekoduje napis s zakodowany metodą base64. Zwraca napis zawierający rozkodowane dane binarne. encode(input, output) Koduje dane metodą base64. input jest nazwą pliku lub obiektem-plikiem otwartym do czytania, output jest nazwą pliku lub obiektem-plikiem otwartym do pisania. encodestring( s) Koduje napis s przy użyciu metody base64. Zobacz także binascii (288), Internet RFC 1421. binascii Moduł binascii służy do konwertowania danych z wersji binarnej na różne kodowane wersje ASCII, takie jak base64, binhex i uuencode, i na odwrót. a2b_uu (s trlng) Konwertuje linię danych zakodowanych metodą uuencode na postać binarną. Linie (z wyjątkiem ostatniej) zawierają zwykle 45 bajtów (binarnych). Na końcu danych może występować biały znak. b2a_uu(data) Konwertuje napis data z danymi binarnymi na linię znaków ASCII zakodowanych metodą uuencode. Długość danych nie powinna przekraczać 45 bajtów. a2b_base64(string) Konwertuje napis z danymi zakodowanymi metodą base64 na postać binarną. b2a_base64(data) Konwertuje napis z danymi binarnymi na linię znaków ASCII zakodowanych metodą base64. a2b__hex (string) Konwertuje napis z cyframi szesnastkowymi na napis z danymi binarnymi. string musi zawierać parzystą liczbę cyfr. b2a_hex(data) Konwertuje napis z danymi binarnymi na napis z cyframi szesnastkowymi. a2b_hqx (string) Konwertuje napis z danymi zakodowanymi metodą binhex4 na dane binarne bez wykonywania dekompresji RLE. Dodatek A: Biblioteka Pythona rledecode_hqx (data) Wykonuje dekompresję RLE (Run-Length Encoding) danych binarnych sanych w da ta. Funkq'a zwraca rozpakowane dane, chyba że dane wejś są niekompletne, co powoduje zgłoszenie wyjątku Incomplete. rlecode_hqx (data) Wykonuje kompresję RLE danych (data) zakodowanych w binhex4. b2a_hqx(data) Konwertuje dane binarne na napis składający się ze znaków ASCII za

wanych metodą binhex4. Zawartość data powinna mieć już postać i mieć długość podzielną przez trzy. erc_hqx(data, erc) Oblicza sumę kontrolną CRC danych binhex4. erc jest wartością począi sumy kontrolnej. crc32(data [, olderc]) Oblicza sumę kontrolną CRC-32 argumentu data. Nieobowiązkowy ment olderc umożliwia przyrostowe obliczanie sumy kontrolnej. WYJąTKI

Error Wyjątek zgłaszany na skutek błędów. Incomplete Wyjątek zgłaszany na skutek niekompletnych danych. Wyjątek ten nast wtedy, gdy funkcja oczekuje wielu bajtów, a zbiór danych wejściowyc już wyczerpany. Zobacz także base64 (288), binhex (289), ui binhex Moduł binhex służy do kodowania i dekodowania plików w formacie bin powszechnie wykorzystywanym do reprezentowania plików w Macintosł binhex(input, output) Konwertuje plik binarny o nazwie input na plik binhex. output jest n pliku lub otwartym obiektem w stylu pliku udostępniającym metody te () i close (). hexbin (input [, output]) Dekoduje plik binhex. input jest nazwą pliku lub otwartym obiektem w pliku udostępniającym metody write() iclose(). output jest nazw ku wyjściowego. Bez tego argumentu nazwa pliku wyjściowego jest ust na podstawie pliku binhex. UWAGI • W Macintoshach są obsługiwane zarówno część data fork, jak i resource fork. • Na pozostałych platformach obsługiwana jest tylko część data fork. Zobacz także binascii (288), macostool:

290 Python

L

mailcap Moduł mailcap służy do czytania uniksowych plików mailcap. Pliki te są uży- wane do informowania czytników poczty i przeglądarek WWW o tym, jak należy przetwarzać różnego rodzaju pliki MIME (Multipurpose Internet Mail Extension - uniwersalne rozszerzenie poczty internetowej). Plik mailcap ma zwykle zawar- tość podobną do następującej: video/mpeg; xmpeg %s application/pdf; acroread %s Po napotkaniu danych jakiegoś typu MIME na podstawie pliku mailcap ustalana jest aplikaqa, która ma obsłużyć dane. getcaps() Wczytuje wszystkie dostępne pliki mailcap i zwraca słownik mapujący typy MIME na pozycje mailcap. Pliki mailcap są szukane w miejscach $HOME/ .mailcap, /etc/mailcap, /usr/etc/mailcap i /usr/local/ etc/mailcap. findmatch(caps, mimetype [, key [, filename [, pllst]]]) Szuka w słowniku caps pozyqi mailcap odpowiadającej typowi mimetype. key jest napisem wskazującym działanie i jest to z reguły ' view', ' com- pose1 lub 'edit1, filename jest nazwą pliku podstawianą w miejsce słowa kluczowego %s w pozycji mailcap. plist jest listą parametrów nazwanych, opisaną szczegółowo w dokumentacji online pod adresem http://www.python.org/doc/lib/module-mailcaop.html. Funk- qa zwraca tupię (cmd, mail cap), w której cmd zawiera polecenie z pliku mailcap, a mailcap jest pozycją mailcap dla podanego typu MIME. PRZYKŁAD import mailcap import urllib import os # Pobranie dokumentu ur11ib.urlretrieve("http://www.swig.org/Docl.1/PDF/ Python.pdf", M/tmp/tmpl234") caps = mailcap.getcaps() cmd, mc = mailcap.findmatch(caps, 'application/pdf, filename='/tmp/tmpl234') i f cmd: os.system(cmd + " &") else: print "Brak aplikacji dla typu application/pdf" Zobacz także http://www.python.org/doc/lib/module-mailcap.html, mimetypes (292), Internet RFC 1524. mimetools Moduł mimetools udostępnia szereg funkcji do wykonywania działań na zakodowanych wiadomościach MIME. MIME jest standardem przesyłania wieloczę- ściowych danych multimedialnych przy użyciu poczty internetowej. Elementy tego standardu są również wykorzystywane w innych miejscach, na przykład Dodatek A: Biblioteka Pythona w protokole HTTP. Zakodowana wiadomość MIME może wyglądać pująco: Content-Type: multipart/mixed; boundary="==== Date: Fri, 06 Jul 2001 03:20:47 -0500 From: John Doe <[email protected]> To: Jane Doe ([email protected]> Subject: Important Message From John Doe ~====_931526447== Content-Type: text/plain; charset="us-ascii" 931526447==' Oto dokument, o który prosiłe ś nie pokazuj go nikomu ;-) ~====_931526447==

Content-Type: application/msword; name="list.doc" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="list.doc " SXQgd2FzIGEgbG9uZyBob3QgZGF5IGluIHRcZSBtb250aCBvZiB KdWx5LCB3aGVuIExhcn YXJ0ZWQgdGFsa21uZwphYm91dCBzb2Npbylwb2xpdGljYWwgc2N hbGFibGUgaWltZXJzaX cnRlYWwgdGVtcG9yYWwKY29sbGFib3JhdG12ZSBwYXJhbGxlbCBoaWdoIHBlcmZvcmlhbm YiliYXNlZCBtb2JpbGUKb2JqZWN0LW9yaWVudGVkIHNjaWVudGl maWMgY29tcHV0aW5nIG b25tZW50cy4gIEZvcnRlbmF0ZWx5LCBQZXRlCmhhZCByZWllbWJ lcmVkIHRvIGJyaW5nIG NDUuLi4KCg== 931526447==-- Wiadomości MIME są podzielone na części za pomocą speqalnej linii rującej, takiej jak --====_931526447==-- wprzykładzie powyżej. Lini< rująca zaczyna się zawsze od dwóch łączników. Ostatnia taka linia ma rć dodane dwa łączniki na końcu (--) wskazujące koniec wiadomości. Bezp nio po każdym separatorze występuje zbiór nagłówków RFC 822, opisu typ zawartości i kodowanie. Dane oddziela od nagłówków jedna pusta lii Moduł mimetools definiuje następujące funkcje do analizowania nagłó i dekodowania danych: Message(file [, seekable]) Dokonuje rozbioru nagłówków MIME i zwraca obiekt Message pochc od klasy rf c822 .Message, file i seekable mają to samo znaczei w rfc822.Message. choose_boundary() Tworzy unikatowy napis postaci 'adriphosta. uid. pid. datowni} rlosowa ', którego można użyć jako elementu rozgraniczenia podczas rowania wiadomości. decode(input, output, encoding) Czyta zakodowane dane z otwartego obiektu-pliku input i zapisuje ic kodowaną wersję w otwartym obiekcie-pliku output, encoding o metodę kodowania: ?base64', 'quoted-printable' lub 'uuenco encode(input, output, encoding) Czyta dane z otwartego obiektu-pliku input i zapisuje ich zakodowani sję w otwartym obiekcie-pliku output, encoding ma to samo znaczę w decode().

292 Python DoćateKA: bionowKa tytnona copyliterał(input, output) Czyta linie tekstu z otwartego obiektu-pliku input, aż do napotkania EOF, i zapisuje je w otwartym obiekcie-pliku output. copybinary(input, output) Czyta bloki danych binarnych z otwartego obiektu-pliku input, aż do napotkania EOF, i zapisuje je w otwartym obiekcie-pliku output. Instancje klasy Message udostępniają wszystkie metody opisane w module r f c 8 2 2 oraz kilka dodatkowych: m.getplist() Zwraca parametry nagłówka typu zawartości w postaci listy napisów. Jeśli wia- domość zawiera przykładowo nagłówek 'Content-type: text /html; charset=US-ASCII', funkcja ta zwraca [' charset=US-ASCII' ]. W przypadku parametrów postaci 'klucz=wartość' klucz jest konwertowany na małe litery, a wartość pozostaje bez zmian. m. getparam(name) Zwraca wartość pierwszego parametru postaci 'nazwa=wartość' z na- główka 'content-type'. Jeśli wartość jest zacytowana przy użyciu zna- ków '<...>' lub "...", są one usuwane przez funkcję. m. getencoding() Zwraca kodowanie podane w nagłówku wiadomości 'content-trans- f er-encoding'. Jeśli taki nagłówek nie występuje, funkcja zwraca ' 7bit'. m.gettype() Zwraca typ wiadomości podany w nagłówku ' content-type '. Jest to napis postaci ' typ/podtyp'. Jeśli taki nagłówek nie występuje, funkcja zwraca 'text/plain'. m.getmaintype() Zwraca główny typ wiadomości podany w nagłówku ' content-type'. Je- śli taki nagłówek nie występuje, funkcja zwraca napis ' text'. fit .getsubtype() Zwraca podtyp wiadomości podany w nagłówku ' content-type '. Jeśli taki nagłówek nie występuje, funkcji zwraca napis 'plain'. Zobacz także rf c822 (299), mimetypes (292), MimeWriter (295), multifile (297), mailcap (290), Internet RFC 1521. mimetypes Moduł mimetypes służy do ustalania typu MIME plików o podanym rozszerzeniu. Pozwala również konwertować typy MIME na odpowiadające im standardowe rozszerzenia. Typy MIME są reprezentowane przez pary postaci typ/podtyp. Oto tabela z listą typów MIME rozpoznawanych aktualnie przez moduł mimetypes: Rozszerzenie pliku .a . ai Typ MIME application/octet-stream application/postscript Rozszerzenie pliku

Typ MIME

.aif audio/x-aiff

.aifc audio/x-aiff

.aiff audio/x-aiff ,au audio/basic

. avi video/x-msvideo

.bcpio application/x-bcpio • bin application/octet-stream .cdf application/x-netcdf . cpio application/x-cpio .csh application/x-csh .dll application/octet-stream .dvi application/x-dvi .exe application/octet-stream .eps application/postscript .etx text/x-setext .gif image/gif .gtar application/x-gtar .hdf application/x-hdf .htm text/html .html text/html .ief image/ief . jpe image/jpeg . jpeg image/jpeg • jpg image/jpeg . latex application/x-latex .man application/x-troff-man .me application/x-troff-me .mif application/x-mif .mov video/quicktime .movie video/x-sgi-movie .mpe video/mpeg .mpeg video/mpeg .mpg video/mpeg .ms application/x-troff-ms .nc application/x-netcdf . o application/octet-stream .obj application/octet-stream .oda application/oda .pbm image/x-portable-bitmap .pdf application/pdf .pgm image/x-portable-graymap

294 Python

L_ Rozszerzenie pliku

Typ MIME

.pnm image/x-portable-anymap • png image/png .ppm image/x-portable-pixmap • py text/x-python .pyc application/x-python-code .ps application/postscript .qt video/quicktime .ras image/x-cmu-raster .rgb image/x-rgb .rdf application/xml .roff application/x-troff .rtf application/rtf . rtx text/richtext . sgm text/x-sgml . sgml text/x-sgml .sh application/x-sh . shar application/x-shar . snd audio/basic .so application/octet-stream . src application/x-wais-source .sv4cpio application/x-sv4cpio .sv4crc application/x-sv4crc • t application/x-troff .tar application/x-tar .tcl application/x-tcl . tex application/x-tex . texi application/x-texinfo .texinfo application/x-texinfo .tif image/tiff .tiff image/tiff . tr application/x-troff . tsv text/tab-separated-values .txt text/plain . ustar application/x-ustar . wav audio/x-wav .xbm image/x-xbitmap . xml text/xml . xsl application/xml . xpm image/x-xpixmap . xwd image/x-xwindowdump . zip application/zip Dodatek A: Biblioteka Pythona guess__type (filename) Ustala typ MIME pliku na podstawie jego nazwy lub wskaźnika URL. \ tupię (typ, kodowanie), gdzie typ jest napisem postaci typ/podtyp, i wanie programem używanym do kodowania danych (na przykłac press lub gzip). Jeśli funkcja nie może ustalić typu, zwraca (None, fr guess_extension(type)

Ustala standardowe rozszerzenie pliku na podstawie jego typu MIME ca napis z rozszerzeniem pliku i kropką na początku. Jeśli funkcja nii ustalić typu, zwraca None. init( [files]) Iniqalizuje moduł, files jest sekwencją nazw plików czytanych w o brania informacji o typie. Pliki te zawierają linie mapujące typy MIME odpowiadających im rozszerzeń, na przykład: image/jpeg: text/html: Dpe Dpeg jpg htm html r e ad_mime_type s(fil ename) Ładuje mapowanie typów z podanego pliku. Zwraca słownik mapująi szerzenia plików na napisy z typami MIME. Jeśli plik filename nie i lub nie można go odczytać, funkcja zwraca None. knownfiles Lista typowych nazw plików mime . types. suffix__map Słownik mapujący jedne rozszerzenia na drugie. Umożliwia on rozpoz nie zakodowanych plików, których rozszerzenie zawiera informacje c i kodowaniu jednocześnie. Na przykład rozszerzenie . tg z jest mapow . tar. g z, co pozwala już rozpoznać oddzielnie rodzaj kodowania i typ encod±ngs_map Słownik mapujący rozszerzenia plików na typy kodowania. types_map Słownik mapujący rozszerzenia plików na typy MIME. Zobacz także mimetool MimeWriter Moduł MimeWriter definiuje klasę MimeWriter, używaną do genero wieloczęściowych kodowanych plików MIME. MimeWri ter (fp) Tworzy nową instancję klasy MimeWriter. fp jest otwartym obiektei kiem, przeznaczonym do pisania. Można również użyć obiektu Strin

296 Python Instancja m klasy MimeWriter ma następujące metody: m.addheader(key, value [, prefix]) Dodaje do wiadomości MIME lini ę nagłówka postaci "key: value", prefix decyduje o miejscu wstawienia nagłówka: 0 oznacza koniec (miejsce standardowe), a 1 początek. m. flushheaders() Zapisuje wszystkie skumulowane dotąd nagłówki. m.startbody (ctype [, plist [, prefix]]) Zwraca obiekt w stylu pliku, używany do zapisywania treści wiadomości. ctype podaje typ zawartości, a plist jest listą tupli postaci (nazwa, war- tość), zawierającą dodatkowe parametry deklaracji typu. prefix ma to samo znaczenie, co w metodzie addheader (), tyle że domyślnym miejscem nagłówka jest początek. m. startmultipartbody (subtype [, boundary [, plist [ ,prefix] ] ]) Zwraca obiekt w stylu pliku, używany do zapisywania treści wieloczęścio- wych wiadomości, subtype podaje podtyp, taki jak ' mixed', a boundary może służyć do zdefiniowania przez użytkownika własnej linii rozdzielającej. plist jest listą zawierającą nieobowiązkowe parametry pod typu, a prefix ma to samo znaczenie, co w metodzie startbody(). Kolejne części są tworzone przy użyciu metody nextpart (). m.nextpart() Zwraca nową instancję MimeWriter, reprezentującą pojedynczą część wia- domości wieloczęściowej. Przed użyciem tej metody trzeba koniecznie wywołać startmultipartbody (). ja.lastpart () Metoda używana do zaznaczenia ostatniej części wiadomości wieloczęścio- wej. Należy ją wywoływać zawsze na końcu wiadomości wieloczęściowej. PRZYKŁAD Oto przykład kodu pobierającego listę plików przekazanych w linii polecenia i generującego wieloczęściowy dokument MIME, w którym każdy plik jest zakodowany metodą base64: import sys import mimetools, mimetypes, MimeWriter # Otwarcie pliku wyj ściowego i utworzenie instancji MimeWriter plikwy = open ("output.txt","w") writer = MimeWriter.MimeWriter(plikwy) # Rozpocz ęcie wiadomo ści wielocz ęściowej writer.startmultipartbody("mixed") writer.flushheaders() # P ętla obsługuj ąca pliki z linii polecenia for plik in sys.argv[l:]: fragm = writer.nextpart() # Utworzenie nowej cz ęści # Próba ustalenia typu MIME i kodowania pliku typ,kodowanie = mimetypes.guess_type(plik) if kodowanie: Dodatek A: Biblioteka Pythona fragm.addheader("Content-encoding", kodowanie) fragm.addheader("Content-transfer-encoding", "base6 4") if typ: czplikwy = fragm.startbody(typ, [("name",plik)]) else: czplikwy = fragm.startbody("text/plain",[("name",pl ik)]) plikwe = open(plik, "rb") # Zakodowanie surowych danych metod ą base64 mimetools.encode(plikwe,czplikwy, 'base64') plikwe.close() # Sprz ątanie

writer.lastpart() plikwy.close() Zobacz tak że mimetypes (292), mimetools (290), rf c822 (299), multif i multifile Moduł multifile definiuje obiekt umożliwiający czytanie wieloczęśd plików tekstowych występujących w zakodowanych wiadomościach Obiekt multifile dzieli plik na szereg obiektów w stylu plików logiczn] dzielonych unikatowymi napisami granicznymi, takimi jak: —216.150.6.70.100.4397.932677969.082.3036 Część 1 —216.150.6.70.100.4397.932677969.082.3036 Część 2 —-216.150.6.70.100.4397.932677969.082.3036-- W tym przykładzie napis graniczny ma postać stosowaną przez funkq'e tools. choose_boundary (). Ostatni napis graniczny (zakończony łą< mi —) sygnalizuje koniec danych wieloczęściowych. MultiFile(fp [, seekable]) Tworzy obiekt MultiFile. fp jest obiektem w stylu pliku zawier; dane wejściowe. Jego metoda readline () służy do wczytywania d Jeśli jest ustawiona opcja seekable, obiekt MultiFile umożliwia bezpośredni za pomocą metod seek() i tell (). Instanqa m obiektu MultiFile ma następujące metody: m. push(str) Dokłada na stos napis graniczny. Napotkanie takiego napisu w danycl ciowych sygnalizuje koniec sekcji lub wiadomości. Można dołożyć wic jeden napis graniczny i obsługiwać w ten sposób zagnieżdżone dane częściowe. Jednak napotkanie innego napisu granicznego niż ostatnio ny, powoduje błąd. m. readline() Wczytuje linię tekstu. Jeśli pasuje ona do ostatnio dołożonego napisu gi nego, metoda zwraca ' ' na znak końca części. Co więcej, jeśli napis gra: odpowiada znacznikowi końca, atrybut m. last jest ustawiany na 1.1

298 Python kanie znacznika EOF przed pobraniem wszystkich napisów granicznych powoduje zgłoszenie wyjątku Error. m.readlines() Wczytuje wszystkie pozostałe linie bieżącej części i zwraca je jako listę napisów. m.read() Wczytuje wszystkie pozostałe linie bieżącej części i zwraca je jako jeden napis. m. next() Przeskakuje do następnej sekcji. Jeśli taka istnieje, zwraca prawdę, a w przypadku napotkania znacznika końca zwraca fałsz. m.popO Zdejmuje ze stosu znacznik graniczny sekcji. Napis ten nie będzie już interpretowany jako EOF. m.seek(pos [, whence]) Przeskakuje do nowego miejsca w bieżącej sekqi. Argumenty pos i whence mają to samo znaczenie co w przypadku przeskakiwania w zwykłym pliku. m. tell () Zwraca położenie w pliku względem początku bieżącej sekcji. Ponadto instancje MultiFile mają dwie publiczne zmienne: m.level Poziom zagnieżdżenia bieżącej części. ID. last Prawda, jeśli ostatni znacznik końca pliku był znacznikiem końca wiadomości. PRZYKŁAD # Rozło żenie na cz ęści wiadomo ści pocztowej MIME import mimetools, multifile, sys def rozpak_fragm(plik,nrfragm=0): nagłówki = mimetools.Message(plik) # Pobranie nagł ówków typ = nagłówki.getmaintype() # Pobranie główn ego typu zawarto ści if typ == 'multipart': # Multipart? granica = nagłówki.getparam("boundary") plik.push(granica) plik.readlines() while not plik.last: plik.next() nrfragm = nrfragm + 1 rozpak_fragm(plik, nrfragm) plik.popO return nazwa = nagłówki.getparam("name") # Pobranie nazw y pliku if not nazwa: nazwa = "part%d" % (nrfragm,) kodowanie = nagłówki.getencoding() print "Rozpakowanie '%s'. Kodowanie = %s" % (nazwa, kodowanie) if kodowanie == '7bit': plikwy = open(nazwa, "w") mimetools.copyliteral(plik, plikwy) else: plikwy = open(nazwa, "wb") mimetools.decode(plik, plikwy, kodowanie) plikwy.close() Dodatek A: Biblioteka Pythona # Odczytanie nazwy pliku z opcji i rozpakowanie go f = open(sys.argvfl]) mf = multifile.MultiFile(f,O) rozpak_fragm(mf) UWAGA • Klasa MultiFile definiuje szereg metod, które można dostosować tworząc własne podklasy. \ formacji na ten temat znajdziesz w dokumentacji online biblioteki pod adresem http: //wv thon.org/doc/lib/module-multifile.html. Zobacz tak że mimetools (290), MimeWrit< http://www.python.org/doc/lib/module-multifile quopri Moduł quopri służy do kodowania i dekodowania danych w formacie quote table. Formatu tego używa się głównie do kodowania plików tekstowych,

decode(input, output) Dekoduje zawartość input i zapisuje wynik w output. Oba argumei winny być obiektami-plikami. encode(input, output, quotetabs) Koduje zawartość input i zapisuje wynik w output. Oba argumenty j ny być obiektami - plikami. Jeśli argument quotetabs ma wartość pi wymusza to dodatkowo cytowanie znaków tabulacji. Zobacz także binascii (288), Internet K rfc822 Moduł rf c822 służy do analizowania nagłówków poczty elektronicznej 2 nych w formacie zdefiniowanym przez standard internetowy RFC Nagłówki te są używane w wielu sytuacjach, między innymi do obsługi oraz w protokole HTTP. Zbiór nagłówków RFC 822 może wyglądać następ Return-Path: <[email protected]> Date: Sun, 15 Apr 03:18:21 -0500 (CDT) Message-Id: <[email protected] cago.edu> Reply-To: [email protected] References: <15065.6056.897223.775915@empire-builde r.es.uchicago.edu <[email protected]> Mime-Version: 1.0 (generated by tm-edit 7.78) Content-Type: text/plain; charset=US-ASCII From: David Beazley <[email protected]> To: techstaff@cs Subject: Problemy z modemem Mam problemy z działaniem MPI przez ultraskalowaln ą tablic ę modemów naszym klasterze Beowulf. Czy kto ś może na to rzuci ć okiem? Linia każdego nagłówka ma postać ' nazwanagłówka: wartość1 i moż mować kilka wierszy. Wielkość liter w nazwach nagłówków jest ignorowa więc zapis ' Content-Type ' traktowany jest tak samo, jak ' content-t Na końcu listy nagłówków musi wystąpić pusta linia.

300 Python Nagłówki RFC 822 są analizowane za pomocą instancji klasy Message. Message(file [, seekable]) Wczytuje nagłówki RFC 822 z obiektu w stylu pliku file i zwraca obiekt Message. Nagłówki są czytane przy użyciu metody f"iie.readline(),aż do napotkania pustej linii. Jeśli argument seekable ma wartość zero, oznacza to, że obiekt file nie umożliwia swobodnego dostępu (jak plik utworzony z gniazda). Instancja m obiektu Message zachowuje się podobnie jak słownik, ale ignoruje wielkość liter w wartościach kluczy oraz nie obsługuje pewnych operacji słowni- kowych, w tym update () i clear (). Metoda m[name] m[name]=value m.keys() m. values() m. items() m. has_key (nawie) m. get (name [, default]) len(m) str(m) Opis Zwraca wartość nagłówka name. Dodaje nagłówek. Zwraca listę nazw nagłówków. Zwraca listę wartości nagłówków. Zwraca listę par nagłówkowych (nazwa, wartość). Sprawdza istnienie nagłówka name. Pobiera wartość nagłówka. Jeśli nie ma takiego, zwraca default. Zwraca liczbę nagłówków. Konwertuje nagłówki na napisy w formacie RFC 822. A oto inne dostępne metody: m.getallmatchingheaders(name) Zwraca listę wszystkich linii z nagłówkami pasującymi do name, łącznie z liniami kontynuacji (o ile występują). m.getfirstmatchingheader(name) Zwraca listę linii pierwszego nagłówka pasującego do name, łącznie z liniami kontynuaqi. Jeśli żaden nagłówek nie pasuje do name, metoda zwraca None. m. getrawheader(name) Zwraca napis zawierający surowy tekst zaraz po dwukropku w pierwszym nagłówku pasującym do name. Jeśli żaden nagłówek nie pasuje do name, metoda zwraca None. m.getheader(name [, default]) Podobna do getrawheader (name), ale obcina wszystkie początkowe i ko- ńcowe białe znaki, default zawiera wartość domyślną zwracaną przez me- todę, gdy żaden nagłówek nie pasuje do name. m.getaddr(name) Zwraca parę (pełne_nazwisko, adres_email) na podstawie napisu zwró- conego przez getheader (name). Jeśli żaden nagłówek nie pasuje do name, metoda zwraca (None, None). Dodatek A: Biblioteka Pythona m.getaddrlist(name) Analizuje nagłówek zawierający listę adresów e-mail i zwraca listę tup jak metoda getaddr (). Jeśli wiele nagłówków pasuje do podanej i z wszystkich są wyciągane adresy (dotyczy to na przykład nagłówków '. m. getdate (name)

Analizuje nagłówek zawierający datę i zwraca 9-elementową tupię kor bilną z time. mktime (). Jeśli żaden nagłówek nie pasuje do name 1 można rozpoznać daty, metoda zwraca None. m.getdate_tz(name) Analizuje nagłówek zawierający datę i zwraca 10-elementową tupię, pierwszych dziewięć elementów jest takich samych jak w tupli zwr przez getdate (), a dziesiąty jest liczbą wskazującą przesunięcie strei sowej względem UTC (Greenwich Mean Time). Jeśli żaden nagłówek i suje do name lub nie można rozpoznać daty, metoda zwraca None. m.headers Lista zawierająca cały zbiór linii nagłówkowych. m. fp Obiekt w stylu pliku przekazany w momencie tworzenia Message. Oprócz Message moduł rf c822 definiuje następujące funkcje narzędzio parsedate(date) Analizuje datę w formacie RFC 822, taką jak 'Mon, 16 Apr 17:30:08 -0600' i zwraca 9-elementową tupię kompatybilną z fi time . mktime (). Jeśli nie można rozpoznać daty, metoda zwraca Nor parsedate_tz (date) Analizuje datę w formacie RFC 822, ale zwraca 10-elementową tupię, 9 elementów jest takich samych, jakie zwraca funkcja parse da te(), s siaty jest liczbą wskazującą przesunięcie strefy czasowej względem UTC enwich Mean Time). Jeśli nie można rozpoznać daty, metoda zwraca No mktime__tz (tupie) Zamienia 10-elementową tupię, ta ą̂ jaką zwraca parsedate_tz (), n UTC. Jeśli dziesiąty element tupli (strefa czasowa) ma wartość None, mowany jest czas lokalny. AddressList (addrllst) Konwertuje napis zawierający listę adresów e-mail na obiekt Address Obiekt ten pozwala wykonywać następujące operacje: Operacja len(a) str (a) a + b a - b Opis Podaje liczbę adresów na liście. Konwertuje listę z powrotem na napis adresów email. Łączy dwie listy adresów i usuwa powtórzenia. Usuwa z a wszystkie adresy na liście b.

302 Python Dodatek A: Biblioteka Pythona PRZYKŁAD import rfc822 # Otwarcie wiadomo ści pocztowej f = open("mailmessage") # Wczytanie nagłówków m = rfc822.Message(f) # Wyci ęcie kilku pól m_from = m["From"] m_to = m.getaddr("To") m_subject = m["Subject"] UWAGA # Klasa Mes sage definiuje kilka dodatkowych metod, które można przestanie w podklasach. Szczegółowe informacje znajdują się w dokumentacji online pod adresem http: / /www. python. org/doc/1 ib/ module-rfc822.html. Zobacz także mimetools (290), MimeWriter (295), mimetypes (292), mailcap (290), Internet RFC 822, http://www.python.org/doc/lib/module-rfc822.html. uu Moduł uu służy do kodowania i dekodowania plików w formacie uuencode, powszechnie wykorzystywanym do transferu danych binarnych za pomocą połączeń ASCII. encode(input, output [, name [, mode]]) Koduje zawartość input i zapisuje w output, input musi być nazwą pliku lub otwartym obiektem-plikiem do czytania, output musi być nazwą pliku lub otwartym obiektem-plikiem do pisania, name jest nazwą, pod jaką ma być zakodowany plik w output, a mode ustala jego prawa dostępu. Standardo- wo wartości name i mode są wzorowane na pliku input. decode(input [, output [, mode]]) Dekoduje input i zapisuje wynik w output, input musi być nazwą pliku lub otwartym obiektem-plikiem do czytania, output musi być nazwą pliku lub otwartym obiektem-plikiem do pisania, mode służy do ustawienia praw dostępu i przesłania wartości zakodowanej w pliku input. Zobacz także binascii (288). xdrlib Moduł xdrlib służy do kodowania i dekodowania danych w formacie XDR (External Data Representation) firmy SUN. Format ten jest często używany do kodowania danych binarnych wykorzystywanych przez aplikacje sieciowe. Znajduje też szerokie zastosowanie w aplikacjach związanych ze zdalnym wywoływaniem procedur (RPC). Kodowanie i dekodowanie jest nadzorowane za pomocą dwóch klas: Packer() Tworzy obiekt do pakowania danych w formacie XDR. Unpacker(data) Tworzy obiekt do rozpakowywania danych zapisanych w formacie XDR. Dane te są zawarte w napisie data. Instancja p klasy Packer udostępnia następujące metody: p.getjbuffer() Zwraca bieżącą zawartość bufora pakowania jako napis. p.reset() Ustawia zawartość bufora pakowania na pusty napis. p. pack_uint(x) Pakuje 32-bitową liczbę całkowitą bez znaku x. p.pack__int(x) Pakuje 32-bitową liczbę całkowitą ze znakiem x. p. pack_enum (x) Pakuje wartość wyliczeniową x (całkowitą). p. pack_bool(x)

Pakuje wartość boolowską x. p.pack_uhyper(x) Pakuje 64-bitową liczbę całkowitą bez znaku x. p. pack__hyper (x) Pakuje 64-bitową liczbę całkowitą ze znakiem x. p.pack_float(x) Pakuje liczbę zmiennoprzecinkową pojedynczej precyzji x. p.pack_double(x) Pakuje liczbę zmiennoprzecinkową podwójnej precyzji x. p.pack_fstring(n, s) Pakuje napis s o stałej długości n. p. pack_f opaque (ii, data) Pakuje stałej długości nieprzejrzysty strumień danych. Metoda podoi pack_fstring(). p. pack_s tring( s) Pakuje napis zmiennej długości s. p. pack_opaque(data) Pakuje zmiennej długości nieprzejrzysty napis z danymi s. Metoda pc do pack_string(). p.pack_bytes (bytes) Pakuje zmiennej długości strumień bajtowy bytes. Metoda podot pack_string(). p.pack_list (list, pack_func) Pakuje listę jednorodnych elementów. pack_func jest funkcją wywoJ w celu zapakowania każdego pojedynczego elementu (na pr p. pack_int). Dla każdego elementu listy najpierw pakowana jest liczbę wita bez znaku 1, a po niej dane. Na końcu listy pakowana jest liczba cal bez znaku 0.

304 Python p.pack_farray (n, array, pack_func) Pakuje stałej długości listę jednorodnych elementów, n jest długością listy, array listą zawierającą dane, a pack_func funkcją wywoływaną w celu zapakowania każdego pojedynczego elementu listy. p.pack_array(list, pack__func) Pakuje zmiennej długości listę jednorodnych elementów. Najpierw pakowana jest długość listy, a po niej wywoływana metoda pack_farray(). Instancja u klasy Unpacker udostępnia następujące metody: u. reset(data) Ustawia zawartość bufora napisu na da ta. u. get__position () Zwraca aktualną pozycję w buforze rozpakowywanych danych. u. set_position(position) Ustawia bieżącą pozyqe w buforze rozpakowywanych danych na posi ti on. u. getjbuf f er () Zwraca bieżącą zawartość bufora rozpakowywanych danych jako napis. u.done() Sygnalizuje zakończenie rozpakowywania. Jeśli nie wszystkie dane zostały rozpakowane, zgłasza wyjątek Error. Ponadto każdy typ danych, który można zapakować przy użyciu klasy Packer, daje się rozpakować za pomocą klasy Unpacker. Metody rozpakowujące są postaci unpack_typ (), nie mają argumentów i zwracają rozpakowany obiekt. u. unpack_int() Rozpakowuje i zwraca 32-bitową liczbę całkowitą ze znakiem. u. unpack_uint() Rozpakowuje i zwraca 32-bitową liczbę całkowitą bez znaku. Jeśli wartość ta jest większa od sys.maxint, metoda zwraca ją w postaci długiej liczby całkowitej bez znaku. u. unpack_enum() Rozpakowuje i zwraca wartość wyliczeniową (całkowitą). u. unpack__bool () Rozpakowuje wartość boolowską i zwraca ją jako liczbę całkowitą. u.unpack_hyper() Rozpakowuje i zwraca 64-bitową liczbę całkowitą ze znakiem jako długą licz- bę całkowitą Pythona. u. unpack__uhyper () Rozpakowuje i zwraca 64-bitową liczbę całkowitą bez znaku jako długą liczbę całkowitą Pythona. u.unpack_float() Rozpakowuje i zwraca liczbę zmiennoprzecinkową pojedynczej precyzji. W przypadku liczby zmiennoprzecinkowej Pythona jest ona konwertowana na podwójną precyzję. Dodatek A: Biblioteka Pythona u.unpack_double() Rozpakowuje i zwraca liczbę zmiennoprzecinkową podwójnej precy: u. unpack_f string (n) Rozpakowuje i zwraca napis stałej długości, n jest spodziewaną Iic2 ków. u. unpack_f opaque (n) Rozpakowuje i zwraca stałej długości nieprzejrzysty strumień dan) dobny do unpack_f string ().

u.unpack_string() Rozpakowuje i zwraca napis zmiennej długości. u.unpack_opaque() Rozpakowuje i zwraca nieprzejrzysty napis z danymi o zmiennej dłuj u.unpack_bytes() Rozpakowuje i zwraca strumień bajtów o zmiennej długości. u. unpack_lis t (unpack_func) Rozpakowuje i zwraca listę jednorodnych elementów, podobną do up nej przez pack_list (). unpa ck_ fun c jest funkcją wywoływaną w c< pakowania każdego pojedynczego elementu (na przykład u. unpack u. unpack__farray (n, unpack_func) Rozpakowuje i zwraca (jako listę) stałej długości tablicę jednorodny mentów. n jest spodziewaną liczbą elementów listy, a unpack_funci używaną do rozpakowania każdego pojedynczego elementu. ~ u. unpack_array ( unpack_func) Rozpakowuje i zwraca zmiennej długości tablicę jednorodnych elem unpack_func jest funkcją używaną do rozpakowania każdego pojed go elementu. WYJĄTKI Error Klasa bazowa wyjątków. Ma jedną składową publiczną /nsg zawierają* błędu. ConversionError Klasa pochodna od Error. Nie zawiera żadnych dodatkowych składo UWAGA • Obiekty utworzone za pomocą modułu xdrlib można serializować przy użyciu modułu pick: Zobacz także struct (160), array (142), Internet RI

Działanie w trybie ograniczonym Standardowo programy Pythona mają pełny dostęp do komputera, w którj wykonują. W szczególności mogą otwierać pliki i połączenia sieciowe ora konywać inne potenqalnie groźne operaqe. W przypadku pewnych aplika* to jednak niepożądane - zwłaszcza jeśli chodzi o programy internetowe,

306 Python mogą być przedmiotem ataków z zewnątrz lub w których może dochodzić do wykonania kodu z niepewnego źródła. Aby zapewnić wyższy poziom bezpieczeństwa, Python pozwala wykonywać programy w trybie ograniczonym. Podstawą tego jest możliwość podziału kodu na wiarygodny (zaufany) i niewiarygodny. W szczególności program działający w trybie zaufanym (nadzorca) może utworzyć środowisko wykonania (inaczej piaskownicę), w którym działanie niewiarygodnego kodu będzie podlegać pew- nym ograniczeniom. Możliwości kodu są wówczas ściśle kontrolowane przez nadzorcę, który może ograniczyć dostęp do pewnych obiektów, jak również zmienić zachowanie poszczególnych funkcji. Wykonywanie programów Pythona w trybie ograniczonym jest implementowane za pomocą różnych trików wykorzystujących słowniki, przestrzenie nazw oraz środowisko kodu niewiarygodnego. W efekcie taki kod może używać tych samych nazw funkcji i modułów co zwykły program, ale niektóre z funkcji wbudowanych i modułów będą dla niego niedostępne lub przedefiniowane na wersję „bez- pieczną" (w przeciwieństwie do oddzielnych, bezpiecznych interfejsów API). Na poziomie wewnętrznym interpreter Pythona ustala tryb wykonania na podstawie obiektu__bu i 11 i n s__w swojej globalnej przestrzeni nazw. Jeśli jest on tożsamy ze standardowym modułem__built in__, kod wykonuje się bez ograniczeń. W przeciwnym wypadku obowiązuje tryb ograniczony. W trybie ograniczonym interpreter stosuje szereg zakazów, których celem jest zapobieże- nie przekształceniu kodu niewiarygodnego w wiarygodny: • Nie ma dostępu do atrybutu__diet__klas i instanq'i. • Nie ma dostępu do atrybutu f unc_globals funkcji. Ograniczenia te uniemożliwiają zmianę globalnej przestrzeni nazw kodu niewiarygodnego (wykorzystując tę przestrzeń, nadzorca blokuje dostęp do różnych obiektów). Na koniec trzeba dodać, że choć środowisko trybu ograniczonego Pythona zapobiega dostępowi do niebezpiecznych obiektów i działań, to nie chroni przed ata- kami typu „odmowa usługi", polegającymi na próbie wyczerpania pamięci lub zajęcia całego czasu CPU przez niewiarygodny program. Wykonanie w trybie ograniczonym jest realizowane za pomocą dwóch modułów: rexec i Bastion. Pierwszy z nich pozwala ograniczyć środowisko, w którym działa kod, a drugi - dostęp do obiektów utworzonych przez nadzorcę. Dodatek A: Biblioteka Pythona rexec Moduł rexec służy do uruchamiania kodu w środowisku ograniczonym. Środo- wisko to jest kapsułkowane w klasie RExec zawierającej atrybuty decydujące o możliwościach wykonywanego kodu. RExec([hooks [, verbose]]) Tworzy instancję klasy RExec, reprezentującą środowisko ograniczone, hooks jest instancją klasy używanej do implementacji niestandardowych metod importowania modułów, której nie będziemy tutaj opisywać, verbose jest flagą, która powoduje wysyłanie na standardowy strumień wyjsciov nych informaqi debugera. Omówimy teraz składowe klasy RExec używane w momencie tworzeń: stancji przez metodę__i n i t__(). Modyfikowanie ich w samej instancj daje. Można co najwyżej utworzyć podklasę RExec i dopiero wtedy pr zmieniać wartości tych zmiennych. RExec.nok_builtin_names Tupla napisów zawierających nazwy funkcji wbudowanych niedost w programach niewiarygodnych. Standardowo są to (' open', ' re J '__import__').

RExec. ok__builtin_modules Tupla napisów zawierających narewy modułów wbudowanych nie nych w programach niewiarygodnych. Standardowo są to: ('audioop', 'array1, 'binascii', 'cmath', 'errno', 'ima 'math1, 'md5', 'operator', 'parser1, 'pcre', 'regex', ' 'Select'. 'stroD1. ' st-ruri-' '+•-i mo ' \ 'strop', 'struct', 'time') imageop', 'ma: rotor', RExec.ok_path Lista katalogów przeszukiwanych podczas wykonywania importu w ograniczonym. Standardowo jest to taka sama wartość jak sys . path RExec.ok_posix_naxnes Tupla nazw funkcji z modułu os, dostępnych dla programów wykc nych w trybie ograniczonym. Standardowa wartość wygląda następuj ('error', 'fstat 1, 'listdir', 'Istat', 'readlink', 'stat', 'times', 'uname', 'getpid', 'getppid', 'getewd', 'getuid', 'getgid', 'geteuid', 'getegid') RExec. ok_sys_names Tupla nazw funkcji i zmiennych z modułu sys, dostępnych dla progi wykonywanych w trybie ograniczonym. Standardowa wartość wyglą stępująco: ('psi', 'ps2', 'copyright', 'version 1, 'platform', 'exit', 'maxin Oto lista metod używanych przez instancję r klasy RExec podczas wyko nia kodu w trybie ograniczonym: r. r_eval (code) Podobna do eval (), ale wykonuje kod w środowisku ograniczonym, musi być napisem lub obiektem ze skompilowanym kodem. Zwraca w wyrażenia. r .r_exec(code) Podobna do instrukcji exec, ale wykonuje kod w środowisku ogranicz* code musi być napisem lub obiektem ze skompilowanym kodem. r.r_execfile (filename) Podobna doexecfile(), ale wykonuje kod w środowisku ograniczo

308 Python r. s_eval (code) Podobna do r_eval (), ale umożliwia dostęp do sys . stdin, sys . stdout i sys. stderr. r. s_exec (code) Podobna do r_exec (), ale umożliwia dostęp do sys . stdin, sys . stdout i sys. stderr. r. s_eacecf ile (code) Podobna do r_execfile (), ale umożliwia dostęp do sys. stdin, sys.stdout i sys.stderr. Wymienione niżej metody są wywoływane jawnie przez kod wykonywany w środowisku ograniczonym i mogą być przedefiniowane w podklasach RExec: r.reimport (modulename [r globals [, locals [, fromllst]]]) Importuje moduł modulename. Jeśli moduł jest niewiarygodny, powinna zgłosić wyjątek ImportError. r.r_open(filename [, mode [, bufsize]]) Otwiera plik w środowisku ograniczonym. Argumenty są takie same jak w przypadku wbudowanej funkcji open (). Standardowo można otwierać pliki do czytania, ale nie do pisania. r. r_reload (module) Przeładowuje obiekt-moduł module. r. r_unload (module) Wyładowuje obiekt-moduł module. r. s_Lmport (modulename [, globals [, locals [, fromlist]]]) Podobna do r_import(), ale z dostępem do standardowych strumieni We/Wy. r. s_reload (module) Podobna do r_reload(), ale z dostępem do standardowych strumieni We/Wy. r. s_unload (module) Podobna do r_unload(), ale z dostępem do standardowych strumieni We/Wy. PRZYKŁAD Oto przykład programu Pythona wykonującego kod za pośrednictwem skryptu CGI w środowisku ograniczonym z limitem nałożonym na wykorzystanie pa- mięci i CPU: #!/usr/local/bin/python import rexec import cgi, StringlO, sys, form = cgi.FieldStorage() kod = form["code"].value kod = string.replace(kod, sys.stderr = sys.stdout string, resource # Pobranie dowolnego kodu do wykonania •\015", "") # Ujawnienie komunikatów o bł ędach Dodatek A: Biblioteka Pythona print "Content-type: text/plain\n\n" print "Dane wyj ściowe programu: \n\n" class CGIExec(rexec.RExec): def r_open(*args): raise SystemError, "niedozwolone u życie open" r = CGIExec() # Utworzenie piaskownicy # Limit pami ęci 4 megabajty resource.setrlimit(resource.RLIMIT_DATA, (4000000,4 000000)) # Limit czasu CPU 10 sekund resource.setrlimit(resource.RLIMIT_CPU, (10,10)) # Uruchomienie kodu r.s_exec(kod) # Wykonanie kodu niewiarygodnego Zobacz także Basti

Bastion Moduł Bastion pozwala ograniczyć dostęp do atrybutów obiektów. Ui jest zwykle razem z modułem rexec w sytuaqach, gdy jakiś uprzywile program chce zezwolić ograniczonym programom na dostęp do wybrany< butów obiektów bez ograniczeń. Idea modułu Bastion jest prosta - w obiekt umieszcza się w obudowie, która przepuszcza próbę dostępu do metody przez funkq'e filtrującą, decydującą o akceptaqi lub odrzucenii próby. Ponadto obowiązuje zakaz dostępu do wszystkich atrybutów dany metod). Bastion(object [, filter [, name [, class]]]) Zwraca „bastion" obiektu object, filter jest funkqa akceptująca z nazwą metody i zwracającą prawdę lub fałsz, w zależności od tego, < stęp do tej metody jest dozwolony, czy nie. name jest nazwą obiektu pod przez metodę str () bastionu, class jest obiektem-klasą implement! obiekt Bastion i nie będzie tu opisany (rzadko kiedy zachodzi konie używania go). PRZYKŁAD W tym przykładzie chodzi o ograniczenie dostępu do obiektu StringlO, t zezwalał tylko na operację czytania (zobacz moduł StringlO): import StringlO, Bastion str = StringlO("") strbast = Bastion.Bastion(str, lambda x: x in ['read','readline','readlin strbast.readline() strbast.write("Ha ha") UWAGI # OK # Niepowodzenie. AttributeError : write • Bez funkcji filter bastion udaremnia dostęp do wszystkich metod zaczynających się od podki • Nie można tworzyć bastionów wokół typów wbudowanych, takich jak pliki czy gniazda.

310 Python

Inne moduły W tej części rozdziału są omawiane moduły używane do różnych celów, nie pa- sujące do żadnej z wcześniejszych kategorii. bisect Moduł bisect służy do utrzymywania list w stanie posortowanym. W tym celu wykorzystuje algorytm przeszukiwania binarnego. bisect(list, item [, low [, high]]) Zwraca indeks właściwego miejsca wstawienia elementu i te/n na listę list, tak aby zachować ją w kolejności posortowanej. lowi high są indeksami wy- znaczającymi podzbiór listy, który ma być rozpatrywany. insort(list, item [, low [, high]]) Wstawia element i te/n na listę list z zachowaniem kolejności sortowania. Dodatek A: Biblioteka Pythona cmd Moduł cmd definiuje klasę Cmd, używaną jako szkielet do budowy interpretera poleceń wierszowych. Instancje klasy Cmd nie są nigdy używane bezpośrednio, lecz pełnią rolę bazy klas faktycznie implementujących interpreter. Instancja c klasy Cmd udostępnia następujące metody: c.cmdloop( [intro]) Wyświetla napis tytułowy zawarty w intro, a następnie cyklicznie wypisuje znak zachęty, wczytuje linię polecenia i wykonuje odpowiednie działanie. Pierwszy wyraz każdej linii tekstu jest wycinany i traktowany jako nazwa polecenia. W przypadku nazw poleceń takich jak 'coś', następuje próba wywołania metody do_coś() z resztą linii wejściowej jako argumentem typu napis. Jeśli linia zawiera tylko znak ' ? ', uruchamiana jest predefiniowa- na metoda do_help(). Jeśli nazwą polecenia jest wykrzyknik ('!')/ wywoływana jest metoda do_shell () (o ile została zdefiniowana). Koniec pliku jest konwertowany na napis ' EOF' i powoduje wywołanie polecenia do_EOF. Podklasy Cmd dziedziczą predefiniowaną metodę do_help (). Wywołanie jej z argumentem ' coś ' powoduje wywołanie metody help_coś (). Bez żadnego argumentu metoda do_heip () podaje wszystkie dostępne tematy pomocy: polecenia, dla których istnieje odpowiednia metoda help_*, polecenia nieudokumentowane (bez odpowiadającej im metody help_*) oraz tematy dodatkowe (metody pomocy nie odpowiadające żadnemu poleceniu). Każda metoda polecenia powinna zwracać kod całkowity sygnalizujący po- wodzenie lub niepowodzenie. Wartość ujemna oznacza błąd i powoduje po- wrót z interpretera. W każdej innej sytuacji interpreter kontynuuje czytanie linii po wykonaniu polecenia. Jeśli jest załadowany moduł readline, interpreter poleceń umożliwia korzystanie z klawiszy edycji i historii. c.onecmd(str) Interpretuje str jako pojedynczą linię danych wejściowych. c.emptyline () Jest to metoda wywoływana po otrzymaniu pustej linii wejściowej. P być zdefiniowana przez użytkownika. Jeśli nie jest przesłonięta, po powtórzenie ostatnio wprowadzonego polecenia, c.default(line) Metoda wywoływana po wprowadzeniu nierozpoznanego poleceni; dardowo wyświetla komunikat o błędzie i kończy działanie, c. precmd() Metoda wykonywana tuż przed wyświetleniem znaku zachęty. Powii przedefiniowana w klasie pochodnej.

c.postcmdO Metoda wykonywana zaraz po zakończeniu wczytanego polecenia. c.preloopO Metoda wykonywana tylko raz, w momencie wywołania cmdloop () c.postloop() Metoda wykonywana tylko raz, tuż przed powrotem z cmdloop (). Oto zmienne instancji, które powinny być również definiowane w podklasać Zmienna c.prompt c.identchars c. lastcmd c. intro c. doc_header c.misc_header c.undoc_header c.ruler Opis Znak zachęty wyświetlany na znak gotowości do wczytania < Łańcuch znaków akceptowany jako prefiks polecenia Ostatnie polecenie niepuste Wstępny nagłówek; przesłaniany przez argument cmdloo Nagłówek wyświetlany na początku sekqi pomocy dla udokumentowanych poleceń Nagłówek wyświetlany na początku sekcji pomocy dla rói poleceń Nagłówek wyświetlany na początku sekqi pomocy dla nieudokumentowanych poleceń Znak używany do podkreślania nagłówków wiadomości p Standardowo ' ='. Bez niego nagłówki nie są podkreślane PRZYKŁAD Oto przykład wykorzystania modułu cmd do implementacji interpretera wującego wywoływalne obiekty modułu. Zwróć również uwagę na cieką konanie kodu w definiqi klasy. # cmdhelp.py # Buduje interpreter polece ń, który pozwala wpisa ć dowolne polecenia I # i w przypadku rozpoznania go wy świetla jego napis dokumentacyjny # Aby móc z niego skorzysta ć, wystarczy wykona ć w module polecenie # execfile(cmdhelp.py). import cmd, sys, traceback

312 Python # Definicja klasy interpretera class Interpreter(cmd.Cmd): symbole = globalsO znakzach = "?» " wst ęp = "Interpreter dla " + __name__ # Wyszukanie wszystkich obiektów wywoływalnych # i pobranie ich napisów dokumentacyjnych for n in symbole.keys O: c = symbole[n] if callable(c): if c.__doc__: exec """ def help_%s (self) :print %s.__doc__ """ % (n,n) # Wykonanie dowolnego polecenia def default(self, I): try: exec self.lastcmd in globalsO except: traceback.print_exc() # Gdy pusta linia, nic si ę nie dzieje, def emptyline(self): pass def do_EOF(self,arg): return -1 # Utworzenie instancji interp = Interpreter() Oto kod przedstawiający użycie zdefiniowanej klasy: Python 2.0 (#1, Feb 25 2001, 07:54:16) [GCC 2.95.2 19991024 (release)] on sunos5 Type "copyright", "credits" or "license" for more i nformation. >» from socket import * >» execf ile ("cmdhelp.py") >» interp .cmdloop () Interpreter dla __main__ ?» help Miscellaneous help topics: Dodatek A: Biblioteka Pythona md5 getservbyname gethostbyaddr htons socket ntohs gethostbyname fromfd getprotobyname gethostname htonl Undocumented commands: EOF help ?>> help socket socket(family, typet, proto]) -> socket object Open a socket of the given type. The family argume nt specifies the address family; it is normally AF_INE T, sometimes AF_Unix. The type argument specifies whe ther this is a stream (SOCK_STREAM) or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0, specifying the default protocol. ?» s = socket (AF_INET, SOCK__STREAM) ?» s .connect ("www.python .org", 80) sha Moduł md 5 implementuje interfejs algorytmu streszczania wiadomości M sowanego w RSA. Algorytm MD5 pobiera sekwencję znaków i gener streszczenie (rodzaj 128-bitowej sumy kontrolnej) w postaci hasza. Aby uzy wartość, należy za pomocą funkcji new () utworzyć obiekt md5, dost do niego dane za pomocą metody update (), a następnie wywołać E digest (), która zwraca wartość hasza. new([argr]) Zwraca nowy obiekt md 5. Jeśli jest podany arg, wywołuje również i update(arg). Instancja m obiektu md 5 ma następujące metody: JD . update (arg) Aktualizuje m na podstawie napisu arg. Kolejne wywołania są równe

pojedynczemu użyciu tej metody z konkatenacją wszystkich argumen m.digest() Zwraca streszczenie wszystkich danych przekazanych wcześniej do c za pomocą metody update (). Wartość powrotna jest 16-bajtowym na który może zawierać znaki niedrukowalne, łącznie z pustymi bajtami m. copy () Zwraca kopię obiektu md 5. PRZYKŁAD import md5 m = md5.new() m.update("Hello") m.update("World") d = m.digest() # Tworzy nowy obiekt MD5 # Pobranie streszczenia To samo można uzyskać za pomocą skrótu: d = md5.new("Hello World").digest() Zobacz także sha (313), Internet R Moduł sha implementuje bezpieczny algorytm haszujący (SHA). SHA j sekwencję znaków i generuje 160-bitową wartość haszowaną. Aby uzy wartość, trzeba za pomocą funkcji new () utworzyć obiekt sha i dostarc niego dane. new( [string]) Zwraca nowy obiekt sha. Jeśli jest podany argument s tring, wywołu nież metodę update (string). blocksize Rozmiar bloków dostarczanych do funkcji haszującej. Wynosi zawsze digestsize Rozmiar tworzonych streszczeń w bajtach. Wynosi zawsze 20. Zobacz także shlex (314).

314 Python Instancja s obiektu sha ma następujące metody: s. upda te (argr) Aktualizuje obiekt sha na podstawie napisu arg. Kolejne wywołania są rów- noważne pojedynczemu użyciu tej metody z konkatenacją wszystkich argu- mentów. s.digest() Zwraca streszczenie wszystkich danych przekazanych wcześniej do obiektu za pomocą metody update (). Wartość powrotna jest 20-bajtowym napisem, który może zawierać znaki niedrukowalne, łącznie z pustymi bajtami. s.copyO Zwraca kopię obiektu sha. s.hexdigest() Zwraca wartość streszczenia w postaci napisu złożonego z cyfr szesnastkowych. UWAGA • Algorytm SHA jest zdefiniowany przez NIST w dokumencie FIPS PUB 180-1: Secure Hash Standard, do- stępnym pod adresem http://csrc.nist.gov/fips/fipl80-l.ps. Zobacz także md5 (313). shlex Moduł shlex definiuje klasę shlex, umożliwiającą budowanie analizatorów leksykalnych prostych składni, takich jak shella. shlex ([stream]) Tworzy instancję klasy shlex. stream podaje strumień lub obiekt w stylu strumienia, z którego będą czytane znaki. Obiekt ten musi udostępniać metody read () ireadline(). Bez niego dane wejściowe są pobierane ze standardowego strumienia sys.stdin. Instancja s klasy shlex udostępnia następujące metody: s. get__token () Zwraca leksem (jako napis). Jeśli leksemy zostały wcześniej zapisane za po- mocą push_token (), metoda pobiera leksem ze stosu. W przeciwnym wypadku leksem jest czytany ze strumienia wejściowego. s.push_token(str) Dokłada leksem na stos. Ponadto można ustawiać następujące zmienne instancji: Zmienna s. commenters s. wordchars s.whitespace Opis Łańcuch znaków rozpoznawany jako początek komentarza. Komentarze ciągną się do końca linii. Standardowym znakiem jest Łańcuch znaków tworzących leksem wieloznakowy. Standardowo obejmuje wszystkie alfanumeryczne znaki ASCII oraz podkreślenie. Łańcuch białych znaków, które należy pomijać. Dodatek A: Biblioteka Pythona Zmienna Opis

s.quotes s.lineno s. token

Łańcuch znaków cytowania, stosowanych w napisach. Standardowo obejmuje apostrof i cudzysłów. Numer linii źródłowej. Bufor leksemów.

UWAGA • Każdy znak nie zadeklarowany jako znak tworzący wyraz, biały znak lub znak cytowania jest w formie jednoznakowego leksemu. Ponadto wyrazy muszą być oddzielone białymi znakami. Syrr cjalne, takie jak znaki cytowania i komentarzy, nie są uważane za wyrazy. W efekcie wyraz is

traktowany jako jeden leksem. Zobacz także c

Debuger Pythona Debuger Pythona jest ładowany w wyniku importu modułu pdb. Moduł wiera interaktywny debuger kodu źródłowego, który pozwala śledzić pi post-mortem, analizować ramki stosu, ustawiać punkty przerwań i wykc kod źródłowy krok po kroku. Aby uruchomić debuger, trzeba załadować moduł pdb i wywołać jedną i pujących funkcji: run(statement [, globals [, locals]]) Wykonuje polecenie zawarte w napisie statement pod kontrolą del Tuż przed wykonaniem kodu pojawi się znak zachęty debugera. Aby i: mić kod, należy wpisać 'continue1, globals i locals definiuj ą wiednio globalną i lokalną przestrzeń nazw dla wykonywanego kodu runeval(expression [, globals [, locals]]) Oblicza wartość wyrażenia z napisu expression pod kontrolą del Tuż przed wykonaniem kodu pojawi się znak zachęty debugera, jak \ padku run (). Jeśli nie ma błędów, funkcja zwraca wartość wyrażeni* runcall {function [, argument, ...]) Wywołuje funkcj ę pod kontrolą debugera. function musi być ob wywoływalnym. Tuż przed wykonaniem kodu pojawi się znak zachęt] gera. Na koniec zwracana jest wartość powrotna funkcji. set__trace () Uruchamia debuger w miejscu wywołania tej funkcji. Można to wyko do tworzenia na stałe zakodowanych punktów przerwań w konki miejscach programu. post_mortem(traceback) Uruchamia debugowanie post-mortem obiektu-śladu traceback. pm() Włącza debugowanie post-mortem z użyciem śladu w sys. last_trace

316 Python Dodatek A: Biblioteka Pythona Po uruchomieniu debugera na ekranie pojawia się następujący tekst: >» import pdb >» import modułzbł ędami >» pdb. run ('modułzbł ędami .start () ') > <string>(0)?() (Pdb) (Pdb) jest znakiem zachęty debugera, po którym można wydawać podane niżej polecenia. Uwaga: Pewne polecenia mają dwie formy - krótką i długą. W takim przypadku nawiasy okrągłe służą rozróżnieniu obu tych form. Na przykład h (elp) oznacza, że rozpoznawane jest zarówno polecenie h, jak i help. h(elp) [polecenie] Wyświetla listę dostępnych poleceń, polecenie pozwala uzyskać pomoc o tym konkretnym poleceniu. w(here) Podaje ślad stosu. d (own) Przenosi bieżącą ramkę o jeden poziom w dół śladu stosu. u(p) Przenosi bieżącą ramkę o jeden poziom w górę śladu stosu. b(reak) [lok [, warunek]] Ustawia punkt przerwania w miejscu lok. Lokalizacja ma jedną z nastę- pujących postaci: Ustawienie Opis n Numer linii w bieżącym pliku nazwapliku: n Numer linii w innym pliku funkcja Nazwa funkqi w bieżącym pliku nazwapliku: funkcja Nazwa funkqi w innym pliku Bez 1 ok wyświetlane są wszystkie bieżące punkty przerwania, warunek jest wy- rażeniem, które musi dawać wartość prawda, aby zadziałał punkt przerwania. tbreak [lok [, warunek]] Ustawia tymczasowy punkt przerwania, usuwany zaraz po pierwszym za- działaniu. cl(ear) [numerpp [numerpp ...]] Usuwa listę podanych punktów przerwania. Bez tej listy usuwane są wszystkie ustawione punkty przerwania. disable [numerpp [numerpp ...]] Blokuje listę podanych punktów przerwania. W odróżnieniu od clear pozwala uaktywnić później te punkty. enable [numerpp [numerpp . . .]] Uaktywnia z powrotem podane punkty przerwania. ignore numerpp [licz] Ignoruje podany punkt przerwania przez licz wykonań. condition numerpp [warunek] Ustawia warunek w punkcie przerwania, condi tion jest wyrażenierr musi dawać prawdę, aby wskazany punkt przerwania mógł zadziałać, nięcie warunku powoduje usunięcie jego poprzedniej wersji. s(tep) Wykonuje jedną linię kodu źródłowego. Zatrzymuje się w środku wywo funkqi. n(ext) Wznawia wykonanie aż do następnej linii bieżącej funkcji. Przeskaki zawarty w wywoływanych funkcjach. r(eturn)

Wznawia wykonanie aż do powrotu z bieżącej funkcji. c(ont(inue)) Kontynuuje wykonanie aż do napotkania następnego punktu przerwa l(ist) [pierwsza [, ostatnia]] Listuje kod źródłowy. Bez argumentów wyświetla 11 linii sąsiadi z bieżącą. Z jednym argumentem wyświetla 11 linii wokół podanej. Z c argumentami wyświetla linie z podanego zakresu. Jeśli ostatn. mniejszą wartość niż pierwsza, jest interpretowana jako licznik linii. a(rgs) Wyświetla listę argumentów bieżącej funkcji. p expression Oblicza i podaje wartość wyrażenia w bieżącym kontekście. alias [nazwa [polecenie]] Tworzy alias podanego polecenia W momencie wpisania aliasu pod ' %1', ' %2 ' i tak dalej są zastępowane przez kolejne argumenty, nat podnapis ' % * • jest zastępowany przez wszystkie argumenty. Bez po. wyświetlana jest aktualna definiqa podanego aliasu (nazwa), a bez pojawia się lista wszystkich aliasów. Aliasy można zagnieżdżać. Mogą wierać wszystko, co wolno wpisać po znaku zachęty Pdb. Na przykłai # Wyświetlanie zmiennych instancji (u życie "pi classlnst") alias pi for k in %1.__diet__.keys(): print "%1. ", k, " = ", %1.__did # Wyświetlanie zmiennych instancji w self alias ps pi self unalias nazwa Usuwa podany alias. [! ] instrukcja Wykonuje podaną instrukcję (jednoliniową) w kontekście bieżącej rarr su. Można pominąć wykrzyknik, o ile pierwszy wyraz instrukcji nie p

318 Python Dodatek A: Biblioteka Pythona mi« polecenia debugera. Aby ustawić zmienną globalną, na początku linii instrukqa przypisania należy umieścić instrukcję ' global': mina z (Pdb) global list_options; list_options (Pdb) '-I'] q(uit) Wyjście z debugera. UWAGI • Wprowadzenie pustej linii powtarza ostatnie polecenie. • Polecenia nie rozpoznane przez debuger, są uznawane za instrukcje Pythona i wykonywane w kontekście debugowanego programu. • Jeśli w katalogu domowym użytkownika lub w bieżącym istnieje plik . pdbr c, zostanie on wczytany i wyko- nany tak, jakby został wpisany po znaku zachęty debugera.

Profiler Pythona W tej części znajduje się opis profilera Pythona - narzędzia umożliwiającego ana- lizowanie wydajności programu. profile Moduł profile służy do zbierania informacji o profilu programu. run (command [, filename]) Wykonuje w profilerze zawartość commandiprzy użyciu instrukcji exec, fi - lename jest nazwą pliku, w którym są zapisywane surowe dane profilu. Bez tego argumentu raport jest kierowany na standardowy strumień wyjściowy i wygląda następująco: 126 function calls (6 primitive calls) in 5.130 CPU seconds filename:lineno(function) <string>:l(?) book.py:ll(process) book.py:5(?) exceptions .py: 101 (__init__) profile:0(execfile('book.py 1)) profile:0(profiler) mają następujące zna- Ordered by: standard name ncalls tottime percall cumtime percall 1 0.030 0.030 5.070 5.070 121/1 5.020 0.041 5.020 5.020 1 0.020 0.020 5.040 5.040 2 0.000 0.000 0.000 0.000 1 0.060 0.060 5.130 5.130

0 0.000 0.000 Poszczególne części raportu generowanego przez run czenie: Sekcja Opis primitive calls Liczba wywołań nierekurenyqnych funkcji ncalls Całkowita liczba wywołań (łącznie z rekurencyjnymi) tottime Czas spędzony w tej funkqi (nie licząc podfunkqi) percall tottime/ncalls cumtime Całkowity czas spędzony w funkqi percall cumtime/(primitive calls) filename:lineno(function) Lokalizacja i nazwa każdej funkcji. Jeśli w pierwszej kolumnie występują dwie liczby (na przykład "12 pierwsza z nich jest właściwą liczbą n c a 11 s, a druga liczbą primitive c UWAGI

• Analiza zapisanych danych profilu jest wykonywana przez moduł p s t a t s. • Uzyskanie dokładnych informacji może wymagać kalibracji profilu. Szczegóły znajdziesz pod http://www.python.org/doc/lib/profile.html. pstats Moduł pstats definiuje klasę Stats, służącą do analizowania danych : nych przez moduł profile. Stats (filename) Wczytuje dane profilu z filename - pliku utworzonego przez funkcji file.run() -i zwraca obiekt statystyczny, umożliwiający drukowa portów. Obiekt statystyczny s ma następujące metody: s.strip_dirs () Usuwa z nazw plików początkowe informaq'e o ścieżce. s.add(filename [, . . . ]) Dodaje nowe informaqe do profilu, filename jest nazwą pliku rającego dane zapisane wcześniej przez profile.run(). s.sort_stats(key [, ...]) Sortuje dane statystyczne według podanych kluczy. Każdy klucz moż jedną z następujących wartości: Nazwa klucza Opis 'calls' Liczba wywołań 1 cumulative' Łączny czas 'file' Nazwa pliku 'module' Nazwa pliku 'pcalls' Liczba wywołań podstawowych 'line' Numer linii 'name' Nazwa funkcji 'nfl' Nazwa / plik/ linia 'stdname' Nazwa standardowa 'time' Wewnętrzny czas Czasy i liczby wywołań są posortowane malejąco, a numery linii i nazwy ] - rosnąco. s.print_stats(restriction [, ...]) Kieruje raport o profilu na standardowy strumień wyjściowy. Kolejność macji jest taka sama jak w przypadku metody sort_stats (). Argu służą do wyeliminowania niektórych pozycji z raportu. Każde ograni

320 Python Dodatek A: Biblioteka Pythona (res trictioń) może być liczbą całkowitą wyznaczającą maksymalną liczbę linii, liczbą dziesiętną wyznaczającą w procentach liczbę linii lub wyrażeniem regularnym filtrującym drukowane nazwy. s.print_callers(restrictions [, ...]) Podaje listę wszystkich funkqi wywołujących poszczególne funkcje z bazy danych profilu. Argument res trictions ma to samo znaczenie, co w metodzie print_stats (). s.print_callees(restrictions [, .. . ]) Podaje listę wszystkich funkqi wywołujących poszczególne funkqe. Argument restrictions ma to samo znaczenie co w metodzie print_stats (). UWAGA • Użycie modułu pstats jako skryptu powoduje uruchomienie interaktywnej przeglądarki danych staty- stycznych profilu. Aby uzyskać listę dostępnych poleceń, wystarczy wówczas wpisać ' help'. Jest to nowa cecha wprowadzona w Pythonie 2.1.

Moduły nieudokumentowane Moduły wymienione w tej części nie są omawiane szczegółowo w tej książce, ale ich opisy można znaleźć w różnych miejscach, między innymi w dokumentacji online. Usługi Pythona Moduł Opis code Działania na kodzie codeop Kompilaqa kodu Pythona compileall Kompilaqa plików Pythona w całym poddrzewie katalogów dis Deasemblaqa kodu bajtowego fpectl Kontrola wyjątków zmiennoprzecinkowych imp Dostęp do implementacji instrukqi import inspect Uzyskiwanie informacji o czynnych obiektach keyword Sprawdzanie napisów pod kątem słów kluczowych Pythona linecache Pobieranie linii z plików parser Dostęp do drzewa składniowego kodu źródłowego Pythona pprint „Ładne" drukowanie obiektów pyclbr Pobieranie informaq'i dla przeglądarek klas py compile Kompilacja kodu źródłowego Pythona na kod bajtowy repr Alternatywna implementaqa funkqi repr () symbol Stałe używane do reprezentaq'i wewnętrznych węzłów drzewa

składniowego tabnanny Wykrywanie niejednoznacznych wcięć token Końcowe węzły drzewa składniowego tokenize Skaner kodu źródłowego Pythona user Analiza składniowa pliku konfiguracyjnego użytkownika

Przetwarzanie napisów Moduł I Opis difflib fpformat regex regsub Funkqe do obliczania odchyleń Formatowanie liczb zmiennoprzecinkowych Dopasowywanie wyrażeń regularnych (przestarzały) Podstawianie wyrażeń regularnych (przestarzały) Moduły systemu operacyjnego

Moduł Opis curses Interfejs biblioteki curses dl Dostęp do bibliotek dzielonych Uniksa dircache Pamięć podręczna katalogów mutex Blokady wykluczające się wzajemnie pty Obsługa pseudoterminali pipes Interfejs łączy shella posixfile Blokowanie plików nis Interfejs NIS dla Sun-a rlcompleter Funkcja dopełniająca dla readline GNU sched Szeregowanie zdarzeń statcache Wersja stat () z pamięcią podręczną syslog Interfejs uniksowego demona syslog

Sieć Moduł gopherlib telnetlib urllib2 Opis Protokół Gophera Protokół Telneta Rozszerzalna biblioteka do otwierania URL-i Obsługa danych internetowych Moduł Opis formatter Ogólne formatowanie wyjścia htmllib Analiza leksykalna dokumentów HTML mailbox Czytanie różnych formatów skrzynek pocztowych mhlib Dostęp do skrzynek pocztowych MH mimify Przetwarzanie MIME wiadomości pocztowych netrc Przetwarzanie plików Netrc sgmllib Analiza leksykalna prostych dokumentów SGML xml Pakiet do analizy leksykalnej XML xmllib Analiza leksykalna prostych dokumentów XML

322 Python Usługi multimedialne Moduł Opis audioop Proste działania na danych dźwiękowych imageop Proste działania na obrazach aifc Czytanie i zapisywanie plików AIFF i AIFC sunau Czytanie i zapisywanie plików Sun AU wave Czytanie i zapisywanie plików WAV chunk Czytanie porqowanych danych IFF colorsys Konwertowanie systemów kolorów rgbimg Czytanie i zapisywanie plików SGI RGB imghdr Ustalanie typu obrazu sndhdr Ustalanie typu pliku dźwiękowego

Dodatek B

Rozszerzanie i osadzanie

Pythona

SGI Irix Moduł Opis al Funkcje audio na SGI cd Dostęp do CD-ROM-u na SGI fl Biblioteka FORMS flp Ładowanie projektów formularzy fm Interfejs menedżera czcionek gl Interfejs biblioteki graficznej imgfile Obsługa plików imglib na SGI jpeg Czytanie i zapisywanie plików JPEG Dodatek B zawiera omówienie interfejsu programistycznego (API) języka C ui nego do budowania modułów rozszerzeń oraz osadzania interpretera Pythona nych aplikacjach. Nie będzie to podręcznik do nauki, dlatego zainteresowanyd telników odsyłamy do dokumentu „Embedding and Extending the Python Inte ter" dostępnego pod adresem http://www.python.org/doc/txt, a tak dokumentu „Python/C API Reference Manual" dostępnego pod adi http://www.python.org/doc/api. Opisywane dalej funkcje są aktualn wersji Pythona 2.1 i powinny być również kompatybilne z przyszłymi wydai Pythona 2.x.

Udost ępnianie dodatkowych modułów

Usługi specyficzne dla Sun-a Moduł Opis sunaudiodev Dostęp do sprzętu audio Sun-a Różne Moduł Opis ConfigParser Analiza leksykalna plików konfiguracyjnych calendar Funkqa do generowania kalendarza doctest Testowanie oparte na napisach dokumentujących unittest Szkielet do testowania jednostek kodu

whrandom Generowanie liczb losowych winsound Generowanie dźwięków w Windows xreadlines Wydajne iterowanie lini: pliku Z powodu różnic systemowych i zależności między pakietami poszczególnycł ducentów kilka modułów z biblioteki standardowej jest niedostępnych. Aby żliwi ć korzystanie z nich, trzeba dokonać zmian w pliku konfiguracyjnym i na i zbudować interpreter (dotyczy to przede wszystkim systemów uniksowych). W wersjach Pythona wcześniejszych niż 2.1 plik Modules/Setup ze źródł go pakietu dystrybucyjnego zawiera dane konfiguracyjne modułów wbud nych w interpreter. Poszczególne pozycje tego pliku mają następującą post signal signalmodule.c # signal (2) łreadline readline.c -lreadline -ltermcap Każda linia zawiera nazwę modułu, po niej pliki źródłowe, opcje kompiL oraz niezbędne biblioteki dołączane podczas kompilacji modułu. Linia z< nająca się od znaku # jest komentarzem i zawiera moduł wyłączony z uż Długie linie można rozbijać na kilka wierszy. W tym celu na końcu każdego tynuowanego wiersza należy umieścić odwrotny ukośnik (\). Aby włączy< datkowy moduł, trzeba zmienić plik Setup i podać w nim lokalizację pot nych bibliotek innych producentów. Na przykład, aby włączyć moduł reac ne, można zmodyfikować plik Setup w następujący sposób: readline readline.c -I/usr/local/include -L/usr/loc al/lib \ -lreadline -ltermcap

324 Python Aby zmiany w pliku Setup stały się widoczne, trzeba w katalogu głównym poddrzewa kodu źródłowego Pythona wpisać polecenia make i make install,któ- re spowodują ponowne zbudowanie i zainstalowanie interpretera. Począwszy od Pythona 2.1 większość powodów edyqi pliku Setup stała się nieak- tualna, gdyż zmodyfikowany proces instalacji obejmuje teraz kompilację jedynie podstawowego zestawu modułów. Większość pozostałych modułów jest skonfi- gurowanych jako moduły dynamiczne i automatycznie dokonuje się sprawdzenia, czy nie można ich zbudować w czasie instalacji. Na przykład, jeśli w trakcie budowania pliku wykonywalnego Pythona 2.1 okaże się, że są zainstalowane wszystkie biblioteki niezbędne dla modułu readline, zostanie on udostępniony automatycznie. Aby ręcznie wpłynąć na proces budowania interpretera, trzeba zmodyfi- kować plik setup. py w głównym katalogu źródłowej wersji Pythona. Przykład modułu rozszerzenia Moduły rozszerzeń służą do wzbogacania interpretera o funkqe napisane w ję- zyku C. Wyobraźmy sobie na przykład, że chcemy w module Pythona o nazwie dod użyć następujących funkqi napisanych w języku C: /* Obliczanie najwi ększego wspólnego dzielnika dodatnich liczb całkowitych x

i y V

int nwd(int 2 in

t y)

{

int g; g = y; while (x > 0) { g = x

; X = y %

X ;

y = g;

return g; /* Drukowanie pewnych danych */ void print_dane(char *nazwisko, char *email, char * tel) { printf("Nazwisko : %s\n", nazwisko); printf("Email : %s\n printf("Tel : %s\n email); tel); Aby dostać się do tych funkcji z poziomu modułu rozszerzenia, trzeba napisać kod podobny do tego z listingu B.l: Listing B.1 Dost ęp do funkcji z poziomu modułu rozszerzenia /* moduł "dod" */ /* Doł ączenie API C Pythona */ ♦include "Python.h" /* Deklaracje obiektów zewn ętrznych */ extern int nwd(int,int); extern void print_dane(char *, char *, char *); /* Obudowa funkcji nwd() */ PyObject *dod_nwd(PyObject *self, PyObject *args) { int x, y, g; /* Pobranie argumentów Pythona */ Dodatek B: Rozszerzanie i osadzanie Pythona if (!PyArg_ParseTuple(args,"ii",&x,&y)) { return NULL; } /* Wywołanie funkcji C */ g = nwd(x,y); return Py BuildValue("i",g); /* Obudowa funkcji print_dane() */ PyObject * dod_print_dane(PyObject *self, PyOtject *args, PyOb ject *kwargs) char *nazwisko = "None"; char *email = "None"; char *tel = "None";

static char *nazwyarg[] • {"nazwisko","email","tel", NULL}; /* Pobranie argumentów Pythona */ if (!PyArg_ParseTupleAndKeywords(args,kwargs,"Isss" ,nazwyarg, snazwisko,&email,&tel)) { return NULL; /* Wywołanie funkcji C */ print_data(nazwisko,email,tel); return Py_BuildValue("") ; /* Zwraca None */ /* Tablica metod mapuj ąca nazwy na obudowy */ static PyMethodDef metodydodf] = { {"nwd", dod_nwd, METH_VARARGS}, {"print_dane", dod_print_dane, METH_VARARGS | METH_ KEYWORDS }, {NULL, NULL} /* Funkcja inicjalizuj ąca moduł */ initdod(void) { Py_InitModule("dod", metodydoc); Moduły rozszerzeń muszą zawsze włączać plik "Python. h". Każda udo niana funkqa C musi zostać obudowana. Funkcje obudowujące muszą mieć argumenty (self i args, oba typu PyObject *) lub trzy (self, < i kwargs, wszystkie typu PyObject *). self używa się wtedy, gdy fu: obudowująca implementuje wbudowaną metodę, stosowaną w odniesieni instanqi jakiegoś obiektu. W takim przypadku instancja ta jest umieszc w parametrze self. W przeciwnym razie wartością self jest NULL, arg; tupią zawierającą argumenty funkqi przekazane przez interpreter, a kwć słownikiem z argumentami hasłowymi. Argumenty są konwertowane z Pythona na C za pomocą funkcji PyAr g_Paj Tupie () lub PyArg_ParseTupleAndKeywords (). Z kolei do konstruow odpowiednich wartości powrotnych używa się funkcji Py_BuildValu Funkcje te zostaną opisane w następnych podrozdziałach. Funkqe sygnalizują błąd zwracając wartość NULL. Jeśli funkcja nie ma wartość wrotnej (czyli jest typu vo i d), jej obudowa musi zwracać obiekt No n e. Na przy! PyObject *wrap_f00(PyObject *self, \ PyObject *args) { /* Zwraca None */ return Py_BuildValue("");

326 Python Dodatek B: Rozszerzanie i osadzanie Pythona Obiekt None można również zwrócić w następujący sposób: PyObject *wrap_foo(PyObject *self, PyObject *args) { /* Zwraca None */ Py_INCREF(Py_None); return Py_None; } Tablica metodydod z listingu B.l służy do kojarzenia nazw Pythona z funkcjami obudowującymi w C. Są to nazwy używane do wywoływania funkcji z poziomu interpretera. Flaga METH_VARARGS oznacza konwencję wywoływania obudowy. W tym przypadku mają być akceptowane wyłącznie argumenty pozycyjne w postaci tupli. Flaga może być również ustawiona na METH_VARARGS | METH_KEYWORDS, co oznacza, że funkcja obudowująca akceptuje argumenty hasłowe. Funkcja initdod służy do inicjalizacji zawartości modułu. W tym przypadku wywołuje ona funkcję Py_InitMoudle ("dod", metody dod), która tworzy moduł dod i wstawia do niego obiekty funkcji wbudowanych odpowiadających funkcjom wymienionym w tabeli metod.

Kompilowanie rozszerze ń Skompilowane moduły rozszerzeń mają zwykle postać bibliotek dzielonych lub plików DLL, które mogą być dynamicznie ładowane przez interpreter. Przebieg tego procesu na niskim poziomie zależy od typu komputera. Można próbować go uprościć za pomocą modułu distutilsz biblioteki Pythona. Aby utworzyć moduł rozszerzenia przy użyciu distutils, trzeba wykonać następujące działania: 1. Utworzyć plik o nazwie setup. py zaczynający się od kodu: # setup.py from distutils.core import setup, Extension 2. Dodać pewne informacje o rozszerzeniu: setup (name="dod", version="l.0", ext modules=[Extension("dod", ^"dod.c", "obudowadod.c"])] 3. Zbudować rozszerzenie za pomocą polecenia: python setup.py build Doprowadzi to do utworzenia biblioteki dzielonej, takiej jak dodmodule. so (lub innego wariantu tej nazwy, na przykład dodmodule.sl czy dodmodule.dll) w specjalnym katalogu „budowy". Aby zainstalować moduł, można wpisać polecenie python setup.py install, które skopiuje bibliotekę dzieloną do katalogu site-packages (na przykład /usr/local/lib/python2.1/site-packages). Jeśli potrzebne są dodatkowe informade do budowy rozszerzenia - o dołącza- nych katalogach, bibliotekach i makrach preprocesora - można je podać w pliku setup. py w następujący sposób: setup (name="dod ext_modules= Extension( "dod", ["dod.c version="l.0", obudowadod.c"] , include_dirs = ["/usr/include/Xll","/opt/include' define_macros = [('DEBUG',1), ('WYMAGA_CPLUSPLUS',0)], undef_macros = ['MA_XYZ', 'NIE_MA'], library_dirs= ["/usr/lib/Xll", "/opt/lib"], libraries = ["Xli", "Xt", "blah"] Warto zaznaczyć, że moduł distutils może służyć również do tworzeni kietów Pythona nadających się do dystrybucji i instalowania przez innych kowników. Pozwala na przykład dystrybuować pakiety w postaci komb: skryptów i skompilowanych rozszerzeń. Umie również tworzyć pliki RP\ i samorozpakowujące się pliki ZIP dla Windows. Bardziej szczegółowe infc cje o module distutils są podane na stronie http: //www.python .< doc/current/dist/dist.hmtl.

W pewnych sytuacjach trzeba ręcznie zbudować moduł rozszerzenia. Ni zawsze wymaga to zaawansowanej wiedzy o różnych opcjach kompilatora: gramu łączącego. Oto przykład pochodzący z Linuksa: linux % gcc -c -fpic -I/usr/local/include/python2.1 dod.c obudowadod. linux % gcc -shared dod.o obudowadod.o -o dodmodule .so Budując moduł należy pilnować, aby biblioteka dzielona pasowała do n< modułu używanej w kodzie obudowy. Na przykład, jeśli moduł ma nazwę funkcja iniq'alizujaca musi nazywać się initdod, a biblioteka dzielona - dmodule . so (z dokładnością do rozszerzenia, które zależy od komputera] Po skompilowaniu moduł rozszerzenia może być używany jak każdy inn) duł za pomocą instrukcji import: % python Python 2.0 (#1, Oct 27 2000, 14:34:45) [GCC 2.95.2 19991024 (release)] on sunos5 Type "copyright", "credits" or "license" for more i nformation. >» import dod >» dod.nwd(63,56) 7 >» dod.nwd(71,89) 1 »> dod.print_dane(nazwisko="Dave", tel="555-1212") Nazwisko : Dave Email : None Tel : 555-1212 >» Szukając modułu rozszerzenia, Python używa tej samej ścieżki, co w przyp plików . py. W efekcie, interpreter potrafi odnaleźć tylko te moduły, któ umieszczone w bieżącym katalogu roboczym lub w jednym z katalogów za nych na zmiennej sys . path.

328 Python Dodatek B: Rozszerzanie i osadzanie Pythona

Konwertowanie danych z Pythona na C Omawiane w tej części funkcje służą do konwertowania argumentów przekazywanych z Pythona do C: int PyArg_ParseTuple(PyObject *args, char *format, ...); Konwertuje tupię obiektów w args na serię zmiennych C. forma t jest napisem formatującym zawierającym zero lub więcej specyfikatorów z tabeli B.l, podających oczekiwaną zawartość args. Wszystkie pozostałe argumenty za- wierają adresy zmiennych C, w których należy umieścić wyniki konwersji. Kolejność tych argumentów i ich typy muszą odpowiadać specyfikatorom podanym w format. Ponadto należy używać typów danych wymienionych w tabeli B.l. W przypadku nieudanej konwersji argumentów funkqa zwraca 0. int PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kwdlct, char *format, char **kwllst, ...); Konwertuje zarówno tupię argumentów, jak i słownik zawierający argumenty hasłowe podane w kwdict. forma t ma to samo znaczenie co w PyArg_Par- seTupie (). Jedyna różnica polega na tym, że kwlist jest zakończoną pustym elementem listą napisów zawierających nazwy wszystkich argumentów. W przypadku powodzenia zwraca 1, a w przeciwnym razie 0. Uwaga: W tabeli B.l wyniki konwersji są reprezentowane zawsze przez parametr o etykiecie r (na przykład char *r czy char **r). Tam, gdzie ma to sens, w parametrze len podana jest długość argumentu. Tabela B.1 Format Typ Pythona TypC "s" Napis lub Unicode chcr **r

"s#" Napis lub Unicode char **r, int *len "z" Napis, Unicode lub None char **r "z#" Napis, Unicode lub None char **r, int *len "u" Unicode Py_UNICODE **r "u#" Unicode Py_UNICODE **r, int * len "es" Napis, Unicode lub bufor const char *enc, char **r "es#" Napis, Unicode lub bufor const char *enc, char **r, int *len "b" Liczba całkowita char *r 11 h" Liczba całkowita short *r "i" Liczba całkowita int *r "1" Liczba całkowita long int *r "c" Napis o długości 1 char *r "f" Liczba zmiennoprzecinkowa float *r "d" Liczba zmiennoprzecinkowa double *r "D" Liczba zespolona Py complex *r "0" Cokolwiek PyObject **r "0!" Cokolwiek PyTypeObject *type, PyObject **r Format Typ Pythona TypC »0&" Cokolwiek int (*converter) (PyObject *, voi< void *r u s u Napis PyObject **r "U" Unicode PyObject **r "t#" Bufor tylko do odczytu char **r, int *len "w" Bufor do odczytu/zapisu char **r "w#" Bufor do odczytu/zapisu char **r, int * len Jeśli konwertowana wartość całkowita Pythona jest za duża, aby dało się prezentować w żądanym typie danych C, następuje zgłoszenie wyjątku C f lowEr r or. Wszędzie tam, gdzie jest dozwolone użycie liczby całkowite

żna również użyć długiej liczby całkowitej, o ile oczywiście nie przekrac2 możliwości docelowego typu C. Podczas konwertowania napisów ze specyfikatorami " s ", " s # ", " z " i " z # żna używać zarówno napisów standardowych, jak i Unicode. Specyfikato pozwala również przekazywać wartość None (zwracany jest wówczas wsk NULL). W obu przypadkach nie trzeba alokować miejsca na napis, gdyż zv ny jest wskaźnik do surowych danych napisowych zapisanych w interpn Pythona. Gdy jest to napis Unicode, najpierw konwertuje się go na 8-bitov pis, używając domyślnej metody kodowania. Specyfikatory "u" i "u#" w gają napisu Unicode i zwracają wskaźnik do surowych danych Unicode, \ rych każdy znak jest typu PyUNICODE (aktualnie to samo co typ wchar_t zyku C). Specyfikatory " s# ", " z # " i "u# " zwracają oprócz danych napisc także ich długość. Specyfikatory "es " i "es# " służą do czytania napisów standardowych or; pisów Unicode zakodowanych zgodnie z konkretną regułą. Na przykład: char *bufor; PyArg_ParseTuple(args, "es", "utf-8",&bufor) W tym przypadku funkcja PyArg_ParseTuple () odczytuje najpierw r kodowania, a następnie zwraca wskaźnik do bufora, w którym znajduje się dowana wersja napisu. Bufor ten należy do dynamicznie alokowanej pa i musi zostać jawnie zwolniony za pomocą PyMem_Free (), gdy wywo] kod przestanie już używać jego zakodowanej zawartości. Specyfikator " dopuszcza podanie długości bufora. W takim przypadku użytkownik przekazać adres i długość prealokowanego bufora, w którym zostaną umies ne zakodowane dane tekstowe. W momencie powrotu parametr 1 en jest z< ustawiany na faktyczną długość danych. Specyfikatory "t#", "w", "w#" są podobne do specyfikatorów konwersji sów, ale powodują zwrot wskaźnika do bajtowo zorientowanych danych z« nych w obiekcie Pythona implementującym interfejs bufora. Takim interf dysponują napisy i obiekty Unicode, a także niektóre typy z biblioteki stand wej, takie jak tablice tworzone przez moduł array oraz obiekty nunap two przez moduł mmap.

330 Python Dodatek B: Rozszerzanie i osadzanie Pythona . Specyfikatory "O", "S", "U" zwracają surowe obiekty Pythona typu PyObject *, przy czym specyfikatory "S" i "U" wymagają, aby był to odpowiednio obiekt typu napis standardowy lub Unicode. Konwersja "0! " wymaga dwóch argumentów C: wskaźnika do odpowiedniego obiektu typu Pythona oraz wskaźnika do PyObject *, w którym zostanie umieszczony wskaźnik do przekonwertowanego obiektu. Jeśli obiekt-typ nie pasuje do typu konwertowanego obiektu, następuje zgłoszenie wyjątku TypeEr- ror. Oto przykład: /* Konwersja argumentu listowego */ PyObject *listobjl; PyArg_ParseTuple(args, "0! ", &PyList_Type, &listob jl); Specyfikator "O&" pobiera dwa argumenty (converter, addr) i konwertuje PyObj ect * na typ danych C za pomocą funkcji podanej przez użytkownika. converter jest wskaźnikiem do tej funkcji. Jej prototyp ma postać int converter (PyObject *obj, void * a ddr), gdzie ob j jest przekazanym obiektem Pythona, a a ddr adresem przekazanym przez drugi argument. Po uda- nej konwersji funkqa converter () powinna zwracać 1, a w przeciwnym razie 0. Ponadto musi zgłaszać wyjątki w przypadku błędów. Oto przykład: struct Point { int x; int y; int konwersja_punktu(PyObject *obj, void *addr) { Point *p = (Point *) addr; return PyArg_ParseTuple(obj, "ii", &p->x, &p->y); PyObject *wrapper(PyObject *self, PyObject *args) { Point p; /* Pobranie punktu */ if (!PyArg_ParseTuple(args, "O&", kowersja_punktu, &p) return NULL; W tabeli B.2 wymienione są modyfikatory formatu, których można używać rów- nież w napisach formatujących. Tabela B.2 Modyfikatory napisów formatuj ących Napis formatujący Opis

"(elementy)" Tupla obiektów ■i i u Początek argumentów nieobowiązkowych u . u Koniec argumentów (pozostały tekst jest nazwą funkcji) II . u Koniec argumentów (pozostały tekst jest komunikatem błędu) Znak " | " oznacza, że wszystkie pozostałe argumenty są nieobowiązkowe. Może występować tylko raz w specyfikatorze formatu i nie wolno go zagnieżdżać. " : " oznacza z kolei koniec argumentów. Cały występujący po nim tek traktowany jako nazwa funkcji podawana w komunikatach o błędach. "; " również oznacza koniec argumentów, ale następujący po nim teki używany jako komunikat o błędzie. Uwaga: Należy używać tylko jedne znaków " : " i "; ". Kilka przykładów zastosowania specyfika torów foi pokazanych jest w listingu B.2. Listing B.2 Specyfikatory formatu int ival, ival2, len; double dval; char *sval; PyObject *ol, *o2; /* Konwersja liczby całkowitej, podwójnej precyzji i napisu */ PyArg_ParseTuple(args, "ids", &ival, &dval, &sval); /* Konwersja napisu i długo ści */ PyArg_ParseTuple(args, "s#", &sval, &len); /* Konwersja argumentów nieobowi ązkowych */ PyArg_ParseTuple(args, "id|s", &ival, &dval, &sval) ; /* Konwersja z komunikatem o bł ędzie */ PyArg_ParseTuple(args, "ii; nwd wymaga 2 liczb całk owitych", &ival, &iv,

/* Konwersja dwóch tupli */ PyArg ParseTuple(args, "(ii)(ds)", &ival, &ival2, & dval, &sval);

Konwertowanie danych z C na Pythona Do konwertowania wartości zawartych w zmiennych języka C na obiekty P na służy funkcja: PyObject *Py_BuildValue(char * format, ...) Tworzy ona obiekty Pythona na podstawie szeregu zmiennych języka C. fo jest napisem, który określa sposób konwersji. Pozostałe argumenty są warte mi konwertowanych zmiennych. Specyfikator forma t (zobacz tabelę B.3) jest podobny specyfikatora używa w przypadku funkcji PyArg_Parse*. Tabela B.3

Specyfikatory formatu dla

Py_BuildValue()

Format Typ Pythona Type Opis

"s" "s#"

Napis Napis

char * char *, int

Napis zakończony znakiem pustym. Jeśli wskaźnik napi ma wartość NULL, funkqa zwraca None. Napis i długość. Może zawi puste bajty. Jeśli wskaźnik napisu C ma wartość NULL, funkqa zwraca None. Dokończenie tabeli na następnej

332 Python Dodatek B: Rozszerzanie i osadzanie Pythona Dokończenie tabeli z poprzednie] strony Format Typ Pythona TypC Opis "z" Napis char * To samo co " s ". lub None "z#" Napis char *, int To samo co "s#". lub None "u" Unicode Py_UNICODE * Napis Unicode zakończony znakiem pustym. Jeśli wskaźnik napisu C ma wartość NULL, funkcja zwraca None. "u#" Unicode Py UNICODE *, int Napis Unicode i długość. "b" Całkowity char 8-bitowa liczba całkowita. "h" Całkowity short Krótka 16-bitowa liczba

całkowita. "i" Całkowity int Liczba całkowita.

r-l Całkowity long Długa liczba całkowita. "c" Napis char Pojedynczy znak. Tworzy napis Pythona o długości 1. 11 f" Zmienno- float Liczba zmiennoprzecinkowa przecinkowy pojedynczej precyzji. 11 d" Zmienno- double Liczba zmiennoprzecinkowa przecinkowy podwójnej precyzji. "0" Dowolny PyObject * Dowolny obiekt Pythona. Sam obiekt nie ulega zmianie, tylko zwiększany jest o 1 jego licznik odwołań. Dostarczenie wskaźnika NULL powoduje również zwrot wskaźnika

NULL. "0&" Dowolny converter, dowolny Konwersja danych C przez podaną funkqe. "S" Napis PyObject * To samo co "0". "U" Unicode PyObject * To samo co "0". "N" Dowolny PyObject * To samo co "0", ale bez zwiększania licznika odwołań. "(elementy) " Tupla vars Tworzy tupię elementów. elementy to łańcuch specyfikatorów formatu z tej tabeli, a vars - lista zmiennych C odpowiadających poszczególnym elementom. "[elementy]" Lista vars Tworzy listę elementów. elementy to łańcuch specyfikatorów formatu z tej tabeli, a vars - lista zmiennych C odpowiadających poszczególnym elementom. 11 {elementy}" Słownik vars Tworzy słownik elementów. PRZYKŁADY:

Py_BuildValue(' ") None Py_BuildValue(' i",37) 37 Py_BuildValue(' ids", 37,3.4,"witaj") (37, 3.5, "witaj") Py_BuildValue(' s#", "witaj",4) "wita" Py_BuildValue(' 0") 0 Py_BuildValue(' (i)",37) (37,) Py BuildValueC [ii]",1,2) [1,2] Py_BuildValue("[i,i]",1,2) Py BuildValue("{s:i,s:i}","x", 1, "y",2)

[1,2]

Obsługa bł ędów Wystąpienie błędu jest sygnalizowane przez zwrócenie wartości NULL do pretera. Zanim to jednak nastąpi, należy ustawić lub wyczyścić wyjątek i mocą jednej z następujących funkqi: void PyErr_Clear() Czyści wszystkie zgłoszone wcześniej wyjątki. PyObject *PyErr_0ccurred() Sprawdza, czy został wygenerowany błąd. Jeśli tak, zwraca obiekt z bież wyjątkiem. W przeciwnym razie zwraca NULL. void PyErr_NoMemory () Zgłasza wyjątek MemoryError. void PyErr_SetFromErrno(PyObject *exc) Zgłasza wyjątek, exc to obiekt-wyjątek. Wartość wyjątku pobierana j( zmiennej errno z biblioteki C. void PyErr_SetFromErrnoWithFilename(PyObject *exc, chai * filename) Podobna do PyErr_SetFromErrno (), ale podaje dodatkowo nazwę pl void PyErr_SetObject(PyObject *exc, PyObject *val) Zgłasza wyjątek. Argument exc jest obiektem-wyjątkiem, aval- obie zawierającym wartość wyjątku. void PyErr_SetString(PyObject *exc, char *msg) Zgłasza wyjątek. Argument exc jest obiektem-wyjątkiem, a msg- komu tem opisującym, co się stało. Używany w tych funkcjach argument exc może mieć jedną z następujących waii Nazwa C Wyjątek Pythona PyExc_ArithmeticError ArithmeticError

PyExc AssertionError AssertionError PyExc_AttributeError AttributeError PyExc_EnvironmentError EnvironmentError PyExc_EOFError EOFError PyExc Exception Exception

1

334 Python Dodatek B: Rozszerzanie i osadzanie Pythona Nazwa C Wyjątek Pythona PyExc_FloatingPointError FloatingpointError PyExc_ImportError ImportError PyExc IndexError IndexError PyExc IOError IOError PyExc KeyError KeyError PyExc_KeyboardInterrupt Keyboardlnterrupt PyExc LookupError LookupError PyExc MemoryError MemoryError PyExc NameError NameError PyExc NotlmplementedError NotlmplementedError PyExc_OSError OSError PyExc OverflowError OverflowError PyExc RuntimeError RuntimeError PyExc StandardError StandardError PyExc SyntaxError SyntaxError PyExc SystemError SystemError PyExc SystemExit SystemExit PyExc TypeError TypeError PyExc UnicodeError UnicodeError PyExc ValueError ValueError PyExc ZeroDivisionError ZeroDivisionError

Oto przykład ilustrujący typowy sposób ustawiania wyjątku i zwracania błędu w module rozszerzenia: PyErr_SetString(PyExc_ValueError, "Oczekiwana warto ść dodatnia!"); return NULL; Moduł rozszerzenia może również definiować nowy typ wyjątku. Służy do tego funkcja: PyObject *PyErr_NewException(char *excname, PyObject *base, PyObject *dict) Funkcja ta tworzy nowy wyjątek. Argument excname jest nazwą wyjątku postaci "nazwamodułu. nazwawyjątku", base jest nieobowiązkową klasą ba- zową wyjątku, a diet nieobowiązkowym słownikiem używanym jako atrybut __diet__wynikowej klasy wyjątku. Oba te argumenty są ustawione zwykle na NULL. Wartością powrotną funkcji jest obiekt-klasa. Kolejny przykład ilustruje metodę tworzenia nowego wyjątku w module rozszerzenia: static PyObject *DodError; /* Funkcja inicjalizuj ąca moduł */ initdod(void) { PyObject *m, *d; m = Py_InitModule("dod",MetodySpam); d = PyModule_GetDict(m); DodError = PyErr_NewException("dod.error", NULL, NU LL) PyDict_SetItemString(d, "error",DodError);

Zliczanie odwoła ń W odróżnieniu od programów napisanych w Pythonie rozszerzenia twe w języku C muszą same kontrolować liczniki odwołań obiektów Pythona. do tego następujące makra: Makro Py_INCREF(obj) Py_DECREF(obj) Py_XINCREF(obj) Py_XDECREF(obj)

Opis Zwiększa licznik odwołań obiektu obj (nie może być NULI Zmniejsza licznik odwołań obiektu obj (nie może być NUL Zwiększa licznik odwołań obiektu obj (może być NULL). Zmniejsza licznik odwołań obiektu obj (może być NULL). Operowanie licznikami obiektów Pythona w C jest dość skomplikowane i d przed zastosowaniem tego w praktyce stanowczo polecam przeczytanie mentu „Rozszerzanie i osadzanie interpretera Pythona", dostępnego pod ad http: //www.python. org/doc/ext. Wszystkie obiekty Pythona są dos w C za pośrednictwem wskaźników typu PyObj ect *. Wskaźniki te możi dzielić na dwie kategorie: odwołania własne i odwołanie pożyczone. Odu własne to wskaźnik do obiektu Pythona, którego licznik odwołań uwzględni że jakiś fragment kodu C lub jakaś struktura danych C ma do niego wskaźnl tomiast odwołanie pożyczone to po prostu goły wskaźnik do obiektu Pythona, go istnienie nie jest odzwierciedlone w liczniku odwołań tego obiektu. Odwołania własne powstają najczęściej w wyniku działania funkqi, które ti nowe obiekty Pythona - takich jak Py_BuildValue (), PyInt_FromLong i PyList_New (). Po wywołaniu zwracają one nowy obiekt i mówi się, że ji własnością funkcji wołającej. Odwołania pożyczone pojawiają się często wted] funkqa uzyskuje skądś wskaźnik do obiektu Pythona lub gdy dochodzi do p nia zawartości takiego obiektu Pythona, jak lista czy słownik. Odwołaniami czonymi są na przykład parametry selfiargs funkqi obudowującej, jak ró1

wskaźnik zwracany przez funkqe taką jak PyList_GetItem (). Właściciel odwołania musi albo zrezygnować z jego posiadania za pomocą r Py_DECREF (), albo przekazać je korr uś innemu. Na przykład obiekty tymc we utworzone wewnątrz funkqi obudowującej powinny być niszczone za po Py_DECREF(), podczas gdy wartość zwrotna takiej funkcji jest odwoła własnym przekazywanym z powrotem do interpretera. Z kolei użytkownik o łania pożyczonego może wejść w jego posiadanie za pomocą makra Py_INCRI Trzeba jednak zachować szczególną ostrożność, jeśli chodzi o kolejność dz Na przykład zmniejszenie licznika odwołań odwołania pożyczonego może z; czyć się na dalszym etapie wykonania awarią interpretera spowodowaną błi

336 Python Dodatek B: Roz szerzanie i osadzanie Pytona segmentacji. Natomiast nieudane zwolnienie odwołania własnego lub nieumyślne zwiększenie licznika odwołań obiektu prowadzi do straty pamięci. Przedstawienie ogólnego schematu zliczania odwołań w Pythonie jest nieco skomplikowane, gdyż nie są one traktowane w sposób jednorodny. Mimo to istnieje parę podstawowych reguł: • Funkcje tworzące nowe obiekty Pythona zawsze zwracają odwołania własne. • Jeśli chcesz zapisać odwołanie do obiektu Pythona, zwiększ jego licznik odwołania za pomocą makra Py_lNCREF (). • Aby pozbyć się odwołania własnego, użyj makra Py_DECREF (). • Wiele funkcji (ale nie wszystkie), które zwracają wskaźniki do obiektów zawartych w sekwencjach oraz obiektach mapujących, zwraca odwołania własne. • Wiele funkcji (ale nie wszystkie), które zapisują obiekty w kontenerach takich, jak sekwencje czy struktury mapujące, zwiększa liczniki odwołań zawartych w nich obiektów. • Wszystkie funkqe obudowujące w C muszą zwracać odwołanie własne. Wyjątki od tych reguł będą podane w dalszej części tego dodatku.

Wywoływanie Pythona z poziomu C Czasami wygodnie jest użyć funkcji Pythona w programie napisanym w języku C. W tym celu należy wywołać następującą funkqe: PyObject *PyEval_CallObject(PyObject *func, PyObject *args) Wywołuje func z argumentami args. func jest obiektem wy woły walnym Pythona (funkcją, metodą, klasą i tak dalej), a args - tupią argumentów. PyObject *PyEval__CallObjectWithKeywords(PyObject *func, PyObject *axgs, PyObject *kwargs) Wywołuje func z argumentami pozycyjnymi args. i argumentami hasłowymi kwargsfunc jest obiektem wywoływalnym Pythona (funkqa, metodą, klasą i tak dalej), a args tupią argumentów. Oto przykład ilustrujący użycie jednej z tych funkcji: /* Wywoływanie funkcji Pythona */ PyObject *func; /* Obiekt wywoływalny. */ PyObject *args; PyObject *result; int argl, arg2; func = get_python_function() /* Zobacz ni żej */ args = Py_BuildValue("(ii)", argl, arg2); /* Buduj e list ę argumentów */ result = PyEval_CallObject(func, args) ; /* Wyw ołuje func */ Ostatni problem polega na tym, że w czasie kompilaqi kod C nie może znać adresu obiektu Pythona, który nie został jeszcze utworzony, gdyż Python działa dynamicznie. Aby temu zaradzić, można pozwolić Pythonowi utworzyć obiekt-funkcję, a następnie zarejestrować jej adres za pomocą funkqi wywoływanej zwrotnie. Oto przykład kodu rozszerzenia, którego można użyć do ustawienia takiej funkcji: static PyObject *func = 0; /* Funkcja wywoływana zw rotnie */ static PyObject * set_callback(PyObject *self, PyObject *args) { PyObject *f; if (PyArg_ParseTuple(args, "O", &f)) { if (!PyCallable_Check(f)) { PyErr_SetString (PyExc_TypeError, "oczekiwany obiekt wywoływ return NULL; } Py_XINCREF (f) ; /* Zapisanie odwołania do funkcji wywoływanej zwrc Py_XDECREF(func); /* Zwolnienie wcześniejszej funkcji */ func = f; Py_INCREF(Py_None) ; return Py_None;

ł return NULL; }

Funkqa ta zostanie wywołana w Pythonie w sposób następujący: # Pewna funkcja def foo(x,y): return x+y set_callback(foo) Innym rozwiązaniem może być uzyskanie obiektu wywoływalnego Pyth< pomocą funkqi API osadzania, opisanych w dalszej części tego dodatku.

Warstwa obiektów abstrakcyjnych Funkcje wymienione w tabelach od B.4 do B.8 służą do wykonywania dziai obiektach Pythona w podobny sposób, jak to ma miejsce w interpreterze. W kie funkqe z tej części zwracające wartość int w przypadku błędu zwraca Z kolei funkqe zwracające PyOb j ect * w przypadku niepowodzenia z w NULL. Zwróć uwagę, że w tym kontekście „błąd" nie oznacza tego samego, > gatywny wynik sprawdzenia. Na przykład funkcja PyNumber_Check Ob j ect * obj) zwraca 0, jeśli obj nie jest liczbą, ale to nie jest to samo, co I wreszcie, jeśli nie jest powiedziane inaczej, wszystkie funkcje z tej części, zwracają PyObject *, zwracają odwołanie własne do obiektu. Ewent zmniejszenie licznika odwołań do uzyskanego w ten sposób obiektu nalei wyłącznie od funkqi wywołującej. Tabela B.4 Obiekty Typ int PyObject * PyObject * PyObject * Funkcja PyCallable_Check(PyObject *o) PyObject_CallFunction(PyObject *callable_object, < * format, . . .) PyObject_CallMethod(PyObject *o, char * methodname, char * format, . . .) PyObject_CallObject (PyObject * callable_object, PyObject *args) Dokończenie tabeli na następnej

338 Python Dodatek B: Rozszerzanie i osadzanie Pythona Dokończenie tabeli z poprzedniej strony

Typ Funkcja Tabela B.5 Liczby void PyObject

_ int PyObject

_ int PyObject

_ int PyObject

_ int PyObject int PyObject PyObject * PyObject PyObject * PyObject PyObject * PyObject int PyObject int PyObject int PyObject int PyObject int PyObject int PyObject PyObject * PyObject PyObject * PyObject

_ int PyObject

int op) int PyObject

PyObject int PyObject

PyObject int PyOb j

ect_ PyObject * PyObject PyObject * PyObject ClearWeakRefs(PyObject *obj) _Cmp(PyObject *ol, PyObject *o2, int *result) Compare(PyObject *ol, PyObject *o2) _DelAttr(PyObject *o, PyObject *attr_name) DelAttrString(PyObject *o, char *attr_name) _DelItem(PyObject *o, PyObject *key) _GetAttr(PyObject *o, PyObject *attr_name) _GetAttrString(PyObject *o, char *attr_name) _GetItem(PyObject *o, PyObject *key) _HasAttr(PyObject *o, PyObject *attr_name) _HasAttrString(PyObject *o, char *attr_na/ne) _Hash(PyObject * o) _IsTrue(PyObject *o) _Length(PyObject *o) _Print(PyObject *o, FILE *fp, int flags) _Repr(PyObject *o) _RichCompare(PyObject *ol, PyObject *o2, int op) _RichCompareBool(PyObject *ol, PyObject *o2, _SetAttr(PyObject *o, PyObject *attr_name, *v) _SetAttrString(PyObject *o, char *attr_na/ne, *v) Setltem(PyObject *o, PyObject *A:ey, PyObject *v) _Str(PyObject * o) Type(PyObj ect * o) Argument flags funkcji PyOb j ect_Print () służy do wybierania opcji wyjś- cia. Aktualnie dostępna jest jedynie opcja Py_PRINT_RAW, która zmusza funkqe do generowania danych wyjściowych przy użyciu PyObject_Str () zamiast PyOb j ect_Repr () (ustawienie domyślne).

PyOb j ect_Hash () i PyObj ect_Length () zwracają w przypadku powodzenia dodatnią wartość całkowitą, a w przypadku błędu -1. Argument opfunkqi PyObject_RichCompare() i PyObject_RichCompa- reBool () może mieć jedną z następujących wartości: Py_EQ, Py_NE, Py_LT, Py_GT, Py_GE lub Py_LE. PyObject PyObject PyObject int PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject PyObject Funkcja *o2) PyObject **p2) PyObject *o2) PyObject *o2) PyObject *o2) >o2) PyNumber_Absolute(PyObject *o) PyNumber_Add(PyObject *ol, PyObject PyNumber_And(PyObject *ol, PyObject PyNumber_Check(PyObject *o) PyNumber_Coerce(PyObj ect * *pl , PyNumber_Divide(PyObject *ol, PyNumber_Divmod(PyObject *ol, PyNumber_Float(PyObject *o) PyNumber_Int(PyObject *o) PyNumber_Invert(PyObject *o) PyNumber_Long(PyObj ect * o) PyNumber_Lshift(PyObject *ol, PyNumber_Multiply(PyObject *ol, PyObject PyNumber_Negative(PyObject *o) PyNumber_Or(PyObject *ol, PyObject *o2) PyNumber_Positive(PyObject *o) PyNumber_Power(PyObject *ol, PyObject *o2, PyObject PyNumber_Remainder(PyObject *ol, PyObject *o2) PyNumber_Rshift(PyObject *ol, PyObject *o2)

PyNumber_Subtract(PyObject *ol, PyObject *o2) PyNumber_Xor(PyObject *ol, PyObject *o2) PyNumber_InPlaceAdd(PyObject *ol, PyObject *o2) PyNumber__InPlaceSubtract (PyObject *ol, PyObject PyNumber_InPlaceMultiply(PyObject *ol r PyObject PyNumber_InPlaceDivide(PyObject *ol, PyObject *o PyNumber_InPlaceRemainder(PyObject *ol, PyObject PyNumber_InPlacePower(PyObject *ol, PyObject *o2 PyNumber_InPlaceLshift(PyObject *ol, PyObject *o PyNumber_InPlaceRshift(PyObject *ol, PyObject *o PyNumber_InPlaceAnd(PyObject *ol, PyObject *o2) PyNumber_InPlaceXor(PyObject *ol, PyObject *o2) PyNumber_InPlaceOr(PyObject *ol, PyObject *o2) Tabela B.6 Sekwencje Typ int PyObject int Funkcja PySequence_Check(PyObject *o) PySequence_Concat(PyObject *ol, PyObject *o2) PySequence_Contains(PyObject *o, PyObject *value] Dokończenie tabeli na nastepnt

340 Python Dokończenie tabeli z poprzedniej strony

Typ \Funkcja int int int PyObject * PyObject * int int PyObject * PyObject * int int PyObject * PyObject * PyObject * PyObject * PyObject * PySequence_Count(PyObject *o, PyObject *value) PySequence_DelItem(PyObject *o, int i) PySequence_DelSlice(PyObject *o, int ii, int i2) PySequence_GetItem(PyObject *o, int i) PySequence_GetSlice(PyObject *o, int ii, int i2) PySequence_In(PyObject *o, PyObject *value) PySequence_Index(PyObject *o, PyObject *value) PySequence_List(PyObject *o) PySequence_Repeat(PyObject *o, int count) PySequence_SetItem(PyObject *o, int i, PyObject *v) PySequence_SetSlice(PyObject *o, int ii, int i2, PyObject *v) PySequence_Tuple(PyObject *o) PySequence_InPlaceConcat(PyObject *ol, PyObject *o2) PySequence_InPlaceRepeat(PyObject *ol, int count) PySequence_Fast(PyObject *o, const char *errmsg) PySequence_Fast_GET_ITEM(PyObject *o, int i) Funkqa PySequence_Fast () zwraca niezmieniony obiekt o, jeśli jest on tupią lub listą, i zwiększa jego licznik odwołań. W przeciwnym razie o musi być se- kwencją. Jeśli nie jest, następuje zgłoszenie wyjątku TypeError z errmsg jako komunikatem błędu. Funkcja PySequence_Fast_GET_lTEM() powinna być używana tylko z obiektami zwróconymi przez PySequence_Fast (). Tabela B.7 Mapowania Typ int int int int PyObject int int PyObject PyObject int int PyObject Funkcja PyMapping_Check(PyObj ect * o) PyMapping_Clear(PyObj ect * o) PyMapping_DelItem(PyObject *o, PyObject *key)

PyMapping_DelItemString(PyObject *o, char *key) PyMapping_GetItemString(PyObject *o, char *key) PyMapping_HasKey(PyObject *o, PyObject *key) PyMapping_HasKeyString(PyObject *o, char *key) PyMapping_Items(PyObject *o) PyMapping_Keys(PyObject *o) PyMapping_Length(PyObject *o) PyMapping_SetItemString(PyObject *o, char *key, PyObject *v) PyMapping_Values(PyObject *o) Dodatek B: Rozszerzanie i osadzanie Pythona Tabela B.8 Interfejs bufora

Typ Funkcja int int int

PyObj ect_AsCharBuffer(PyObj ect *, PyObject AsReadBuffer(PyObject *, PyObject_AsWriteBuffer(PyObject *,

const const void

char **buffer, void **buffer, * *buffer, int

int int *len)

Interfejs bufora używany jest przez obiekty, które chcą udost^ wywołującym je funkcjom surowe bajty przeznaczone do zapisu danych b nieczności tworzenia ich kopii. Zazwyczaj dotyczy to tylko napisów, na] Unicode i tablic tworzonych przez moduł array. Rozmiar i sposób interpi tych danych zależy od konkretnego typu obiektu.

Funkcje niskiego poziomu dla typów wbudowanych Funkcje wymienione w tabelach od B.9 do B.21 służą do wykonywania d; na różnych typach wbudowanych. Funkcje postaci Py< fcyp>_Check () są wane do sprawdzania typu obiektu i jeśli jest on prawidłowy, zwrac. a w przeciwnym wypadku 0. Funkqe postaci Py< typ>_From< typ> są ui ne do tworzenia obiektów Pythona na podstawie typów danych C. Funkq staci Py<typ>_As<typ> są używane do konwersji typów Pythona na ty Wszystkie te funkqe są podane bez żadnych dodatkowych objaśnień. Tabela B.9 Liczby całkowite Typ Funkcja

long PyInt_AsLong(PyObject *iobj) int Pylnt Check(PyObject *obj) PyObject * Pylnt FromLong(long) long PyInt_GetMax(void) Tabela B.10 Długie liczby całkowite Typ double PyLon

g long PyLon

g long long PyLon

g unsigned long PyLon

g unsigned long long PyLon

g void * PyLon

g int PyLon

g PyObject * PyLon

g PyObject * PyLon

g PyObject * PyLon

g Funkcja _AsDouble(PyObject *lobj) _AsLong(PyObject * lobj) _AsLongLong(PyObject * lobj) _AsUnsignedLong(PyObject * lobj) _AsUnsignedLongLong(PyObject * lobj) AsVoidPtr(PyObject *lobj) _Check(PyObject *obj) FromDouble(double) FromLong(long) FromLongLong(long long) Dokończenie tabeli na następnej s

342 Python Dokończenie tabeli z Typ

poprzedniej strony Funkcja

PyObject PyObject PyObject

PyLong FromUnsignedLong(unsigned long) PyLong FromUnsignedLongLong(unsigned long long) PyLong FromVoidPtr(void *)

Tabela B.11

Liczby zmiennoprzecinkowe

Typ Funkcja int double PyObject

* PyFloat Check(PyObject *obj) PyFloat_AsDouble(PyObject *fobj) PyFloat_FromDouble(double)

Tabela B.12

Liczby zespolone

Typ Funkcja Py_complex int PyObject * PyObject * double double PyComplex_AsCComplex(PyObject *cobj) PyComplex_Check(PyOb^ect *obj) PyComplex_FromCComplex(Py_complex *cobj) PyComplex_FromDoubles(double real, double imag) PyComplex_ImagAsDouble(PyObject *cobj) PyComplex_RealAsDouble(PyObject *cobj) Tabela B.13

Napisy

Typ Funkcja char * PyString_AsString(PyObject *str) PyObject PyString AsEncodedString(PyObject *unicode, const

char ^encoding, const char *errors) int PyString Check(PyObject *obj) void PyString_Concat(PyObject **str, PyObject *newpart) void PyString ConcatAndDel(PyObject **str, PyObject

*newpart) PyObject PyString Decode(const char *s, int size, const char

* encoding, const char * errors) PyObject * PyString Encode(cons i Py UNICODE *s, int size,

const char *encoding, const char *errors)

PyObject * PyString_Format(PyObject * format, PyObject *args) PyObject PyString_FromString(char *str) PyObject * PyString FromStringAndSize(char *str, int len) int PyString_Resize(PyObject **str, int newsize) int PyString Size(PyObject *str)

Dodatek B: Rozszerzanie i osadzanie Pytona Uwaga: Funkq'e Encode i Decode wymagają takich samych parametrów wania i błędu jak wbudowana funkcja unicode (). Tabela B.14 Napisy Unicode Typ

Funkcja int PyObject * PyJJNICODE int PyObject * PyObject * PyObject * int ■ PyUnicode_ PyUnicode_ PyUnicode_ PyUnicode_ PyUnicode_ * encoding, PyUnicode_ PyUnicode_ PyUnicode_. maxlen) Check(PyObject *o) FromUnicode(PyJJNICODE *, AsUnicode(PyObj ect * o) GetSize(PyObject *o) FromEncodedObject(PyObject const char *errors) FromObject(PyObject *o) FromWideChar(const wchar t int size) 'obj, const int size) AsWideChar(PyObject *o, wchar t *buf, i: Tabela B.15 Listy Typ Funkcja int PyList_Append(PyObject *list, PyObject *obj) PyObject * PyList AsTuple(PyObject *list) int PyList Check(PyObject *obj) PyObject * PyList_GetItem(PyObject *list, int index) PyObject * PyList_GetSlice(PyObject *list, int i, int j) int PyList_Insert(PyObject *list, int

index, PyObject *o

PyObject * PyList_New(int size) int PyList Reverse(PyObject *list) int PyList_SetItem(PyObject *list, int

index, PyObject *o

int PyList_SetSlice(PyObject *list, int i, int j, PyObject *slc) int PyList_Size(PyObject *list) int PyList_Sort(PyObject *list) Uwaga: PyList_GetItem () zwraca odwołanie pożyczone. Tabela B.16 Tupie Typ Funkcja int PyTuple Check(PyObject *obj) PyObject * PyTuple_GetItem(PyObject *tup, int index) PyObject * PyTuple GetSlice(PyObject

*tup. int i, int j)

PyObject * PyTuple New(int size) int PyTuple_SetItem(PyObject ''tup, int index,

PyObject * OJ int PyTuple_Size(PyObject * tup)

344 Python Dodatek B: Roz szerzanie i osadzanie Pythona Uwaga: PyTuple_SetItem() zwiększa licznik odwołań obj nawet wtedy, gdy się nie powiedzie. PyTuple_GetItem () zwraca odwołanie pożyczone. Tabela B.17 Słowniki Typ Typ Funkcja int PyDict_Check(PyObject *obj) void PyDict Clear(PyObject *dict) int PyDict_DelItem(PyObject

*dict, PyObject * key)

int PyDict_DelItemString(PyObject *dict, char

*key)

PyObject * PyDict_GetItem(PyObject *dict,

PyObject * key)

PyObject * PyDict_GetItemString(PyObject *dict, char

*key)

PyObject * PyDict_Items(PyObject *dict) PyObject * PyDict Keys(PyObject *dict) PyObject * PyDict New(void) int PyDict Setltem(PyObject

*dict, PyObject * key,

PyObject *value) int PyDict SetltemString(PyObject *dict,

char *key,

PyObject * value) int PyDict_Size(PyObject *dict) PyObject * PyDict_Values(PyObject *dict) Uwaga: PyDict_GetItem () i PyDict_GetItemString łania pożyczone. Tabela B.18 Obiekty buforujące zwracają odwo- Typ int PyObject * PyObject * PyObject * PyObject * PyObject * Funkcja PyBuffer_check(PyObject *o) PyBuffer_FromObject(PyObject *base, int offset, int size) PyBuffer_FromReadWriteObject(PyObject *base, int offset, int size) PyBuffer_FromMemory(void *ptr, int size) PyBuffer_FromReadWriteMemory(void *ptr, int size) PyBuffer_New(int size) Tabela B.19 Pliki Typ Funkcja

FILE * PyFile_AsFile(PyObject *file)

int PyFile_Check(PyObject *obj) PyObject * PyFile_FromFile(FILE *, char

*, char *, int (*)(FILE *))

PyObject * PyFile_FromString(char *name,

char *mode)

PyObject * PyFile GetLine(PyObject *file

, int)

PyObject * PyFile_Name(PyObject *file)

void PyFile SetBufSize(PyObject *file, int size) int int int Funkcja PyFile_SoftSpace(PyObject *file, int) PyFile_WriteObject(PyObject *file, PyObject *obj, PyFile_WriteString(char *str, PyObject *file) Tabela B.20

Moduły

Typ Funkcja int PyModule Check(PyObject *obj) PyObject * PyModule GetDict(PyObject *mod) char * PyModule GetFilename(PyObject *mod) char * PyModule GetName (PyObject '''mod) PyObject PyModule New(char *name)

Tabela B.21

CObject

Typ Funkcja int PyCObject Check(PyObject *o) PyObject * PyCObject FromVoidPtr(void *cobj, void (*destr)

(voic PyObject * PyCObject FromVoidPtrAndDesc(void *cobj, void

*d void (*destr) (void *, void *)) void * PyCObject AsVoidPtr(PyObject *self) void * PyCObject_GetDesc(PyObject *self)

Uwaga: Interfejs CObject służy zazwyczaj do tworzenia obudowy wokół d nych wskaźników C. Obiekty te są najczęściej używane przez narzędzia do I wy rozszerzeń, takie jak SWIG.

Definiowanie nowych typów W modułach rozszerzeń można również definiować nowe typy obiektów. F ten wymaga jednak czegoś znacznie więcej niż użycia paru funkcji w C. Z p du tej złożoności implementowanie nowych typów należy brać pod uwagę w następujących sytuacjach: • Potrzebny typ nie daje się łatwo zbudować za pomocą istniejących typói thona. • Potrzebny typ ma współpracować z systemem operacyjnym lub jakimś qalnym narzędziem, nieudostępnianym przez interpreter ani jego biblii standardową. • Potrzebny typ nie został jeszcze nigdzie zaimplementowany. Na przykła ma sensu wymyślać wydajnych typów macierzowych, skoro zostały już 2 plementowane. Przed podjęciem decyzji dobrze jest zawsze sprawdzić b teki i grupy dyskusyjne Pythona. Doskonałym źródłem informacji o zair

346 Python Dodatek B: Rozszerzanie i osadzanie Pythona mentowanych do tej pory modułach rozszerzeń jest Vaults of Parnassas Py- thon Resources (http: //www.vex.net/parnassus). Proces tworzenia nowego typu Pythona obejmuje następujące działania: 1. Zdefiniowanie struktury przeznaczonej na zapisywanie faktycznych danych nowego typu - na przykład typ Lista wymaga tablicy na poszczególne elementy listy. 2. Zdefiniowanie funkcji pełniących rolę metod nowego typu - na przykład metody append () obiektu List. 3. Zdefiniowanie pary funkcji do tworzenia i usuwania instancji typu. 4. Zdefiniowanie zbioru funkcji implementujących metody speqalne nowego typu, takich jak__add__() i__getitem__(), opisanych w rozdziale 3 „Typy i obiekty". 5. Wypełnienie struktury danych zawierającej wskaźniki do operacji numerycznych nowego typu. 6. Wypełnienie struktury danych zawierającej wskaźniki do operacji sekwencyjnych nowego typu. 7. Wypełnienie struktury danych zawierającej wskaźniki do operatorów ma- pujących nowego typu. 8. Zdefiniowanie struktury danych zawierającej wszystkie właściwości obiektu i skojarzone z nim metody. 9. Zarejestrowanie w interpreterze metod i wszystkich dodatkowych funkcji za pomocą funkcji inicjalizującej moduł. Listing B.3 ilustruje proces tworzenia nowego typu Pythona na przykładzie implementacji obiektu BuforDzielony. Bufor dzielony jest specjalną strukturą danych, która zawiera dane używane przez kilka interpreterów Pythona działających jako oddzielne procesy. Każda zmiana dokonana przez jeden interpreter jest automatycznie widoczna za pośrednictwem bufora dzielonego w po- zostałych interpreterach. Taka implementacja dzielonego bufora wykorzystuje narzędzie systemu operacyjnego zwane plikiem odwzorowanym w pamięci, w kt- órym zawartość „pliku" jest mapowana na przestrzeń adresową procesu i może być używana jako zwykła pamięć. Pliki odwzorowane w pamięci są dostępne za- równo w Uniksie, jak i w Windows, chociaż listing B.3 przedstawia jedynie implementaq'e uniksową. Jest to jednak tylko ilustraqa procesu tworzenia nowego typu - aby naprawdę użyć plików odwzorowanych w pamięci, wygodniejsze może być skorzystanie z modułu mmap występującego w bibliotece standardowej. Listing B.3 Typ bufor dzielony _______________________________________________________ * buford.c * * Bufor dzielony - obiekt implementowany przy u życiu mmap(). ♦include "Python.h" ♦include <unistd.h> ♦include <fcntl.h> ♦include <sys/mman.h> ♦include <sys/stat.h> informacje o obiekcie bufordobiekt typedef struct { PyObject_HEAD char *buffer; int size; int fd; int prot; int offset; } bufordobiekt; Bufor pami ęci */ Rozmiar struktury */ Deskryptor pliku */ Bity ochrony */ Przesuni ęcie w pliku */ /* Obiekt wyj ątku u żywany przez ten moduł */

static PyObject *AccessError; /* Deklaracja wyprzedzaj ąca deskryptora typu. staticforward jest makrem zdefiniowanym w Python.h, które pozwala w przeno śny sposób tworzy ć odwołania "forward" do funkcji statycznych */ staticforward PyTypeObject BuforDType; Metody instancji buford.lock() - Blokuje bufor dzielony buford.unlock() - Odblokowuje bufor dzielony buford.get() - Pobiera dane w postaci napisu zako ńczonegc buford.store() - Zapisuje dane w postaci napisu zako ńczonego static PyObject * buford_lock(bufordobiekt *self, PyObject *args) { if (!PyArg_ParseTuple(args,"")) return NULL; lockf(self->fd,F_LOCK,0); return Py BuildValue(""); static PyObject * buford__unlock (bufordobiekt *self, PyObject *args) if (!PyArg_ParseTuple(args,"")) return NULL; lockf(self->fd,F_ULOCK,0); return Py_BuildValue(""); static PyObject * buford_get(bufordobiekt *self, PyObject *args) { int i; if (!PyArg_ParseTuple(args, "")) return NULL; if (self->prot & PROT_READ) { for (i =0; i < self->size; i++) { if (!self->buffer[i]) break; } return PyString_FromStringAndSize(self->buffer, i) } else { return PyString_FromString("");

348 Python Dodatek B: Rozszerzanie i osadzanie Pythona static PyObject * buford_store(bufordobiekt *self, PyObiect *args) { char *str; int len; if (!PyArg_ParseTuple(args, "s", &str)) return NULL ; if (self->prot & PROT_WRITE) { len = strlen(str)+1; if (len > self->size) len = self->size; memcpy(self->buffer,str,len) ; } else { PyErr_SetString(AccessError, "BuforD jest tylko do odczytu' return NULL; return Py BuildValue(""); /* Tablica metod instancji. U żywana przez buford_getattr() static struct PyMethodDef buford_metody[] = { {"lock", {"unlock" {"get", {"store", { NULL, buford_lock, METH_VARARGS}, buford_unlock, METH_VARARGS}, buford_get, buford_store, NULL } METH_VARARGS}, METH_VARARGS}, Działania podstawowe /* Utworzenie nowego obiektu bufora dzielonego */ static bufordobiekt * new_buford(int fd, int size, int offset, int prot) { bufordobiekt *self; void *buffer; buffer = mmap(0,size,prot,MAP_SHARED,fd,offset) ; if (buffer <= 0) { PyErr_SetFromErrno(PyExc_OSError); return NULL; } self = PyObject_NEW(bufordobiekt, SBuforDTyp); if (self == NULL) return NULL; self->buffer = (char *) buffer; self->size = size; self->offset = offset; self->prot = prot; self->fd = fd; return self; /* Zwolnienie bufora dzielonego */ static void buford_dealloc(bufordobiekt *self) { munmap(self->buffer, self->size); close(self->fd); PyMem DEL(self); /* Pobranie atrybutu */ static PyObject * buford getattr(bufordobiekt *self, char *name) { if (strcmp(name, "prot") == 0) { return Py_BuildValue("i", self->prot); } else if (strcmp(name, "fd") == 0) { return Py_BuildValue("i", self->fd); } /* self.prot */ /* self.fd */ /* Szukanie metody */ return Py_FindMethod(bufordjnetody, (PyObject *)sel f, name); /* Funkcja repr() */ static PyObject * buford_repr(bufordobiekt *self) { char rbuffer[256]; sprintf(rbuffer, "<BuforDzielony, fd = %d, length = %d, prot = %d at self->fd, self->size, self->prot, self); return PyString_FromString(rbuffer); Operacje sekwencyjne

/* len() */ static int buford_length(bufordobiekt *self) { return self->size; /* getitem - Pobranie jednego znaku */ static PyObject * buford_getitem(bufordobiekt *self, int index) { if (index < 0 || index >= self->size) { PyErr_SetString(PyExc_IndexError, "indeks spoza zak resu"); return NULL; } if (!(self->prot & PROT_READ)) { PyErr_SetString(AccessError, "BuforDzielony jest ni edost ępny"); return NULL; return Py_BuildValue("c",self->buffer[index]); /* setitem - Zapisanie jednego znaku */ static int buford_setitem(bufordobiekt *self, int index, PyObj ect *obj) char *str; int strsize; if (!PyString_Check(obj)) { PyErr_SetString(PyExc_TypeError, "Spodziewany napis ."); return 1; } if (PyString_Size(obj) != 1) { PyErr_SetString(PyExc_ValueError, "Spodziewany napi s jednoznakow^ return 1; } if (index < 0 I| index >= self->size) { PyErr_SetString(PyExc_IndexError, "indeks spoza zak resu"); return 1; } if (! (self->prot & PROT_WRITE)) {

350 Python Dodatek B: Rozszerzanie i osadzanie Pythona PyErr_SetString(AccessError, return 1; "BuforDzielony tylko do odczytu"); self->buffer[index] return 0; (PyString_AsString(obj) /* getslice - Pobranie wycinka bufora */ static PyObject * buford_getslice(bufordobiekt *self, int start, int end) { if (start < 0) start = 0; if (end > self->size) end = self->size; if (end < start) end = start; if (!(self->prot & PROT_READ)) { PyErr_SetString(AccessError, "BuforDzielony niedost ępny"); return NULL; } return PyString_FromStringAndSize(self->buffer+star t, (end-start)); /* Metody standardowe*/

(destructor) buford dealloc, /* tp_dealloc : refcount = 0

(printfunc) 0, /* tp_print : print x (getattrfunc) buford

getattr, /* tp_getattr : x.attr

(setattrfunc) 0, /* tp_setattr : x.attr = v (cmpfunc) 0, /* tp_compare : x > y (reprfunc) buford repr, /* tp repr : repr(x) /* Kategorie typu */ 0, /

* tp_as number Metody liczbowe

Sbuford as sequence, /*

tp_as sequence Metody sekwencyjn

0, /*

tp_as mapping Metody mapuj ące

(hashfunc) 0, /*

tp_hash diet[x]

(ternaryfunc) 0, /*

tp_call x()

(reprfunc) };

0, /*

tp_str str(x)

* Funkcje poziomu modułu /* setslice - Ustawienie wycinka w buforze */ static int buford_setslice(bufordobiekt *self, int start, int end, PyObject *obj) int size; if (start < 0) start = 0; if (end > self->size) end = self->sLze; if (end < start) end = start; if (!PyString_Check(obj)) { PyErr_SetString(PyExc_TypeError, "Spodziewany napis ."); return 1; if (! (self->prot & PROT_WRITE)) { PyErr_SetString(AccessError, "BuforDzielony tylko d o odczytu"); return 1; size = PyString_Size(obj); if (size < (end-start)) end = start+size; memcpy(self->buffer+start,PyString_AsString(obj),(e nd-start)); return 0; itic PySequenceMethods buford as sequence

= { [inquiry) buford length, /* sq length len(x) */ [binaryfunc) 0, /* sq concat x + y */ (intargfunc) 0, /* sq repeat x * n */ [intargfunc) buford_getitem, /* sq item x[i] */ [ intintargfunc) buford getslice, /* sq_slice x[i:j] */ [intobjargproc) buford setitem, /* sq_as item x[i] = v

*/ lintintobjargproc)

buford setslice, /* sq as slice x[i:j] = V */

/* Obiekt typu dla buforów dzielonych */ static PyTypeObject BuforDTyp = { PyObject_HEAD_INIT(&PyType_Type) /' 0, /' "BuforDzielony", / i sizeof(bufordobiekt), / i 0, /' Konieczna inicjalizacja */ ob_size : Zazwyczaj 0 */ tp_name : Nazwa typu */ tp_basicsize : Rozmiar obiektu */ tp_itemsize : Zazwyczaj 0 */ /* Tworzenie nowego obiektu bufora dzielonego jako SharedBuffer(filename,size,offset,prot) */ static PyObject * bufordobiekt_new(PyObject *self, PyObject *args) { char *filename; int size; int fd, flags; int prot = PROT_READ | PROT_WRITE; int offset = 0; struct stat finfo; if (!PyArg_ParseTuple(args, "si|ii", &filename, &si ze, &offset, &pr return NULL; if (stat (filename,&finfo) < 0) { PyErr_SetFromErrno(PyExc_OSError) ; return NULL; if (size + offset > finfo.st_size) { PyErr_SetString(PyExc_IndexError, " Żądany rozmiar i przesuni ęcie s ą za du że."); return NULL; if ((fd = open(filename,O_RDWR, 0666)) < 0) { PyErr_SetFromErrno(PyExc_OSError); return NULL; return (PyObject *) new_buford(fd,size,offset,prot) ; /* Tabela metod modułu */ static struct PyMethodDef bufordtyp_metody[] = { { "BuforDzielony", bufordobiekt_new, METH_VARARGS } , { NULL, NULL } /* Funkcja inicjalizuj ąca moduł */ void initbuford() { PyObject *m, *d; m = Py_InitModule("buford", bufordtyp metody);

352 Python Dodatek B: Rozszerzanie i osadzanie Pythona d = PyModule_GetDict(m); /* Dodanie kilku u żytecznych stałych dla parametru prot */ PyDict_SetItemString(d, "PROT_READ'\ PyInt_FromLong (PROT_READ)); PyDict_SetItemString(d, "PROT_WRITE", PyInt_FromLon g(PROT_WRITE)); /* Definicja wyj ątku */ AccessError = PyErr_NewException("buford.AccessErro r", NULL, NULL); PyDict_SetItemString(d, "AccessError", AccessError) ; } I na koniec jeszcze jeden listing, B.4, zawierający przykład użycia typu Buf or- Dzielony. W tym przypadku bufor dzielony jest używany do wymiany danych między procesem rodzicem i jego procesem potomnym utworzonym za pomocą wywołania os . f ork (). W tym przykładzie (zainspirowanym przez problem zgłoszony na liście adresowej Pythona), następuje przetłumaczenie adresu hosta na jego numer IP z ograniczonym czasem oczekiwania. Listing B.4 Program napisany w Pythonie wykorzystuj ący typ BuforDzielony # Szukanie nazwy hosta przez ograniczony czas. # (z podzi ękowaniami dla Andy'ego D.) import sbuffer, socket, os, sys, signal # Utworzenie mapowanego regionu pami ęci buffer - open("address", "w") buffer.write(" "*2048) buffer.close() # Otwarcie pliku jako bufora dzielonego buffer = sbuffer.SharedBuffer("address", 2048) # Zwrócenie nazwy hosta lub "", je śli nie da si ę rozwi ązać IP # w ci ągu 1 sekundy. def gethostbyname(hostname): # Wyczyszczenie bufora adresu # Utworzenie podprocesu # Uruchomienie zegara buffer.store("") pid = os.fork() if pid == 0: # Proces potomny signal.alarm(1) try: name = socket.gethostbyname(hostname) except: sys.exit() buffer.store(name) # Zapisanie nazwy w buforze sys.exit() # Zrobione else: os.wait() # Czekanie na zako ńczenie return buf fer. get () # Pobra'nie adresu # Wypróbowanie ip = gethostbyname("www.python.org")

Metody specjalne typów W tej części opisane są struktury danych języka C używane do implementowania typów Pythona. Jest to temat zaawansowany i jego prezentacja ogranicza się tylko do krótkiego wykazu. Typy są definiowane przez struktur ę o podanych niżej polach. Wiele z ni nazwy typów takie jak hashf unc, binaryf unc czy intargf unc, będą* nikiem deklaracji typedef. Dokładny opis tych typów zawiera tabela B.2 typedef struct _typeobject { PyObj ect_VAR_HEAD char int int destructor printfunc getattrfunc setattrfunc cmpfunc reprfunc PyNumberMethods PySequenceMethods PyMappingMethods

hashfunc ternaryfunc reprfunc getattrofunc setattrofunc PyBufferProcs long traverseproc inquiry richcmpfunc long PyTypeObject; *tp_name; tp_basicsize; tp_itemsize; tp_dealloc; tp_print; tp_getattr; tp_setattr; tp_compare; tp_repr; *tp_as_number; *tp_as_sequence; *tp_as_mapping; tp_hash; tp_call; tp_str; tp_getattro; tp_setattro; *tp_as_buffer; tp_flags; tp_traverse; tp_clear; tp_richcompare; tp_weaklistoffset; Większość metod specjalnych typów kryje się w czterech strukturach danyd SequenceMethods, PyMappingMethods, PyNumberMethods i PyBui Procs. Zawartość tych struktur podana jest w tabelach od B.22 do B.26. Tabela B.22 Struktura PySequenceMethods Typ danych C Nazwa Metoda Pythona

(inquiry) sq_length __len__(x) (binaryfunc) sq concat __add__ (x,y) (intargfunc) sq_repeat __mul__ (x, n) (intargfunc) sq item __getitem _(x,n) (intintargfunc) sq_slice __getslice__(x,

i, j (intobjargproc) sq ass item setitem (x, n,

v) (intintobjargproc)

sq ass slice setslice (x,i, j

(objobjproc) sq_contains contains (x, o) (binaryfunc) sq inplace concat __iadd__ (x, y) (intargfunc) sq_inplace_repeat imul (x, n)

354 Python Tabela B.23 Struktura PyMappingMethods Typ danych C Nazwa Metoda Pythona (inquiry) (binaryfunc) (objobjargproc)

mp length mp_subscript mp_ass_subscript

__len__(x) getitem (x, key) __setitem__(x, key, value)

Tabela B.24 Struktura PyNumberMethods Typ danych C Nazwa Metoda Pythona

(binaryfunc) nb add __add__(x,y) (binaryfunc) nb subtract __sub__(x,y) (binaryfunc) nb_multiply __mul__ (x,y) (binaryfunc) nb divide __div__ (x,y) (binaryfunc) nb remainder __mod__(x, y) (binaryfunc) nb_divmod divmod (x,y) (ternaryfunc) nb_power __pow__(x,y, n) (unaryfunc) nb_negative __neg__(x) (unaryfunc) nb_positive __pos__(x) (unaryfunc) nb absolute __abs__(x) (inquiry) nb_nonzero __zero (x) (unaryfunc) nb invert __invert (x) (binaryfunc) nb_lshift __lshift__(x,y) (binaryfunc) nb_rshift __rshift _(x,y) (binaryfunc) nb and __and__(x,y) (binaryfunc) nb xor __xor__ (x,y) (binaryfunc) nb or __or__(x,y) (coercion) nb coerce __coerce (x,y) (unaryfunc) nb_int __int__(x) (unaryfunc) nb long __long_ (x) (unaryfunc) nb_float __float_ (x) (unaryfunc) nb_oct __oct (x) (unaryfunc) nb hex __hex__(x) (binaryfunc) nb inplace add __iadd__(x,y) (binaryfunc) nb_inplace_subtract isub (x,y) (binaryfunc) nb_inplace_multiply imul (x,y) (binaryfunc) nb_inplace_divi de __idiv__(x,y) (binaryfunc) nb inplace remainder imod (x,y) (ternaryfunc) nb_inplace_power __ipow__ (x,y,n) (binaryfunc) nb_inplace lshift ilshift (x,y) (binaryfunc) nb_inplace rshift irshift (x,y) (binaryfunc) nb inplace and iand (x,y) (binaryfunc) nb inplace xor __ixor__(x,y) (binaryfunc) nb inplace or ior (x,y)

Dodatek B: Rozszerzanie i osadzanie Pythona Tabela B.25 Struktura PyBufferProcs Typ danych C Metoda Pythona (getreadbufferproc) bf_getreadbuffer (getwritebufferproc) bf getwritebuffer (getsegcountproc) bf getsegcount (getcharbufferproc) bf getcharbuffer

Tabela B.26 Prototypy metod zdefiniowanych w tej cz ęści Typ danych C Prototyp

(inquiry) int (*)(PyObject *) (unaryfunc) PyObject (*)(PyObject *) (binaryfunc) PyObject (*)(PyObject *, PyObject *) (ternaryfunc) PyObject (*)(PyObject *, PyObject *, PyObject *) (coercion) int (*)(PyObject **, PyObject **) (intargfunc) PyObject (*)(PyObject *, int) (intintargfunc) PyObject (*)(PyObject *, int, int) (intobjargproc) int (*)(PyObject *, int, PyObject *) (intintobjargproc) int (*)(PyObject *, int, int, PyObject

' (destructor) void (*)(PyObject *) (printfunc) int (*) (PyObject *, FILE *, int) (getattrfunc) PyObject (*)(PyObject *, char *) (getattrofunc) PyObject (*)(PyObject *, PyObject *) (setattrfunc) int (*)(PyObject *, char *, PyObject *) (setattrofunc) int (*)(PyObject *, PyObject *, PyObjed (cmpfunc) int (*)(PyObject *, PyObject *) (reprfunc) PyObject (*)(PyObject *) (hashfunc) long (*)(PyObject *) (objobjfunc) int (*)(PyObject *, PyObject *) (getreadbufferproc) int (*)(PyObject *, int, void **) (getwritebufferproc) int (*)(PyObject *, int, void **) (getsegcountproc) int (*)(PyObject *, int *) (getcharbufferproc) int (*)(PyObject *, int, const char **) (richcmpfunc) PyObject *(*)(PyObject *, PyObject *, i (visitproc) int (*)(PyObject *, void *) (traverseproc) int (*)(PyObject *, visitproc, void *)

356 Python

Wątki Podczas korzystania z wątków interpreter stosuje globalną blokadę zapobie- gającą wykonywaniu więcej niż jednego wątku jednocześnie. Jeśli jakaś funkcja napisana w module rozszerzenia wykonuje się przez długi czas, również blokuje ona wykonanie innych wątków do momentu swojego zakończenia. Jest to wynikiem nakładania blokady po każdym wywołaniu funkqi rozszerzenia". Jeśli moduł rozszerzenia jest dostosowany do wielowątkowości, to można włączać i wyłączać w nim globalną blokadę interpretera za pomocą następujących makr: Py_BEGIN_ALLOW_THREADS Wyłącza globalną blokadę interpretera i umożliwia wykonywanie innych wątków przez interpreter. Kiedy blokada jest wyłączona, nie można wywoływać w rozszerzeniu C żadnych funkcji z API C Pythona. PyJEND_ALLOW_THREADS Włącza ponownie globalną blokadę interpretera. Rozszerzenie blokuje się do momentu, aż uda się z powrotem ustawić tę blokadę. Poniższy przykład ilustruje użycie obu tych makr: PyObject *pewnafunkcja(PyObject *self, PyObject *ar gs) { PyArg_ParseTuple(args, ...) Py_BEGIN_ALLOW_THREADS wynik = czasochłonne_obliczenia(args); Py_END_ALLOW_THREADS return Py_BuildValue(fmt, wynik); } Bardziej wyszukane aspekty uruchamiania wątków nie będą tu omawiane. Czy- telnicy zainteresowani tym tematem powinni koniecznie sięgnąć do C API Refe- rence Manual. Ponadto trzeba pamiętać o sprawdzaniu, czy rozszerzenie C jest przystosowane do wielowątkowości, gdyż wkrótce po zwolnieniu blokady interpretera może ono zostać wywołane przez inny wątek Pythona.

Osadzanie Interpreter Pythona może być również osadzany w innych aplikacjach. Dokonując tego w Uniksie, trzeba koniecznie włączyć plik conf ig. c (znajdujący się zwykle w miejscu takim jak <pythofl>/lib/python2.1/config/config.c, gdzie <py thon> jest katalogiem, w którym interpreter został zainstalowany) oraz łącze do biblioteki Iibpython2.1 .a. (Podobny, ale nieco bardziej skomplikowany mechanizm jest wymagany w przypadki. Windows i Macintosha. Szczegółowe informacje można znaleźć w dokumentacji online). Oto lista funkcji używanych do wywoływania interpretera i wykonywania kodu oraz do kontroli jego działania: Dodatek B: Rozszerzanie i osadzanie Pytona int PyRun_AnyFile(FILE *fp, char *filename) Jeśli fp jest urządzeniem interakcyjnym, takim jak TTY w Uniksie, funkc wywołuje PyRun_InteractiveLoop(). W przeciwnym razie nastę wywołanie PyRun_SimpleFile (). Jeśli filename ma wartość Ni nazwą pliku jest domyślny napis "???". int PyRun_SiinpleString(char * command) Wykonuje polecenie command w module__main__interpretera. W p padku powodzenia zwraca wartość 0, a w przypadku zgłoszenia wyjątku int PyRun_SimpleFile(FILE *£p, char *filename) Podobna do PyRun_SimpleString (), tylko wczytuje program z pliki; int PyRun_InteractiveOne(FILE *fp, char *filename) Wykonuje jedno polecenie interakcyjne. int PyRun_InterativeLoop(FILE *fp, char *filename) Uruchamia interpreter w trybie interakcyjnym. int PyRun_String(char *str, int start, PyObject *global PyObject * locals)

Wykonuje kod podany w str, używając przestrzeni nazw zdefiniowa przez globals (globalna) i locals (lokalna), start wskazuje pierwsz) sem używany podczas analizowania składni kodu źródłowego. Fui zwraca rezultat obliczeń, a w przypadku błędu wartość NULL. int PyRun_File(FILE *fp, char *filename, int start, PyObject *globals, PyObject *locals) Podobna do PyRun_String (), tylko wczytuje kod z pliku fp. PyObject *Py_CompileString(char *str, char *filename, start) Kompiluje kod zapisany w s tr na obiekt-kod. start jest początkowyn semem, a filename nazwą pliku ustawianą w obiekcie-kodzie i uży1

w śladach. W przypadku powodzenia funkcja zwraca obiekt-kod, a w ciwnym razie wartość NULL. Py_Initialize(void) Inicjalizuje interpreter Pythona. Funkcja ta powinna być wywoływana j użyciem wszystkich pozostałych funkcji API C, z wyjątkiem Py_Set gramName(), PyEval_InitThreads(), PyEval_ReleaseLock() Eval_AcquireLock(). int Py_lslnitialized(void) Jeśli interpreter został zainicjalizowany, zwraca 1, a w przeciwnym wypadł Py_Finalize (void) Sprząta po interpreterze, usuwając wszystkie podinterpretery i obiekty i rzone od momentu wywołania funkcji Py_Initialize (). Standan zwalnia całą pamięć alokowaną przez interpreter. Stosowanie odwoła klicznych i modułów rozszerzeń może jednak prowadzić do utraty pai której ta funkcja nie potrafi odzyskać.

358 Python void Py_SetProgramName (char *iiame) Ustawia nazwę programu, podaną zwykle w argumencie argv [ 0 ] modułu sys. Funkcję tę należy wywoływać tylko przed Py_Initialize (). char *Py_GetPrograxnName (void) Zwraca nazwę programu ustawioną przez Py_SetProgramName (). char *Py_GetPrefix(void) Zwraca prefiks zainstalowanych plików niezależnych od platformy. char *Py_GetExecPrefix(void) Zwraca prefiks zainstalowanych plików exec zależnych od platformy. char *Py__GetProgramFullPath(void) Zwraca pełną nazwę ścieżkową pliku wykonywalnego Pythona. char *Py_GetPath(void) Zwraca domyślną ścieżkę poszukiwań modułu. Ścieżka jest zwracana w postaci napisu zawierającego nazwy katalogów oddzielone separatorem właściwym dla danej platformy (: w Uniksie,; w DOS/Windows i ' \n' w Macintoshu). const char *Py_GetVersion(void) Zwraca napis z wersją interpretera. const char *Py_GetPlatform(void) Zwraca napis identyfikujący bieżącą platformę. const char *Py_GetCopyright(void) Zwraca oficjalny napis ochrony praw autorskich. const char *Py_GetCompiler(void) Zwraca napis kompilatora. const char *Py_GetBuildInfo(void) Zwraca wbudowaną informację o interpreterze. int PySys_SetArgv(int argc, char **argv) Ustawia opcje linii polecenia używane do ustawienia wartości sys .argv. Funkcja ta powinna być wywoływana tylko przez Py_Initialize ().

Narzędzia do budowy rozszerze ń Istnieje kilka narzędzi ułatwiających budowanie rozszerzeń Pythona. Extension Classes Extension Classes to narzędzie napisane przez Jima Fultona i dostępne pod adresem http://www.digicool.com/release/ExtensionClass/. Można za pomocą niego definiować typy rozszerzeń w sposób zbliżony do klas. W szcze- gólności umożliwia tworzenie podklas w C i Pythonie oraz zapewnia lepsze wykorzystanie napisów dokumentacyjnych i innych elementów interpretera. Dodatek B: Rozszerzanie i osadzanie Pythona CXX Rozszerzenie CXX, napisane przez Paula Dubois, upraszcza tworzenie modi rozszerzeń w C++ (http: //cxx. sourcef orge. net). pyfort Narzędzie to, również autorstwa Paula Dubois, pozwala budować moduły szerzeń Pythona w kodzie Fortranu. Szczegółowe informacje są dostępne adresem http://pyfortran.sourceforge.net. f2py f 2py to generator interfejsu Fortran- Python, napisany przez Pearu Petersona. S: gółowe informacje można znaleźć pod adresem http://cens.ioc.eeA jects/f2py2e/. Boost Python Library Boost Python Library udostępnia narzędzia do obudowywania bibliotek C++ użyciu rozszerzeń Pythona. Oferuje szereg zaawansowanych możliwości, łąc z przeciążaniem funkqi i operatorów. Szczegółowe informacje można znaleźć

adresem http://www.boost.org/libs/python/doc/index.html. SWIG Narzędzie SWIG (Simplified Wrapper and Interface Generator), napisane p autora tej książki i dostępne pod adresem http: / /www. swig. org, umożl automatyczne tworzenie rozszerzeń Pythona na podstawie wskazanych pli nagłówkowych C.

Dodatek C

Podsumowanie zmian

W tym dodatku wymienione są krótko najważniejsze zmiany dokonane w kc nych wersjach Pythona od momentu pierwszego* wydania tej książki, opisuj wówczas Pythona 1.5.2. Zamieszczone informacje dotyczą głównie modyfii języka, które mogą być przyczyną niekompatybilności. Ze względu na dość ogólne potraktowanie tematu osoby zainteresowane sz< gółowym wykazem zmian powinny sięgnąć do dokumentacji Pythona dostęj pod adresem http: / /www. python. org. Dokładne informacje o najnowsz zmianach w języku zawiera także plik Mi sc/NEWS, należący do pakietu dys bucyjnego Pythona.

Python 1.6 Wersja Pythona 1.6 pojawiła się mniej więcej tydzień przed Pythonem 2.0. P czyny tego faktu są skomplikowane i mają charakter poniekąd polityczny. O ny wniosek jest jednak taki, że nie ma raczej sensu używać tej wersji, skoro isł je Python 2.O.

Python 2.0 • Obsługa Unicode. • Wyczerpywanie list. • Rozszerzone operatory przypisania (+=, -=, *=, /=, %=, * *=, &=, I =, A=, »= i oraz skojarzone z nimi metody specjalne__i add__,__i sub__i tak dalej. • Możliwość wywoływania funkcji przy użyciu składni f(*az **kwargs), gdzie args oznacza argumenty pozycyjne, a kwargs - hasło • Odzyskiwanie pamięci po cyklicznych strukturach danych plus moduł g • Rozszerzonainstrukqaprint.print »f, obj przekierowujeobecnie jście do obiektu-pliku f. • Instrukqa import poszerzona o modyfikator as (na przykład import Ć b). Nie jest to jednak nowe słowo kluczowe Pythona. • Nowe metody zarówno napisów standardowych, jak i Unicode. Zastę większość narzędzi modułu string. * amerykańskiego

362 Python Dodatkowa metoda słowników d.setdefault(). Nowe funkcje wbudowane: zip (), unichr () i Unicode (). Nowe moduły (opisane w dodatku A „Biblioteka Pythona"): gc, UserString, _winreg, zipfile,unicodedata, encodings,codecs,atexit,filecmp, gettext, nunap, robotparser i webbrowser. Nowe wyjątki: UnboundLocalError, UnicodeError.

Python 2.1 Zagnieżdżone zasięgi funkq'i. Aby wł ączyć tę opcję, trzeba jednak użyć w programie polecenia from__future__import nested_scopes. W przyszłych wydaniach interpretera opcja ta będzie włączona domyślnie. Bogatsze porównania i skojarzone z nimi metody___le___(),___lt___(), ___eq__(),__ne___(),__gt___(),___ge___(). Nowa metoda d. pop item () słowników. Nowa metoda f. xreadline () plików, służąca do szybkiego iterowania linii. Możliwość dołączania atrybutów do funkqi i metod. Dodanie obsługi słabych odniesień. Interfejs zapewnia nowy moduł o nazwie weakref. Zobacz także weakref (139). Dodanie szkieletu do tworzenia ostrzeżeń. Interfejs zapewnia nowy moduł 0 nazwie warnings. Zobacz także warnings (136). Możliwość importu z uwzględnieniem wielkości liter na platformach igno- rujących tę cechę. Możliwość ustawiania sposobu wyświetlania w trybie interakcyjnym (sys. displayhook). Możliwość przekazywania nieprzechwyconych wyjątków do własnej funkcji (sys. excepthook). Dodatkowa dyrektywa from__future__, która pozwala włączać lub wyłączać nowe opqe. Ograniczenie porównywania liczb zespolonych tylko do relaq'i równości. Po- równania <, >, <= i >= powodują zgłoszenie wyjątku. Możliwość stosowania instrukcji continue wewnątrz bloków try. Wcze- śniej było to niedozwolone. Nowe moduły (opisane w dodatku A) warnings i weakref. Możliwość podawania listy eksportowanych symboli w instrukq'i from module import * za pomocą___all___. Szereg pomniejszych zmian w formatowaniu wyjścia. Kody formatu %x, %X 1 %o generują teraz zawsze znak w przypadku ujemnej długiej liczby całkowi- tej, a funkcja repr () używa standardowych kodów ucieczki, takich jak " \n", zamiast "\012".

Indeks #!, dyrektywa, 2 #, znak komentarza, 1 %, modulo, 47 **, potęgowanie, 47 *, mnożenie, 47 -, odejmowanie, 47 -, zmiana znaku, 47 . (kropka), operator, 54 ., operator, 21 ..., obiekt, 37 .pythonrc, plik konfiguracyjny., 107 /, dzielenie, 47 _ (podkreślenie), zmienna, 112 __abs__(), metoda, 42

_add_(), metoda, 40-41 __and__(), metoda, 41 __builtin__, moduł, 112 __builtins__, atrybut, 112 __cali__(), metoda, 44 __cmp__(), metoda, 37 __coerce__(), metoda, 42 __complex__(), metoda, 42 __contains__(), metoda, 39 _del_(), metoda, 37, 81 __delattr_O, metoda, 39 _delitem_(), metoda, 39 _delslice_0, metoda, 39 __displayhook__, zmienna, 131 __div__(), metoda, 41 __divmod__(), metoda, 41 _doc_, atrybut, 20 __eq__0, metoda, 43 __excepthook__, zmienna, 131 _float_(), metoda, 42 __ge__(), metoda, 43 _getattr__(), metoda, 39 __getattr__, metoda klasy, 34 __getitem__(), metoda, 39 __getslice__(), metoda, 39 __gt_(), metoda, 43 _hash_(), metoda, 37 __hex__(), metoda, 42 __iadd__(), metoda, 41 __iand__(), metoda, 42 __idiv__(), metoda, 42 __ilshift__(), metoda, 42 imod__(), metoda, 42 __import__, funkcja, 112 __imul__0, metoda, 42 _init_(), metoda, 37 __init__(), metoda klasy, 80 __int__(), metoda, 42 __invert__(), metoda, 42 __ior__(), metoda, 42 __ipow__(), metoda, 42 __irshift_(), metoda, 42 __isub__(), metoda, 41 __ixor__(), metoda, 42 _le_0, metoda, 43 _len__(), metoda, 39 __long__0, metoda, 42 _lshift_(), metoda, 41 _lt_(), metoda, 43 __mod__(), metoda, 41 _mul_(), metoda, 40-41 __ne__0, metoda, 43 __neg__0, metoda, 42 __nonzero__(), metoda, 37 __oct__0, metoda, 42 __or__0, metoda, 41 __pos__0, metoda, 42 __pow__(), metoda, 41 _radd_(), metoda, 40-41 __rand__0, metoda, 41 __rdiv__(), metoda, 41 __rdivmod__(), metoda, 41 _repr__(), metoda, 37 __rlshift__(), metoda, 41 __rmod__(), metoda, 41 __rmul__(), metoda, 40-41 __ror__(), metoda, 41

__rpow__0, metoda, 41 __rrshif t__(), metoda, 41 __rshift_(), metoda, 41 __rsub__(), metoda, 41 __rxor__(), metoda, 41 _setattr_(), metoda, 39 __setitem__(), metoda, 39 _setslice_O, metoda, 39 __stderr__, zmienna, 132 __stdin__, zmienna, 132 __stdout__, zmienna, 132 _str__0, metoda, 37 __sub__(), metoda, 41 __xor__(), metoda, 41 getframe, funkcja, 133 _winreg, moduł, 232 +, dodawanie, 47 a2b_base64(), funkcja, 288 a2b_hex(), funkcja, 288 a2b_hqx(), funkcja, 288 a2b_uu(), funkcja, 288 abortO, funkcja, 207 absO, funkcja, 48,113,127 abspathO, funkcja, 213 accessO, funkcja, 205 acosO, funkcja, 144-145 acoshO, funkcja, 144 activeCountO, funkcja, 243 addO, funkcja, 126 AddressListO, funkcja, 301 adler32(), funkcja, 238 alarmO, funkcja, 220 Alias, obiekt, 193 allocate_lock(), funkcja, 241 alternatywa bitowa, 47 analizator leksykalny, 314 and, słowo kluczowe, 4 and_(), funkcja, 127 anydbm, moduł, 166 appendO, metoda listy, 6 applyO, funkcja, 73,113 argumenty hasłowe, 70 pozycyjne, 70 argv, zmienna, 131 ArithmeticError, wyjątek, 64 arrayO, funkcja, 143 array, moduł, 142 as, kwalifikator, 88 ASCII, kodowanie, 103 asctimeO, funkcja, 229 asercje, 67 asinO, funkcja, 144-145 asinhO, funkcja, 144 assert, instrukcja, 67 AssertionError, wyjątek, 64,12C asyncore, moduł, 252 atanO, funkcja, 144-145 atan2(), funkcja, 145 atanhO, funkcja, 144 atexit, moduł, 109,122 atofO, funkcja, 157,190

364 Python atoi(), funkcja, 158,190 atolO, funkcja, 158 atrybut, 21 atrybuty funkcji i metod wbudowanych, 33 funkcji zdefiniowanej przez użytkownika, 31 klas, 34 modułów, 33 pliku, 97 ustawianie w obiektach, 118 AttributeError, wyjątek, 64,120 B b2a_base64(), funkcja, 288 b2a_hex(), funkcja, 288 b2a_uu(), funkqa, 288 bajty, kolejność, 150 base64, moduł, 288 BaseCookie, klasa, 264 BaseHTTPRequestHandler, klasa, 255 BaseHTTPServer, moduł, 255 basenameO, funkcja, 213 Bastion, moduł, 309 bazy danych, 165 metody kursora, 167 Beta, rozkład, 146 betavariateO, funkcja, 146 bezpieczeństwo, 306 bidirectionalO, funkqa, 163 Big Endian, kodowanie, 104 binascii, moduł, 288 bindtextdomain(), funkcja, 185 binhex, moduł, 289 bisect, funkqa, 310 bisect, moduł, 310 blokowanie rekordów, 179 błędy, obsługa, 333 boolowskie wyrażenia, 4 Boost Python Library, 359 break, instrukcja, 62 bsddb, moduł, 167 btopenO, funkqa, 167 bufferO, funkqa, 113 Build Applet, narzędzie, 2,108 Build Application, narzędzie, 108 builtin_module_names, tupla, 131 byteorder, zmienna, 131 C, język, 328,331 calcsizeO, funkcja, 160 callableO, funkqa, 113 całkowity, typ, 25 capitalize^), funkqa, 158 capitalizeO, metoda napisu, 27 capwordsO, funkqa, 158 categoryO, funkcja, 162 ceil(), funkqa, 145 centerO, funkcja, 159 centerO, metoda napisu, 27 cgi, moduł, 258 CGIHTTPRequestHandler, klasa, 262 CGIHTTPServer, moduł, 262

chdirO, funkqa, 199 chmod(), funkqa, 205 choiceO, funkqa, 146 choose_boundary(), funkqa, 291 chownO, funkqa, 205 chr(), funkqa, 55,113 class, instrukcja, 79 classobjO, funkqa, 126 ClassType, typ, 85 clearO, metoda słownika, 30 clockO, funkqa, 229 closeO, funkqa, 201 closeO, metoda pliku, 96 closed, atrybut pliku, 97 CloseKeyO, funkqa, 232 cmath, moduł, 144 Cmd, klasa, 310 cmd, moduł, 310 cmpO, funkqa, 113,179 cmpfilesO, funkqa, 179 codeO, funkqa, 126 codecs, moduł, 101,147 coerced, funkqa, 113 collectO, funkqa, 124 combiningO, funkcja, 164 commands, moduł, 171 commonprefixO, funkcja, 213 compiled, funkqa, 77,113,153 complexO, funkcja, 55,113 compressO, funkcja, 238 concatO, funkqa, 127 ConditionO, funkqa, 245 confstrO, funkcja, 211 ConnectRegistryO, funkqa, 232 constructor(), funkqa, 123 containsO, funkqa, 127 continue, instrukqa, 62 cookie, moduł, 262 copyO, funkqa, 122,182,194,220 copy, moduł, 122 copy_reg, moduł, 123 copy2(), funkcja, 220 copybinaryO, funkqa, 292 copyfileO, funkcja, 219 copyliteralO, funkcja, 292 copymodeO, funkqa, 219 copyright, zmienna, 131 copystatO, funkqa, 219 copytreeO, funkqa, 194,220 cosO, funkcja, 144-145 cosh(), funkqa, 144-145 countO, funkqa, 158 countO, metoda listy, 27 countOfO, funkcja, 127 cPickle, moduł, 127 crc_hqx(), funkcja, 289 crc32(), funkcja, 239, 289 CreateKeyO, funkqa, 233 crypt(), funkcja, 172 crypt, moduł, 172 cStringlO, moduł, 160 ctermidO, funkcja, 199 ctimeO, funkcja, 230 cunifvariateO, funkcja, 146 currentThreadO, funkcja, 243 CXX, 359 cytowanie

napisów, 5 potrójne, 5 dbhash, moduł, 168 dbm, moduł, 168 debuger Pythona, 315 decimalO, funkcja, 162 decodeO, funkcja, 148,288, 291 decodestringO, funkcja, 288 decompositionO, funkqa, 164 decompressO, funkcja, 239 deepcopyO, funkcja, 122 def, instrukqa, 10,11 definiowanie typów, 345 dekodowanie napisów, 147 del, instrukqa, 10 delattrO, funkqa, 114 DeleteKeyO, funkqa, 233 DeleteValueO, funkqa, 233 delitemO, funkqa, 127 delsliceO, funkqa, 127 DES, 172 deskryptory plików, 177,197> 201 dgettextO, funkqa, 185 digitO, funkqa, 162 dir(), funkqa, 13,114 dircmpO, funkqa, 180 dirnameO, funkqa, 213 disableO, funkcja, 124 dispatcher, klasa, 252 display hook, funkcja, 133 div(), funkqa, 126 divmodO, funkqa, 48,114 dllhandle, zmienna, 131 dumbdbm, moduł, 168 dumpO, funkqa, 125,128 dumpsO, funkqa, 125,128 dup(), funkqa, 201 dup2(), funkcja, 201 działania na słownikach, 53 dziedziczenie, 82 dzielenie całkowite, 47 E e, stała matematyczna, 144-145 EditPythonPrefs, program, 107 elif, instrukcja, 5, 61 Indeks Ellipsis, obiekt, 37 else, instrukcja, 4,61 enableO, funkcja, 124 enc_func(), funkcja, 101 encodeO, funkcja, 148,288,291 encodeO, metoda, 55 encodeO, metoda napisu, 28 EncodedFileO, funkcja, 148 encodestringO, funkcja, 288 endswithO, metoda napisu, 28 enumerated, funkqa, 243 EnumKeyO, funkcja, 233 EnumValueO, funkcja, 233 EnvironmentError, wyjątek, 64 EOFError, wyjątek, 64,120 errno, moduł, 172 escapeO, funkcja, 260 eval(), funkcja, 55,76,114 EventO, funkqa, 247 exc_info, funkcja, 133 except, instrukcja, 11

excepthook, funkcja, 133 Exception, wyjątek, 64 exec, instrukcja, 76 execfileO, funkcja, 77,114 execlO, funkcja, 207 execleO, funkcja, 208 execlpO, funkcja, 208 executable, zmienna, 131 execv(), funkcja, 208 execveO, funkcja, 208 execvpO, funkcja, 208 execvpeO, funkcja, 208 existsd, funkcja, 213 exit(), funkcja, 241 exit, funkcja, 133 exitfunc, zmienna, 131 exp(), funkcja, 144-145 expandtabs(), funkcja, 158 expandtabsO, metoda napisu, 27 expanduserO, funkcja, 213 expandvars(), funkcja, 213 expovariateO, funkcja, 146 extendO, metoda, 26 Extension Classes, 358 extract_stack, funkcja, 135 extract_tb, funkcja, 135 f2py, 359 fabsO, funkcja, 145 fcntK), funkqa, 177 fcntl, moduł, 177 fdopenO, funkcja, 201 FieldStorage, klasa, 259 FIFO, kolejki, 248 filecmp, moduł, 179 fileinputO, moduł, 181 Filelnput, klasa, 181 filenoO, metoda pliku, 96 filterO, funkcja, 75,114 filterwarnings, funkcja, 138 finally, klauzula, 65 findO, funkcja, 158,186 findO, metoda napisu, 27 findallO, funkcja, 154 FindApplicationO, funkcja, 192 findertoolsO, moduł, 182 FindFolderO, funkcja, 191 findmatchO, funkcja, 290 FInfoO, funkcja, 190 floatO, funkcja, 54,114 FloatingPointError, wyjątek, 64, 120 flockO, funkcja, 178 floor(), funkcja, 145 flushO, metoda pliku, 96 FlushKeyO, funkcja, 234 fmod(), funkcja, 145 fnmatchO, funkcja, 183 fnmatch, moduł, 182 fnmatchcaseO, funkcja, 183 for, instrukcja, 8,61 forkO, funkcja, 208 forkptyO, funkcja, 208 formatO, funkcja, 190 format_exception, funkcja, 135 format_exception_only, funkcja, 135

format_list, funkcja, 135 format_stack, funkcja, 135 format_tb, funkqa, 135 formatowanie, 4 napisów, 52 wyjścia, 99 formatwarning, funkcja, 137 fpathconfO, funkcja, 201 frexpO, funkqa, 145 from, instrukcja, 88 fromfdO, funkcja, 275 FSSpecO, funkcja, 190 FSSpec, obiekt, 192 fstatO, funkcja, 202 fstatvfsO, funkcja, 202 ftplib, moduł, 265 ftruncateO, funkcja, 202 functionO, funkcja, 126 funkcja wbudowana, 33 funkcje argumenty pozycyjne, 70 definiowanie, 69 dowolna liczba argumentów, 70 hasłowe, 70 parametry domyślne, 69 tworzenie, 10 wartości domyślne, 10 wbudowane, 112 wywoływanie, 10 zwracanie wartości, 10 funkcje matematyczne, 142 funkcje zdefiniowane przez użytkownika, 31 gammaO, funkcja, 147 gamma, rozkład, 147 garbage, zmienna, 124 gaussO, funkcja, 147 Gaussa, rozkład, 147 gąsienice, 272 gc, moduł, 124 gdbm, moduł, 169 generatory liczb losowych, 3( getO, metoda słownika, 30 get_debug(), funkcja, 124 get_ident(), funkcja, 241 get_osfhandle(), funkcja, 197 get_threshold(), funkcja, 124 getatimeO, funkqa, 213 getattrO, funkcja, 114 getbootvoK), funkcja, 205 getcapsO, funkcja, 290 getchO, funkcja, 197 getcheO, funkcja, 197 getcwdO, funkcja, 199 getdefaultencoding, funkcja, GetDirectoryO, funkcja, 191 getegidO, funkcja, 199 geteuidd, funkcja, 199 getfqdnd, funkqa, 276 getgidO, funkqa, 199 getgrallO, funkqa, 188 getgrgidO, funkcja, 188 getgrnamO, funkqa, 188 getgroupsd, funkcja, 199 gethostbyaddrO, funkcja, 27ć gethostbynameO, funkqa, 27

gethostnameO, funkcja, 276 getitemO, funkq'a, 127 getmtimeO, funkcja, 213 getoptO, funkcja, 183 getopt, moduł, 183 getoutputO, funkcja, 171 getpagesizeO, funkcja, 219 getpassO, funkcja, 184 getpass, moduł, 184 getpgrpO, funkcja, 199 getpidO, funkcja, 199 getppidd, funkcja, 199 getprotobynameO, funkcja, 2 getpwallO, funkcja, 216 getpwnamO, funkqa, 216 getpwuidO, funkqa, 216 getrecursionlimit, funkcja, 1: getrefcount, funkqa, 134 getrlimitO, funkqa, 218 getrusageO, funkqa, 218 getservbynameO, funkcja, 27 getsignaK), funkqa, 221 getsizeO, funkcja, 213 getsliceO, funkqa, 127

366 Python Indeks getstateO, funkcja, 146 getstatusO, funkcja, 171 getstatusoutputO, funkcja, 171 gettempprefixO, funkcja, 224 gettextO, funkcja, 185 gettext, moduł, 184 getuidO, funkcja, 199 getuserO, funkcja, 184 getweakrefcountO, funkcja, 139 getweakrefsO, funkcja, 139 globO, funkcja, 188 glob, moduł, 187 global, instrukcja, 87 globalsO, funkcja, 114 głębokie kopiowanie, 23 gmtimeO, funkcja, 230 gniazda, 249 GNU DBM, biblioteka, 169 grp, moduł, 188 grupy Uniksa, 188 guess_extension(), funkcja, 295 guess_type(), funkcja, 295 gzip(), funkcja, 188 GzipFileO, funkcja, 188 GzipFile, klasa, 188 H has_key(), metoda, 9 hasattrO, funkqa, 114 hashO, funkcja, 114 hashopenO, funkcja, 167 hasła Uniksa, dostęp, 216 heapminO, funkcja, 197 hex(), funkcja, 55,115 hexversion, zmienna, 131 htonlO, funkcja, 276 htonsO, funkcja, 276 HTTP, 262,266 httplib, moduł, 266 HTTPServer, klasa, 255 hypotO, funkqa, 145 id(), funkcja, 22,115 identyfikatory, 16 if, instrukcja, 4, 61 imaplib, moduł, 271 import, instrukcja, 7,12,87 ImportError, wyjątek, 64,120 importowanie modułów, 12 indeksowanie, operator, 6 IndentationError, wyjątek, 65, 120 index(), funkcja, 158 index(), metoda listy, 26 index(), metoda napisu, 27 IndexError, wyjątek, 64,120 indexOfO, funkcja, 127 initO, funkcja, 295 inputO, funkcja, 115,181 insert(), metoda listy, 7,27 insort, funkcja, 310 installO, funkcja, 186 instanceO, funkcja, 126 instancemethodO, funkcja, 126 InstanceType, typ, 85 instancja klasy, 21

instancja typu, 21 instancje klas, 34 instrukcje assert, 67 break, 62 class, 79 continue, 62 def, 10-11 del, 10 elif, 5, 61 else, 4, 61 except, 11 exec, 76 for, 8, 61 from, 88 global, 87 if, 4,61 import, 7,12,87 pass, 4 print, 4, 99 raise, 12, 63 try, 11 warunkowe, 4, 61 while, 8,61 int(), funkcja, 54 intern(), funkcja, 44,115 Internet, 321 internowanie napisu, 44 interpreter poleceń wierszowych, 310 invO, funkqa, 127 ioctlO, funkcja, 178 IOError, wyjątek, 64,120 Irix, 322 is, operator, 22 is_zipfile(), funkcja, 235 isabsO, funkcja, 213 isalnumO, metoda napisu, 28 isalphaO, metoda napisu, 28 isattyO, metoda pliku, 96 isdigitO, metoda napisu, 28 isdirO, funkcja, 214 isenabledO, funkcja, 124 isfileO, funkcja, 214 isinstanceO, funkcja, 22, 85,115, 135 islink(), funkcja, 214 islowerO, metoda napisu, 28 isMappingTypeO, funkcja, 127 ismountO, funkcja, 214 IsNumberTypeO, funkcja, 127 ISO-8859, kodowanie, 103 isSequenceType(), funkcja, 127 isspaceO, metoda napisu, 28 issubclassO, funkcja, 85,115 istitleO, metoda napisu, 28 isupperO, metoda napisu, 28 iterowanie sekwencji, 49 J join(), funkcja, 159,214 joinO, metoda napisu, 28 joinfieldsO, funkcja, 159 jumpaheadO, funkcja, 146 K katalogi, 205 porównywanie, 179 kbhitO, funkcja, 197

Keyboardlnterrupt wyjątek, 64,120 Key Error, wyjątek, 30,64,120 keysO, metoda, 10 kilK), funkcja, 208 klasy, 34,79 _del__0, metoda, 81 __init_0, metoda, 80 __init__, metoda, 11 atrybuty, 34 bazowe, 34,82 definiowanie, 11 dziedziczenie, 82 instancje, 34, 80 metody, 11, 79 pochodne, 34, 82 polimorfizm, 83 przeciążanie operatorów, 84 self, argument metody, 11 tworzenie, 34 ukrywanie atrybutów, 83 zmienne, 79 kod, obiekt, 35 kodeki, tworzenie, 147 kodowanie napisów, 28,147 napisów Unicode, 56 obsługa błędów, 56 Unicode, 103 kody ucieczki, 17-18 kolejność bajtów, 150 obliczeń, 58 kolekcja, 21 kołowy, rozkład, 146 komentarze, 1,16 kompilowanie rozszerzeń, 326 kompresja danych, 238 konfigurowanie Pythona, 323 koniunkcja bitowa, 47 konkatenacja list, 7 sekwencji, 49 kontener, 21 kontynuowanie linii, 15 konwersja danych, 328,331 konwersja typu, 42 konwersja typów, 54 konwersja typów danych, 6 kopia głęboka, 122 kopie obiektów, 23 kopiowanie głębokie, 23 płytkie, 23 sekwencji, 49 lambda, operator, 74 last_traceback, zmienna, 131 last_type, zmienna, 131 last_value, zmienna, 131 Latin-1, kodowanie, 103 launchO, funkcja, 182 ldexpO, funkcja, 145 lenO funkcja, 6, 26,115 metoda słownika, 30 liczby pseudolosowe, 145 linia

oddzielanie instrukcji, 16 struktura, 15 wcięcia, 15 znak kontynuacji, 15 link(), funkcja, 205 listO, funkcja, 26, 55,115 listdirO, funkcja, 205 listy, 6 dołączanie elementów, 6 konkatenowanie, 7 max(), funkcja, 8 minO, funkcja, 8 modyfikowanie elementów, 6 odwracanie kolejności, 27 pobieranie elementów, 6 sortowanie, 27,310 szukanie elementu, 26 tworzenie, 6 ustalanie długości, 6 wstawianie elementów, 7 wycinanie elementów, 7 wyczerpywanie elementów, wydłużanie, 26 zagnieżdżanie, 7 literał napisowy, 5 literały, 17 Little Endian, kodowanie, 104 ljustO, funkcja, 159 ljustO, metoda napisu, 28 loadO, funkcja, 125,128 loadsO, funkcja, 125,128 locale, moduł, 189 localeconvO, funkcja, 189 localsO, funkcja, 115 localtimeO, funkcja, 230 lockO, funkcja, 179 lockingO, funkcja, 197 LockType, obiekt, 241 logO, funkcja, 144-145 loglOO, funkcja, 144-145 lognormvariateO, funkcja, 147 longO, funkcja, 54,115 lookupO, funkcja, 148 LookupError, wyjątek, 64 lowerO, funkcja, 158 lowerO, metoda napisu, 29 lseekO, funkcja, 202 lshiftO, funkcja, 127 lstatO, funkcja, 206 lstripO, funkcja, 159 lstripO, metoda napisu, 29 łańcuchy porównań, 48 M macfs, moduł, 190 Macintosh, 190,194 macostools, moduł, 194 mailcap, moduł, 290 makedirsO, funkcja, 206 maketransO, funkcja, 158 map(), funkcja, 74,115 mapowania, metody, 39 marshal, moduł, 125 matchO, funkcja, 154 matematyczne metody, 40 math, moduł, 144 max(), funkcja, 8,26,116

maxint, zmienna, 131 MD5, algorytm, 313 md5, moduł, 313 MemoryError, wyjątek, 64,120 MessageO, funkcja, 291 Message, klasa, 292 metoda, 21 wbudowana, 33 związana, 32 metody klas, nazwy, 11 konwersji, 42 matematyczne, 40 napisów, 27 niezwiązane, 32 pliku, 96 porównujące, 43 sekwencji i mapowania, 39 specjalne, 37 typów mapujących, 30 mimetools, moduł, 290 mimetypes, moduł, 292 MimeWriter, klasa, 295 MimeWriter, moduł, 295 minO, funkcja, 8,26,116 MiniFieldStorage, klasa, 259 mirroredO, funkcja, 164 mkaliasO, funkcja, 194 mkargO, funkcja, 171 mkdirO, funkcja, 206 mkfifoO, funkcja, 206 mktempO, funkcja, 224 mktimeO, funkcja, 230 mktimeJzO, funkcja, 301 mmapO, funkcja, 195 mmap, moduł, 195 mmap, obiekt, 195 modO, funkcja, 126 mode, atrybut pliku, 97 modfO, funkcja, 145 moduleO, funkcja, 126 modules, zmienna, 132 modulo, operator, 47 moduły, 33, 87 atrybuty, 33 dirO, funkcja, 13 importowanie, 12 kompilowanie, 89 listowanie zawartości, 13 ładowanie, 89 powtórne ładowanie, 117 przeładowywanie, 90 rozszerzeń, 324 ścieżka poszukiwań, 89 tworzenie, 12 używanie w programie, 1! moveO, funkcja, 182 msvcrt, moduł, 197 mulO, funkcja, 126 multifile, moduł, 297 multimedia, 322 N name, atrybut pliku, 97 NameError, wyjątek, 64,120 napisy, 5,147 cytowanie, 5 dekodowanie, 147

działania, 157 dokumentacyjne, 20 formatowanie, 52 formatujące, 4 internowanie, 44 kodowanie, 28,147 metody, 27 porównywanie, 57 przetwarzanie, 321 sekwencje ucieczki, 153 surowe, 19 symbole wieloznaczne, 1 Unicode, 18,55 wyrażenia regularne, 15 negO, funkcja, 126 negacja bitowa, 47 New, moduł, 126 NewAliasMinimalFromFulll (), funkqa, 192 niceO, funkcja, 208 nntplib, moduł, 272 None, typ, 25 normalvariateO, funkcja, 14!

368 Python normcaseO, funkcja, 214 normpathO, funkcja, 214 not, słowo kluczowe, 4 not_(), funkcja, 127 NotlmplementedError, wyjątek, 65,120 ntohU), funkcja, 276 ntohsO, funkq'a, 276 numericO, funkqa, 162 O obiekt mapujący, 30 obiekt stały, 21 obiekt zmienny, 21 obiekty, 21 bazy danych, 165 kod, 35 kopie, 23 odniesienia, 22-23 ramka, 35 reprezentowanie, 37 serializacja, 125,127 sprawdzanie równości, 58 ślad, 36 tożsamość, 21-22,58 tworzenie, 37,126 typ, 21-22 ustawianie atrybutów, 118 usuwanie, 37 wielokropek, 37 wycinek, 36 wywoływalne, 44 obliczenia, kolejność, 58 obsługa błędów kodowania, 56 oct(), funkcja, 55,116 odniesienia do obiektów, 23 odniesienia, zliczanie, 22 odwołania, zliczanie, 335 odwrotne apostrofy, 6 ograniczniki, 20 opcje linii polecenia, 95,105 Pythona, 105 -t,16 -tt, 16 openO, funkcja, 5,35,96,116, 148,166,168-170,202 open_osfhandle(), funkcja, 198 OpenKeyO, funkcja, 234 openptyO, funkcja, 203 operaq"e matematyczne, 41 porównywania, 43 operator indeksowania, 6 kropka (.), 21 moduł, 126 wycinania, 6 operatory, 20,47 . (kropka), 54 bitowe, 47 boolowskie, 58 is, 22 lambda, 74 modulo, 47 porównania, 48

przeciążanie, 84 or, słowo kluczowe, 4 or (), funkcja, 127 ord(), funkcja, 55,116 os, moduł, 198 os.environ, słownik, 95 os.exitO, funkcja, 110 os.path, moduł, 213 os.putenv(), funkcja, 95 osadzanie Pythona, 356 OSError, wyjątek, 64,121 ostrzeżenia, 136 otwieranie bazy danych, 166 pliku, 96 OverflowError, wyjątek, 25,64, 121 packO, funkcja, 160 PackerO, funkcja, 302 pająki, 272 pakiety, 91 inicjalizowanie, 130 pamięć programu, 44 pozyskiwanie, 23,109,124 Pareto, rozkład, 147 paretovariateO, funkcja, 147 parseO, funkcja, 260 parse_header(), funkq'a, 260 parsedateO, funkcja, 301 parsedate_tz(), funkqa, 301 pary zastępcze, 27 pass, instrukcja, 4 path, zmienna, 132 pathconfO, funkcja, 206 pauseO, funkq'a, 221 pdb, moduł, 315 pętle, 8,61 pi, stała matematyczna, 144-145 pickleO, funkcja, 123 piekle, moduł, 100,127 PicklerO, funkcja, 128 pipeO, funkqa, 203 platform, zmienna, 132 pliki, 35,205 atrybuty, 97 konfiguracyjne, 107,108 metody, 96 open(), funkcja, 96 otwieranie, 96 porównywanie, 179 tryby otwierania, 96 wejściowe, 5 wyjściowe, 5 plockO, funkcja, 209 płytkie kopiowanie, 23 pm, funkcja, 315 podklasa, 82 polimorfizm, 83 popO, metoda listy, 27 popen(), funkqa, 204 popen2(), funkcja, 204,215 popen2, moduł, 215 popen3(), funkcja, 204,215 Popen3, klasa, 215 popen4(), funkcja, 204,215 Popen4, klasa, 216

popitemO, metoda słownika, 30 poplib, moduł, 272 porównywanie obiektów, 43 plików i katalogów, 179 sekwencji, 51 porty, 249 posO, funkq"a, 126 POSIX, 171 postmortem, funkqa, 315 potrójny znak cytowania, 5 pow(), funkcja, 48,116,145 pozyskiwanie pamięci, 23,109, 124 prefix, zmienna, 132 print(), funkcja, 182 print, instrukcja, 4 Print, instrukcja, 99 print_directory(), funkq'a, 261 print_environ(), funkcja, 261 print_exc, funkcja, 134 print_exception, funkcja, 134 print_form(), funkcja, 261 print_last, funkcja, 134 print_stack, funkcja, 135 print_tb, funkq'a, 134 proces, środowisko, 199 procesy, zarządzanie, 207 profil, analiza danych, 319 profile, moduł, 318 profiler, 134 profiler Pythona, 318 programy kończenie, 109 uruchamianie, 108 PromptGetFileO, funkcja, 191 proxy (), funkcja, 139 przeciążanie operatorów, 84 przeglądarki, 287 przekierowywanie wyjścia, 99 przeładowywanie modułu, 117 przepływ sterowania, 61 przestrzenie nazw, 72 przestrzeń nazw globalna, 114 lokalna, 115,118 przesunięcie bitowe, 47 przypisania rozszerzone, 42,53 Indeks psi, zmienna, 132 ps2, zmienna, 132 pseudoterminal, 203 pstats, moduł, 319 putchO, funkcja, 198 putenv(), funkcja, 200 pwd, moduł, 216 Py_CompileString, funkcja, 357 Py_Finalize, funkcja, 357 Py_GetBuildInfo, funkcja, 358 Py_GetCompiler, funkcja, 358 Py_GetCopyright, funkcja, 358 Py_GetExecPrefix, funkcja, 358 Py_GetPath, funkcja, 358 Py_GetPlatform, funkcja, 358 Py_GetPrefix, funkcja, 358 Py_GetProgramFullPath, funkcja, 358

Py_GetProgramName, funkcja, 358 Py_GetVersion, funkcja, 358 Py_Initialize, funkcja, 357 Py_lslnitialized, funkcja, 357 Py_SetProgramName, funkcja, 358 PyErr_Clear, funkcja, 333 PyErr_NoMemory, funkcja, 333 PyErr_Occurred, funkcja, 333 pyfort, 359 PyRun_AnyFile, funkcja, 357 PyRun_File, funkcja, 357 PyRunJnteractiveOne, funkcja, 357 PyRunJnterativeLoop, funkcja, 357 PyRun_SimpleFile, funkcja, 357 PyRun_SimpleString, funkcja, 357 PyRun_String, funkqa, 357 PySys_SetArgv, funkqa, 358 Python debuger, 134 opcje, 16,105 osadzanie, 356 sesja interakcyjna, 107 słowa zarezerwowane, 16 uruchamianie, 1 uruchamianie programów, 108 usługi, 122 wykonywanie programów, 1 wywoływanie w C, 336 zmiany, 361 znak zgłoszenia, 132 PYTHONCASEOK, zmienna, 106 PYTHONHOME, zmienna, 106 PYTHONINSPECT, zmienna, 106 PYTHONPATH, zmienna, 106 PYTHONSTARTUP, zmienna, 106 PYTHONUNBUFFERED, zmienna, 106 PyZipFileO, funkcja, 236 QuerylnfoKeyO, funkcja, 234 QueryValueO, funkcja, 234 QueueO, funkcja, 248 Queue, moduł, 248 quopri, moduł, 299 quoted, funkcja, 285 quote_plus(), funkcja, 285 R raise, instrukcja, 12,63 ramka, obiekt, 35 random, moduł, 145 randrangeO, funkcja, 146 rangeO, funkqa, 8,116 raw_input(), funkqa, 98,117 RawAliasO, funkqa, 190 RawFSSpecO, funkcja, 190 re, moduł, 151 read(), funkcja, 149,204 read(), metoda pliku, 96 read_mime_types(), funkcja, 295 readintoO, metoda pliku, 96 readlineO, funkcja, 149 readlineO, metoda, 5 readlineO, metoda pliku, 96 readline, biblioteka GNU, 217 readline, moduł, 217 readlinesO, funkq'a, 149 readlinesO, metoda pliku, 96

readlinkO, funkq'a, 206 reduceO, funkcja, 75,117 ref(), funkcja, 139 registerO, funkcja, 122,147,287 RegLoadKeyO, funkcja, 234 Rejestr Windows, 107,232 rekurenqa, 73 reloadO, funkqa, 117 removeO, funkcja, 206 removeO, metoda listy, 27 removedirs(), funkcja, 206 renameO, funkcja, 206 renamesO, funkcja, 206 repeatO, funkcja, 127 replaceO, funkcja, 159 replaceO, metoda napisu, 29 repr(), funkcja, 6,55,117 reprezentacja liczb całkowitych, 48 resetO, funkcja, 149 resetwarnings, funkcja, 138 ResolveAliasFileO, funkcja, 191 resource, moduł, 218 restartO, funkcja, 182 reverse(), metoda listy, 27 RExec, klasa, 306 rexec, moduł, 306 rfc822, moduł, 299 rfindO, funkcja, 158 rfindO, metoda napisu, 27 rindexO, funkcja, 158 rindexO, metoda napisu, 27 rjustO, funkcja, 159 rjustO, metoda napisu, 29 rlecode_hqx(), funkcja, 289 rledecode_hqx(), funkcja, 289 RLockO, funkcja, 245 rmdirO, funkcja, 206 rmtreeO, funkqa, 220 rnopenO, funkcja, 167 robotparser, moduł, 272 roundO, funkcja, 48,118 rozłączna alternatywa bitowa, rozszerzanie Pythona, 323 rozszerzenia, kompilowanie, 3 rozwiązywanie nazw, 72 równość obiektów, 58 rshiftO, funkcja, 127 rstripO, funkqa, 159 rstripO/ metoda napisu, 29 run, funkqa, 315,318 runcall, funkcja, 315 runeval, funkcja, 315 RuntimeError, wyjątek, 65,12 samefileO, funkcja, 214 SaveKeyO, funkcja, 235 searchO, funkcja, 154 seed(), funkcja, 145 seek(), metoda pliku, 96 sekwencje działania, 49 metody, 39 porównywanie, 51 sekwencyjne, typy, 26 selectO, funkcja, 252 select, moduł, 273 self, argument metody, 11

semafory, 246 SemaphoreO, funkcja, 246 sequencelncludesO, funkcja, 1 serializacja obiektów, 100,12J 127 set_debug(), funkcja, 124 set_threshold(), funkcja, 124 set_trace, funkcja, 315 setattrO, funkcja, 118 setcbreakO, funkcja, 232 setcheckinterval, funkcja, 134 setdefaultO, metoda słowniki setdefaultencoding, funkcja, SetFolderO, funkcja, 191 setgidO, funkcja, 200 setitemO, funkcja, 127 setlocaleO, funkcja, 189 setmodeO, funkqa, 198 setpgidO, funkcja, 200 setpgrpO, funkqa, 200 setprofile, funkqa, 134 setrawO, funkq'a, 232 setrecursionlimit, funkcja, 13 setregidO, funkcja, 200 setreuidO, funkcja, 200 setrlimitO, funkcja, 218

370 Python Indeks setsidO, funkcja, 200 setsliceO, funkcja, 127 setstateO, funkcja, 146 settrace, funkcja, 134 setuidO, funkcja, 200 Setup, plik, 323 SetValueO, funkcja, 235 SHA, algorytm, 313 sha, moduł, 313 shelf(), funkcja, 170 shelve, moduł, 100,169 shlex, klasa, 314 shlex, moduł, 314 showwarning, funkcja, 137 shuffleO, funkcja, 146 shutdownO, funkcja, 182 shutil, moduł, 219 sieciowe programowanie, 249 sieciowe zdarzenia, obsługa, 252 sieć, 321 signalO, funkcja, 221 signal, moduł, 220 SimpleHTTPServer, moduł, 274 sin(), funkcja, 144-145 sinhO, funkcja, 144-145 site, moduł, 130 sitecustomize, moduł, 130 sleepO, funkcja, 182, 230 sliceO, funkcja, 118 słabe odniesienia, 138 słowa zarezerwowane, 16 słowniki, 30 działania, 53 has_key(), metoda, 9 keysO, metoda, 10 metody, 30 modyfikowanie, 9 rodzaje kluczy, 9 sięganie do zawartości, 9 tworzenie, 9 usuwanie elementów, 10 słowo kluczowe and, 4 not, 4 or, 4 smtplib, moduł, 275 SocektServer, moduł, 282 socketO, funkcja, 277 socket, moduł, 275 SocketServer, klasa, 255 softspace, atrybut pliku, 97 sortO, metoda listy, 27 sortowanie list, 27 spawnvO, funkqa, 209 spawnveO, funkcja, 209 splitO, funkcja, 154,158,214 splitO, metoda napisu, 29 splitdriveO, funkcja, 215 splitfieldsO, funkcja, 158 splitlinesO, metoda napisu, 29 splittextO, funkcja, 215 sqrt(), funkcja, 144-145 ssl(), funkqa, 276 sstripO, funkcja, 159

StandardError, wyjątek, 64 StandardGetFileO, funkcja, 191 standardowy strumień diagnostyczny, 98 wejściowy, 98 wyjściowy, 98 StandardPutFileO, funkcja, 191 start_new_thread(), funkcja, 241 startfileO, funkcja, 209 startswithO, metoda napisu, 29 statO, funkcja, 207 statO, moduł, 223 Stats, klasa, 319 statvfsO, funkcja, 207 statvfs, moduł, 224 stderr, obiekt, 98 stderr, zmienna, 132 stdin, obiekt, 98 stdin, zmienna, 132 stdout, obiekt, 98 stdout, zmienna, 132 sterowanie w programie, 61 str(), funkcja, 6,55,118,190 strcollO, funkcja, 189 StreamReaderO, funkcja, 149 StreamReaderWriterO, funkcja, 149 StreamRecorderO, funkqa, 149 StreamWriter(), funkcja, 149 strerrorO, funkcja, 200 strftimeO, funkcja, 230 string, moduł, 157 StringlO, moduł, 160 stripO, metoda napisu, 29 strptimeO, funkqa, 231 struct, moduł, 160 struktura linii, 15 strumienie standardowe, 98 strxfrmO, funkcja, 190 sub(), funkcja, 126,154 subnO, funkcja, 154 Sun, 322 superklasa, 82 surowe napisy, 19 swapcaseO, funkcja, 159 swapcaseO, metoda napisu, 29 SWIG, 359 sygnały, obsługa, 220 symbole specjalne, 20 symlinkO, funkcja, 207 syncO, funkcja, 207 SyntaxError, wyjątek, 65,121 sys, moduł, 131 sys.argv, zmienna, 95 sys.path, zmienna, 130 sysconf(), funkcja, 211 systemO, funkcja, 209 system konfiguracja, 211 kontrola zasobów, 218 SystemError, wyjątek, 65,121 SystemExit, wyjątek, 64,121 system operacyjny dostęp, 198 usługi, 171 szyfrowanie, 172

ścieżki plików, działania, 213 ślad, obiekt, 36 środowisko procesu, 199 wykonania, 306 TabError, wyjątek, 16,65,121 tablica metody, 143 tworzenie, 143 tabulaqe, 16 tan(), funkcja, 144-145 tanh(), funkcja, 144-145 tb_lineno, funkcja, 135 tcdrainO, funkqa, 228 tcflowO, funkcja, 228 tcflushO, funkcja, 228 tcgetattrO, funkqa, 225 tcgetpgrpO, funkcja, 204 TCP, 249 TCPServer, klasa, 282 tcsendbreakO, funkcja, 228 tcsetattrO, funkcja, 228 tcsetpgrpO, funkcja, 204 tellO, metoda pliku, 96 tempfile, moduł, 224 TemporaryFileO, funkcja, 224 terminale kontrolowanie, 225 ustawianie, 232 termios, moduł, 225 testO, funkqa, 261 textdomain(), funkcja, 185 Thread, klasa, 243 thread, moduł, 241 threading, moduł, 242 timeO, funkcja, 231 time, moduł, 229 timesO, funkcja, 209 titleO, metoda napisu, 29 touchedO, funkcja, 194 tożsamość obiektów, 21-22,58 traceback, moduł, 134 tracebacklimit I, zmienna, 132 translateO, funkcja, 159 translateO, metoda napisu, 28-29 translationO, funkcja, 187 truncateO, metoda pliku, 96 truthO, funkqa, 127 try, instrukcja, 11 tryb ograniczony, 305 try, moduł, 232 ttynameO, funkcja, 204 tupie, 6 działania na elementach, 8 tworzenie, 8 tupleO, funkcja, 55,118 typeO, funkcja, 22,118 TypeError, wyjątek, 65,121 types, moduł, 135 typy całkowity, 25 ClassType, 85 definiowanie, 345 InstanceType, 85 konwersja, 54 mapujące, 30 metody specjalne, 352

None, 25 numeryczne, 25 obiektu, 21 sekwencyjne, 26 wbudowane, 24 wewnętrzne, 35 wywoływalne, 31 XRangeType, 29 zespolony, 25 zmiennoprzecinkowy, 25 typy danych, wymagania pamięciowe, 44 U UCS-2,27 UDP, 249 UDPServer, klasa, 282 umaskO, funkcja, 200 unameO, funkcja, 200 UnboundLocalError, wyjątek, 65,121 ungetchO, funkcja, 198 unichrO, funkcja, 55,118 Unicode, 27,55,100,162 napisy, 18 unicodeO, funkcja, 55,118 Unicode, kodowanie, 101-102 Unicode, kodowanie domyślne, 130 Unicode, kodowanie napisów, 56 Unicode, właściwości znaków, 104 unicodedata, moduł, 162 UnicodeError, wyjątek, 65,121 UnixDatagramServer, klasa, 282 UnixStreamServer, klasa, 282 unlinkO, funkcja, 207 unpackO, funkcja, 160 UnpackerO, funkcja, 302 UnpicklerO, funkcja, 128 unquoteO, funkcja, 285 upper(), funkcja, 159 upperO, metoda napisu, 29 urlcleanupO, funkcja, 285 urlencodeO, funkcja, 285 urljoinO, funkcja, 286 urllib, moduł, 284 urlopenO, funkcja, 284 urlparseO, funkcja, 286 urlparse, moduł, 286 urlunparseO, funkcja, 286 UserDictO, funkcja, 141 UserDict, moduł, 141 UserListO, funkcja, 141 UserList, moduł, 141 UserStringO, funkcja, 141 UserString, moduł, 141 usługi Pythona, 122,320 usługi systemu operacyjnego, 171 ustawienia regionalne, 189 UTF-16,102 UTF-16, kodowanie, 104 UTF-16be, kodowanie, 104 UTF-161e, kodowanie, 104 UTF-8,102 UTF-8, kodowanie, 103

utimeO, funkcja, 207 uu, moduł, 302 uuencode, 302 ValueError, wyjątek, 26,65,121 varsO, funkcja, 118 version, zmienna, 132 version_info, zmienna, 132 vonmisesvariateO, funkcja, 147 W waitO, funkcja, 210 waitpidO, funkcja, 210 walkO, funkcja, 215 wamO, funkcja, 137 warn_explicit, funkcja, 137 warnings, moduł, 136 warnoptions, zmienna, 132 wątki, 240-242,356 wcięcia, 3 wcięcia linii, 15 WeakKeyDictionary (), funkcja, 140 WeakKeyDictionaryO, funkcja, 140 weakref, moduł, 138 webbrowser, moduł, 287 Weibulla, rozkład, 147 weibullvariateO, funkcja, 147 wejście/wyjście z użyciem Unicode, 100 wersje Pythona, 361 whichdbO, funkcja, 170 whichdb, moduł, 170 while, instrukcja, 8,61 wielokropek, obiekt, 37 Windows, Rejestr, 232 WindowsError, wyjątek, 64, 121 winver, zmienna, 133 writeO, funkcja, 149, 204 writeO, metoda pliku, 96 writelinesO, funkcja, 149 writelinesO, metoda pliku, 96 wybór listowy, 76 wychodzenie z programu, 10S wycinanie rozszerzone, 40 operator, 6 wycinek rozszerzony, 40 wycinek, obiekt, 36 wydajność programu, 44 wyjątki, 11, 63 definiowanie nowych, 66 przechwytywanie, 11 wbudowane, 64,119 zgłaszanie, 12 wykładniczy, rozkład, 146 wyrażenia, 47 arytmetyczne, 3 boolowskie, 4,58 regularne, 151 xdrlib, moduł, 302 xor(), funkcja, 127 xrangeO, funkcja, 9,118 XRangeType, typ, 29 xreadlinesO, metoda pliku, 9( xstat(), funkcja, 207 zagnieżdżanie list, 7 zaokrąglanie wartości, 48, 111

zasięg, 72 zdarzenia, 247 ZeroDivisionError, wyjątek, i 121 zespolony, typ, 25 zfillO, funkcja, 159 zgłaszanie wyjątków, 12 zip(), funkcja, 75,119 ZipFileO, funkcja, 235 zipfile, moduł, 235 ZipInfoO, funkcja, 236 zlib, moduł, 238 zmienne, 3 stanu, 245 środowiskowe, 95,106 zmiennoprzecinkowy, typ, 2

Python Programowanie

Documents

Transcript of Python Programowanie