Zespół autorów python. od podstaw pełna wersja.mobi

(4216 KB) Pobierz
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
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
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
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

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin