Wstęp

• Dla kogo jest ta książka? (xxvi)
• Wiemy, co myślisz (xxvii)
• Czytelnika książek z serii Rusz głową! traktujemy jak ucznia (xxviii)
• Metapoznanie: myślenie o myśleniu (xxix)
• Oto co MY zrobiliśmy (xxx)
• A co TY możesz zrobić, żeby zapanować nad swoim mózgiem? (xxxi)
• Przeczytaj to (xxxii)
• Podziękowania (xxxvii)
• Recenzenci (xxxviii

1. Myślenie komputacyjne. Zaczynamy

• Dzielenie zadań na mniejsze (2)
• Jak działa kodowanie? (6)
• Ale po jakiemu to? (7)
• Świat języków programowania (8)
• Pisanie i uruchamianie kodu w Pythonie (13)
• Bardzo krótka historia Pythona (15)
• Python - pierwsza próba (18)
• Zapisywanie wyników swojej pracy (20)
• Gratulacje! Właśnie napisałeś swój pierwszy program w Pythonie! (21)
• Dyrdymałomat (25)
• Wprowadzenie kodu do maszyny (26)

2. Proste wartości, zmienne i typy. Znaj swoje wartości

• Kodowanie kalkulatora wieku psa (34)
• Od pseudokodu do kodu (36)
• Krok 1. Pobranie danych wejściowych (37)
• Jak działa funkcja input (38)
• Używanie zmiennych do zapisywania i przechowywania wartości (38)
• Przypisanie danych wejściowych użytkownika do zmiennej (39)
• Krok 2. Zbieranie kolejnych danych (39)
• Czas uruchomić kod (40)
• Wprowadzanie kodu (43)
• Ze zmiennymi na głęboką wodę (44)
• Wyraźmy to lepiej (45)
• Zmienne nazywają się tak nie bez powodu (46)
• Pierwszeństwo operatorów kluczem do szczęśliwego życia (47)
• Obliczanie z wykorzystaniem pierwszeństwa (48)
• Ręce z klawiatury! (51)
• Krok 3. Obliczanie wieku psa (52)
• Houston, mamy problem! (53)
• Ludzką rzeczą jest błądzić (54)
• Jeszcze trochę debugowania... (56)
• Co to za typy? (58)
• Naprawianie kodu (59)
• Houston, wystartowaliśmy (60)
• Krok 4. Czytelny wynik (61)
• Końcowa jazda próbna (62)

3. Wartości logiczne, decyzje i pętle. Decyzyjny kod

• Może chciałbyś zagrać? (72)
• Najpierw projekt (74)
• Wybór komputera (75)
• Jak używać liczb losowych? (76)
• Kolejny krok... (77)
• Prawda czy fałsz? (78)
• Wartości logiczne (79)
• Podejmowanie decyzji (80)
• Decyzje, decyzje... (81)
• Wracamy do gry (82)
• Pobranie wyboru użytkownika (83)
• Sprawdzenie wyboru użytkownika (86)
• Wprowadzenie kodu wykrywającego remis (87)
• Kto wygrał? (88)
• Jak zaimplementować logikę gry? (90)
• Więcej o operatorach logicznych (91)
• Wyświetl, kto wygrał (94)
• A dokumentacja jest? (96)
• Jak umieszczać komentarze w kodzie? (97)
• Musimy dokończyć grę! (98)
• Skąd wiemy, że wybór użytkownika jest niepoprawny? (99)
• Sprawdzanie i porządkowanie wyrażenia (100)
• Jak wyświetlać zapytanie cyklicznie? (102)
• Wykonywanie działań więcej niż raz (103)
• Jak działa pętla while? (104)
• Jak użyć while do wyświetlania zapytań aż do otrzymania poprawnego wyboru (108)
• Gratulacje! Zakodowałeś swoją pierwszą grę! (110)

4. Listy i iteracje. Odrobina struktury

• Czy pomożesz Bańkom? (122)
• Jak przedstawić wiele wartości w Pythonie? (123)
• Jak działają listy? (124)
• Jak pobrać element listy? (125)
• Zmiana wartości w liście (125)
• Jak długa jest ta lista? (127)
• Pobieranie ostatniego elementu listy (128)
• Stosowanie indeksów ujemnych Pythona (129)
• Tymczasem w firmie Bańki S.A... (131)
• Dyskusja nad biurkiem (133)
• Jak iterować listę? (134)
• Usuwanie błędu (135)
• Krótka jazda próbna (135)
• Skuteczne usuwanie błędu (136)
• Szybka jazda próbna (136)
• Pętla for - preferowana metoda iterowania listy (138)
• Jak pętla for działa na zakresie liczb? (141)
• Zastosowania zakresów (142)
• Generowanie raportu (144)
• Przetestuj raport o roztworach na bańki (145)
• Dyskusja nad biurkiem - ciąg dalszy (149)
• Tworzenie własnej listy od podstaw (152)
• Dodatkowe działania na listach (153)
• Przetestuj gotowy kod raportu (157)
• Najlepsze roztwory to... (157)
• Testowanie kodu znajdującego najbardziej opłacalny roztwór (161)

5. Funkcje i abstrakcje. Funkcyjny kod

• Co jest z tym kodem nie tak? (175)
• Przekształcenie bloku kodu w FUNKCJĘ (177)
• Jak użyć utworzonej funkcji? (178)
• Jak to właściwie działa? (178)
• Funkcje mogą też ZWRACAĆ wyniki (186)
• Jak wywołać funkcję z wartością zwrotną? (187)
• Pierwsze kroki z refaktoryzacją (189)
• Wykonanie kodu (190)
• Jak wyabstrahować kod awatara? (191)
• Pisanie ciała funkcji pobierz_ceche (192)
• Wywoływanie funkcji pobierz_ceche (193)
• Musimy porozmawiać o zmiennych... (195)
• Zasięg zmiennej (196)
• Kiedy zmienne są przekazywane funkcjom? (197)
• Wywołanie funkcji wypij_mnie (198)
• Co ze zmiennymi globalnymi w funkcjach? (201)
• Zaawansowane parametry: wartości domyślne i argumenty kluczowe (204)
• Zawsze deklaruj wymagane parametry jako pierwsze! (205)
• Używanie argumentów kluczowych (206)
• Jak korzystać z tych opcji? (206)

4. Część II. Sortowanie i zagnieżdżona iteracja. Porządkowanie danych

• Dyskusja nad biurkiem (219)
• Zrozumieć sortowanie bąbelkowe (220)
• Pseudokod sortowania bąbelkowego (223)
• Dyskusja nad biurkiem - ciąg dalszy (224)
• Implementacja sortowania bąbelkowego w Pythonie (226)
• Obliczanie numerów roztworów na bańki (228)

6. Tekst, łańcuchy i heurystyki. Składanie wszystkiego w całość

• Wprowadzenie do analityki danych (238)
• Jak obliczyć czytelność? (239)
• Plan działania (240)
• Przygotowanie pseudokodu (241)
• Potrzebujemy tekstu do analizy (242)
• Przygotowanie funkcji (244)
• Przede wszystkim: musimy uzyskać łączną liczbę słów w tekście (245)
• Dyskusja nad biurkiem (246)
• Obliczanie łącznej liczby zdań (249)
• Tworzenie funkcji policz_zdania (250)
• Obliczanie liczby sylab, czyli jak przestałem się martwić i pokochałem heurystykę (256)
• Dyskusja nad biurkiem - ciąg dalszy (258)
• Formułowanie heurystyki (259)
• Pisanie heurystyki (260)
• Jak liczyć samogłoski? (261)
• Ignorowanie konsekutywnych samogłosek (261)
• Pisanie kodu ignorującego konsekutywne samogłoski (262)
• Pomijanie końcowych liter e i y oraz interpunkcji (264)
• Krojenie w praktyce (266)
• Wykończenie kodu heurystyki (268)
• Implementacja wzoru na czytelność (270)
• Co dalej? (275)

7. Moduły, metody, klasy i obiekty. Myślenie modularne

• Dyskusja nad biurkiem (283)
• Krótkie omówienie modułów (284)
• Dyskusja nad biurkiem - ciąg dalszy (285)
• Zmienna globalna __name__ (286)
• Rozmowa nad biurkiem - ciąg dalszy (287)
• Aktualizacja pliku analyze.py (287)
• Wykorzystanie pliku analyze.py jako modułu (289)
• Dodawanie notek dokumentacyjnych do pliku analyze.py (291)
• Inne moduły Pythona (295)
• Zaraz... "żółwie"?! (296)
• Tworzenie własnego żółwia (298)
• Żółwiowe laboratorium (299)
• Dodawanie drugiego żółwia (301)
• Czym w ogóle są te żółwie? (304)
• Czym są obiekty? (305)
• Czym jest w takim razie klasa? (306)
• Klasa określa, co obiekt wie i co może zrobić (307)
• Jak używać obiektów i klas? (308)
• Co z metodami i atrybutami? (309)
• Klasy i obiekty są wszędzie (310)
• Zorganizujmy wyścigi żółwi (312)
• Planowanie gry (313)
• Zacznijmy pisać kod (314)
• Pisanie kodu przygotowującego (315)
• Hola, hola! (316)
• Rozpoczęcie wyścigu (318)

8. Rekurencja i słowniki. Poza iteracją i indeksami

• Inny sposób wykonywania obliczeń (330)
• Zróbmy to teraz inaczej... (331)
• Napiszmy teraz kod na potrzeby obydwu przypadków (332)
• Ćwiczymy dalej (335)
• Wykrywanie palindromów rekurencyjnie (336)
• Pisanie rekurencyjnego wykrywacza palindromów (337)
• Serwis Aspołecznościowy (348)
• Wprowadzenie do słowników (350)
• Co z iterowaniem po słowniku? (352)
• Wykorzystanie słowników w Serwisie Aspołecznościowym (354)
• Jak dodać więcej właściwości? (356)
• Pamiętasz o głównej funkcji Serwisu Aspołecznościowego? (358)
• Teraz wszystko w Twoich rękach! (360)
• Czy możemy po prostu zapisywać wyniki? (364)
• Użyjmy cennego słówka: memoizacja (365)
• Jak działa funkcja koch? (368)
• Fraktal Kocha z bliska (370)
• Ten fraktal nieprzypadkowo nazywa się płatkiem (370)

9. Zapisywanie i zwracanie plików. Trwałość danych

• Może opowiemy sobie szaloną historię? (380)
• Jak działają Szalone historie? (382)
• Krok 1. Odczytanie tekstu historyjki z pliku (385)
• Jak używać ścieżek plików? (386)
• Ścieżki bezwzględne (387)
• Pamiętaj, żeby po sobie posprzątać! (388)
• Wczytywanie pliku do kodu Pythona (389)
• Odczyt pliku przy użyciu obiektu plikowego (389)
• Zrób sobie przerwę (392)
• Hej, musimy jeszcze skończyć naszą grę! (393)
• Skąd wiemy, że dotarliśmy do ostatniego wiersza? (395)
• Sekwencje Pythona mogą nam to ułatwić (395)
• Wczytywanie szablonu Szalonych historii (396)
• Przetwarzanie tekstu szablonu (397)
• Użycie nowej metody łańcucha do naprawienia błędu (399)
• Naprawienie błędu (400)
• Problemy z kodem (401)
• Obsługa wyjątków (403)
• Bezpośrednie obsługiwanie wyjątków (404)
• Obsługa wyjątków w Szalonych historiach (406)
• Ostatni krok: zapisywanie historyjki (407)
• Aktualizacja pozostałej części kodu (407)

10. Używanie webowych API. Żądania i odpowiedzi

• Sięgnij dalej za pomocą webowych API (420)
• Jak działają webowe API? (421)
• Każde webowe API ma adres internetowy (422)
• Wprowadźmy drobne ulepszenie (425)
• Aktualizacja (426)
• Potrzebujemy teraz dobrego webowego API... (427)
• API z bliska (428)
• Webowe API przekazują dane przy użyciu JSON-a (429)
• Przyjrzyjmy się ponownie modułowi requests (431)
• Składanie wszystkiego w całość: wysłanie żądania do Open Notify (433)
• Jak używać JSON-a w Pythonie? (434)
• Używanie modułu JSON z danymi ISS (435)
• Dodajemy grafikę (436)
• Tworzymy obiekt ekranu (437)
• Dodajemy żółwia reprezentującego ISS (439)
• Żółw może też wyglądać jak stacja kosmiczna (440)
• Stacja jak stacja, ale co z kodem? (441)
• Uzupełnienie kodu ISS (442)

11. Widżety, zdarzenia i zachowania emergentne. Interaktywność

• Poznaj CUDOWNY ŚWIAT niesamowitego SZTUCZNEGO ŻYCIA (450)
• Gra w życie z bliska (451)
• Co chcemy stworzyć? (454)
• Czy mamy odpowiedni projekt? (455)
• W jaki sposób utworzymy symulator? (458)
• Tworzenie modelu danych (459)
• Obliczanie stanu pokolenia w grze (460)
• Uzupełnianie kodu modelu (464)
• Na jakim etapie jesteśmy? (466)
• Tworzenie widoku (467)
• Tworzenie swojego pierwszego widżetu (468)
• Dodawanie pozostałych widżetów (469)
• Poprawianie układu (470)
• Rozmieszczanie widżetów w układzie siatki (471)
• Zajmijmy się kontrolerem (473)
• Gotów na kolejny nowy styl programowania? (476)
• Dodajmy handler kliknięć (477)
• Jak będzie działać przycisk startu/pauzy? (479)
• Implementacja przycisku startu i pauzy (480)
• Zdarzenie innego rodzaju (481)
• Mamy odpowiednią technologię: metodę after (483)
• Daleko jeszcze? (484)
• Jak bezpośrednio wprowadzać i edytować komórki? (486)
• Pisanie handlera widok_siatki (487)
• Czas dodać predefiniowane wzorce (488)
• Pisanie kodu handlera OptionMenu (489)
• Jak zdefiniować wzorce? (491)
• Pisanie funkcji wczytywania wzorców (492)
• Jazda próbna (493)

12. Programowanie obiektowe. Wycieczka do Obiektowa

• Rozkładanie zadań w inny sposób (506)
• Jaki jest sens programowania obiektowego? (507)
• Projektujemy swoją pierwszą klasę (509)
• Piszemy swoją pierwszą klasę (510)
• Pisanie metody szczekanie (513)
• Jak działają metody? (514)
• Dodawanie dziedziczenia (516)
• Implementacja klasy PiesTowarzyszacy (517)
• Podklasy z bliska (518)
• PiesTowarzyszacy to też Pies (519)
• Sprawdzanie obecności relacji IS-A (520)
• Oddajmy głos psom (523)
• Nadpisywanie i rozszerzanie metod (524)
• Witamy w Żargonowie (526)
• Obiekt może zawierać inny obiekt (528)
• Projektowanie Hotelu dla Psiaków (531)
• Implementacja Hotelu dla Psiaków (532)
• Remont Hotelu dla Psiaków (535)
• Dodawanie zajęć w hotelu (536)
• Umiem wszystko, co ty umiesz, czyli polimorfizm (537)
• Czas nauczyć pozostałe psy chodzenia (538)
• Moc dziedziczenia (540)
• Tworzenie usługi wyprowadzania psów (541)
• Jak mamy zatrudnić wyprowadzacza, skoro nawet nie mamy obiektów osób? (542)
• Tymczasem na wyścigach żółwi... (545)
• ROZWIĄZANIE afery z żółwiami (547)

A. Dodatek. Coś na deser. Dziesięć najważniejszych tematów (których nie omówiliśmy)

• #1 Listy składane (556)
• #2 Daty i godziny (557)
• #3 Wyrażenia regularne (558)
• #4 Inne typy danych: krotki (559)
• #5 Inne typy danych: zbiory (560)
• #6 Kod po stronie serwera (561)
• #7 Ewaluacja leniwa (562)
• #8 Dekoratory (563)
• #9 Funkcje wyższego rzędu i pierwszoklasowe (564)
• #10 Biblioteki (565)

Skorowidz (567)

• Tytuł: Nauka programowania. Rusz głową!
• Autor: Eric Freeman
• Tytuł oryginału: Head First Learn to Code: A Learner's Guide to Coding and Computational Thinking
• Tłumaczenie: Maksymilian Gutowski
• ISBN: 978-83-283-4698-7, 9788328346987
• Data wydania: 2019-03-19
• Format: Ebook
• Identyfikator pozycji: nauprg
• Wydawca: Helion