Darmowa dostawa od 150,00 zł
Python 3. Proste wprowadzenie do fascynującego świata programowania

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

  • Rok wydania: 2018 Oprawa: miękka ISBN: 9788328341418 Ilość stron: 312 Format: 17,5 x 23,5 cm  
Rozmiar
Najniższa cena z 30 dni przed obniżką: / szt.
Cena regularna: / szt.
Cena katalogowa:
Możesz kupić za pkt.
z
Produkt dostępny w bardzo dużej ilości
Skontaktuj się z obsługą sklepu, aby oszacować czas przygotowania tego produktu do wysyłki.
Produkt dostępny w bardzo dużej ilości
Wysyłka
14 dni na łatwy zwrot
Sprawdź, w którym sklepie obejrzysz i kupisz od ręki
Python 3. Proste wprowadzenie do fascynującego świata programowania
Python 3. Proste wprowadzenie do fascynującego świata programowania
Bezpieczne zakupy
Odroczone płatności. Kup teraz, zapłać później, jeżeli nie zwrócisz
Kup teraz, zapłać później - 4 kroki
Przy wyborze formy płatności, wybierz PayPo.PayPo - kup teraz, zapłać za 30 dni
PayPo opłaci twój rachunek w sklepie.
Na stronie PayPo sprawdź swoje dane i podaj pesel.
Po otrzymaniu zakupów decydujesz co ci pasuje, a co nie. Możesz zwrócić część albo całość zamówienia - wtedy zmniejszy się też kwota do zapłaty PayPo.
W ciągu 30 dni od zakupu płacisz PayPo za swoje zakupy bez żadnych dodatkowych kosztów. Jeśli chcesz, rozkładasz swoją płatność na raty.
Po zakupie otrzymasz pkt.

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!

O autorze

Zed A. Shaw — ceniony programista, którego najbardziej znanym projektem jest serwer WWW Mongrel dla aplikacji Ruby. Jest również autorem wielu artykułów i książek dotyczących technik programowania, jak Learn Python the Hard Way i Learn Ruby the Hard Way, które cieszą się ogromną popularnością — są czytane i dyskutowane przez miliony Czytelników na całym świecie. Shaw posiada niezwykłą umiejętność pisania o trudnych zagadnieniach w sposób przystępny, żywy i interesujący. Potrafi objaśniać najtrudniejsze zagadnienia informatyki jak nikt inny.

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)

Marka
Autor
Zed A. Shaw
ISBN
9788328341418
Potrzebujesz pomocy? Masz pytania?Zadaj pytanie a my odpowiemy niezwłocznie, najciekawsze pytania i odpowiedzi publikując dla innych.
Zapytaj o produkt
Jeżeli powyższy opis jest dla Ciebie niewystarczający, prześlij nam swoje pytanie odnośnie tego produktu. Postaramy się odpowiedzieć tak szybko jak tylko będzie to możliwe. Dane są przetwarzane zgodnie z polityką prywatności. Przesyłając je, akceptujesz jej postanowienia.
Napisz swoją opinię
Twoja ocena:
5/5
Dodaj własne zdjęcie produktu:
pixel