Details zum E-Book

Django. Praktyczne tworzenie aplikacji sieciowych

Django. Praktyczne tworzenie aplikacji sieciowych

Antonio Melé

E-book

Django to bardzo przydatne narzędzie ułatwiające pisanie aplikacji sieciowych w języku Python.

Jest uważane za framework, który łączy wielkie możliwości z prostotą użytkowania. Pozwala na szybkie tworzenie oprogramowania na podstawie przejrzystych i praktycznych projektów. To atrakcyjne rozwiązanie dla programistów zarówno początkujących, jak i doświadczonych.

Książka, którą trzymasz w rękach, jest znakomitym podręcznikiem pisania aplikacji sieciowych w Django. Krok po kroku pokazano tu pełny proces tworzenia profesjonalnego oprogramowania, a przykładami, na których oparto poszczególne rozdziały, są rzeczywiste projekty aplikacji. Dzięki takiemu podejściu można bardzo szybko zapoznać się z frameworkiem, nauczyć się rozwiązywania często występujących problemów i w naturalny sposób stosować najlepsze praktyki programistyczne. Autorzy pokazali również, w jaki sposób w projektach Django stosować kilka popularnych technologii związanych z aplikacjami sieciowymi.

Najważniejsze zagadnienia omówione w książce:

  • przygotowanie środowiska i wprowadzenie do frameworka,
  • tworzenie praktycznego projektu aplikacji umożliwiającego dalsze modyfikacje i rozbudowę,
  • implementacja zaawansowanych funkcjonalności aplikacji sieciowych,
  • praca z bazami danych Redis i innymi technologiami (w tym Celery, Solr i Memcached),
  • tłumaczenie aplikacji na wiele języków,
  • API typu RESTful.

Django — framework dla perfekcjonistów, którzy muszą przestrzegać terminów!

O autorze (13)

O recenzentach technicznych (14)

Wprowadzenie (17)

Rozdział 1. Utworzenie aplikacji bloga (21)

  • Instalacja Django (22)
    • Utworzenie odizolowanego środowiska Pythona (22)
    • Instalacja Django za pomocą pip (23)
  • Utworzenie pierwszego projektu (24)
    • Uruchomienie serwera programistycznego (25)
    • Ustawienia projektu (27)
    • Projekty i aplikacje (28)
    • Utworzenie aplikacji (28)
  • Projekt schematu danych dla bloga (29)
    • Aktywacja aplikacji (31)
    • Utworzenie i zastosowanie migracji (31)
  • Utworzenie witryny administracyjnej dla modeli (33)
    • Utworzenie superużytkownika (33)
    • Witryna administracyjna Django (33)
    • Dodanie modeli do witryny administracyjnej (34)
    • Zmiana sposobu wyświetlania modeli (36)
  • Praca z obiektami QuerySet i menedżerami (38)
    • Tworzenie obiektów (38)
    • Uaktualnianie obiektów (39)
    • Pobieranie obiektów (40)
    • Usunięcie obiektu (41)
    • Kiedy następuje określenie zawartości kolekcji QuerySet? (41)
    • Utworzenie menedżerów modelu (42)
  • Przygotowanie widoków listy i szczegółów (42)
    • Utworzenie widoków listy i szczegółów (43)
    • Dodanie wzorców adresów URL do widoków (44)
    • Kanoniczne adresy URL dla modeli (45)
  • Utworzenie szablonów dla widoków (46)
  • Dodanie stronicowania (49)
  • Użycie widoków opartych na klasach (51)
  • Podsumowanie (52)

Rozdział 2. Usprawnienie bloga za pomocą funkcji zaawansowanych (53)

  • Współdzielenie postów przy użyciu wiadomości e-mail (53)
    • Tworzenie formularzy w Django (54)
    • Obsługa formularzy w widokach (55)
    • Wysyłanie wiadomości e-mail w Django (57)
    • Generowanie formularza w szablonie (59)
  • Utworzenie systemu komentarzy (62)
    • Utworzenie formularza na podstawie modelu (64)
    • Obsługa klasy ModelForm w widoku (65)
    • Dodanie komentarzy do szablonu szczegółów posta (67)
  • Dodanie funkcjonalności tagów (70)
  • Pobieranie podobnych postów (75)
  • Podsumowanie (77)

Rozdział 3. Rozbudowa aplikacji bloga (79)

  • Utworzenie własnych filtrów i znaczników szablonu (79)
    • Utworzenie własnych znaczników szablonu (80)
    • Utworzenie własnych filtrów szablonu (84)
  • Dodanie mapy witryny (87)
  • Utworzenie kanału wiadomości dla postów bloga (90)
  • Implementacja silnika wyszukiwania z użyciem Solr i Haystack (92)
    • Instalacja Solr (92)
    • Utworzenie Solr core (94)
    • Instalacja Haystack (96)
    • Utworzenie indeksów (97)
    • Indeksowanie danych (99)
    • Utworzenie widoku wyszukiwania (100)
  • Podsumowanie (103)

Rozdział 4. Utworzenie witryny społecznościowej (105)

  • Utworzenie projektu witryny społecznościowej (106)
    • Rozpoczęcie pracy nad aplikacją społecznościową (106)
  • Użycie frameworka uwierzytelniania w Django (107)
    • Utworzenie widoku logowania (108)
    • Użycie widoków uwierzytelniania w Django (113)
    • Widoki logowania i wylogowania (114)
    • Widoki zmiany hasła (119)
    • Widoki zerowania hasła (121)
  • Rejestracja użytkownika i profil użytkownika (126)
    • Rejestracja użytkownika (126)
    • Rozbudowa modelu User (130)
    • Użycie frameworka komunikatów (135)
  • Implementacja własnego mechanizmu uwierzytelniania (137)
  • Dodanie do witryny uwierzytelnienia za pomocą innej witryny społecznościowej (139)
    • Uwierzytelnienie za pomocą serwisu Facebook (141)
    • Uwierzytelnienie za pomocą serwisu Twitter (143)
    • Uwierzytelnienie za pomocą serwisu Google (145)
  • Podsumowanie (148)

Rozdział 5. Udostępnianie treści w witrynie internetowej (149)

  • Utworzenie witryny internetowej do kolekcjonowania obrazów (150)
    • Utworzenie modelu Image (150)
    • Zdefiniowanie związku typu "wiele do wielu" (152)
    • Rejestracja modelu Image w witrynie administracyjnej (153)
  • Umieszczanie treści pochodzącej z innych witryn internetowych (153)
    • Usunięcie zawartości pól formularza (154)
    • Nadpisanie metody save() egzemplarza ModelForm (155)
    • Utworzenie bookmarkletu za pomocą jQuery (158)
  • Utworzenie widoku szczegółowego obrazu (165)
  • Utworzenie miniatury za pomocą sorl-thumbnail (167)
  • Dodanie akcji AJAX za pomocą jQuery (168)
    • Wczytanie jQuery (170)
    • CSRF w żądaniach AJAX (171)
    • Wykonywanie żądań AJAX za pomocą jQuery (172)
  • Utworzenie własnego dekoratora dla widoków (175)
  • Dodanie stronicowania AJAX do listy widoków (176)
  • Podsumowanie (181)

Rozdział 6. Śledzenie działań użytkownika (183)

  • Utworzenie systemu obserwacji (184)
    • Utworzenie związku typu "wiele do wielu" za pomocą modelu pośredniego (184)
    • Utworzenie widoków listy i szczegółowego dla profilu użytkownika (187)
    • Utworzenie widoku AJAX pozwalającego na obserwację użytkowników (191)
  • Budowa ogólnego strumienia aktywności aplikacji (193)
    • Użycie frameworka contenttypes (194)
    • Dodanie ogólnego związku do modelu (195)
    • Uniknięcie powielonych akcji w strumieniu aktywności (198)
    • Dodanie akcji użytkownika do strumienia aktywności (199)
    • Wyświetlanie strumienia aktywności (200)
    • Optymalizacja kolekcji QuerySet dotyczącej powiązanych obiektów (201)
    • Tworzenie szablonów dla akcji (202)
  • Użycie sygnałów dla denormalizowanych zliczeń (204)
    • Praca z sygnałami (204)
    • Definiowanie klas konfiguracyjnych aplikacji (207)
  • Użycie bazy danych Redis do przechowywania różnych elementów widoków (208)
    • Instalacja bazy danych Redis (209)
    • Użycie bazy danych Redis z Pythonem (210)
    • Przechowywanie różnych elementów widoków w bazie danych Redis (211)
    • Przechowywanie rankingu w bazie danych Redis (213)
    • Kolejne kroki z bazą danych Redis (215)
  • Podsumowanie (216)

Rozdział 7. Utworzenie sklepu internetowego (217)

  • Utworzenie projektu sklepu internetowego (218)
    • Utworzenie modeli katalogu produktów (219)
    • Rejestracja modeli katalogu w witrynie administracyjnej (221)
    • Utworzenie widoków katalogu (222)
    • Utworzenie szablonów katalogu (224)
  • Utworzenie koszyka na zakupy (228)
    • Użycie sesji Django (228)
    • Ustawienia sesji (229)
    • Wygaśnięcie sesji (230)
    • Przechowywanie koszyka na zakupy w sesji (231)
    • Utworzenie widoków koszyka na zakupy (235)
    • Utworzenie procesora kontekstu dla bieżącego koszyka na zakupy (241)
  • Rejestracja zamówienia klienta (244)
    • Utworzenie modeli zamówienia (244)
    • Dołączenie modeli zamówienia w witrynie administracyjnej (246)
    • Utworzenie zamówienia klienta (247)
  • Wykonywanie zadań asynchronicznych za pomocą Celery (251)
    • Instalacja Celery (251)
    • Instalacja RabbitMQ (251)
    • Dodanie Celery do projektu (252)
    • Dodanie zadania asynchronicznego do aplikacji (253)
    • Monitorowanie Celery (255)
  • Podsumowanie (255)

Rozdział 8. Zarządzanie płatnościami i zamówieniami (257)

  • Integracja bramki płatności (258)
    • Utworzenie konta PayPal (258)
    • Instalacja django-paypal (259)
    • Dodanie bramki płatności (260)
    • Użycie środowiska sandbox w PayPal (264)
    • Otrzymywanie powiadomień o płatnościach (267)
    • Konfiguracja aplikacji (269)
    • Przetestowanie powiadomień o dokonanej płatności (269)
  • Eksport zamówienia do pliku CSV (271)
    • Dodanie własnych akcji do witryny administracyjnej (271)
  • Rozbudowa witryny administracyjnej za pomocą własnych widoków (274)
  • Dynamiczne generowanie rachunków w formacie PDF (278)
    • Instalacja WeasyPrint (279)
    • Utworzenie szablonu PDF (279)
    • Generowanie pliku w formacie PDF (280)
    • Wysyłanie dokumentów PDF za pomocą wiadomości e-mail (283)
  • Podsumowanie (284)

Rozdział 9. Rozbudowa sklepu internetowego (285)

  • Utworzenie systemu kuponów (285)
    • Utworzenie modeli kuponu (286)
    • Zastosowanie kuponu w koszyku na zakupy (288)
    • Zastosowanie kuponu w zamówieniu (294)
  • Internacjonalizacja i lokalizacja projektu (296)
    • Internacjonalizacja za pomocą Django (296)
    • Przygotowanie projektu do internacjonalizacji (299)
    • Tłumaczenie kodu Pythona (300)
    • Tłumaczenie szablonów (305)
    • Użycie interfejsu do tłumaczeń o nazwie Rosetta (309)
    • Opcja fuzzy (312)
    • Wzorce adresów URL dla internacjonalizacji (312)
    • Umożliwienie użytkownikowi zmiany języka (315)
    • Tłumaczenie modeli za pomocą django-parler (316)
    • Format lokalizacji (326)
    • Użycie modułu django-localflavor do weryfikacji pól formularza (327)
  • Utworzenie silnika rekomendacji produktu (328)
    • Rekomendacja produktu na podstawie wcześniejszych transakcji (329)
  • Podsumowanie (336)

Rozdział 10. Budowa platformy e-learningu (337)

  • Utworzenie platformy e-learningu (338)
  • Utworzenie modeli kursu (339)
    • Rejestracja modeli w witrynie administracyjnej (341)
    • Dostarczenie danych początkowych dla modeli (341)
  • Utworzenie modeli dla zróżnicowanej treści (344)
    • Wykorzystanie dziedziczenia modelu (345)
    • Utworzenie modeli treści (347)
  • Utworzenie własnych kolumn modelu (349)
  • Utworzenie systemu zarządzania treścią (354)
    • Dodanie systemu uwierzytelniania (354)
    • Utworzenie szablonów uwierzytelniania (355)
    • Utworzenie widoków opartych na klasach (357)
    • Użycie domieszek w widokach opartych na klasach (358)
    • Praca z grupami i uprawnieniami (360)
    • Użycie zbioru formularzy (367)
    • Dodanie treści do modułów kursów (372)
    • Zarządzanie modułami i treścią (376)
    • Zmiana kolejności modułów i treści (380)
  • Podsumowanie (383)

Rozdział 11. Buforowanie treści (385)

  • Wyświetlanie kursów (385)
  • Dodanie rejestracji uczestnika (390)
    • Utworzenie widoku rejestracji uczestnika (390)
    • Zapisanie się na kurs (393)
  • Uzyskanie dostępu do treści kursu (396)
    • Generowanie różnych rodzajów treści (399)
  • Użycie frameworka buforowania (401)
    • Dostępne mechanizmy buforowania (402)
    • Instalacja Memcached (403)
    • Ustawienia bufora (403)
    • Dodanie Memcached do projektu (404)
    • Poziomy buforowania (405)
    • Użycie działającego na niskim poziomie API buforowania (405)
    • Buforowanie fragmentów szablonu (409)
    • Buforowanie widoków (410)
  • Podsumowanie (412)

Rozdział 12. Utworzenie API (413)

  • Utworzenie API typu RESTful (413)
    • Instalacja Django Rest Framework (414)
    • Definiowanie serializacji (415)
    • Poznajemy analizator składni i generatory do określonych formatów (416)
    • Utworzenie widoków listy i szczegółowego (417)
    • Serializacja zagnieżdżona (419)
    • Utworzenie własnych widoków (421)
    • Obsługa uwierzytelnienia (422)
    • Określenie uprawnień do widoków (423)
    • Utworzenie kolekcji widoku i routerów (424)
    • Dołączenie dodatkowych akcji do kolekcji widoku (425)
    • Tworzenie własnych uprawnień (426)
    • Serializacja treści kursu (427)
  • Podsumowanie (429)

Rozdział 13. Wdrożenie (431)

  • Wdrożenie w środowisku produkcyjnym (431)
    • Zarządzanie ustawieniami dla wielu środowisk (431)
    • Instalacja PostgreSQL (434)
    • Sprawdzenie projektu (435)
    • Udostępnianie Django za pomocą WSGI (436)
    • Instalacja uWSGI (436)
    • Konfiguracja uWSGI (436)
    • Instalacja Nginx (438)
    • Środowisko produkcyjne (439)
    • Konfiguracja Nginx (440)
    • Udostępnianie zasobów statycznych i multimedialnych (441)
    • Ochrona połączeń za pomocą SSL (442)
  • Utworzenie własnego oprogramowania pośredniczącego (445)
    • Utworzenie oprogramowania pośredniczącego do obsługi subdomeny (447)
    • Obsługa wielu subdomen za pomocą Nginx (448)
  • Implementacja własnych poleceń administracyjnych (448)
  • Podsumowanie (451)

Skorowidz (452)

  • Titel: Django. Praktyczne tworzenie aplikacji sieciowych
  • Autor: Antonio Melé
  • Originaler Titel: Django by Example
  • Übersetzung: Robert Górczyński
  • ISBN: 978-83-283-2588-3, 9788328325883
  • Veröffentlichungsdatum: 2016-07-07
  • Format: E-book
  • Artikelkennung: djptas
  • Verleger: Helion