Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie

Nauka programowania. Rusz głową! Język: 1

978-83-283-4697-0

Cena Brutto: 99.00

Cena netto: 94.29

Ilość:
Wersja: Drukowana
Autor Eric Freeman
Liczba_stron 616
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2019-03-19

Nauka programowania. Rusz głową!

Programista to bardzo szczególny typ specjalisty. Jeśli uważasz, że myśli w inny sposób niż tak zwani normalni ludzie, to masz rację. Dobra wiadomość jest taka, że i Ty możesz się nauczyć myślenia komputacyjnego - umiejętności, która się przydaje niezależnie od charakteru rozwiązywanego problemu, środowiska czy języka programowania. Tylko w ten sposób można od początku nauki programowania pisać przejrzysty, uporządkowany, znakomity kod, zgodny z najlepszymi praktykami wypracowanymi przez mistrzów. Innymi słowy: pracować jak profesjonalny programista.


Ta książka jest niezwykłym podręcznikiem programowania. Być może wygląda nieco dziwacznie, ale prędko się przekonasz, że to podręcznik jest wyjątkowo skuteczny: w końcu jego formuła została opracowana na podstawie najlepszych osiągnięć neurologii i kognitywistyki. W ten sposób Twój mózg się zaangażuje i błyskawicznie przyswoi sobie zasady programowania w Pythonie. Autor wykorzystał oczywistą prawdę, że najszybciej uczymy się wtedy, gdy uwzględnimy specyfikę działania własnego mózgu! Najpierw więc się zainteresujesz, potem zaangażujesz, wreszcie przygotujesz sobie warsztat pracy, czyli zainstalujesz Pythona. Później zaczniesz ćwiczyć myślenie komputacyjne i oczywiście napiszesz swój pierwszy program. A dalej będzie coraz ciekawiej...


W tej książce między innymi:

  • Istotne koncepcje programistyczne
  • Zasady programowania w Pythonie
  • Funkcje i rekurencja
  • Programowanie obiektowe
  • Tworzenie API dla aplikacji internetowych
  • Widgety i zdarzenia

Neurony płoną. Emocje szaleją. Tak napiszesz kod godny mistrza!

    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)

powrót
 
Produkty Podobne
Python. Kurs dla nauczycieli i studentów
Nowoczesny C++.  Zbiór praktycznych zadań dla przyszłych ekspertów
Zrozumieć oprogramowanie. O prostocie kodu i doskonaleniu warsztatu programisty
Programowanie w języku Ruby. Mikrousługi i konteneryzacja
C++. Struktury danych i algorytmy
Zawód front-end developer. 11 kroków do zostania webmasterem
Python. Szybko i prosto. Wydanie III
Język Kotlin na platformie Spring. Programowanie aplikacji internetowych
ASP.NET Core, Angular i Bootstrap. Kompletny przybornik front-end developera
Python. Programowanie funkcyjne
Więcej produktów