dareks_
ArkuszeDavid M. Beazley PYTHONWydawnictwo RM L Prorrram
David Beazley - Programowanie. Python
Informacje o dokumencie
| Rozmiar : | 3.0 MB |
| Rozszerzenie: |
David Beazley - Programowanie. Python.pdf
dareks_ 
EBooki Infornatyka
Komentarze i opinie (1)
Transkrypt ( 25 z dostępnych 396 stron)
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 rm@rm.com.pl 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ściWstę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.uchica- go.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 znacze- nie 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 programowa- nia 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- mann@ieee.org.
* 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 wy- dania*, 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 trak- cie 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 na- zwiska 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: Stephanie.Wall@newriders.com 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 programo- wania. 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 systemo- wym (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 dokumen- tacji, 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 stop- niu 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 wyda- nia* tej książki, w którym należało uwzględnić nowe cechy wersji 2.1 oraz dodat- kowe 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 opar- ta 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 bar- dziej 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____________________________________________________________________________P yfan 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 ta- kich narzędziach, jak Tkinter czy XML, ani o rozszerzeniach COM, gdyż są to te- maty 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 stano- wi 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 kwadrato- we 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, funk- qe 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 kompute- rach 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ąć dwu- krotnie właściwą ikonę na Pulpicie). Po wystartowaniu interpretera na ekranie pojawia się znak zgłoszenia umożliwiający wpisywanie programów wykonywa- nych na bieżąco w prostej pętli czytającej. Zamieszczony niżej przykład przedsta- wia 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 information. >» 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 po- kazany 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ć pro- gram napisany w Pythonie w dokument automatycznie uruchamiający interpre- ter 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 interak- cyjnym 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 zmien- nych 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 instruk- cji przypisania: kapitał = kapitał*(1+stopa) Instrukcja ta oblicza wartość wyrażenia arytmetycznego i zapamiętuje ją ponow- nie 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 przypad- ku 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 li- nii 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 da-
nych 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 boolow-
skie:
if b >= a and b <= c:
print "b należy do przedziału
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
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 za- daniem 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 elemen- ty 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ą od- powiednio 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 indeksowa- niem, 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 whi- le. Innym sposobem utworzenia pętli jest użycie instrukqi for, która dokonuje itera- cji 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 argumen- ty 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 kon- strukqi: 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 pro- gramowaniu 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 po- przedzonych 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 po-
jawia się komunikat w rodzaju:
Traceback (most recent call last):
File "
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 ste- rowania", 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 po- staci 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 pli- ku 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, wy- starczy użyć jako prefiksu nazwy modułu. W ostatnim przykładzie stosowny za- pis miał postać dziel. podziel (). Jeśli chcesz dokonać importu modułu pod zmienioną nazwą, musisz użyć w in- strukcji 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ż po- zwala 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', 'capitalize',~ 'capwords', 'center1 , 'count1 , '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 konty- nuacji. Wcięcia służą do wydzielania różnych bloków kodu, takich jak treść funkcji, wa- runku, pętli czy klasy. Wielkość wcięcia zastosowana w pierwszej instrukcji blo- ku 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 in- strukcji, można próbować umieścić ją w jednej linii. Na przykład: if a: instrukcjal else: instrukcja2
Gość • 4 lata temu
DEMO!!!