Nowoczesne aplikacje internetowe nie istniej

Osoby które kupowały "Zaawansowane aplikacje webowe BACK-END dla studenta i technika programisty", wybierały także:

• Matematyka. Kurs video. Teoria dla programisty i data science 399,00 zł, (39,90 zł -90%)
• Deep Learning for the Life Sciences. Applying Deep Learning to Genomics, Microscopy, Drug Discovery, and More 249,17 zł, (29,90 zł -88%)
• Java 9: Building Robust Modular Applications 332,50 zł, (39,90 zł -88%)
• Stream Processing with Apache Flink. Fundamentals, Implementation, and Operation of Streaming Applications 230,00 zł, (29,90 zł -87%)
• Matematyka. Kurs video. 285,00 zł, (39,90 zł -86%)

Spis treści

Zaawansowane aplikacje webowe BACK-END dla studenta i technika programisty eBook -- spis treści

1 SŁOWO WSTĘPU .............................................................................................. 11
2 WPROWADZENIE DO PROGRAMOWANIA W JĘZYKU PYTHON .......................... 15
2.1 CO WARTO WIEDZIEĆ O PYTHONIE? ......................................................................... 15
2.2 INSTALOWANIE PYTHONA I PROGRAMU PYCHARM ...................................................... 16
2.3 HELLO WORLD, CZYLI PIERWSZY PROGRAM W JĘZYKU PYTHON ...................................... 18
2.4 ZMIENNE, OPERACJE ARYTMETYCZNE, MODUŁY MATH I RANDOM, FUNKCJA INPUT() .......... 21
2.4.1 Typy liczbowe i operatory arytmetyczne ................................................. 24
2.4.2 Moduł math ............................................................................................. 24
2.4.3 Moduł random......................................................................................... 30
2.4.4 Funkcja input ........................................................................................... 30
2.4.5 Zadania praktyczne ................................................................................. 32
2.5 NAPISY (STRING) .................................................................................................. 32
2.5.1 Konkatenacja i f-string ............................................................................ 32
2.5.2 Operacje na napisach .............................................................................. 34
2.5.3 Slicing w napisach ................................................................................... 39
2.5.4 Zadania praktyczne ................................................................................. 42
2.6 INSTRUKCJE WARUNKOWE ..................................................................................... 42
2.6.1 Logiczne typy danych i operatory porównujące ...................................... 42
2.6.2 Operatory logiczne .................................................................................. 43
2.6.3 Instrukcja warunkowa if .......................................................................... 44
2.6.4 Instrukcja warunkowa if … else ............................................................... 44
2.6.5 Instrukcja warunkowa if … elif … else ...................................................... 46
2.6.6 Wyrażenie trójargumentowe .................................................................. 49
2.6.7 Zadania praktyczne ................................................................................. 50
2.7 PĘTLA FOR .......................................................................................................... 51
2.7.1 Funkcja range()........................................................................................ 53
2.7.2 Instrukcja break ....................................................................................... 55
2.7.3 For … else ................................................................................................. 56
2.7.4 Instrukcja continue .................................................................................. 57
2.7.5 Sprawdź się! ............................................................................................ 58
2.7.6 Zadania praktyczne ................................................................................. 59
2.8 PĘTLA WHILE ....................................................................................................... 59
2.8.1 While True ............................................................................................... 61
2.8.2 Sprawdź się! ............................................................................................ 62
2.8.3 Zadania praktyczne ................................................................................. 63
2.9 FUNKCJE ............................................................................................................. 64
2.9.1 Definiowanie funkcji ................................................................................ 64
2.9.2 Typy funkcji .............................................................................................. 66
2.9.3 *args ........................................................................................................ 71
2.9.4 **kwargs ................................................................................................. 73
2.9.5 Funkcja lambda ....................................................................................... 74
2.9.6 Dokumentacja funkcji .............................................................................. 75
2.9.7 Zadania praktyczne ................................................................................. 76
2.10 ZBIORY ........................................................................................................... 77
2.10.1 Tworzenie zbioru ..................................................................................... 77
2.10.2 Operacje na zbiorach ............................................................................... 79
2.10.3 Sprawdź się! ............................................................................................ 86
2.11 LISTY.............................................................................................................. 88
2.11.1 Tworzenie listy ......................................................................................... 88
2.11.2 Łączenie list ............................................................................................. 89
2.11.3 Operacje na listach .................................................................................. 90
2.11.4 Operator in .............................................................................................. 98
2.11.5 Slicing ...................................................................................................... 99
2.11.6 Wyrażenie listowe ................................................................................. 100
2.11.7 Funkcja map .......................................................................................... 102
2.11.8 Funkcja filter .......................................................................................... 104
2.11.9 Funkcja zip ............................................................................................. 105
2.11.10 Sprawdź się! ...................................................................................... 106
2.11.11 Zadania praktyczne ........................................................................... 106
2.12 KROTKI ......................................................................................................... 107
2.12.1 Tworzenie krotki .................................................................................... 107
2.12.2 Operacje na krotkach ............................................................................ 108
2.12.3 Zagnieżdżone krotki .............................................................................. 114
2.12.4 Sprawdź się! .......................................................................................... 115
2.12.5 Zadania praktyczne ............................................................................... 116
2.13 SŁOWNIKI ..................................................................................................... 116
2.13.1 Tworzenie słownika ............................................................................... 116
2.13.2 Operacje na słownikach ........................................................................ 118
2.13.3 Sprawdź się! .......................................................................................... 121
2.14 MODUŁY ...................................................................................................... 121
2.14.1 Tworzenie modułów .............................................................................. 121
2.15 OBSŁUGA WYJĄTKÓW ..................................................................................... 123
2.15.1 Wyjątki .................................................................................................. 123
2.15.2 Obsługa wyjątków ................................................................................. 125
2.15.3 Ręczne zgłaszanie wyjątków ................................................................. 130
2.16 OPERACJE NA PLIKACH ..................................................................................... 131
2.16.1 Otwieranie pliku .................................................................................... 131
2.16.2 Odczyt z pliku ......................................................................................... 131
2.16.3 Zapis do pliku ......................................................................................... 133
3 PROGRAMOWANIE OBIEKTOWE W JĘZYKU PYTHON ...................................... 137
3.1 WPROWADZENIE DO PROGRAMOWANIA OBIEKTOWEGO ............................................ 137
3.2 TWORZENIE KLAS ............................................................................................... 138
3.2.1 Konstruktor i metody ............................................................................. 140
3.2.2 Atrybuty instancji i atrybuty klasy ......................................................... 143
3.2.3 Sprawdź się! .......................................................................................... 145
3.2.4 Zadania praktyczne ............................................................................... 146
3.3 MAGICZNE METODY ............................................................................................ 147
3.3.1 Metoda __str__ i metoda __repr__ ...................................................... 147
3.3.1 Porównywanie obiektów ....................................................................... 149
3.3.2 Operacje arytmetyczne na obiektach .................................................... 152
3.3.3 Sprawdź się! .......................................................................................... 153
3.3.4 Zadania praktyczne ............................................................................... 153
3.4 HERMETYZACJA / ENKAPSULACJA ........................................................................... 154
3.4.1 Definicja klasy z metodami dostępu ...................................................... 154
3.4.2 Dekoratory ............................................................................................ 158
3.4.3 @property i @setter .............................................................................. 160
3.4.4 Sprawdź się! .......................................................................................... 163
3.4.5 Zadania praktyczne ............................................................................... 164
3.5 DZIEDZICZENIE ................................................................................................... 164
3.5.1 Zadania praktyczne ............................................................................... 172
3.6 ABSTRAKCJA ...................................................................................................... 172
3.6.1 Sprawdź się! .......................................................................................... 175
3.6.2 Zadania praktyczne ............................................................................... 176
3.7 POLIMORFIZM ................................................................................................... 176
4 DJANGO ......................................................................................................... 181
4.1 PODSTAWOWE POJĘCIA W TWORZENIU STRON INTERNETOWYCH ................................. 181
4.2 INSTALACJA I KONFIGURACJA DJANGO .................................................................... 182
4.2.1 Sprawdź się! .......................................................................................... 188
4.3 STRUKTURA PROJEKTU DJANGO ............................................................................ 189
4.4 WIDOKI I SZABLONY ............................................................................................ 192
4.4.1 Tworzenie pierwszego widoku .............................................................. 192
4.4.2 Konfiguracja URL dla widoku ................................................................ 193
4.4.3 Rejestracja URL-i aplikacji w głównym projekcie .................................. 194
4.4.4 Przekazywanie danych w żądaniach HTTP ............................................ 195
4.4.5 Zastosowanie szablonów w Django ...................................................... 196
4.4.6 Sprawdź się! .......................................................................................... 199
4.5 MODELE DANYCH ............................................................................................... 201
4.5.1 Instalacja DB Browser for SQLite ........................................................... 201
4.5.2 Tworzenie modeli danych ...................................................................... 201
4.5.3 Sprawdź się! .......................................................................................... 210
4.5.4 Zadania praktyczne ............................................................................... 211
4.6 OPERACJE NA DANYCH W DJANGO ORM – DODAWANIE, EDYTOWANIE I POBIERANIE ...... 212
4.6.1 Django Shell – Interaktywne środowisko testowania Django ORM ...... 213
4.6.2 Sprawdź się! .......................................................................................... 220
4.7 ADMINISTRACJA DJANGO ..................................................................................... 221
4.7.1 Konfiguracja strony administracyjnej .................................................... 221
4.7.2 Rejestracja modeli w panelu administracyjnym .................................... 223
4.7.3 Ulepszenia panelu administracyjnego – opcjonalnie ............................ 226
4.8 AUTORYZACJA I UWIERZYTELNIANIE ........................................................................ 227
4.8.1 Organizacja katalogów szablonów ....................................................... 228
4.8.2 Najważniejsze elementy języka szablonów Django – ściągawka .......... 229
4.8.3 Szablon base.html – fundament każdej strony ...................................... 231
4.8.4 Strona główna (home.html) .................................................................. 233
4.8.5 Tworzenie widoku home_view – logika strony głównej ........................ 236
4.8.6 Routing – powiązanie widoku home_view z adresem URL ................... 237
4.8.7 Widok szczegółowy posta (post_detail) ................................................ 239
4.8.8 Routing widoku szczegółowego posta ................................................... 241
4.8.9 Obsługa użytkowników: rejestracja, logowanie, usuwanie konta ........ 243
4.8.10 Szablony HTML ...................................................................................... 249
4.8.11 Routing – obsługa rejestracji, logowania i usuwania konta użytkownika
254
4.8.12 Tworzenie profilu użytkownika .............................................................. 259
4.8.13 Dodawanie postów: tworzenie nowych wpisów na blogu .................... 264
4.8.14 Powtórka mistrza przed zadaniami praktycznymi ................................. 269
4.8.15 Sprawdź się! .......................................................................................... 271
4.8.16 Zadania praktyczne ............................................................................... 272
4.9 PAGINACJA – CZYLI JAK PODZIELIĆ WPISY NA STRONY ................................................. 274
4.9.1 Jak to zrobić? ......................................................................................... 274
4.9.2 Bezpieczne paginowanie – co jeśli ktoś wpisze złą stronę? ................... 277
4.10 BONUSY – FUNKCJE, KTÓRE ROBIĄ WRAŻENIE ....................................................... 277
4.10.1 Resetowanie hasła – bo każdy kiedyś zapomni ..................................... 277
4.10.2 Zdjęcia do postów – bo czasem słowa to za mało ................................. 281
4.10.3 Filtrowanie postów – bo nie zawsze chcemy wszystko ......................... 285
4.11 ZAKOŃCZENIE – CZYLI CO DALEJ? ....................................................................... 289
4.12 ROZWIŃ SKRZYDŁA: PROJEKTY I POMYSŁY NA DALSZĄ PRZYGODĘ Z PROGRAMOWANIEM 290
5 NODE.JS I EXPRESS ......................................................................................... 295
5.1 WPROWADZENIE DO NODE.JS I EXPRESS ................................................................. 295
5.1.1 Czym jest Node.js? ................................................................................. 295
5.1.2 Instalacja i konfiguracja Node.js ........................................................... 295
5.1.3 Struktura projektu Node.js .................................................................... 297
5.1.4 Express.js i jego instalacja ..................................................................... 299
5.1.5 Zalety i wady ......................................................................................... 301
5.1.6 Testowanie ............................................................................................ 301
5.2 TWORZENIE API RESTFUL ................................................................................... 303
5.3 UWIERZYTELNIANIE, AUTORYZACJA I ZABEZPIECZENIE API ........................................... 315
5.4 OBSŁUGA BŁĘDÓW ............................................................................................. 326
6 MONGODB I MONGOOSE ............................................................................... 337
6.1 WPROWADZENIE DO MONGODB .......................................................................... 337
6.2 PRACA Z MONGOOSE .......................................................................................... 346
6.3 RELACJE I AGREGACJE ......................................................................................... 357
6.4 BACKUP I PRZYWRACANIE DANYCH ......................................................................... 373
6.5 PROJEKT – REST API DLA BLOGA .......................................................................... 377
7 ODPOWIEDZI I PRZYKŁADOWE SKRYPTY ......................................................... 399