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. Rusz głową! Wydanie II Język: 1

978-83-283-3734-3

Cena Brutto: 99.00

Cena netto: 94.29

Ilość:
Wersja: Drukowana
Autor Paul Barry
Liczba_stron 616
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2017-11-17

Python

Rusz głową! Wydanie II


Python, prosty, wszechstronny i elastyczny język programowania, nadaje się zarówno do pisania niedużych skryptów, wielkich systemów, jak i do wysoce specjalistycznych zadań, jak choćby analiza danych do celów naukowych. To ulubione narzędzie coraz liczniejszej rzeszy znakomitych programistów. Wiele osób próbuje się uczyć Pythona, jednak mimo różnorodnych podręczników i kursów nauka pisania poprawnego, wydajnego i przejrzystego kodu w tym języku wciąż sprawia problemy.


Ta książka jest doskonałym podręcznikiem Pythona. Poza podstawami języka opisano tu sposoby posługiwania się Pythonem w prawdziwym świecie podczas pisania kodu aplikacji WWW czy obsługiwania baz danych. Przedstawiono tu również dość trudne tematy, takie jak kolekcje i niemodyfikowalność. Co ciekawe, materiał do książki przygotowano w szczególny sposób, posługując się metodami nowoczesnej kognitywistyki i dydaktyki, które uwzględniają specyfikę pracy ludzkiego mózgu, aktywnie go angażując podczas nauki. W ten sposób Python wchodzi do głowy niepostrzeżenie, w szybki, zabawny i interesujący sposób!

W tej książce:

  • szybkie wprowadzenie do Pythona
  • korzystanie z danych i z baz danych
  • praktyczne projektowanie aplikacji WWW
  • zarządzanie kontekstem
  • wątki, wyjątki i iteracje w Pythonie
  • narzędzia, biblioteki i moduły przydatne programiście Pythona

    Wprowadzenie

    • Dla kogo jest ta książka? (xxviii)
    • Wiemy, co myślisz (xxix)
    • Wiemy, co myśli Twój mózg (xxix)
    • Metapoznanie - myślenie o myśleniu (xxxi)
    • To, co MY zrobiliśmy (xxxii)
    • Przeczytaj to (xxxiv)
    • Podziękowania (xxxvii)

    1. Podstawy

    • Znaczenie okien środowiska IDLE (4)
    • Uruchamianie kodu instrukcja po instrukcji (8)
    • Funkcje + moduły = biblioteka standardowa (9)
    • Struktury danych są wbudowane (13)
    • Wywoływanie metod daje wyniki (14)
    • Decydowanie, kiedy należy wykonać blok kodu (15)
    • Co jeszcze może Ci dać instrukcja warunkowa? (17)
    • Zestawy mogą zawierać zagnieżdżone zestawy (18)
    • Powrót do powłoki Pythona (22)
    • Eksperymentowanie w powłoce (23)
    • Iterowanie po sekwencji obiektów (24)
    • Iterowanie określoną liczbę razy (25)
    • Zastosowanie rezultatu Zadania nr 1 w naszym kodzie (26)
    • Przygotowanie do wstrzymania wykonania (28)
    • Generowanie losowych liczb całkowitych w Pythonie (30)
    • Pisanie poważnej aplikacji biznesowej (38)
    • Czy wcięcia doprowadzają Cię do szału? (40)
    • Proszenie interpretera o pomoc dotyczącą funkcji (41)
    • Eksperymentowanie z zakresami (42)
    • Kod przykładów z rozdziału 1. (46)

    2. Listy

    • Liczby, łańcuchy znakowe... i obiekty (48)
    • Poznaj cztery wbudowane struktury danych (50)
    • Nieuporządkowana struktura danych: słownik (52)
    • Struktura danych, która eliminuje duplikaty: zbiór (53)
    • Literalne tworzenie list (55)
    • Korzystaj z edytora, gdy pracujesz nad dłuższym fragmentem kodu (57)
    • "Rozrost" listy w czasie wykonywania (58)
    • Sprawdzanie przynależności za pomocą operatora in (59)
    • Usuwanie obiektów z listy (62)
    • Poszerzanie listy o nowe obiekty (64)
    • Wstawianie obiektu na listę (65)
    • Jak skopiować strukturę danych (73)
    • Listy rozszerzają notację wykorzystującą nawiasy kwadratowe (75)
    • Listy "rozumieją" początek, koniec i krok (76)
    • Działania na początku i końcu listy (78)
    • Zaprzęganie wycinków do pracy z listami (80)
    • Pętla for w języku Python "rozumie" listy (86)
    • Wycinki listy Marvina z bliska (88)
    • Kiedy nie używać list (91)
    • Kod przykładów z rozdziału 2. (1. z 2) (92)

    3. Dane strukturalne

    • Słownik przechowuje pary klucz-wartość (96)
    • Jak znaleźć słownik w kodzie (98)
    • Kolejność wprowadzania NIE jest zachowywana (99)
    • Wyszukiwanie wartości przy użyciu nawiasów kwadratowych (100)
    • Korzystanie ze słowników w czasie wykonywania programu (101)
    • Aktualizacja licznika częstotliwości (105)
    • Iterowanie po słowniku (107)
    • Iterowanie po kluczach i wartościach (108)
    • Iterowanie po słowniku przy użyciu metody items (110)
    • Jak dynamiczne są słowniki? (114)
    • Unikanie wyjątków KeyError w czasie wykonania (116)
    • Sprawdzanie przynależności za pomocą operatora in (117)
    • Zapewnianie inicjalizacji przed użyciem (118)
    • Zastępowanie operatora in operatorami not in (119)
    • Zaprzęganie metody setdefault do pracy (120)
    • Wydajne tworzenie zbiorów (124)
    • Korzystanie z metod zbioru (125)
    • Tworzenie przypadku dla krotek (132)
    • Łączenie wbudowanych struktur danych (135)
    • Uzyskiwanie dostępu do złożonych struktur danych (141)
    • Kod przykładów z rozdziału 3. (1. z 2) (143)

    4. Ponowne użycie kodu

    • Ponowne wykorzystywanie kodu za pomocą funkcji (146)
    • Wprowadzenie do funkcji (147)
    • Wywoływanie Twojej funkcji (150)
    • Funkcje przyjmują argumenty (154)
    • Zwracanie jednej wartości (158)
    • Zwracanie więcej niż jednej wartości (159)
    • Przypomnienie wbudowanych struktur danych (161)
    • Tworzenie funkcji ogólnego przeznaczenia (165)
    • Tworzenie kolejnej funkcji (1. z 3) (166)
    • Określanie domyślnych wartości argumentów (170)
    • Układ pozycyjny kontra słowa kluczowe (171)
    • Odświeżanie tego, co już wiemy o funkcjach (172)
    • Uruchamianie Pythona z wiersza poleceń (175)
    • Tworzenie wymaganych plików konfiguracji (179)
    • Tworzenie pliku dystrybucji (180)
    • Instalowanie pakietów za pomocą narzędzia pip (182)
    • Prezentacja semantyki "wywołania przez wartość" (185)
    • Prezentacja semantyki "wywołania przez referencję" (186)
    • Instalacja narzędzi programistycznych do testowania (190)
    • Jak bardzo zgodny z PEP 8 jest nasz kod? (191)
    • Znaczenie komunikatów błędów (192)
    • Kod przykładów z rozdziału 4. (194)

    5. Budowanie aplikacji WWW

    • Python: co już wiemy (196)
    • Czego oczekujemy od naszej aplikacji WWW? (200)
    • Zainstalujmy framework Flask (202)
    • Jak działa framework Flask? (203)
    • Pierwsze uruchomienie aplikacji WWW wykorzystującej framework Flask (204)
    • Tworzenie obiektu aplikacji WWW frameworka Flask (206)
    • Dekorowanie funkcji za pomocą ciągu URL (207)
    • Uruchamianie działań Twojej aplikacji WWW (208)
    • Udostępnianie funkcji w sieci (209)
    • Budowanie formularza HTML (213)
    • Szablony mają związek ze stronami WWW (216)
    • Renderowanie szablonów z poziomu Flaska (217)
    • Wyświetlanie formularza HTML aplikacji WWW (218)
    • Przygotowanie do uruchomienia kodu szablonu (219)
    • Znaczenie kodów stanu HTTP (222)
    • Obsługa danych przekazywanych za pomocą metody POST (223)
    • Ulepszenie cyklu edycji, zatrzymywania, uruchamiania i testowania (224)
    • Dostęp do danych formularza HTML za pomocą Flaska (226)
    • Używanie danych żądania w swojej aplikacji WWW (227)
    • Generowanie wyników w postaci kodu HTML (229)
    • Przygotowywanie aplikacji WWW do umieszczenia w chmurze (238)
    • Kod przykładów z rozdziału 5. (241)

    6. Przechowywanie danych i manipulowanie nimi

    • Robienie czegoś z danymi Twojej aplikacji WWW (244)
    • Python obsługuje otwieranie, przetwarzanie i zamykanie (245)
    • Odczytywanie danych z istniejącego pliku (246)
    • Lepsze otwieranie, przetwarzanie i zamykanie za pomocą instrukcji with (248)
    • Przeglądanie logu za pomocą naszej aplikacji WWW (254)
    • Sprawdzanie surowych danych za pomocą przeglądarki źródeł strony (256)
    • Czas na użycie sekwencji ucieczki (w stosunku do Twoich danych) (257)
    • Przeglądanie pełnego logu w Twojej aplikacji WWW (258)
    • Logowanie wybranych atrybutów żądania sieciowego (261)
    • Loguj pojedynczy wiersz rozdzielonych danych (262)
    • Od surowych danych do czytelnych danych wyjściowych (265)
    • Generowanie czytelnych danych wyjściowych przy użyciu kodu HTML (274)
    • Osadzanie logiki wyświetlania w swoim szablonie (275)
    • Produkcja czytelnych danych wyjściowych przy użyciu silnika Jinja2 (276)
    • Bieżący stan kodu naszej aplikacji WWW (278)
    • Zadawanie pytań na temat swoich danych (279)
    • Kod przykładów z rozdziału 6. (280)

    7. Używanie bazy danych

    • Włączanie obsługi bazy danych w Twojej aplikacji WWW (282)
    • Zadanie nr 1: Zainstaluj serwer bazy danych MySQL (283)
    • Wprowadzenie do DB-API języka Python (284)
    • Zadanie nr 2: Zainstaluj sterownik bazy danych MySQL dla języka Python (285)
    • Zainstaluj sterownik MySQL-Connector/Python (286)
    • Zadanie nr 3: Utwórz bazę danych i tabele dla naszej aplikacji WWW (287)
    • Wybierz strukturę dla swojego logu (288)
    • Potwierdź, że Twoja tabela jest gotowa na przyjęcie danych (289)
    • Zadanie nr 4: Utwórz kod, za pomocą którego nasza aplikacja WWW będzie korzystała z bazy danych i tabel (296)
    • Przechowywanie danych to dopiero połowa sukcesu (300)
    • Jak najlepiej ponownie użyć Twojego kodu obsługi bazy danych? (301)
    • Zastanów się, co próbujesz ponownie wykorzystać (302)
    • A co z tą instrukcją importowania? (303)
    • Miałeś już wcześniej do czynienia z tym wzorcem (305)
    • Zła wiadomość nie jest wcale aż taka zła (306)
    • Kod przykładów z rozdziału 7. (307)

    8. Trochę klasy

    • Zastosowanie instrukcji with (310)
    • Elementarz programowania zorientowanego obiektowo (311)
    • Tworzenie obiektów klas (312)
    • Obiekty współdzielą zachowanie, ale nie stan (313)
    • Więcej działań z klasą CountFromBy (314)
    • Wywołanie metody: zrozumienie szczegółów (316)
    • Dodawanie metody do klasy (318)
    • Duże znaczenie self (320)
    • Radzenie sobie z zasięgiem (321)
    • Poprzedzaj swoje atrybuty nazwą self (322)
    • Inicjalizuj wartości (atrybutów) przed użyciem (323)
    • Dunder init umożliwia inicjalizowanie atrybutów (324)
    • Inicjalizowanie atrybutów za pomocą dundera init (325)
    • Znaczenie reprezentacji klasy CountFromBy (328)
    • Definiowanie reprezentacji klasy CountFromBy (329)
    • Zapewnianie sensownych wartości domyślnych dla klasy CountFromBy (330)
    • Klasy: co już wiemy (332)
    • Kod przykładów z rozdziału 8. (333)

    9. Protokół zarządzania kontekstem

    • W jaki sposób najlepiej współdzielić kod obsługi bazy danych naszej aplikacji WWW? (336)
    • Zarządzanie kontekstem za pomocą metod (338)
    • Menedżer kontekstu widziałeś już w akcji (339)
    • Utwórz nową klasę menedżera kontekstu (340)
    • Zainicjalizuj klasę przy użyciu konfiguracji bazy danych (341)
    • Dokonaj konfiguracji za pomocą metody __enter__ (343)
    • Przeprowadź demontaż za pomocą metody __exit__ (345)
    • Zrewiduj kod swojej aplikacji WWW (1. z 2) (348)
    • Przypomnienie funkcji log_request (350)
    • Modyfikacja funkcji log_request (351)
    • Przypomnienie funkcji view_the_log (352)
    • Nie tylko kod się tu zmienia (353)
    • Modyfikacja funkcji view_the_log (354)
    • Odpowiadanie na pytania o dane (359)
    • Kod przykładów z rozdziału 9. (1. z 2) (360)

    10. Dekoratory funkcji

    • Twój kod działa na serwerze WWW (nie na Twoim komputerze) (366)
    • Technologia sesji frameworka Flask zapewnia stan (368)
    • Przeszukiwanie słownika umożliwia pobranie stanu (369)
    • Zarządzanie logowaniem za pomocą sesji (374)
    • Zajmijmy się wylogowywaniem i sprawdzaniem stanu (377)
    • Przekaż funkcję do funkcji (386)
    • Wywoływanie przekazanej funkcji (387)
    • Przyjmowanie listy argumentów (390)
    • Przetwarzanie listy argumentów (391)
    • Przyjmowanie słowników argumentów (392)
    • Przetwarzanie słownika argumentów (393)
    • Przyjmowanie dowolnej liczby i typu argumentów funkcji (394)
    • Tworzenie dekoratora funkcji (397)
    • Ostatni krok: obsługa argumentów (401)
    • Zaprzęganie Twojego dekoratora do pracy (404)
    • Powrót do ograniczania dostępu do strony /viewlog (408)
    • Kod przykładów z rozdziału 10. (1. z 2) (410)

    11. Obsługa wyjątków

    • Bazy danych nie są zawsze dostępne (418)
    • Ataki sieciowe to prawdziwy problem (419)
    • Operacje wejścia-wyjścia są (czasami) powolne (420)
    • Wywołania Twoich funkcji mogą się nie powieść (421)
    • Kod podatny na błędy powinieneś zawsze próbować wykonywać (423)
    • Korzystaj z jednej instrukcji try, ale wielu klauzul except (426)
    • Kod obsługi wszystkich wyjątków (428)
    • Poznawanie wyjątków za pomocą modułu sys (430)
    • Zrewidowany kod obsługi wszystkich wyjątków (431)
    • Powrót do kodu naszej aplikacji WWW (433)
    • Cicha obsługa wyjątków (434)
    • Obsługa innych błędów bazy danych (440)
    • Unikaj ściśle sprzężonego kodu (442)
    • Zrewidowany moduł DBcm (443)
    • Tworzenie własnego wyjątku (444)
    • Co jeszcze może pójść źle z modułem DBcm? (448)
    • Obsługa wyjątku SQLError odbywa się w inny sposób (451)
    • Zgłaszanie wyjątku SQLError (453)
    • Szybkie przypomnienie: poprawianie odporności (455)
    • Jak radzić sobie z czekaniem? To zależy... (456)
    • Kod przykładów z rozdziału 11. (1. z 3) (457)

    11 i 3/4. Trochę wątków

    • Oczekiwanie: co robić? (462)
    • Jak odpytujesz swoją bazę danych? (463)
    • Instrukcje INSERT i SELECT są różne (464)
    • Robienie więcej niż jednej rzeczy naraz (465)
    • Nie daj się zdołować: użyj wątków (466)
    • Najpierw najważniejsze: nie panikuj (470)
    • Nie daj się zdołować: pomóc może Ci framework Flask (471)
    • Czy Twoja aplikacja jest teraz odporna? (474)
    • Kod przykładów z rozdziału 11 3/4 (1. z 2) (475)

    12. Zaawansowana iteracja

    • Odczytywanie danych CSV jako list (479)
    • Odczytywanie danych CSV jako słowników (480)
    • "Obieranie", a następnie podział Twoich surowych danych (482)
    • Zachowaj ostrożność, łącząc wywołania metod w łańcuch (483)
    • Przekształcanie danych na format, którego potrzebujesz (484)
    • Przekształcanie do postaci słownika list (485)
    • Dostrzeganie wzorców w przypadku list (490)
    • Przekształcanie wzorców w komprehencje (491)
    • Przyjrzyj się uważnie swojej komprehencji (492)
    • Definiowanie komprehencji słownika (494)
    • Rozszerz komprehencje za pomocą filtrów (495)
    • Poradź sobie z komplikacjami w sposób charakterystyczny dla Pythona (499)
    • Komprehencja zbioru w akcji (505)
    • Co z "komprehencjami krotek"? (507)
    • Nawiasy okrągłe wokół kodu = generator (508)
    • Używanie komprehencji listy do przetwarzania URL-i (509)
    • Używanie generatora do przetwarzania URL-i (510)
    • Zdefiniuj, co powinna robić Twoja funkcja (512)
    • Ulegnij potędze funkcji generatorowych (513)
    • Śledzenie Twojej funkcji generatorowej (1. z 2) (514)
    • Ostatnie pytanie (518)
    • Kod przykładów z rozdziału 12. (519)
    • Czas w drogę... (520)

    A. Instalacja

    • Zainstaluj Pythona 3 w systemie Windows (522)
    • Sprawdź Pythona 3 w systemie Windows (523)
    • Dodawanie modułów do Pythona 3 w systemie Windows (524)
    • Zainstaluj Pythona 3 w systemie Mac OS X (macOS) (525)
    • Sprawdź i skonfiguruj Pythona 3 w systemie Mac OS X (526)
    • Zainstaluj Pythona 3 w systemie Linux (527)

    B. PythonAnywhere

    • Krok 0. Niewielkie przygotowania (530)
    • Krok 1. Zarejestruj się w serwisie PythonAnywhere (531)
    • Krok 2. Wgraj swoje pliki do chmury (532)
    • Krok 3. Rozpakuj i zainstaluj swój kod (533)
    • Krok 4. Utwórz starter aplikacji WWW (1. z 2) (534)
    • Krok 5. Skonfiguruj swoją aplikację WWW (536)
    • Krok 6. Weź w obroty swoją aplikację WWW działającą w chmurze! (537)

    C. Dziesięć najważniejszych tematów, których nie poruszyliśmy

    • 1. Co z Pythonem 2? (540)
    • 2. Wirtualne środowiska programistyczne (541)
    • 3. Więcej na temat obiektowości (542)
    • 4. Specyfikatory formatów łańcuchów znakowych i tym podobne (543)
    • 5. Sortowanie rzeczy (544)
    • 6. Więcej z biblioteki standardowej (545)
    • 7. Równoległe wykonywanie Twojego kodu (546)
    • 8. Graficzne interfejsy użytkownika z biblioteką tkinter
    • (i zabawa z żółwiami) (547)
    • 9. Kod nie jest skończony, dopóki nie jest przetestowany (548)
    • 10. Debuguj, debuguj, debuguj (549)

    D. Dziesięć najważniejszych nieomówionych projektów

    • 1. Alternatywy dla wiersza poleceń powłoki Pythona (552)
    • 2. Alternatywy dla środowiska IDLE (553)
    • 3. Jupyter Notebook: IDE dostępne z poziomu przeglądarki WWW (554)
    • 4. Przeprowadzanie analizy danych (555)
    • 5. Rozwiązania do tworzenia aplikacji WWW (556)
    • 6. Korzystanie z danych sieciowych (557)
    • 7. Więcej źródeł danych (558)
    • 8. Narzędzia programistyczne (559)
    • 9. Kivy: nasz wybór w kategorii "Najfajniejszy projekt wszech czasów" (560)
    • 10. Alternatywne implementacje (561)

    E. Zaangażowanie się

    • BDFL: Benevolent Dictator for Life (564)
    • Tolerancyjna społeczność: szacunek dla różnorodności (565)
    • Podkasty dotyczące Pythona (566)
    • Zen Pythona (567)
    • Którą książkę powinienem przeczytać jako następną? (568)
    • Nasze ulubione książki na temat Pythona (569)

    Skorowidz (570)

powrót
 
Produkty Podobne
Python. Rusz głową! Wydanie II
Python, C++, JavaScript. Zadania z programowania
Elegant SciPy. The Art of Scientific Python
Zaawansowane uczenie maszynowe z językiem Python
Python. Ćwiczenia praktyczne
Tablice informatyczne. Python
Profesjonalne programowanie w Pythonie. Poziom ekspert. Wydanie II
The Python 3 Standard Library by Example
Python. Podstawy nauki o danych. Wydanie II
Automatyzacja nudnych zadań z Pythonem. Nauka programowania
Więcej produktów