Szczegóły ebooka

Python 3. Proste wprowadzenie do fascynującego świata programowania

Python 3. Proste wprowadzenie do fascynującego świata programowania

Zed A. Shaw

Ebook

Python jest dojrzałym, elastycznym i bardzo wszechstronnym językiem programowania. Nadaje się do budowy przeróżnych aplikacji, a także do tworzenia programów służących do bardzo specyficznych zastosowań, takich jak badania naukowe. Aby jednak w pełni wykorzystać te imponujące możliwości, musisz pisać dobry kod: przejrzysty, zwięzły, działający poprawnie. Niestety, nie jest łatwo nauczyć się dobrego programowania. To coś więcej niż przyswojenie zestawu poleceń i słów kluczowych. Wymaga czasu, wysiłku, sporego zaangażowania i... dobrego przewodnika na tej trudnej ścieżce.

Niniejsza książka jest właśnie takim dobrym przewodnikiem dla początkujących programistów. Jest napisana w sposób łatwy i wciągający. Duży nacisk położono na analizę tworzonego kodu. Jeśli tylko skoncentrujesz się na wykonywanych zadaniach, zdobędziesz się na zaangażowanie i dokładność, zrozumienie znaczenia każdej linii programu przyjdzie łatwo. Wartościowym elementem książki są wskazówki, jak zepsuć napisany kod, a następnie go zabezpieczyć. Dzięki temu łatwiej Ci przyjdzie unikanie błędów. Dzięki tej książce zdobędziesz trzy najważniejsze umiejętności każdego programisty: czytanie i pisanie ze zrozumieniem, dbałość o szczegóły oraz dostrzeganie różnic.

Najistotniejsze zagadnienia poruszone w książce:

  • przygotowanie kompletnego środowiska programistycznego
  • organizowanie, pisanie, psucie i naprawianie kodu
  • programowanie obiektowe
  • projektowanie programu i testowanie kodu
  • podstawy budowy aplikacji internetowych i prostszych gier

Zrozum Pythona, pisz dobry kod!

Przedmowa (15)

  • Ulepszenia w edycji Python 3 (15)
  • Trudna droga jest łatwiejsza (16)
    • Czytanie i pisanie (16)
    • Dbałość o szczegóły (16)
    • Dostrzeganie różnic (16)
    • Pytaj, pytaj i pytaj (17)
    • Nie przeklejaj (17)
    • Uwagi na temat ćwiczeń i wytrwałości (17)
  • Podziękowania (18)

Ćwiczenie 0. Konfiguracja (20)

  • macOS (20)
    • macOS. Co powinieneś zobaczyć (21)
  • Windows (21)
    • Windows. Co powinieneś zobaczyć (22)
  • Linux (23)
    • Linux. Co powinieneś zobaczyć (23)
  • Szukanie informacji w internecie (24)
  • Ostrzeżenia dla początkujących (24)
  • Alternatywne edytory tekstów (25)

Ćwiczenie 1. Dobry pierwszy program (28)

  • Co powinieneś zobaczyć (29)
  • Zrób to sam (31)
  • Typowe pytania (31)

Ćwiczenie 2. Komentarze i znaki kratki (34)

  • Co powinieneś zobaczyć (34)
  • Zrób to sam (34)
  • Typowe pytania (35)

Ćwiczenie 3. Liczby i działania algebraiczne (36)

  • Co powinieneś zobaczyć (37)
  • Zrób to sam (37)
  • Typowe pytania (37)

Ćwiczenie 4. Zmienne i nazwy (40)

  • Co powinieneś zobaczyć (41)
  • Zrób to sam (41)
  • Typowe pytania (42)

Ćwiczenie 5. Więcej zmiennych i drukowania (44)

  • Co powinieneś zobaczyć (44)
  • Zrób to sam (45)
  • Typowe pytania (45)

Ćwiczenie 6. Łańcuchy znaków i tekst (46)

  • Co powinieneś zobaczyć (47)
  • Zrób to sam (47)
  • Popsuj kod (47)
  • Typowe pytania (48)

Ćwiczenie 7. Więcej drukowania (50)

  • Co powinieneś zobaczyć (50)
  • Zrób to sam (50)
  • Popsuj kod (51)
  • Typowe pytania (51)

Ćwiczenie 8. Drukowanie, drukowanie (52)

  • Co powinieneś zobaczyć (52)
  • Zrób to sam (53)
  • Typowe pytania (53)

Ćwiczenie 9. Drukowanie, drukowanie, drukowanie (54)

  • Co powinieneś zobaczyć (54)
  • Zrób to sam (55)
  • Typowe pytania (55)

Ćwiczenie 10. Co to było? (56)

  • Co powinieneś zobaczyć (57)
  • Sekwencje ucieczki (57)
  • Zrób to sam (58)
  • Typowe pytania (58)

Ćwiczenie 11. Zadawanie pytań (60)

  • Co powinieneś zobaczyć (60)
  • Zrób to sam (61)
  • Typowe pytania (61)

Ćwiczenie 12. Wyświetlanie podpowiedzi dla użytkownika (62)

  • Co powinieneś zobaczyć (62)
  • Zrób to sam (62)
  • Typowe pytania (63)

Ćwiczenie 13. Parametry, rozpakowywanie i zmienne (64)

  • Chwileczkę! Funkcjonalności mają jeszcze inną nazwę (65)
  • Co powinieneś zobaczyć (65)
  • Zrób to sam (66)
  • Typowe pytania (66)

Ćwiczenie 14. Znak zachęty i przekazywanie zmiennej (68)

  • Co powinieneś zobaczyć (69)
  • Zrób to sam (69)
  • Typowe pytania (69)

Ćwiczenie 15. Czytanie z plików (72)

  • Co powinieneś zobaczyć (73)
  • Zrób to sam (73)
  • Typowe pytania (74)

Ćwiczenie 16. Czytanie i zapisywanie plików (76)

  • Co powinieneś zobaczyć (77)
  • Zrób to sam (78)
  • Typowe pytania (78)

Ćwiczenie 17. Więcej plików (80)

  • Co powinieneś zobaczyć (80)
  • Zrób to sam (81)
  • Typowe pytania (82)

Ćwiczenie 18. Nazwy, zmienne, kod i funkcje (84)

  • Co powinieneś zobaczyć (85)
  • Zrób to sam (86)
  • Typowe pytania (86)

Ćwiczenie 19. Funkcje i zmienne (88)

  • Co powinieneś zobaczyć (89)
  • Zrób to sam (89)
  • Typowe pytania (89)

Ćwiczenie 20. Funkcje i pliki (92)

  • Co powinieneś zobaczyć (93)
  • Zrób to sam (93)
  • Typowe pytania (93)

Ćwiczenie 21. Funkcje mogą coś zwracać (96)

  • Co powinieneś zobaczyć (97)
  • Zrób to sam (97)
  • Typowe pytania (98)

Ćwiczenie 22. Czego nauczyłeś się do tej pory? (100)

  • Miej świadomość, czego się uczysz (100)

Ćwiczenie 23. Łańcuchy znaków, bajty i kodowanie znaków (102)

  • Wstępne badanie kodu (102)
  • Przełączniki, konwencje i rodzaje kodowania (104)
  • Analizujemy dane wyjściowe (106)
  • Analizujemy kod (106)
  • Bawimy się kodowaniem (109)
  • Popsuj kod (109)

Ćwiczenie 24. Więcej praktyki (110)

  • Co powinieneś zobaczyć (111)
  • Zrób to sam (111)
  • Typowe pytania (111)

Ćwiczenie 25. Jeszcze więcej praktyki (112)

  • Co powinieneś zobaczyć (113)
  • Zrób to sam (114)
  • Typowe pytania (115)

Ćwiczenie 26. Gratulacje, rozwiąż test! (116)

  • Typowe pytania (117)

Ćwiczenie 27. Zapamiętywanie logiki (118)

  • Wyrażenie logiczne (119)
  • Tablice prawdy (119)
  • Typowe pytania (120)

Ćwiczenie 28. Ćwiczymy logikę boolowską (122)

  • Co powinieneś zobaczyć (124)
  • Zrób to sam (124)
  • Typowe pytania (124)

Ćwiczenie 29. Co, jeśli... (126)

  • Co powinieneś zobaczyć (126)
  • Zrób to sam (127)
  • Typowe pytania (127)

Ćwiczenie 30. Else oraz if (128)

  • Co powinieneś zobaczyć (129)
  • Zrób to sam (129)
  • Typowe pytania (129)

Ćwiczenie 31. Podejmowanie decyzji (130)

  • Co powinieneś zobaczyć (131)
  • Zrób to sam (131)
  • Typowe pytania (131)

Ćwiczenie 32. Pętle i listy (134)

  • Co powinieneś zobaczyć (135)
  • Zrób to sam (136)
  • Typowe pytania (136)

Ćwiczenie 33. Pętle while (138)

  • Co powinieneś zobaczyć (139)
  • Zrób to sam (139)
  • Typowe pytania (140)

Ćwiczenie 34. Uzyskiwanie dostępu do elementów list (142)

  • Zrób to sam (143)

Ćwiczenie 35. Gałęzie i funkcje (144)

  • Co powinieneś zobaczyć (145)
  • Zrób to sam (146)
  • Typowe pytania (146)

Ćwiczenie 36. Projektowanie i debugowanie (148)

  • Zasady dotyczące instrukcji if (148)
  • Zasady dotyczące pętli (148)
  • Wskazówki dotyczące debugowania (149)
  • Praca domowa (149)

Ćwiczenie 37. Przegląd symboli (150)

  • Słowa kluczowe (150)
  • Typy danych (151)
  • Sekwencje ucieczki (152)
  • Formatowanie łańcuchów znaków w starym stylu (152)
  • Operatory (153)
  • Czytanie kodu (154)
  • Zrób to sam (155)
  • Typowe pytania (155)

Ćwiczenie 38. Operacje na listach (156)

  • Co powinieneś zobaczyć (157)
  • Co mogą robić listy (158)
  • Kiedy używać list (159)
  • Zrób to sam (159)
  • Typowe pytania (160)

Ćwiczenie 39. Słowniki, piękne słowniki (162)

  • Przykład słownika (163)
  • Co powinieneś zobaczyć (164)
  • Co mogą robić słowniki (165)
  • Zrób to sam (166)
  • Typowe pytania (166)

Ćwiczenie 40. Moduły, klasy i obiekty (168)

  • Moduły są jak słowniki (168)
    • Klasy są jak moduły (169)
    • Obiekty są jak import (170)
    • Różne sposoby pobierania elementów (171)
    • Pierwszy przykład klasy (172)
  • Co powinieneś zobaczyć (172)
  • Zrób to sam (172)
  • Typowe pytania (173)

Ćwiczenie 41. Uczymy się mówić obiektowo (174)

  • Ćwiczymy słówka (174)
  • Ćwiczymy zdania (174)
  • Ćwiczenie łączone (175)
  • Test z czytania (175)
  • Tłumaczenie ze zdań na kod (177)
  • Poczytaj jeszcze więcej kodu (178)
  • Typowe pytania (178)

Ćwiczenie 42. Jest, ma, obiekty i klasy (180)

  • Jak to wygląda w kodzie (181)
  • Na temat class Nazwa(object) (183)
  • Zrób to sam (183)
  • Typowe pytania (184)

Ćwiczenie 43. Podstawowa analiza obiektowa i projekt (186)

  • Analiza prostego silnika gry (187)
    • Opisz lub rozrysuj problem (187)
    • Wyodrębnij kluczowe pojęcia i zbadaj je (188)
    • Utwórz hierarchię klas i mapę obiektów dla koncepcji (188)
    • Zakoduj klasy i napisz test, aby je uruchomić (189)
    • Powtórz i udoskonal (191)
  • Z góry do dołu i z dołu do góry (191)
  • Kod gry Goci z planety Percal 25 (192)
  • Co powinieneś zobaczyć (198)
  • Zrób to sam (198)
  • Typowe pytania (199)

Ćwiczenie 44. Porównanie dziedziczenia i kompozycji (200)

  • Co to jest dziedziczenie (200)
    • Dziedziczenie domyślne (201)
    • Bezpośrednie nadpisanie (202)
    • Zmiana zachowania przed lub po (202)
    • Połączenie wszystkich trzech sposobów (203)
  • Dlaczego super() (205)
    • Używanie super() z __init__ (205)
  • Kompozycja (205)
  • Kiedy używać dziedziczenia, a kiedy kompozycji (207)
  • Zrób to sam (207)
  • Typowe pytania (207)

Ćwiczenie 45. Tworzysz grę (210)

  • Ocenianie napisanej gry (210)
  • Styl funkcji (211)
  • Styl klas (211)
  • Styl kodu (212)
  • Dobre komentarze (212)
  • Oceń swoją grę (213)

Ćwiczenie 46. Szkielet projektu (214)

  • Konfiguracja w systemach macOS i Linux (214)
  • Konfiguracja w systemie Windows 10 (215)
  • Tworzenie szkieletu katalogu projektów (217)
    • Ostateczna struktura katalogów (218)
  • Testowanie konfiguracji (219)
  • Używanie szkieletu (220)
  • Wymagany quiz (220)
  • Typowe pytania (220)

Ćwiczenie 47. Zautomatyzowane testowanie (222)

  • Pisanie przypadku testowego (222)
  • Wytyczne testowania (224)
  • Co powinieneś zobaczyć (224)
  • Zrób to sam (225)
  • Typowe pytania (225)

Ćwiczenie 48. Zaawansowane wprowadzanie danych przez użytkownika (226)

  • Nasz leksykon gry (226)
    • Rozkładanie zdań na części (227)
    • Krotki leksykonu (227)
    • Skanowanie danych wejściowych (227)
    • Wyjątki i liczby (227)
  • Wyzwanie "najpierw przygotuj testy" (228)
  • Co powinieneś przetestować (229)
  • Zrób to sam (231)
  • Typowe pytania (231)

Ćwiczenie 49. Tworzenie zdań (232)

  • Dopasowywanie i podglądanie (232)
  • Gramatyka zdania (233)
  • Słowo o wyjątkach (233)
  • Kod parsera (233)
  • Zabawa z parserem (236)
  • Co powinieneś przetestować (237)
  • Zrób to sam (237)
  • Typowe pytania (237)

Ćwiczenie 50. Twoja pierwsza strona internetowa (238)

  • Instalowanie frameworku flask (238)
  • Tworzenie prostego projektu "Witaj, świecie" (238)
  • Co się tutaj dzieje (240)
  • Naprawianie błędów (240)
  • Tworzenie podstawowych szablonów (241)
  • Zrób to sam (243)
  • Typowe pytania (243)

Ćwiczenie 51. Pobieranie danych wejściowych z przeglądarki (246)

  • Jak działa sieć (246)
  • Jak działają formularze (248)
  • Tworzenie formularzy HTML (249)
  • Tworzenie szablonu układu (251)
  • Pisanie zautomatyzowanych testów dla formularzy (252)
  • Zrób to sam (254)
  • Popsuj kod (254)

Ćwiczenie 52. Początek Twojej gry internetowej (256)

  • Refaktoryzacja gry z ćwiczenia 43. (256)
  • Tworzenie silnika (261)
  • Twój egzamin końcowy (263)
  • Typowe pytania (264)

Następne kroki (266)

  • Jak uczyć się dowolnego języka programowania (267)

Porada starego programisty (270)

Dodatek. Przyspieszony kurs wiersza poleceń (272)

  • Wprowadzenie: zamknij się i zacznij używać powłoki (272)
    • Jak korzystać z tego dodatku (273)
    • Będziesz musiał zapamiętywać rzeczy (273)
  • Konfiguracja (274)
    • Zadanie (274)
    • Czego się nauczyłeś (275)
    • Zadanie dodatkowe (275)
  • Ścieżki, foldery, katalogi (pwd) (277)
    • Zadanie (277)
    • Czego się nauczyłeś (278)
    • Zadanie dodatkowe (278)
  • Jeśli się zgubisz (279)
    • Zadanie (279)
    • Czego się nauczyłeś (279)
  • Tworzenie katalogu (mkdir) (279)
    • Zadanie (279)
    • Czego się nauczyłeś (280)
    • Zadanie dodatkowe (281)
  • Zmienianie katalogu (cd) (281)
    • Zadanie (281)
    • Czego się nauczyłeś (284)
    • Zadanie dodatkowe (284)
  • Listowanie katalogu (ls) (285)
    • Zadanie (285)
    • Czego się nauczyłeś (287)
    • Zadanie dodatkowe (288)
  • Usuwanie katalogu (rmdir) (288)
    • Zadanie (288)
    • Czego się nauczyłeś (290)
    • Zadanie dodatkowe (290)
  • Poruszanie się po katalogach (pushd, popd) (290)
    • Zadanie (291)
    • Czego się nauczyłeś (292)
    • Zadanie dodatkowe (293)
  • Tworzenie pustych plików (touch/New-Item) (293)
    • Zadanie (293)
    • Czego się nauczyłeś (294)
    • Zadanie dodatkowe (294)
  • Kopiowanie pliku (cp) (294)
    • Zadanie (294)
    • Czego się nauczyłeś (296)
    • Zadanie dodatkowe (297)
  • Przenoszenie pliku (mv) (297)
    • Zadanie (297)
    • Czego się nauczyłeś (298)
    • Zadanie dodatkowe (298)
  • Przeglądanie pliku (less/more) (299)
    • Zadanie (299)
    • Czego się nauczyłeś (300)
    • Zadanie dodatkowe (300)
  • Strumieniowanie pliku (cat) (300)
    • Zadanie (300)
    • Czego się nauczyłeś (301)
    • Zadanie dodatkowe (301)
  • Usuwanie pliku (rm) (301)
    • Zadanie (301)
    • Czego się nauczyłeś (303)
    • Zadanie dodatkowe (303)
  • Wyjście z terminala (exit) (303)
    • Zadanie (303)
    • Czego się nauczyłeś (303)
    • Zadanie dodatkowe (303)
  • Następne kroki z wierszem poleceń (304)
    • Zasoby dla uniksowej powłoki bash (304)

Skorowidz (305)

  • Tytuł: Python 3. Proste wprowadzenie do fascynującego świata programowania
  • Autor: Zed A. Shaw
  • Tytuł oryginału: Learn Python 3 the Hard Way: A Very Simple Introduction to the Terrifyingly Beautiful World of Computers and Code (Zed Shaw's Hard Way Series)
  • Tłumaczenie: Lech Lachowski
  • ISBN: 978-83-283-4142-5, 9788328341425
  • Data wydania: 2018-05-11
  • Format: Ebook
  • Identyfikator pozycji: pyt3pw
  • Wydawca: Helion