Python. Instrukcje dla programisty

 
Python. Instrukcje dla programisty
Zawiera darmowych rozdziałów: 19
Stron w książce: 640 Udostępniono darmowych stron: 25
Data wydania: 2016-10-28Przejdź na stronę księgarni
Czytano online: 1Cena książki drukowanej: 89,00 zł
Język wydania: PolishWydawnictwo: Helion
Pobierz pdfCzytaj Alt+1Czytaj online
( Alt+1 )

Przekonaj się, jak szybko możesz zacząć tworzyć świetne aplikacje w Pythonie!

Python to język programowania o bardzo wszechstronnych możliwościach. Nadaje się do tworzenia gier i aplikacji sieciowych oraz wdrażania indywidualnych rozwiązań biznesowych. Wykorzystuje się go do różnych celów naukowych i budowania praktycznych rozwiązań najrozmaitszych problemów. Umożliwia pisanie przejrzystego, zwięzłego kodu, który jest łatwy w konserwacji i pozwala na sprawne rozwijanie oprogramowania. Jeśli chcesz zacząć szybko pisać funkcjonujący, efektywny kod i tworzyć działające aplikacje, Python jest świetnym wyborem.

Niniejsza książka jest zwięzłym, praktycznym podręcznikiem programowania w Pythonie. Dzięki niej gruntownie opanujesz podstawy języka i nabierzesz dobrych nawyków w programowaniu. Szybko będziesz mógł skoncentrować się na praktycznej stronie realizacji projektów, a nowo poznane koncepcje wypróbujesz przez opracowywanie konkretnych kwestii. W ten sposób przygotujesz się do nauki zaawansowanych technik Pythona.

 

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

  • podstawowe koncepcje programowania
  • praktyczne sposoby obsługi błędów i testowania kodu
  • biblioteki i narzędzia Pythona, takie jak matplotlib, NumPy i Pygal
  • praca z danymi i generowanie interaktywnych wizualizacji
  • tworzenie praktycznych aplikacji od podstaw i ich wdrażanie na serwerach WWW
  • możliwe problemy i sposoby ich rozwiązywania

 

Eric Matthes — uczy fizyki i matematyki w szkole średniej. Od kilku lat prowadzi kursy dla początkujących programistów Pythona. Swój pierwszy program komputerowy — prostą, poprawnie funkcjonującą grę — napisał w wieku 5 lat.

Mieszka na Alasce z Zoną i synem.

Darmowe rozdziały:

Rozdział 6. Słowniki (139)

  • Prosty słownik (140)
  • Praca ze słownikami (140)
    • Uzyskiwanie dostępu do wartości słownika (141)
    • Dodanie nowej pary klucz-wartość (142)
    • Rozpoczęcie pracy od pustego słownika (143)
    • Modyfikowanie wartości słownika (143)
    • Usuwanie pary klucz-wartość (145)
    • Słownik podobnych obiektów (145)
  • Iteracja przez słownik (148)
    • Iteracja przez wszystkie pary klucz-wartość (148)
    • Iteracja przez wszystkie klucze słownika (150)
    • Iteracja przez uporządkowane klucze słownika (152)
    • Iteracja przez wszystkie wartości słownika (153)
  • Zagnieżdżanie (154)
    • Lista słowników (155)
    • Lista w słowniku (158)
    • Słownik w słowniku (161)
  • Podsumowanie (163)

O autorze (21)

O korektorze merytorycznym (21)

Podziękowania (23)

Wprowadzenie (25)

  • Do kogo jest skierowana ta książka? (26)
  • Czego nauczysz się z tej książki? (26)
  • Dlaczego Python? (27)

Część I. Podstawy (29)

Rozdział 1. Rozpoczęcie pracy (31)

  • Przygotowanie środowiska programistycznego (31)
    • Python 2 i Python 3 (31)
    • Wykonanie fragmentu kodu w Pythonie (32)
    • Witaj, świecie! (32)
  • Python w różnych systemach operacyjnych (33)
    • Python w systemach z rodziny Linux (33)
    • Python w systemie OS X (37)
    • Python w systemie Windows (40)
  • Rozwiązywanie problemów podczas instalacji (44)
  • Uruchamianie programów Pythona z poziomu powłoki (45)
    • W systemach Linux i OS X (45)
    • W systemie Windows (46)
  • Podsumowanie (47)

Rozdział 2. Zmienne i proste typy danych (49)

  • Co tak naprawdę dzieje się po uruchomieniu hello_world.py? (49)
  • Zmienne (50)
    • Nadawanie nazw zmiennym i używanie zmiennych (51)
    • Unikanie błędów związanych z nazwami podczas używania zmiennych (52)
  • Ciągi tekstowe (54)
    • Zmiana wielkości liter ciągu tekstowego za pomocą metod (54)
    • Łączenie ciągów tekstowych (55)
    • Dodawanie białych znaków do ciągów tekstowych za pomocą tabulatora i znaku nowego wiersza (57)
    • Usunięcie białych znaków (57)
    • Unikanie błędów składni w ciągach tekstowych (59)
    • Wyświetlanie danych w Pythonie 2.x (60)
  • Liczby (61)
    • Liczby całkowite (61)
    • Liczby zmiennoprzecinkowe (62)
    • Unikanie błędów typu podczas pracy z funkcją str() (63)
    • Liczby całkowite w Pythonie 2 (64)
  • Komentarze (65)
    • Jak można utworzyć komentarz? (65)
    • Jakiego rodzaju komentarze należy tworzyć? (66)
  • Zen Pythona (66)
  • Podsumowanie (68)

Rozdział 3. Wprowadzenie do list (71)

  • Czym jest lista? (71)
    • Uzyskanie dostępu do elementów listy (72)
    • Numeracja indeksu zaczyna się od 0, a nie od 1 (73)
    • Użycie poszczególnych wartości listy (73)
  • Zmienianie, dodawanie i usuwanie elementów (74)
    • Modyfikowanie elementów na liście (75)
    • Dodawanie elementów do listy (75)
    • Usuwanie elementu z listy (77)
  • Organizacja listy (82)
    • Trwałe sortowanie listy za pomocą metody sort() (82)
    • Wyświetlanie listy w odwrotnej kolejności alfabetycznej (84)
    • Określenie wielkości listy (84)
  • Unikanie błędów indeksu podczas pracy z listą (86)
  • Podsumowanie (87)

Rozdział 4. Praca z listą (89)

  • Iteracja przez całą listę (89)
    • Dokładniejsza analiza pętli (90)
    • Wykonanie większej liczby zadań w pętli for (91)
    • Wykonywanie operacji po pętli for (93)
  • Unikanie błędów związanych z wcięciami (94)
    • Brak wcięcia (94)
    • Brak wcięcia dodatkowych wierszy (95)
    • Niepotrzebne wcięcie (95)
    • Niepotrzebne wcięcie po pętli (96)
    • Brak dwukropka (97)
  • Tworzenie list liczbowych (97)
    • Użycie funkcji range() (97)
    • Użycie funkcji range() do utworzenia listy liczb (99)
    • Proste dane statystyczne dotyczące listy liczb (101)
    • Lista składana (101)
  • Praca z fragmentami listy (103)
    • Wycinek listy (103)
    • Iteracja przez wycinek (104)
    • Kopiowanie listy (105)
  • Krotka (108)
    • Definiowanie krotki (108)
    • Iteracja przez wszystkie wartości krotki (109)
    • Nadpisanie krotki (110)
  • Styl tworzonego kodu (111)
    • Konwencje stylu (111)
    • Wcięcia (112)
    • Długość wiersza (112)
    • Puste wiersze (113)
    • Inne specyfikacje stylu (113)
  • Podsumowanie (114)

Rozdział 5. Konstrukcja if (115)

  • Prosty przykład (115)
  • Test warunkowy (116)
    • Sprawdzenie równości (116)
    • Ignorowanie wielkości liter podczas sprawdzania równości (117)
    • Sprawdzenie nierówności (118)
    • Porównania liczbowe (119)
    • Sprawdzanie wielu warunków (120)
    • Sprawdzanie, czy wartość znajduje się na liście (121)
    • Sprawdzanie, czy wartość nie znajduje się na liście (122)
    • Wyrażenie boolowskie (122)
  • Polecenie if (123)
    • Proste polecenia if (123)
    • Polecenia if-else (125)
    • Łańcuch if-elif-else (125)
    • Użycie wielu bloków elif (127)
    • Pominięcie bloku else (128)
    • Sprawdzanie wielu warunków (128)
  • Używanie poleceń if z listami (132)
    • Sprawdzanie pod kątem wartości specjalnych (132)
    • Sprawdzanie, czy lista nie jest pusta (133)
    • Użycie wielu list (134)
  • Nadawanie stylu poleceniom if (136)
  • Podsumowanie (137)

Rozdział 6. Słowniki (139)

  • Prosty słownik (140)
  • Praca ze słownikami (140)
    • Uzyskiwanie dostępu do wartości słownika (141)
    • Dodanie nowej pary klucz-wartość (142)
    • Rozpoczęcie pracy od pustego słownika (143)
    • Modyfikowanie wartości słownika (143)
    • Usuwanie pary klucz-wartość (145)
    • Słownik podobnych obiektów (145)
  • Iteracja przez słownik (148)
    • Iteracja przez wszystkie pary klucz-wartość (148)
    • Iteracja przez wszystkie klucze słownika (150)
    • Iteracja przez uporządkowane klucze słownika (152)
    • Iteracja przez wszystkie wartości słownika (153)
  • Zagnieżdżanie (154)
    • Lista słowników (155)
    • Lista w słowniku (158)
    • Słownik w słowniku (161)
  • Podsumowanie (163)

Rozdział 7. Dane wejściowe użytkownika i pętla while (165)

  • Jak działa funkcja input()? (166)
    • Przygotowanie jasnych i zrozumiałych komunikatów (167)
    • Użycie funkcji int() do akceptowania liczbowych danych wejściowych (168)
    • Operator modulo (169)
    • Akceptacja danych wejściowych w Pythonie 2.7 (170)
  • Wprowadzenie do pętli while (171)
    • Pętla while w działaniu (171)
    • Umożliwienie użytkownikowi podjęcia decyzji o zakończeniu działania programu (172)
    • Użycie flagi (174)
    • Użycie polecenia break do opuszczenia pętli (175)
    • Użycie polecenia continue w pętli (176)
    • Unikanie pętli działającej w nieskończoność (177)
  • Użycie pętli while wraz z listami i słownikami (179)
    • Przenoszenie elementów z jednej listy na drugą (179)
    • Usuwanie z listy wszystkich egzemplarzy określonej wartości (180)
    • Umieszczenie w słowniku danych wejściowych wprowadzonych przez użytkownika (181)
  • Podsumowanie (183)

Rozdział 8. Funkcje (185)

  • Definiowanie funkcji (185)
    • Przekazywanie informacji do funkcji (186)
    • Argumenty i parametry (187)
  • Przekazywanie argumentów (188)
    • Argumenty pozycyjne (188)
    • Argumenty w postaci słów kluczowych (190)
    • Wartości domyślne (191)
    • Odpowiedniki wywołań funkcji (192)
    • Unikanie błędów związanych z argumentami (193)
  • Wartość zwrotna (195)
    • Zwrot prostej wartości (195)
    • Definiowanie argumentu jako opcjonalnego (196)
    • Zwrot słownika (198)
    • Używanie funkcji wraz z pętlą while (199)
  • Przekazywanie listy (200)
    • Modyfikowanie listy w funkcji (202)
    • Uniemożliwianie modyfikowania listy przez funkcję (205)
  • Przekazywanie dowolnej liczby argumentów (205)
    • Argumenty pozycyjne i przekazywanie dowolnej liczby argumentów (207)
    • Używanie dowolnej liczby argumentów w postaci słów kluczowych (208)
  • Przechowywanie funkcji w modułach (209)
    • Import całego modułu (210)
    • Import określonych funkcji (212)
    • Użycie słowa kluczowego as w celu zdefiniowania aliasu funkcji (212)
    • Użycie słowa kluczowego as w celu zdefiniowania aliasu modułu (213)
    • Import wszystkich funkcji modułu (213)
  • Nadawanie stylu funkcjom (214)
  • Podsumowanie (216)

Rozdział 9. Klasy (217)

  • Utworzenie i użycie klasy (218)
  • Utworzenie klasy Dog (218)
  • Utworzenie egzemplarza na podstawie klasy (220)
  • Praca z klasami i egzemplarzami (223)
    • Klasa Car (224)
    • Przypisanie atrybutowi wartości domyślnej (225)
    • Modyfikacja wartości atrybutu (226)
  • Dziedziczenie (229)
    • Metoda __init__() w klasie potomnej (230)
    • Dziedziczenie w Pythonie 2.7 (231)
    • Definiowanie atrybutów i metod dla klasy potomnej (232)
    • Nadpisywanie metod klasy nadrzędnej (233)
    • Egzemplarz jako atrybut (234)
    • Modelowanie rzeczywistych obiektów (236)
  • Import klas (237)
    • Import pojedynczej klasy (237)
    • Przechowywanie wielu klas w module (240)
    • Import wielu klas z modułu (241)
    • Import całego modułu (242)
    • Import wszystkich klas z modułu (242)
    • Import modułu w module (243)
    • Określenie swojego sposobu pracy (244)
  • Biblioteka standardowa Pythona (245)
  • Nadawanie stylu klasom (246)
  • Podsumowanie (248)

Rozdział 10. Pliki i wyjątki (249)

  • Odczytywanie danych z pliku (250)
    • Wczytywanie całego pliku (250)
    • Ścieżka dostępu do pliku (252)
    • Odczytywanie wiersz po wierszu (253)
    • Utworzenie listy wierszy na podstawie zawartości pliku (255)
    • Praca z zawartością pliku (255)
    • Ogromne pliki, czyli na przykład milion cyfr (257)
    • Czy data Twoich urodzin znajduje się w liczbie pi? (257)
  • Zapisywanie danych w pliku (258)
    • Zapisywanie danych do pustego pliku (259)
    • Zapisywanie wielu wierszy (260)
    • Dołączanie do pliku (261)
  • Wyjątki (262)
    • Obsługiwanie wyjątku ZeroDivisionError (262)
    • Używanie bloku try-except (263)
    • Używanie wyjątków w celu uniknięcia awarii programu (264)
    • Blok else (265)
    • Obsługa wyjątku FileNotFoundError (266)
    • Analiza tekstu (267)
    • Praca z wieloma plikami (269)
    • Ciche niepowodzenie (270)
    • Które błędy należy zgłaszać? (271)
  • Przechowywanie danych (273)
    • Używanie json.dump() i json.load() (273)
    • Zapisywanie i odczytywanie danych wygenerowanych przez użytkownika (274)
    • Refaktoryzacja (277)
  • Podsumowanie (279)

Rozdział 11. Testowanie kodu (281)

  • Testowanie funkcji (282)
    • Test jednostkowy i zestaw testów (283)
    • Zaliczenie testu (283)
    • Niezaliczenie testu (285)
    • Reakcja na niezaliczony test (286)
    • Dodanie nowego testu (288)
  • Testowanie klasy (290)
    • Różne rodzaje metod asercji (290)
    • Klasa do przetestowania (290)
    • Testowanie klasy AnonymousSurvey (293)
    • Metoda setUp() (295)
  • Podsumowanie (297)

Część II. Projekty (299)

Projekt 1. Inwazja obcych

Rozdział 12. Statek, który strzela pociskami (303)

  • Planowanie projektu (304)
  • Instalacja Pygame (304)
    • Instalacja pakietów Pythona za pomocą pip (305)
  • Rozpoczęcie pracy nad projektem gry (310)
    • Utworzenie okna Pygame i reagowanie na działania użytkownika (310)
    • Zdefiniowanie koloru tła (311)
    • Utworzenie klasy ustawień (312)
  • Dodanie obrazu statku kosmicznego (314)
    • Utworzenie klasy statku kosmicznego (314)
    • Wyświetlenie statku kosmicznego na ekranie (316)
  • Refaktoryzacja, czyli moduł game_functions (317)
    • Funkcja check_events() (317)
    • Funkcja update_screen() (319)
  • Kierowanie statkiem kosmicznym (320)
    • Reakcja na naciśnięcie klawisza (320)
    • Umożliwienie nieustannego ruchu (321)
    • Poruszanie statkiem w obu kierunkach (323)
    • Dostosowanie szybkości statku (325)
    • Ograniczenie zasięgu poruszania się statku (327)
    • Refaktoryzacja funkcji check_events() (327)
  • Krótkie powtórzenie (328)
    • alien_invasion.py (328)
    • settings.py (329)
    • game_functions.py (329)
    • ship.py (329)
  • Wystrzeliwanie pocisków (330)
    • Dodawanie ustawień dotyczących pocisków (330)
    • Utworzenie klasy Bullet (330)
    • Przechowywanie pocisków w grupie (332)
    • Wystrzeliwanie pocisków (333)
    • Usuwanie niewidocznych pocisków (334)
    • Ograniczenie liczby pocisków (336)
    • Utworzenie funkcji update_bullets() (337)
    • Utworzenie funkcji fire_bullet() (337)
  • Podsumowanie (338)

Rozdział 13. Obcy! (339)

  • Przegląd projektu (340)
  • Utworzenie pierwszego obcego (341)
    • Utworzenie klasy Alien (341)
    • Utworzenie egzemplarza obcego (342)
    • Wyświetlenie obcego na ekranie (343)
  • Utworzenie floty obcych (343)
    • Ustalenie maksymalnej liczby obcych wyświetlanych w jednym rzędzie (344)
    • Utworzenie rzędów obcych (345)
    • Utworzenie floty (346)
    • Refaktoryzacja funkcji create_fleet() (348)
    • Dodawanie rzędów (349)
  • Poruszanie flotą obcych (351)
    • Przesunięcie obcych w prawo (352)
    • Zdefiniowanie ustawień dla kierunku poruszania się floty (353)
    • Sprawdzenie, czy obcy dotarł do krawędzi ekranu (354)
    • Przesunięcie floty w dół i zmiana kierunku (355)
  • Zestrzeliwanie obcych (356)
    • Wykrywanie kolizji z pociskiem (356)
    • Utworzenie większych pocisków w celach testowych (357)
    • Ponowne utworzenie floty (358)
    • Zwiększenie szybkości pocisku (360)
    • Refaktoryzacja funkcji update_bullets() (360)
  • Zakończenie gry (361)
    • Wykrywanie kolizji między obcym i statkiem (361)
    • Reakcja na kolizję między obcym i statkiem (362)
    • Obcy, który dociera do dolnej krawędzi ekranu (366)
    • Koniec gry! (367)
  • Ustalenie, które komponenty gry powinny być uruchomione (367)
  • Podsumowanie (368)

Rozdział 14. Punktacja (369)

  • Dodanie przycisku Gra (369)
    • Utworzenie klasy Button (370)
    • Wyświetlenie przycisku na ekranie (372)
    • Uruchomienie gry (373)
    • Zerowanie gry (374)
    • Dezaktywacja przycisku Gra (376)
    • Ukrycie kursora myszy (377)
  • Zmiana poziomu trudności (377)
    • Zmiana ustawień dotyczących szybkości (378)
    • Wyzerowanie szybkości (380)
  • Punktacja (381)
    • Wyświetlanie punktacji (381)
    • Utworzenie tablicy wyników (383)
    • Uaktualnienie punktacji po zestrzeleniu obcego (384)
    • Zagwarantowanie uwzględnienia wszystkich trafień (386)
    • Zwiększenie liczby zdobywanych punktów (387)
    • Zaokrąglanie punktacji (388)
    • Najlepsze wyniki (389)
    • Wyświetlenie aktualnego poziomu gry (391)
    • Wyświetlenie liczby statków (396)
  • Podsumowanie (399)

Projekt 2. Wizualizacja danych

Rozdział 15. Generowanie danych (405)

  • Instalacja matplotlib (406)
    • Linux (406)
    • OS X (407)
    • Windows (407)
    • Testowanie matplotlib (407)
    • Galeria matplotlib (408)
  • Wygenerowanie prostego wykresu liniowego (408)
    • Zmienianie etykiety i grubości wykresu (409)
    • Poprawianie wykresu (410)
    • Używanie funkcji scatter() do wyświetlania poszczególnych punktów i nadawania im stylu (411)
    • Wyświetlanie serii punktów za pomocą funkcji scatter() (413)
    • Automatyczne obliczanie danych (413)
    • Usuwanie konturów z wyświetlanych punktów danych (415)
    • Definiowanie własnych kolorów (415)
    • Użycie mapy kolorów (415)
    • Automatyczny zapis wykresu (416)
  • Błądzenie losowe (417)
    • Utworzenie klasy RandomWalk (417)
    • Wybór kierunku (418)
    • Wyświetlenie wykresu błądzenia losowego (419)
    • Wygenerowanie wielu błądzeń losowych (420)
    • Nadawanie stylu danym wygenerowanym przez błądzenie losowe (421)
    • Kolorowanie punktów (421)
    • Kolorowanie punktów początkowego i końcowego (422)
    • Ukrywanie osi (423)
    • Dodawanie punktów do wykresu (424)
    • Zmienianie wielkości wykresu, aby wypełnił ekran (424)
  • Symulacja rzutu kością do gry za pomocą Pygal (426)
    • Instalacja Pygal (427)
    • Galeria Pygal (427)
    • Utworzenie klasy Die (427)
    • Rzut kością do gry (428)
    • Analiza wyników (429)
    • Utworzenie histogramu (430)
    • Rzut dwiema kośćmi (431)
    • Rzut kośćmi o różnej liczbie ścianek (433)
  • Podsumowanie (434)

Rozdział 16. Pobieranie danych (437)

  • Format CSV (438)
    • Przetwarzanie nagłówków pliku CSV (438)
    • Wyświetlanie nagłówków i ich położenia (439)
    • Wyodrębnienie i odczytanie danych (440)
    • Wyświetlenie danych na wykresie temperatury (442)
    • Moduł datetime (442)
    • Wyświetlanie daty (444)
    • Wyświetlenie dłuższego przedziału czasu (445)
    • Wyświetlenie drugiej serii danych (446)
    • Nakładanie cienia na wykresie (447)
    • Sprawdzenie pod kątem błędów (448)
  • Mapowanie globalnych zbiorów danych - format JSON (452)
    • Pobranie danych dotyczących populacji świata (452)
    • Wyodrębnienie interesujących nas danych (453)
    • Konwersja ciągu tekstowego na wartość liczbową (454)
    • Pobranie dwuznakowego kodu państwa (455)
    • Budowanie mapy świata (458)
    • Wyświetlenie danych liczbowych na mapie świata (459)
    • Wyświetlenie pełnej mapy populacji (460)
    • Grupowanie państw według populacji (463)
    • Nadawanie stylu mapie świata w Pygal (464)
    • Rozjaśnienie motywu graficznego (467)
  • Podsumowanie (468)

Rozdział 17. Praca z API (471)

  • Użycie Web API (471)
    • Git i GitHub (472)
    • Żądanie danych za pomocą wywołania API (472)
    • Instalacja requests (473)
    • Przetworzenie odpowiedzi API (473)
    • Praca ze słownikiem odpowiedzi (474)
    • Podsumowanie repozytoriów najczęściej oznaczanych gwiazdką (477)
    • Monitorowanie ograniczeń liczby wywołań API (478)
  • Wizualizacja repozytoriów za pomocą pakietu Pygal (479)
    • Dopracowanie wykresów generowanych przez Pygal (481)
    • Dodanie własnych podpowiedzi (483)
    • Wyświetlanie danych (484)
    • Dodawanie łączy do wykresu (486)
  • Hacker News API (487)
  • Podsumowanie (490)

Projekt 3. Aplikacje sieciowe

Rozdział 18. Rozpoczęcie pracy z Django (495)

  • Przygotowanie projektu (496)
    • Opracowanie specyfikacji (496)
    • Utworzenie środowiska wirtualnego (496)
    • Instalacja virtualenv (497)
    • Aktywacja środowiska wirtualnego (497)
    • Instalacja frameworka Django (498)
    • Utworzenie projektu w Django (498)
    • Utworzenie bazy danych (499)
    • Przegląd projektu (500)
  • Uruchomienie aplikacji (501)
    • Definiowanie modeli (502)
    • Aktywacja modeli (503)
    • Witryna administracyjna Django (505)
    • Zdefiniowanie modelu Entry (508)
    • Migracja modelu Entry (509)
    • Rejestracja modelu Entry w witrynie administracyjnej (509)
    • Powłoka Django (510)
  • Tworzenie stron internetowych - strona główna aplikacji (512)
    • Mapowanie adresu URL (513)
    • Utworzenie widoku (515)
    • Utworzenie szablonu (516)
  • Utworzenie dodatkowych stron (517)
    • Dziedziczenie szablonu (518)
    • Strona tematów (520)
    • Strony poszczególnych tematów (523)
  • Podsumowanie (527)

Rozdział 19. Konta użytkowników (529)

  • Umożliwienie użytkownikom wprowadzania danych (530)
  • Dodawanie nowego tematu (530)
  • Dodawanie nowych wpisów (535)
  • Edycja wpisu (539)
  • Konfiguracja kont użytkowników (543)
  • Aplikacja users (543)
  • Strona logowania (544)
  • Wylogowanie (547)
  • Strona rejestracji użytkownika (548)
  • Umożliwienie użytkownikom bycia właścicielami swoich danych (552)
  • Ograniczenie dostępu za pomocą dekoratora @login_required (552)
  • Powiązanie danych z określonymi użytkownikami (555)
  • Przyznanie dostępu jedynie odpowiednim użytkownikom (558)
  • Ochrona tematów użytkownika (559)
  • Ochrona strony edit_entry (560)
  • Powiązanie nowego tematu z bieżącym użytkownikiem (560)
  • Podsumowanie (562)

Rozdział 20. Nadanie stylu i wdrożenie aplikacji (563)

  • Nadanie stylu aplikacji Learning Log (564)
    • Aplikacja django-bootstrap3 (564)
    • Użycie Bootstrapa do nadania stylu aplikacji Learning Log (565)
    • Modyfikacja pliku base.html (566)
    • Użycie elementu Jumbotron do nadania stylu stronie głównej (570)
    • Nadanie stylu stronie logowania (570)
    • Nadanie stylu stronie new_topic (571)
    • Nadanie stylu stronie tematów (573)
    • Nadanie stylów wpisom na stronie tematu (573)
  • Wdrożenie aplikacji Learning Log (575)
    • Utworzenie konta w Heroku (576)
    • Instalacja Heroku Toolbelt (576)
    • Instalacja wymaganych pakietów (576)
    • Utworzenie listy pakietów w pliku requirements.txt (577)
    • Określenie środowiska uruchomieniowego Pythona (578)
    • Modyfikacja pliku settings.py dla Heroku (579)
    • Utworzenie pliku Procfie do uruchomienia procesu (580)
    • Modyfikacja pliku wsgi.py dla Heroku (580)
    • Utworzenie katalogu dla plików statycznych (580)
    • Użycie serwera gunicorn w środowisku lokalnym (581)
    • Użycie Gita do monitorowania plików projektu (582)
    • Przekazanie projektu do Heroku (584)
    • Konfiguracja bazy danych w Heroku (585)
    • Dopracowanie wdrożenia projektu w Heroku (586)
    • Zabezpieczenie wdrożonego projektu (588)
    • Zatwierdzenie zmian i przekazanie ich do serwera (589)
    • Utworzenie własnych stron błędu (590)
    • Nieustanna rozbudowa (593)
    • Opcja SECRET_KEY (594)
    • Usunięcie projektu z Heroku (594)
  • Podsumowanie (595)

Posłowie (597)

A. Instalacja Pythona (599)

  • Python w systemie Linux (599)
    • Ustalenie zainstalowanej wersji (599)
    • Instalacja Pythona 3 w systemie Linux (600)
  • Python w systemie OS X (600)
    • Ustalenie zainstalowanej wersji (600)
    • Użycie menedżera Homebrew do instalacji Pythona 3 (601)
  • Python w Windows (602)
    • Instalacja Pythona 3 w Windows (602)
    • Odszukanie interpretera Pythona (603)
    • Dodanie Pythona do zmiennej Path (603)
  • Słowa kluczowe Pythona i wbudowane funkcje (604)
    • Słowa kluczowe Pythona (604)
    • Wbudowane funkcje Pythona (604)

B. Edytory tekstu (607)

  • Geany (608)
    • Instalacja Geany w systemie Linux (608)
    • Instalacja Geany w systemie Windows (608)
    • Uruchamianie programów Python w Geany (609)
    • Dostosowanie ustawień Geany do własnych potrzeb (610)
  • Sublime Text (610)
    • Instalacja Sublime Text w systemie OS X (611)
    • Instalacja Sublime Text w systemie Linux (611)
    • Instalacja Sublime Text w systemie Windows (611)
    • Uruchamianie programów Python w edytorze Sublime Text (611)
    • Konfigurowanie edytora Sublime Text (612)
    • Dostosowanie ustawień Sublime Text do własnych potrzeb (612)
  • IDLE (613)
    • Instalacja IDLE w systemie Linux (613)
    • Instalacja IDLE w systemie OS X (613)
    • Instalacja IDLE w systemie Windows (614)
    • Dostosowanie ustawień IDLE do własnych potrzeb (614)
  • Emacs i vim (614)

C. Uzyskiwanie pomocy (615)

  • Pierwsze kroki (615)
    • Spróbuj jeszcze raz (616)
    • Chwila odpoczynku (616)
    • Korzystaj z zasobów tej książki (617)
  • Wyszukiwanie informacji w internecie (617)
    • Stack Overflow (617)
    • Oficjalna dokumentacja Pythona (618)
    • Oficjalna dokumentacja biblioteki (618)
    • r/learnpython (618)
    • Posty na blogach (618)
  • Kanały IRC (618)
    • Założenie konta na kanale IRC (619)
    • Kanały, do których warto się przyłączyć (619)
    • Kultura na kanale IRC (619)

D. Używanie Gita do kontroli wersji (621)

  • Instalacja Gita (622)
    • Instalacja Gita w systemie Linux (622)
    • Instalacja Gita w systemie OS X (622)
    • Instalacja Gita w systemie Windows (622)
    • Konfiguracja Gita (622)
  • Tworzenie projektu (623)
  • Ignorowanie plików (623)
  • Inicjalizacja repozytorium (624)
  • Sprawdzanie stanu (624)
  • Dodawanie plików do repozytorium (625)
  • Zatwierdzanie plików (625)
  • Sprawdzanie dziennika projektu (626)
  • Drugie zatwierdzenie (627)
  • Przywracanie stanu projektu (628)
  • Przywrócenie projektu do wcześniejszego stanu (629)
  • Usunięcie repozytorium (631)

Skorowidz (633)

Informatyka » Python - Programowanie

https://facebook.com/wiedzanaplus
Alt + 9
Pomoc ( Alt + 0 )
Loading...