Dołącz do społeczności programistów Pythona!
Poznaj elementy języka
Zaprojektuj interfejsy użytkownika
Stwórz własne aplikacje sieciowe
Python to jeden z najszybciej rozwijających się języków programowania. Jest dostępny na licencji open source i posiada elastyczną, czytelną składnię. Jego możliwości pozwalają programistom na tworzenie aplikacji sieciowych, komunikację z bazami danych i zarządzanie systemami operacyjnymi. Python jest językiem wieloplatformowym, dzięki czemu napisane w nim programy można uruchamiać w różnych środowiskach i pod kontrolą różnych systemów operacyjnych. Ogromne możliwości tego języka zainspirowały duże grono entuzjastów aktywnie dzielących się wiedzą na jego temat na różnego rodzaju forach i listach dyskusyjnych. Gwarantuje to, że żadne zadane im pytanie dotyczące Pythona nie pozostanie bez odpowiedzi.
Książka 'Python. Od podstaw' to podręcznik dla tych, którzy chcą opanować ten język i tworzyć w nim własne aplikacje. Dzięki niej poznasz wszystkie elementy Pythona i dowiesz się, na czym polega programowanie obiektowe. Nauczysz się przetwarzać dane tekstowe i liczbowe, tworzyć graficzne interfejsy użytkownika za pomocą GTK oraz łączyć aplikacje z bazami danych. Poznasz zasady korzystania z plików XML, pisania aplikacji internetowych i integrowania Pythona z usługami sieciowymi oraz innymi językami programowania.
Oto niektóre z zagadnień poruszanych w tej książce:
operacje na liczbach i ciągach znaków,
konstrukcje sterujące,
funkcje i moduły,
programowanie obiektowe,
operacje na plikach i folderach,
połączenia z bazami danych,
przetwarzanie plików XML,
obsługa serwerów pocztowych,
tworzenie własnych rozszerzeń w języku C,
aplikacje biznesowe,
usługi sieciowe,
integracja Pythona i Javy.
Darmowy fragment publikacji:
IDZ DO
IDZ DO
PRZYK£ADOWY ROZDZIA£
PRZYK£ADOWY ROZDZIA£
SPIS TREœCI
SPIS TREœCI
KATALOG KSI¥¯EK
KATALOG KSI¥¯EK
KATALOG ONLINE
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
TWÓJ KOSZYK
DODAJ DO KOSZYKA
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ZAMÓW INFORMACJE
O NOWOœCIACH
O NOWOœCIACH
ZAMÓW CENNIK
ZAMÓW CENNIK
CZYTELNIA
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
Python. Od podstaw
Autor: Zespó³ autorów
T³umaczenie: Rafa³ Joñca
ISBN: 83-246-0528-2
Tytu³ orygina³u: Beginning Python
Format: B5, stron: 704
Do³¹cz do spo³ecznoœci programistów Pythona!
(cid:129) Poznaj elementy jêzyka
(cid:129) Zaprojektuj interfejsy u¿ytkownika
(cid:129) Stwórz w³asne aplikacje sieciowe
Python to jeden z najszybciej rozwijaj¹cych siê jêzyków programowania.
Jest dostêpny na licencji open source i posiada elastyczn¹, czyteln¹ sk³adniê.
Jego mo¿liwoœci pozwalaj¹ programistom na tworzenie aplikacji sieciowych,
komunikacjê z bazami danych i zarz¹dzanie systemami operacyjnymi.
Python jest jêzykiem wieloplatformowym, dziêki czemu napisane w nim programy
mo¿na uruchamiaæ w ró¿nych œrodowiskach i pod kontrol¹ ró¿nych systemów
operacyjnych. Ogromne mo¿liwoœci tego jêzyka zainspirowa³y du¿e grono entuzjastów
aktywnie dziel¹cych siê wiedz¹ na jego temat na ró¿nego rodzaju forach i listach
dyskusyjnych. Gwarantuje to, ¿e ¿adne zadane im pytanie dotycz¹ce Pythona nie
pozostanie bez odpowiedzi.
Ksi¹¿ka „Python. Od podstaw” to podrêcznik dla tych, którzy chc¹ opanowaæ ten jêzyk
i tworzyæ w nim w³asne aplikacje. Dziêki niej poznasz wszystkie elementy Pythona
i dowiesz siê, na czym polega programowanie obiektowe. Nauczysz siê przetwarzaæ
dane tekstowe i liczbowe, tworzyæ graficzne interfejsy u¿ytkownika za pomoc¹ GTK
oraz ³¹czyæ aplikacje z bazami danych. Poznasz zasady korzystania z plików XML,
pisania aplikacji internetowych i integrowania Pythona z us³ugami sieciowymi oraz
innymi jêzykami programowania.
Oto niektóre z zagadnieñ poruszanych w tej ksi¹¿ce:
(cid:129) operacje na liczbach i ci¹gach znaków,
(cid:129) konstrukcje steruj¹ce,
(cid:129) funkcje i modu³y,
(cid:129) programowanie obiektowe,
(cid:129) operacje na plikach i folderach,
(cid:129) po³¹czenia z bazami danych,
(cid:129) przetwarzanie plików XML,
(cid:129) obs³uga serwerów pocztowych,
(cid:129) tworzenie w³asnych rozszerzeñ w jêzyku C,
(cid:129) aplikacje biznesowe,
(cid:129) us³ugi sieciowe,
(cid:129) integracja Pythona i Javy.
O autorach ..................................................................................................................................................15
Wprowadzenie ...........................................................................................................................................17
Rozdział 1. Podstawy programowania i ciągi znaków ........................................................................... 25
Czym różni się programowanie od używania komputera? ................................................. 25
Programowanie to spójność ..................................................................................... 26
Programowanie to sterowanie .................................................................................. 26
Programowanie podąża za zmianami ........................................................................ 27
Co to wszystko oznacza? ......................................................................................... 27
Pierwsze kroki ............................................................................................................. 27
Uruchamianie edytora codeEditor ............................................................................. 28
Wykorzystywanie powłoki Pythona w edytorze codeEditor ............................................ 28
Zaczynamy korzystać z Pythona — ciągi znaków ............................................................. 29
Czym jest ciąg znaków? ........................................................................................... 30
Dlaczego cudzysłowy? ............................................................................................. 30
Stosowanie apostrofów i cudzysłowów ...................................................................... 31
Łączenie dwóch ciągów znaków ..................................................................................... 32
Złączanie ciągów znaków na różne sposoby ................................................................... 33
Wyświetlanie tekstów za pomocą instrukcji print ............................................................. 34
Podsumowanie ............................................................................................................ 35
Ćwiczenia .................................................................................................................... 36
Rozdział 2. Liczby i operatory .................................................................................................................. 37
Różne rodzaje liczb ...................................................................................................... 37
Liczby w Pythonie .................................................................................................... 38
Pliki programów ........................................................................................................... 40
Korzystanie z różnych typów ..................................................................................... 41
Podstawowe działania matematyczne ....................................................................... 43
Kilka niespodzianek ................................................................................................ 45
Wykorzystywanie obliczeń matematycznych .................................................................... 45
Kolejność wykonywania działań ................................................................................ 45
Formaty liczb .......................................................................................................... 46
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
5
6
Python. Od podstaw
Błędy się zdarzają ................................................................................................... 47
Pewne nietypowe rozwiązania .................................................................................. 48
Podsumowanie ............................................................................................................ 49
Ćwiczenia .................................................................................................................... 50
Rozdział 3. Zmienne — nazwy dla wartości ............................................................................................51
Przechowywanie danych — wykorzystywanie nazw ........................................................... 51
Zmiana danych za pomocą nazwy zmiennej ............................................................... 52
Kopiowanie danych ................................................................................................. 53
Nazwy, których nie można używać, i kilka zasad ........................................................ 53
Kolejne wbudowane typy danych ................................................................................... 54
Krotki — niezmienne sekwencje danych ................................................................... 54
Listy — modyfikowalne sekwencje danych ................................................................ 57
Słowniki — grupowanie danych z indeksacją na podstawie nazw ................................ 59
Traktowanie ciągu znaków jak listy ........................................................................... 61
Typy specjalne ........................................................................................................ 62
Inne typowe właściwości sekwencji ................................................................................ 63
Dostęp do ostatniego elementu ............................................................................... 63
Zakresy sekwencji .................................................................................................. 63
Rozszerzanie list przez dodawanie kolejnych elementów ............................................ 64
Wykorzystywanie list do tymczasowego przechowywania danych ................................. 65
Podsumowanie ............................................................................................................ 66
Ćwiczenia .................................................................................................................... 66
Rozdział 4. Podejmowanie decyzji ........................................................................................................... 69
Porównywanie wartości — czy są takie same? ............................................................... 69
Operacja przeciwna — nierówność ................................................................................ 71
Porównywanie wartości — która jest większa? ............................................................... 71
Większy lub równy, mniejszy lub równy ...................................................................... 73
Negacja prawdy lub fałszu ............................................................................................ 73
Poszukiwanie wyniku więcej niż jednego porównania ....................................................... 74
Podejmowanie decyzji ............................................................................................. 75
Powtarzanie ................................................................................................................. 77
Jak wykonywać coś raz za razem? ............................................................................ 77
Zatrzymywanie pętli ................................................................................................. 79
Obsługa błędów ........................................................................................................... 81
Wypróbowywanie kodu ............................................................................................ 82
Podsumowanie ............................................................................................................ 84
Ćwiczenia .................................................................................................................... 85
Rozdział 5. Funkcje ................................................................................................................................... 87
Umieszczanie programu w osobnym pliku ...................................................................... 87
Funkcje — grupowanie kodu pod konkretną nazwą ......................................................... 89
Dobór nazwy ........................................................................................................... 90
Opisywanie funkcji w jej wnętrzu ............................................................................... 91
Ta sama nazwa w dwóch różnych miejscach ............................................................. 92
Pozostawianie notatek samemu sobie ...................................................................... 93
Przekazywanie wartości do funkcji ............................................................................ 94
Sprawdzanie parametrów ........................................................................................ 96
Ustawianie wartości domyślnej parametru ................................................................ 98
6
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
Spis treści
7
Wywoływanie funkcji wewnątrz innych funkcji ............................................................. 99
Funkcje wewnątrz funkcji ....................................................................................... 101
Zgłaszanie własnych błędów .................................................................................. 102
Warstwy funkcji .......................................................................................................... 103
Sposób analizy błędów w zagnieżdżonych funkcjach ................................................. 103
Podsumowanie .......................................................................................................... 104
Ćwiczenia .................................................................................................................. 105
Rozdział 6. Klasy i obiekty .......................................................................................................................107
Podejścia do programowania ...................................................................................... 107
Pojęcie obiektu jest powszechnie znane ................................................................. 107
W jaki sposób korzystać z obiektów? ...................................................................... 109
Definiowanie klasy ..................................................................................................... 109
W jaki sposób wykonać obiekt? ............................................................................. 110
Obiekty i ich zasięg ............................................................................................... 117
Podsumowanie .......................................................................................................... 120
Ćwiczenia .................................................................................................................. 122
Rozdział 7. Organizacja programów .....................................................................................................123
Moduły ...................................................................................................................... 124
Importowanie modułów, z których chce się skorzystać ............................................. 124
Tworzenie modułu na podstawie istniejącego kodu .................................................. 125
Korzystanie z modułów — zaczynamy od wiersza poleceń ........................................ 127
Zmiana sposobu działania importu ......................................................................... 129
Pakiety ...................................................................................................................... 129
Moduły i pakiety ......................................................................................................... 131
Przeniesienie wszystkiego do aktualnego zasięgu .................................................... 131
Ponowny import modułów i pakietów ...................................................................... 132
Podstawy testowania modułów i pakietów .................................................................... 134
Podsumowanie .......................................................................................................... 135
Ćwiczenia .................................................................................................................. 136
Rozdział 8. Pliki i foldery .........................................................................................................................137
Obiekty file ................................................................................................................ 137
Zapis plików tekstowych ........................................................................................ 138
Odczyt plików tekstowych ...................................................................................... 139
Wyjątki dotyczące plików ....................................................................................... 141
Ścieżki i foldery ......................................................................................................... 142
Ścieżki ................................................................................................................. 142
Zawartość folderu ................................................................................................. 145
Uzyskiwanie informacji o plikach ............................................................................ 146
Rekurencyjne wyświetlanie folderów ....................................................................... 146
Zmiana nazwy, przenoszenie, kopiowanie i usuwanie plików ..................................... 148
Przykład — rotacja plików ...................................................................................... 148
Tworzenie i usuwanie folderów ............................................................................... 150
Globbing .............................................................................................................. 150
Serializacja ................................................................................................................ 152
Wskazówki dotyczące serializacji ............................................................................ 153
Wydajna serializacja .............................................................................................. 154
Podsumowanie .......................................................................................................... 154
Ćwiczenia .................................................................................................................. 155
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
7
8
Python. Od podstaw
Rozdział 9. Inne elementy języka Python ...............................................................................................157
Lambda i filtry — krótkie funkcje anonimowe ............................................................... 157
Funkcja reduce .......................................................................................................... 158
Funkcja map — krótsza wersja pętli ............................................................................ 159
Decyzje wewnątrz list — listy składane ........................................................................ 160
Generowanie list dla pętli ........................................................................................... 161
Zastępowanie ciągów znaków wartościami ze słowników ............................................... 163
Przydatne modułu ...................................................................................................... 165
Getopt — pobieranie opcji z wiersza poleceń .......................................................... 165
Wykorzystywanie więcej niż jednego procesu ........................................................... 167
Wątki — wiele zadań wykonywanych przez jeden proces .......................................... 169
Przechowywanie haseł ........................................................................................... 171
Podsumowanie .......................................................................................................... 172
Ćwiczenia .................................................................................................................. 173
Rozdział 10. Tworzenie modułu ...............................................................................................................175
Szczegóły działania modułów ...................................................................................... 175
Importowanie modułów ......................................................................................... 177
Znajdowanie modułu ............................................................................................. 177
Analiza istniejącego modułu .................................................................................. 178
Tworzenie modułów i pakietów .................................................................................... 181
Stosowanie klas ........................................................................................................ 182
Elementy programowania obiektowego ................................................................... 183
Tworzenie klas ...................................................................................................... 183
Rozszerzanie istniejących klas ............................................................................... 185
Wykonywanie pozostałych zadań związanych z modułami ............................................... 186
Definiowanie błędów specyficznych dla modułu ....................................................... 186
Określanie eksportowanych informacji .................................................................... 187
Dokumentowanie modułu ...................................................................................... 188
Testowanie modułu ............................................................................................... 194
Uruchamianie modułu jako programu ..................................................................... 195
Tworzenie pełnego modułu .......................................................................................... 196
Jak to działa? ....................................................................................................... 199
Instalacja własnych modułów ...................................................................................... 202
Podsumowanie .......................................................................................................... 205
Ćwiczenia .................................................................................................................. 206
Rozdział 11. Przetwarzanie tekstu ........................................................................................................207
Dlaczego przetwarzanie tekstów jest tak istotne? ......................................................... 207
Wyszukiwanie plików ............................................................................................. 208
Analiza dzienników ................................................................................................ 209
Przeszukiwanie poczty ........................................................................................... 210
Poruszanie się po systemie plików za pomocą modułu os ............................................. 210
Wyrażenia regularne i moduł re ................................................................................... 216
Podsumowanie .......................................................................................................... 219
Ćwiczenia .................................................................................................................. 220
Rozdział 12. Testy .....................................................................................................................................221
Asercje ..................................................................................................................... 222
Przypadki testowe i zestawy testowe ........................................................................... 223
Osprzęt testowy ......................................................................................................... 227
8
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
Spis treści
9
Łączymy wszystko, wykorzystując metodologię XP ......................................................... 230
Implementacja w Pythonie narzędzia wyszukiwania .................................................. 231
Bardziej zaawansowany skrypt wyszukujący ............................................................. 236
Testy formalne w cyklu życia oprogramowania .............................................................. 238
Podsumowanie .......................................................................................................... 239
Rozdział 13. Tworzenie graficznych interfejsów użytkownika ...........................................................241
Środowiska do tworzenia graficznych interfejsów dostępne w Pythonie ........................... 241
Wprowadzenie do pyGTK ............................................................................................. 243
Zasoby dotyczące pyGTK ............................................................................................ 243
Tworzenie interfejsów graficznych za pomocą pyGTK ..................................................... 245
Sygnały GUI .......................................................................................................... 247
Wątki pomocnicze GUI i kolejka zdarzeń GUI ........................................................... 248
Pakowanie widgetów ............................................................................................. 254
Glade — tworzenie interfejsów graficznych dla pyGTK .............................................. 255
Systemy budowania GUI dla innych szkieletów interfejsów graficznych ...................... 256
Wykorzystywanie libglade w Pythonie ........................................................................... 256
Krótki przewodnik po Glade ......................................................................................... 257
Uruchamianie Glade .............................................................................................. 257
Tworzenie projektu ................................................................................................ 259
Wykorzystywanie palety do utworzenia okna ............................................................ 259
Umieszczanie widgetów w oknie ............................................................................. 260
Glade tworzy plik XML opisujący interfejs graficzny .................................................. 261
Tworzenie rozbudowanej aplikacji z wykorzystaniem Glade ............................................. 263
Zaawansowane widgety .............................................................................................. 269
Dalsza rozbudowa PyRAP ............................................................................................ 272
Podsumowanie .......................................................................................................... 278
Ćwiczenia .................................................................................................................. 279
Rozdział 14. Dostęp do baz danych ..........................................................................................................281
Korzystanie z trwałych słowników DBM ........................................................................ 282
Wybór modułu DBM .............................................................................................. 282
Tworzenie trwałego słownika .................................................................................. 283
Dostęp do danych trwałego słownika ...................................................................... 285
Kiedy stosować trwały słownik, a kiedy relacyjną bazę danych? ................................ 287
Korzystanie z relacyjnych baz danych ........................................................................... 288
Instrukcje SQL ...................................................................................................... 289
Definicje tabel ...................................................................................................... 291
Tworzenie bazy danych .......................................................................................... 292
Stosowanie interfejsu programistycznego baz danych ................................................... 294
Pobieranie modułów .............................................................................................. 295
Tworzenie połączeń ............................................................................................... 296
Korzystanie z kursorów .......................................................................................... 296
Transakcje — zatwierdzanie i wycofywanie zmian .................................................... 304
Sprawdzanie możliwości modułu oraz metadane ..................................................... 304
Obsługa błędów .................................................................................................... 305
Podsumowanie .......................................................................................................... 306
Ćwiczenia .................................................................................................................. 306
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
9
10
Python. Od podstaw
Rozdział 15. Python i XML .......................................................................................................................309
Czym jest XML? ......................................................................................................... 309
Hierarchiczny język znaczników .............................................................................. 309
Rodzina standardów .............................................................................................. 311
Czym jest Schema i DTD? ........................................................................................... 312
Do czego używa się modelu dokumentów? .............................................................. 312
Czy model dokumentu jest potrzebny? .................................................................... 312
Dokument DTD .......................................................................................................... 312
Przykład DTD ........................................................................................................ 313
DTD to nie XML .................................................................................................... 314
Ograniczenia DTD ................................................................................................. 314
Dokument Schema .................................................................................................... 314
Przykład dokumentu Schema ................................................................................. 315
Schema to standardowy dokument XML ................................................................. 315
Schema jest hierarchiczny ..................................................................................... 315
Inne zalety Schema ............................................................................................... 316
Schema jest znacznie rzadziej obsługiwany ............................................................. 316
XPath ........................................................................................................................ 316
HTML jako podzbiór języka XML ................................................................................... 317
Modele DTD dla języka HTML ................................................................................. 317
Moduł i klasa HTMLParser ..................................................................................... 317
Moduł htmllib ....................................................................................................... 318
Biblioteki XML dostępne w Pythonie ............................................................................ 319
Walidacja dokumentu XML w Pythonie ......................................................................... 320
Czym jest walidacja? ............................................................................................. 320
Poprawność formatu a walidacja ............................................................................ 320
Dostępne narzędzia .............................................................................................. 321
Czym jest SAX? .......................................................................................................... 322
Bazujący na strumieniu ......................................................................................... 323
Sterowany zdarzeniami .......................................................................................... 323
Czym jest DOM? ........................................................................................................ 323
Dostęp bezpośrednio z pamięci operacyjnej ............................................................ 323
SAX czy DOM? ........................................................................................................... 324
Możliwości ........................................................................................................... 324
Wymagania pamięciowe ........................................................................................ 324
Szybkość działania ................................................................................................ 324
Analizatory SAX i DOM dostępne w Pythonie ................................................................. 325
Pakiet PyXML ....................................................................................................... 325
Pakiet xml.sax ...................................................................................................... 325
Pakiet xml.dom.minidom ....................................................................................... 325
Wprowadzenie do XSTL ............................................................................................... 328
XSTL to XML ......................................................................................................... 328
Język formatowania i przekształceń ........................................................................ 329
Funkcyjny, sterowany szablonami ........................................................................... 329
Wykorzystywanie Pythona do przekształceń XML za pomocą XSTL .................................. 329
Łączymy wszystko — kanały RSS ................................................................................ 331
Wstęp do kanałów RSS ......................................................................................... 332
Model DTD dla RSS .............................................................................................. 333
Problem z rzeczywistego świata ............................................................................. 333
Kolejny problem z rzeczywistego świata .................................................................. 336
Podsumowanie .......................................................................................................... 338
Ćwiczenia .................................................................................................................. 338
10
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
Spis treści
11
Rozdział 16. Programowanie sieciowe ...................................................................................................341
Protokoły ................................................................................................................... 343
Porównanie protokołów i języków programowania .................................................... 343
Stos protokołów internetowych .............................................................................. 344
Dodatkowe informacje na temat protokołu IP .......................................................... 346
Wysyłanie wiadomości e-mail ...................................................................................... 347
Format wiadomości e-mail ..................................................................................... 348
Wiadomości MIME ................................................................................................ 349
Wysyłanie poczty za pomocą SMTP i smtplib ........................................................... 358
Odczytywanie wiadomości e-mail ................................................................................. 360
Przetwarzanie lokalnej skrzynki pocztowej modułem mailbox .................................... 360
Pobieranie poczty z serwera POP3 za pomocą modułu poplib ................................... 361
Pobieranie poczty z serwera IMAP modułem imaplib ................................................ 364
Bezpieczne połączenia POP3 i IMAP ....................................................................... 368
Aplikacje obsługi poczty przez WWW nie są typowymi klientami poczty ...................... 369
Programowanie z wykorzystaniem gniazd ...................................................................... 369
Gniazda ............................................................................................................... 369
Dołączanie do zewnętrznych interfejsów .................................................................. 372
Serwer odwracający tekst ...................................................................................... 372
Klient dla serwera odwracającego tekst .................................................................. 374
Moduł SocketServer .............................................................................................. 375
Serwery wielowątkowe ........................................................................................... 377
Serwer pogawędek internetowych ........................................................................... 378
Projekt serwera pogawędek ................................................................................... 378
Protokół serwera pokoju pogawędek ....................................................................... 379
Klient pogawędek ................................................................................................. 384
Jednowątkowa wielozadaniowość uzyskiwana za pomocą select ............................... 386
Inne tematy ............................................................................................................... 388
Rozważania na temat projektowania protokołów ...................................................... 388
Szkielet Twisted ................................................................................................... 389
Architektura komunikacji równorzędnej ................................................................... 392
Podsumowanie .......................................................................................................... 392
Ćwiczenia .................................................................................................................. 393
Rozdział 17. Tworzenie rozszerzeń w języku C ...................................................................................395
Ogólna postać modułu rozszerzeń ............................................................................... 396
Kompilacja i instalacja modułu rozszerzenia ................................................................. 398
Przekazywanie parametrów z Pythona do C ................................................................... 400
Zwracanie wartości z C do Pythona .............................................................................. 403
Projekt LAME ............................................................................................................. 404
Moduł rozszerzenia LAME ........................................................................................... 408
Używanie obiektów Pythona z poziomu kodu języka C ....................................................... 420
Podsumowanie .......................................................................................................... 423
Ćwiczenia .................................................................................................................. 423
Rozdział 18. Pisanie programów komercyjnych i shareware ............................................................425
Analiza przypadku — tło ............................................................................................. 426
W jakim stopniu wykorzystywać Pythona? ..................................................................... 426
Licencjonowanie kodu napisanego w Pythonie .............................................................. 428
Warto skorzystać z usług internetowych .................................................................. 429
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
11
12
Python. Od podstaw
Strategia cen ............................................................................................................. 430
Znaki wodne ......................................................................................................... 430
Inne modele ......................................................................................................... 435
Sprzedaż platformy, a nie produktu ........................................................................ 436
Twoje środowisko programistyczne .............................................................................. 436
Poszukiwanie programistów języka Python .................................................................... 438
Szkolenie programistów znających inne języki niż Python .......................................... 438
Doświadczeni programiści Pythona ......................................................................... 438
Problemy z Pythonem ................................................................................................. 438
Tworzenie kodu dla innych wersji Pythona ............................................................... 439
Przejście na inny system operacyjny ....................................................................... 440
Debugowanie wątków ............................................................................................ 441
Typowe pomyłki .................................................................................................... 441
Przenośna dystrybucja ................................................................................................ 442
Istotne biblioteki ........................................................................................................ 443
Timeoutsocket ...................................................................................................... 443
PyGTK .................................................................................................................. 444
GEOip .................................................................................................................. 444
Podsumowanie .......................................................................................................... 444
Rozdział 19. Programowanie numeryczne ...........................................................................................445
Liczby w Pythonie ....................................................................................................... 446
Liczby całkowite .................................................................................................... 446
Długie liczby całkowite .......................................................................................... 447
Wartości zmiennoprzecinkowe ............................................................................... 447
Formatowanie liczb ............................................................................................... 448
Znaki jako liczby ................................................................................................... 451
Matematyka .............................................................................................................. 452
Arytmetyka ........................................................................................................... 452
Wbudowane funkcje matematyczne ........................................................................ 454
Moduł math ......................................................................................................... 455
Liczby zespolone ........................................................................................................ 456
Tablice ...................................................................................................................... 459
Moduł array .......................................................................................................... 460
Pakiet numarray ................................................................................................... 462
Podsumowanie .......................................................................................................... 465
Ćwiczenia .................................................................................................................. 465
Rozdział 20. Python w firmie .................................................................................................................467
Aplikacje biznesowe ................................................................................................... 468
Zarządzanie dokumentem ...................................................................................... 468
Ludzie skatalogowani ............................................................................................ 471
Podejmowanie akcji za pomocą diagramów przepływu .............................................. 472
Audyty, ustawy i inna cenna wiedza ............................................................................. 473
Audyty i zarządzanie dokumentami ......................................................................... 474
Korzystanie z rzeczywistych systemów biznesowych ...................................................... 475
Wprowadzenie do zestawu narzędzi wftk ................................................................. 476
Moduł python-ldap ................................................................................................ 490
Dodatkowe informacje na temat LDAP .................................................................... 494
Wracamy do wftk .................................................................................................. 495
Podsumowanie .......................................................................................................... 500
Ćwiczenia .................................................................................................................. 500
12
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
Spis treści
13
Rozdział 21. Aplikacje i usługi internetowe ............................................................................................501
REST — architektura sieci WWW ................................................................................. 502
Charakterystyka REST ........................................................................................... 502
Operacje REST ..................................................................................................... 504
HTTP — REST w realnym świecie ................................................................................ 505
Widoczny serwer WWW .......................................................................................... 506
Żądanie HTTP ....................................................................................................... 509
Odpowiedź HTTP ................................................................................................... 510
CGI — zamiana skryptu w aplikację internetową ........................................................... 511
Umowa między serwerem WWW a skryptem CGI ...................................................... 513
Specjalne zmienne środowiskowe CGI .................................................................... 514
Pobieranie danych od użytkownika przy użyciu formularzy HTML ................................ 516
Moduł cgi — przetwarzanie formularzy HTML ........................................................... 517
Tworzenie wiki ........................................................................................................... 522
Główna biblioteka BittyWiki .................................................................................... 524
Interfejs WWW dla BittyWiki ................................................................................... 527
Usługi internetowe ..................................................................................................... 536
Sposób działania usług internetowych .................................................................... 537
Usługi internetowe REST ............................................................................................ 538
Szybkie wprowadzenie do REST — znajdowanie okazji w Amazon.com ...................... 538
Znajdowanie okazji ................................................................................................ 540
Dodawanie interfejsu REST do BittyWiki .................................................................. 544
Wyszukiwanie i zastępowanie w wiki
przy użyciu usługi internetowej w systemie REST ................................................. 547
Protokół XML-RPC ...................................................................................................... 551
Krótkie wprowadzenie do XML-RPC — pobieranie wiadomości z Meerkat ................... 553
Żądanie XML-RPC ................................................................................................. 555
Odpowiedź XML-RPC ............................................................................................. 556
Gdy coś nie działa ................................................................................................ 557
Udostępnianie BittyWiki dzięki XML-RPC ................................................................. 558
Wyszukiwanie i zastępowanie korzystające z usługi XML-RPC .................................... 561
SOAP ........................................................................................................................ 563
Krótkie wprowadzenie do SOAP — interfejs Google API ............................................ 563
Żądanie SOAP ...................................................................................................... 566
Odpowiedź SOAP .................................................................................................. 567
Jeśli zdarzy się błąd .............................................................................................. 568
Udostępnianie BittyWiki za pomocą interfejsu SOAP ................................................ 569
Wyszukiwanie i zastępowanie korzystające z usługi SOAP ........................................ 571
Dokumentowanie interfejsu usługi internetowej ............................................................ 572
Dokumentacja czytelna dla ludzi ............................................................................ 573
Interfejs introspekcji XML-RPC ............................................................................... 574
WSDL .................................................................................................................. 575
Wybór standardu usług internetowych .......................................................................... 578
Etykieta usług internetowych ....................................................................................... 579
Użytkownicy usług ................................................................................................. 579
Twórcy usług ........................................................................................................ 580
Wykorzystywanie aplikacji internetowych jako usługi internetowe .............................. 580
Przykłady publicznie dostępnych usług internetowych .................................................... 581
Podsumowanie .......................................................................................................... 582
Ćwiczenia .................................................................................................................. 582
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
13
14
Python. Od podstaw
Rozdział 22. Integracja Pythona i Javy .................................................................................................583
Powody tworzenia skryptów w aplikacjach Javy ............................................................. 584
Porównanie implementacji Pythona .............................................................................. 585
Instalacja Jythona ...................................................................................................... 586
Uruchamianie Jythona ................................................................................................ 586
Uruchamianie trybu interaktywnego ........................................................................ 586
Wykonywanie skryptów w Jythonie .......................................................................... 588
Opcje sterowania skryptami ................................................................................... 589
Tworzenie poleceń wykonywalnych ......................................................................... 589
Uruchamianie Jythona bez użycia skryptu ..................................................................... 591
Pakiet aplikacji bazującej na Jythonie .......................................................................... 591
Integracja Javy i Jythona ............................................................................................. 592
Stosowanie klas Javy w Jythonie ............................................................................ 592
Dostęp do baz danych z poziomu Jythona ............................................................... 597
Tworzenie serwletów J2EE w Jythonie ..................................................................... 602
Rozszerzanie HttpServlet ............................................................................................ 605
Wybór narzędzi dla Jythona .................................................................................... 608
Testowanie z wykorzystaniem Jythona .......................................................................... 609
Osadzanie interpretera Jythona ................................................................................... 610
Wywoływanie skryptu Jythona w Javie ..................................................................... 610
Kompilacja skryptu Pythona do kodu Javy .................................................................... 612
Obsługa różnic między rozwiązaniami CPython i Jython .................................................. 613
Podsumowanie .......................................................................................................... 614
Ćwiczenia .................................................................................................................. 615
Dodatek A Odpowiedzi do ćwiczeń ..........................................................................................................617
Dodatek B Zasoby internetowe ...............................................................................................................651
Dodatek C Co nowego w Pythonie 2.4? ..................................................................................................655
Słowniczek ..............................................................................................................................................659
Skorowidz ..............................................................................................................................................669
14
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk!spis.doc
Niniejszy rozdział stanowi wprowadzenie do programowania w Pythonie. Python to bardzo
bogaty język, z wieloma funkcjami, więc warto poświęcić chwilę na naukę chodzenia, zanim
rozpocznie się bieganie. Rozdziały od 1. do 3. zawierają opis podstawowych zasad progra-
mowania przedstawiony w sposób jak najbardziej przyjazny, wraz z prostymi przykładami.
Jeśli jesteś doświadczonym programistą i chcesz jedynie poznać Pythona, możesz tylko
przejrzeć ten rozdział, zwracając baczniejszą uwagę na prezentowane przykłady. Od roz-
działu 3. zaczyna się jednak materiał, który warto przeczytać w całości, gdyż zawiera wiele
cennych informacji o nowym języku.
Jeśli jesteś programistą początkującym, pod koniec rozdziału będziesz posiadał już pewną
wiedzę na temat programowania, a także miał za sobą pierwsze interakcje z językiem pro-
gramowania — Pythonem. Ćwiczenia znajdujące się na końcu rozdziału mają za zadanie
sprawdzić i ugruntować zdobytą wiedzę.
Warto zrozumieć, że gdy się programuje, ma się kontrolę nad poczynaniami komputera. Cza-
sem nie wykonuje on od razu tego, czego się oczekiwało, niemniej po kilku próbach i mo-
dyfikacjach najczęściej zaczyna poprawnie realizować powierzone mu zadania — oczywi-
ście do momentu, gdy nie zmieni się programu.
Niestety, w komputerach osobistych pojawił się trend, który oddalił nas od niezawodności,
ponieważ nowe oprogramowanie tworzone jest na podstawie innego oprogramowania, które
nie zawsze bywa stabilne. Z tego powodu typowy użytkownik komputera odnosi czasem
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk
01.doc
25
26
Python. Od podstaw
wrażenie, że komputer jest złośliwą i cwaną bestią, która wymaga ogromnego nakładu pracy
i środków, by coś poprawnie wykonać. Jeśli też tak czujesz, wiedz, że nie jesteś sam. Gdy
ktoś nauczy się programować, zaczyna rozumieć powody takiego stanu rzeczy. Co więcej,
często zdaje sobie sprawę, że pewne zadania mógłby wykonać lepiej niż programiści piszący
oprogramowanie, z którego aktualnie korzysta.
Pamiętaj, że programowanie w języku takim jak Python, czyli w języku interpretowanym,
oznacza, że nie trzeba zawracać sobie głowy całym sprzętem, pamięcią i długimi sekwen-
cjami zer i jedynek. Wszystko zapisuje się w formie tekstowej podobnej do języka natural-
nego, choć prostszej i bardziej zhierarchizowanej. Python jest językiem, więc podobnie jak
język polski jest zrozumiały dla wszystkich osób, które go poznały. Nauka języka programo-
wania jest łatwiejsza od nauki języka naturalnego, ponieważ nie jest związana z dyskusjami,
debatami, rozmowami telefonicznymi, filmami, sztukami i innymi interakcjami. Język pro-
gramowania ma za zadanie przekazać komputerowi konkretne instrukcje i zapewnić ich po-
prawne wykonanie. Z biegiem czasu okazało się, że komputery można zastosować niemal
wszędzie tam, gdzie wcześniej podobne zadania wykonywali ludzie. Mimo to cały czas skła-
dają się z podobnych części i wykonują swe zadania w zbliżony sposób.
Programowanie to spójność
Pomimo całej złożoności różnorakich zastosowań komputerów jego podstawowa struktura
i sposób działania nie ulegały znaczącym zmianom. W zasadzie wewnętrzne mechanizmy
definiujące sposób działania komputera nie zmieniły się w znaczący sposób od lat pięćdzie-
siątych ubiegłego wieku, kiedy to do budowy komputerów zaczęto wykorzystywać tranzystory.
Dzięki tej wewnętrznej prostocie mamy pewność, że komputery mogą i powinny być wysoce
spójne. Dla programistów oznacza to mniej więcej tyle, że gdy każe się komputerowi wyko-
nać wirtualny skok, należy podać jego wysokość i miejsce lądowania, a komputer będzie wy-
konywał to zadanie dowolnie długo z identycznym rezultatem. Program nie powinien zmienić
sposobu swego działania, o ile nie wymusimy tych zmian.
Programowanie to sterowanie
Programowanie komputera znacząco różni się od tworzenia programu dla ludzi, w potocz-
nym znaczeniu tego słowa. W świecie rzeczywistym, gdy poprosi się osobę o wykonanie
pewnego zadania, czasem trzeba się nieźle natrudzić, by prośba ta została spełniona. Jeśli
na przykład planuje się przyjęcie na 30 osób i poprosi dwie z nich, by przyniosły chipsy,
może się okazać, że jedna z nich przyniesie ciasteczka lub drinki.
W świecie komputerów ten problem nie istnieje. Komputer będzie wykonywał dokładnie to
zadanie, które zostało mu powierzone. Nietrudno sobie wyobrazić, że trzeba zwrócić uwagę
na szczegóły — komputer może wykonać nasze zadanie niezależnie od jego konsekwencji.
Jednym z celów Pythona jest zapewnienie możliwości tworzenia bloków kodu, które to po-
zwalają kreować coraz większe aplikacje w sposób modułowy i jak najbardziej zrozumiały.
Stanowi to kluczowy element stylu programowania nazywanego programowaniem obiek-
towym. Główne zasady tego stylu dotyczą tworzenia godnych zaufania fragmentów, które
26
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7 druk
01.doc
Rozdział 1. n Podstawy programowania i ciągi znaków
27
działają poprawnie po złączeniu ich w jedną całość, a jednocześnie są zrozumiałe i uży-
teczne jako niezależne komponenty. Programista ma pełną kontrolę nad sposobem wyko-
nania poszczególnych części programu, ale jednocześnie ma możliwość rozszerzania jego
funkcjonalności, gdy zajdzie taka potrzeba.
Programowanie podąża za zmianami
Programy działają na komputerach borykających się z problemami świata rzeczywistego.
W tym rzeczywistym świecie plany i warunki często się zmieniają. Z racji tych zmian pro-
gramista bardzo rzadko ma okazję napisać perfekcyjnie zgrany, użyteczny i elastyczny pro-
gram. Najczęściej można osiągnąć tylko dwa z podanych celów. Zmiany, z którymi trzeba
się zmierzyć, powodują ostrożne podchodzenie do pewnych zagadnień programistycznych.
Przy odrobinie uwagi można napisać programy, które będą potrafiły stwierdzić, że zostały
poproszone o wykonanie zadania przekraczającego ich możliwości i informowały o tym użyt-
kownika. Czasem można nawet utworzyć programy, które dokładnie wskażą miejsce i przy-
czynę niepowodzenia. Python oferuje specjalne funkcje pozwalające opisać warunki, które
musiały zajść, by uniemożliwić poprawne działanie.
Co to wszystko oznacza?
Po połączeniu tych wszystkich wymienionych elementów można wysnuć następujący wnio-
sek: programowanie umożliwia poinformowanie komputera, jakie zadania ma wykonywać
przy jednoczesnej pełnej kontroli nad tym procesem. Czasem zdarzają się wypadki. Można
je często przewidzieć i zaoferować mechanizm, który pozwoli je obsłużyć w odpowiedni spo-
sób, a nawet powrócić do pracy.
Na początek warto odwiedzić witrynę wydawnictwa Helion (http://helion.pl), pobrać znaj-
dujące się tam przykłady oraz zainstalować program PythonCard. PythonCard to zbiór narzę-
dzi ułatwiających programowanie w Pythonie. Są one dostępne bezpłatnie i zostały napisane
specjalnie z myślą o tym języku. Zawierają edytor, codeEditor, z którego będziemy korzystać
w pierwszej części książki. Ma on wiele wspólnego z domyślnym edytorem dostarczanym
wraz z Pythonem (idle), ale w opinii autorów codeEditor jest lepszym narzędziem do nauki
programowania, gdyż został napisany z myślą o prostszych projektach. Co więcej, sam edytor
został napisany w Pythonie.
Programy pisze się w postaci tak zwanego kodu źródłowego. Kod źródłowy to zestaw
instrukcji w formie zgodnej z danym językiem programowania. Komputer analizuje kod
i wykonuje zawarte w nim zadania.
Tak jak autorzy mają wyspecjalizowane narzędzia do pisania tekstów dla magazynów, książek
i publikacji online, tak programiści mają własne wyspecjalizowane narzędzia. Dla początku-
jącego programisty języka Python dobrym narzędziem będzie codeEditor.
D:Roboczy!!!!makiety poprawki druk pdfPython_Od_podstaw 7
Pobierz darmowy fragment (pdf)