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 \ Python

Python 3. Proste wprowadzenie do fascynującego świata programowania Język: 1

978-83-283-4141-8

Cena Brutto: 59.00

Cena netto: 56.19

Ilość:
Wersja: Drukowana
Autor Zed A. Shaw
Liczba_stron 312
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2018-05-11

Python 3

Proste wprowadzenie do fascynującego świata programowania


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

    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)

powrót
 
Produkty Podobne
Rozwijanie mikrousług w Pythonie. Budowa, testowanie, instalacja i skalowanie
Python 3. Kolejne lekcje dla nowych programistów
Data Analytics with Spark Using Python
Python w analizie danych. Przetwarzanie danych za pomocą pakietów Pandas i NumPy oraz środowiska IPython. Wydanie II
Zestaw 2 książek Python (Zaawansowany Python + Python w uczeniu maszynowym)
Python w uczeniu maszynowym. Podejście sterowane testami
Python 3. Proste wprowadzenie do fascynującego świata programowania
Przewodnik po Pythonie. Dobre praktyki i praktyczne narzędzia
Python dla profesjonalistów. Debugowanie, testowanie i utrzymywanie kodu
Python. Uczenie maszynowe
Więcej produktów