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!

---

Zed A. Shaw jest programistą od ponad 20 lat. Chętnie angażuje się w różne projekty open source, jest również uznanym autorem wielu książek i artykułów dotyczących technik programowania. Jego książki są czytane i dyskutowane przez miliony czytelników na całym świecie. Autor ten posiada niezwykłą umiejętność pisania o trudnych zagadnieniach w sposób przystępny, żywy i interesujący, a równocześnie zmuszający czytelnika do myślenia. W wolnym czasie Shaw studiuje malarstwo i historię sztuki.

 

Osoby które kupowały "Python 3. Proste wprowadzenie do fascynującego świata programowania", wybierały także:

• DevOps w praktyce. Kurs video. Jenkins, Ansible, Terraform i Docker 190,00 zł, (39,90 zł -79%)
• Wyrażenia regularne od podstaw 39,67 zł, (11,90 zł -70%)
• Projektowanie systemów rozproszonych. Wzorce i paradygmaty dla skalowalnych, niezawodnych usług 39,67 zł, (11,90 zł -70%)
• Zrozum struktury danych. Algorytmy i praca na danych w Javie 39,67 zł, (11,90 zł -70%)
• Kosymulacja. Elastyczne projektowanie i symulacja wielodomenowa 38,39 zł, (11,90 zł -69%)

• 
• 
• 
• 
• 

Spis treści

Python 3. Proste wprowadzenie do fascynującego świata programowania eBook -- spis treści

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)