Przedmiotem aukcji jest:

Python. Od podstaw

• Poznaj elementy języka
• Zaprojektuj interfejsy użytkownika
• Stwórz własne aplikacje sieciowe

• 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.

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)
  • 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)
  • 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)

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)
  
• Łą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)

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)

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)
• 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)

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)

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)

Zobacz nasze pozostałe aukcje

Dodaj nas do ulubionych sprzedawców

Zapraszamy serdecznie.