• Jak w kilka minut założyć blog?
• Jak bez wysiłku tworzyć zaawansowane aplikacje?
• Jak budować modele i używać ich?

Django to stworzony w Pythonie, prosty i nowoczesny framework typu open source. Umożliwia on budowanie funkcjonalnych aplikacji webowych bez potrzeby pisania setek wierszy kodu. Został zaprojektowany w ten sposób, aby doskonale działać jako zwarta całość, ale jego składniki są ze sobą na tyle luźno powiązane, że z łatwością można dokonywać zmian, dodawać i aktualizować funkcjonalności. Ten podręcznik pomoże Ci szybko i efektywnie wykorzystać Django w praktyce.

Książka "Python i Django. Programowanie aplikacji webowych" zawiera opisy podstawowych i bardziej zaawansowanych elementów tego frameworka, a także wiele przykładowych aplikacji, wspartych szczegółowymi wyjaśnieniami dotyczącymi ich budowy. Dzięki temu podręcznikowi dowiesz się, jak wykorzystać elastyczność i szybkość tworzenia aplikacji w Pythonie w celu rozwiązania typowych problemów, które możesz napotkać podczas swojej pracy. Nauczysz się tworzyć formularze, skrypty, własny system zarządzania treścią oraz aplikacje Django zaledwie w kilka minut, a dzięki gotowym projektom poznasz także tajniki zaawansowanego projektowania.

• Python dla Django
• Instrukcje warunkowe
• Funkcje i definicje klas
• Programowanie zorientowane obiektowo
• Tworzenie bloga
• Dynamiczne strony internetowe
• Django -- tworzenie i używanie modeli
• URL, obsługa http i widoki
• Szablony i przetwarzanie formularzy
• System zarządzania treścią
• Liveblog
• Zaawansowane programowanie
• Testowanie aplikacji

Osoby które kupowały "Python i Django. Programowanie aplikacji webowych", wybierały także:

• Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
• Zen Steve'a Jobsa 29,67 zł, (8,90 zł -70%)
• ASP.NET MVC. Kompletny przewodnik dla programistów interaktywnych aplikacji internetowych w Visual Studio 86,77 zł, (26,90 zł -69%)
• TDD. Sztuka tworzenia dobrego kodu 48,54 zł, (19,90 zł -59%)
• GitHub. Przyjazny przewodnik 32,90 zł, (16,45 zł -50%)

Spis treści

Python i Django. Programowanie aplikacji webowych -- spis treści

Przedmowa (13)

Podziękowania (19)

O autorach (21)

Wprowadzenie (23)

Część I: Zaczynamy! (27)

Rozdział 1. Python dla Django (29)

• Umiejętności w Pythonie to umiejętności w Django (29)
• Zaczynamy. Interaktywny interpreter Pythona (30)
• Podstawy Pythona (32)
  • Komentarze (32)
  • Zmienne i przypisania (33)
  • Operatory (33)
• Standardowe typy Pythona (34)
  • Logiczne wartości obiektów (34)
  • Liczby (35)
  • Operatory arytmetyczne (36)
  • Wbudowane typy liczbowe i funkcje fabryczne (36)
  • Sekwencje i elementy iterowalne (37)
  • Listy (40)
  • Łańcuchy znaków (42)
  • Sekwencyjne funkcje wbudowane i fabryczne (48)
  • Typ odwzorowań - słownik (49)
  • Podsumowanie typów standardowych (52)
• Kontrola przepływu (52)
  • Instrukcje warunkowe (52)
  • Pętle (52)
• Obsługa wyjątków (54)
  • Klauzula finally (55)
  • Rzucanie wyjątkami z wykorzystaniem raise (55)
• Pliki (56)
• Funkcje (57)
  • Deklarowanie i wywoływanie funkcji (58)
  • Funkcje są obiektami pierwszej klasy (60)
  • Funkcje anonimowe (61)
  • *args i **kwargs (63)
• Programowanie zorientowane obiektowo (67)
  • Definicje klas (68)
  • Tworzenie egzemplarzy klas (68)
  • Klasy pochodne (69)
  • Klasy wewnętrzne (70)
• Wyrażenia regularne (70)
  • Moduł re (71)
  • Wyszukiwanie vs. dopasowywanie (72)
• Typowe pułapki (72)
  • Jednoelementowa krotka (72)
  • Moduły (72)
  • Zmienność (modyfikowalność) (74)
  • Konstruktor vs. inicjalizator (76)
• Styl pisania kodu (PEP 8 i Beyond) (77)
  • Wcięcia - tylko z czterech spacji (78)
  • Korzystaj ze spacji, a nie tabulacji (78)
  • Nie nadużywaj "jednolinijkowców" (78)
  • Twórz łańcuchy dokumentacji (78)
• Podsumowanie (80)

Rozdział 2. Django dla niecierpliwych - tworzymy blog (81)

• Tworzenie projektu (82)
• Uruchamianie serwera (84)
• Tworzenie bloga (85)
• Projektowanie modelu (86)
• Konfiguracja bazy danych (87)
  • Wykorzystywanie serwerów baz danych (87)
  • SQLite w praktyce (88)
  • Tworzenie tabel (89)
• Konfiguracja automatycznej aplikacji administratora (90)
• Testowanie panelu administracyjnego (91)
• Upublicznianie bloga (95)
  • Tworzenie szablonu (96)
  • Tworzenie funkcji widoku (97)
  • Tworzenie wzorca URL (98)
• Końcowe poprawki (99)
  • (Nie)szablonowe rozwiązania (99)
  • Sortowanie i porządkowanie wpisów (100)
  • Formatowanie znacznika czasu przy użyciu filtra szablonów (101)
• Podsumowanie (102)

Rozdział 3. Na dobry początek (103)

• Podstawy dynamicznych stron internetowych (103)
  • Komunikacja - HTTP, URL, żądania i odpowiedzi (104)
  • Przechowywanie danych - SQL i relacyjne bazy danych (104)
  • Warstwa prezentacji - tworzenie dokumentów na podstawie szablonów (105)
  • Łączenie elementów układanki (105)
• Modele, widoki i szablony (106)
  • Separacja warstw (MVC) (106)
  • Modele danych (107)
  • Widoki (107)
  • Szablony (108)
• Architektura Django - ogólne spojrzenie (108)
• Filozofia programowania w Django (110)
  • Django ma być pythoniczne (110)
  • Nie powtarzaj się (DRY)! (111)
  • Luźne powiązania i elastyczność (111)
  • Błyskawiczne programowanie (112)
• Podsumowanie (112)

Część II: Django w szczegółach (113)

Rozdział 4. Tworzenie i używanie modeli (115)

• Tworzenie modeli (115)
  • Dlaczego ORM? (115)
  • Typy pól w Django (117)
  • Relacje pomiędzy modelami (119)
  • Dziedziczenie modeli (123)
  • Wewnętrzna klasa Meta (127)
  • Rejestracja i opcje w panelu administratora (128)
• Wykorzystywanie modeli (129)
  • Tworzenie i modyfikowanie bazy danych za pomocą manage.py (129)
  • Składnia zapytań (131)
  • Wykorzystywanie funkcji SQL niedostępnych w Django (139)
• Podsumowanie (142)

Rozdział 5. URL, obsługa HTTP i widoki (145)

• Adresy URL (145)
  • Wprowadzenie do plików URLconf (145)
  • url - metoda zamiast krotek (147)
  • Wykorzystywanie wielu obiektów patterns (148)
  • Dołączanie plików URL przy użyciu funkcji include (148)
  • Obiekty funkcji vs. łańcuchy zawierające nazwy funkcji (149)
• HTTP w praktyce - żądania, odpowiedzi i warstwa pośrednicząca (150)
  • Obiekty żądań (151)
  • Obiekty odpowiedzi (154)
  • Warstwa pośrednicząca (154)
• Widoki - logika aplikacji (156)
  • To tylko funkcje (156)
  • Widoki generyczne (157)
  • Widoki półgeneryczne (159)
  • Widoki własne (160)
• Podsumowanie (162)

Rozdział 6. Szablony i przetwarzanie formularzy (163)

• Szablony (163)
  • Konteksty (164)
  • Składnia języka szablonów (164)
• Formularze (170)
  • Tworzenie formularzy (170)
  • Wypełnianie formularzy (175)
  • Walidacja i czyszczenie (177)
  • Wyświetlanie formularzy (178)
  • Widgety (180)
• Podsumowanie (182)

Część III: Przykładowe aplikacje Django (183)

Rozdział 7. Galeria zdjęć (185)

• Model danych (186)
• Wysyłanie plików (187)
• Instalacja PIL (188)
• Testowanie pola ImageField (189)
• Tworzenie własnego pola do wysyłania plików (190)
  • Inicjalizacja (192)
  • Dodawanie atrybutów do pola (194)
  • Zapisywanie i usuwanie miniatury (195)
• Wykorzystujemy pole ThumbnailImageField (196)
• Adresy URL zgodne z regułą DRY (196)
• Schematy adresów URL w aplikacji Item (199)
• Wiązanie aplikacji z szablonami (201)
• Podsumowanie (205)

Rozdział 8. System zarządzania treścią (207)

• CMS - z czym to się je? (207)
• Anty-CMS - strony płaskie (208)
  • Włączanie aplikacji Flatpages (208)
  • Szablony stron płaskich (210)
  • Testowanie (211)
• CMS - prosty, ale własny! (211)
  • Tworzenie modelu (212)
  • Instrukcje importujące (214)
  • Uzupełnianie modeli (214)
  • Kontrola widoczności artykułów (215)
  • Wykorzystujemy Markdown (216)
  • Wzorce URL w pliku urls.py (218)
  • Widoki administratora (219)
  • Wyświetlanie treści przy użyciu widoków generycznych (221)
  • Układ szablonów (223)
  • Wyświetlanie artykułów (224)
  • Dodajemy funkcję wyszukiwania (226)
  • Zarządzanie użytkownikami (228)
  • Wspieranie przepływu pracy (229)
• Poszerzanie możliwości systemu (229)
• Podsumowanie (231)

Rozdział 9. Liveblog (233)

• Czym tak naprawdę jest Ajax? (234)
  • Dlaczego Ajax? (234)
• Projekt aplikacji (235)
  • Wybieramy bibliotekę Ajaksa (235)
• Przygotowywanie aplikacji (236)
• Dodajemy kod Ajaksa (240)
  • Podstawy (240)
  • "X" w Ajax (czyli XML vs. JSON) (241)
  • Instalacja biblioteki JavaScript (242)
  • Konfiguracja i testowanie jQuery (243)
  • Tworzenie funkcji widoku (244)
  • Wykorzystywanie funkcji widoku przy użyciu kodu JavaScript (246)
• Podsumowanie (247)

Rozdział 10. Schowek (249)

• Definicja modelu (250)
• Tworzenie szablonów (251)
• Obsługa adresów URL (253)
• Testowanie aplikacji (254)
• Ograniczanie liczby ostatnio dodanych wpisów (258)
• Podświetlanie składni (259)
• Czyszczenie wpisów przy użyciu zadania programu Cron (260)
• Podsumowanie (261)

Część IV: Zaawansowane funkcje i mechanizmy w Django (263)

Rozdział 11. Zaawansowane programowanie w Django (265)

• Dostosowywanie panelu administratora (265)
  • Zmiana wyglądu i stylów przy użyciu obiektu fieldsets (266)
  • Rozszerzanie bazowych szablonów (268)
  • Dodawanie nowych widoków (269)
  • Dekoratory uwierzytelniania (270)
• Wykorzystywanie aplikacji Syndication (271)
  • Klasa Feed (271)
  • Przekazywanie adresu URL do źródła (272)
  • Jeszcze więcej źródeł! (273)
• Udostępnianie plików do pobrania (273)
  • Pliki konfiguracyjne Nagios (274)
  • vCard (275)
  • Wartości rozdzielone przecinkami (CSV) (276)
  • Wykresy i grafiki - moduł PyCha (277)
• Rozszerzanie możliwości systemu ORM przy użyciu własnych menedżerów (279)
  • Zmiana domyślnego zbioru obiektów (279)
  • Dodawanie metod do menedżera (280)
• Rozszerzanie systemu szablonów (281)
  • Własne znaczniki szablonów (281)
  • Znaczniki dołączania (285)
  • Własne filtry (287)
  • Jeszcze więcej o złożonych szablonach znaczników (289)
  • Alternatywne systemy szablonów (290)
• Podsumowanie (292)

Rozdział 12. Zaawansowane wdrażanie aplikacji (293)

• Tworzenie pomocniczych skryptów (293)
  • Czyszczenie niepotrzebnych elementów przy użyciu zadań programu Cron (294)
  • Import i eksport danych (295)
• Modyfikowanie kodu Django (296)
• Buforowanie podręczne (297)
  • Podstawowy sposób buforowania (297)
  • Strategie buforowania (299)
  • Rodzaje buforowania po stronie serwera (304)
• Testowanie aplikacji w Django (307)
  • Podstawy używania Doctest (308)
  • Podstawy używania modułu Unittest (308)
  • Uruchamianie testów (309)
  • Testowanie modeli (309)
  • Testowanie całej aplikacji webowej (311)
  • Testowanie kodu Django (312)
• Podsumowanie (313)

Dodatki (315)

Dodatek A: Podstawy wiersza poleceń (317)

• Wprowadzamy "polecenie" w "wierszu poleceń" (318)
• Opcje i argumenty (320)
• Potoki i przekierowania (321)
• Zmienne środowiskowe (323)
• Ścieżka (325)
• Podsumowanie (327)

Dodatek B: Instalacja i uruchamianie Django (329)

• Python (329)
  • Mac OS X (330)
  • Unix i Linux (330)
  • Windows (330)
  • Aktualizacja ścieżki (331)
  • Testowanie (333)
  • Opcjonalne dodatki (334)
• Django (336)
  • Dostępne pakiety (336)
  • Wersja deweloperska (336)
  • Instalacja (336)
  • Testowanie (337)
• Serwer WWW (337)
  • Serwer wbudowany - nie w środowiskach produkcyjnych! (337)
  • Rozwiązanie standardowe - Apache i mod_python (338)
  • Elastyczna alternatywa - WSGI (340)
  • Podejście nr 3 - Flup i FastCGI (342)
• Baza danych SQL (342)
  • SQLite (343)
  • PostgreSQL (343)
  • MySQL (344)
  • Oracle (346)
  • Inne bazy danych (346)
• Podsumowanie (346)

Dodatek C: Narzędzia ułatwiające tworzenie aplikacji w Django (347)

• Systemy kontroli wersji (347)
  • Gałęzie główne i rozwojowe (348)
  • Scalanie (348)
  • Scentralizowana kontrola wersji (349)
  • Zdecentralizowana kontrola wersji (349)
  • Kontrola wersji w Twoim projekcie (350)
• Zarządzanie projektem programistycznym (353)
  • Trac (353)
• Edytory tekstowe (354)
  • Emacs (354)
  • Vim (354)
  • TextMate (354)
  • Eclipse (354)

Dodatek D: Wyszukiwanie i wykorzystywanie aplikacji Django (355)

• Poszukiwania gotowych aplikacji (356)
• Wykorzystywanie znalezionych aplikacji (356)
• Jak wykorzystywać aplikacje? (357)
• Udostępnianie własnych aplikacji (358)

Dodatek E: Django w Google App Engine (359)

• Siła i magia App Engine (360)
• App Engine (prawie) bez Django (360)
• Ograniczenia frameworka App Engine (361)
• Helper App Engine dla Django (361)
  • Pobieranie SDK i Helpera (361)
  • Helper - więcej informacji (362)
• Aplikacje Django w App Engine (363)
  • Kopiowanie kodu App Engine do projektu Django (363)
  • Dodawanie obsługi Helpera App Engine (363)
  • Przenoszenie aplikacji do App Engine (364)
  • Testowanie aplikacji (365)
  • Dodawanie danych (365)
• Tworzenie nowej aplikacji Django w App Engine (366)
• Podsumowanie (367)
• W sieci (368)

Dodatek F: Twój udział w projekcie Django (369)

Skorowidz (371)

Kolofon (389)