Python dla dzieci. Programowanie na wesoło - ebook

„Jason Briggs skutecznie, bez spłycania tematu, wyjaśnia dzieciom zasady programowania. Zawartość lekcji jest tak przemyślana, że po każdym przeczytanym rozdziale Czytelnik ma poczucie zdobycia kolejnych umiejętności”.

Marziah Karch, Wired.com

„Doskonałe wprowadzenie dla każdego, kto – niezależnie od wieku – chciałby nauczyć się programowania. Wspaniała organizacja i przedstawienie zagadnień sprawiają, że jest to świetny materiał do nauki zarówno w domu, jak i w szkole”.

Roy Wood, GeekDad

„Ta książka to dobre wprowadzenie do programowania, a zarazem porywające przeżycie zacieśniające więzi rodzinne”.

Patrice Gans, „Education Week”

„Nagrodą za przerobienie materiału z tej książki jest ukończona gra zręcznościowa i prawdopodobnie głowa pełna pomysłów na napisanie kolejnej gry. Python dla dzieci jest dobrym wprowadzeniem również dla dorosłych, którzy chcą się nauczyć pisać kod”.

Matthew Humphries, Geek.com

„Przyjemna lektura, zawierająca rozsądne rady dotyczące programowania i bardzo klarowne wyjaśnienia działania języków programowania. Świetna książka dla każdego, kto chciałby bez żadnych kompleksów zająć się programowaniem”.

Sandra Henry-Stocker, ITworldO AUTORZE

Jason R. Briggs jest programistą od ósmego roku życia, kiedy to nauczył się języka BASIC na komputerze Radio Shack TRS-80. Pracuje jako programista i architekt systemów informatycznych, a poza tym współtworzy Java Developer’s Journal. Jego artykuły ukazują się na portalach JavaWorld, ONJava i ONLamp. Python dla dzieci to jego pierwsza książka.

Z Jasonem można się skontaktować przez jego stronę internetową http://jasonrbriggs.com/ albo pisząc na adres [email protected] REDAKTORACH TECHNICZNYCH

Świeżo upieczony abiturient The Nueva School, 15-letni Josh Pollock, jest pierwszoroczniakiem w Lick-Wilmerding High School w San Francisco. Zaczął programować w języku Scratch w wieku 9 lat, w szóstej klasie zaczął używać TI-BASIC, w siódmej zainteresował się Javą i Pythonem, a w ósmej językiem UnityScript. Oprócz programowania lubi grać na trąbce, pisać gry komputerowe i prowadzić interesujące zajęcia z przedmiotów technicznych.

Maria Fernandez ma tytuł magistra lingwistyki stosowanej i od ponad 20 lat interesuje się komputerami i technologią. Uczyła angielskiego młode kobiety-uchodźców w ramach Global Village Project w stanie Georgia, a w tej chwili mieszka w północnej Kalifornii i pracuje dla ETS (Educational Testing Service).PODZIĘKOWANIA

Tak zapewne czuje się ktoś, kto wchodzi na scenę odebrać nagrodę i nagle uświadamia sobie, że listę osób, którym chciał podziękować, zostawił w innej parze spodni: na pewno o kimś zapomnisz, a wkrótce zabrzmi muzyka ponaglająca do opuszczenia sceny.

Pomimo świadomości tego, że mogę kogoś pominąć, poniżej zwracam się z podziękowaniami do kilku osób, którym jestem ogromnie wdzięczny za to, że pomogli mi napisać książkę tak dobrą, jak – moim zdaniem – jest ona teraz.

Dziękuję zespołowi No Starch, a szczególnie Billowi Pollockowi, za zredagowanie tej książki z punktu widzenia dziecka. Gdy jesteś programistą już od wielu lat, bardzo łatwo zapomnieć, jak trudne są niektóre partie tego materiału dla uczących się, a Bill okazał się nieoceniony w wychwytywaniu tych trudnych do wychwycenia, zbyt skomplikowanych fragmentów. Dziękuję również Serenie Yang, niesamowitej menedżerce produkcji; mam nadzieję, że nie wyrwałaś sobie zbyt wielu włosów, starając się poprawne pokolorować ponad 300 stron kodu.

Ogromne podziękowania ślę do Mirana Lipovačy za niesłychanie błyskotliwe ilustracje. Brak mi słów. Przysięgam. Gdybym to ja je wykonywał, przy odrobinie szczęścia Czytelnik musiałby oglądać pokryte nieregularnymi kleksami postaci, które nie przypominają niczego konkretnego. Czy to niedźwiedź? A może pies? Nie, chwilka… A może to miało być drzewo?

Dziękuję recenzentom. Przepraszam, jeśli niektóre z waszych sugestii nie zostały ostatecznie wprowadzone w życie. Pewnie macie rację, a wszystkie ewentualne błędy są skutkiem moich wad charakteru. Szczególne podziękowania kieruję do Josha za kilka naprawdę celnych podpowiedzi i błyskotliwych spostrzeżeń. I przepraszam Marię za to, że czasami miała do czynienia z nieczytelnie sformatowanym kodem.

Dziękuję żonie i córce za to, że wytrzymały z mężem i ojcem, który spędzał przy komputerze jeszcze więcej czasu niż zwykle.

Dziękuję mamie za bezgraniczne wsparcie przez wszystkie te lata.

Wreszcie dziękuję ojcu za to, że kupił komputer w latach 70. i znosił obecność osoby, która chciała go używać tak często jak on sam. Nic z tego, co udało mi się osiągnąć, bez niego nie byłoby możliwe.Po co się uczyć programowania komputerów? Programowanie sprzyja rozwojowi kreatywności, logicznego rozumowania i umiejętności rozwiązywania problemów. Programista dostaje szansę utworzenia czegoś z niczego, używając logiki, sprowadza konstrukcje programistyczne do postaci, która może zostać wykonana przez komputer, a gdy coś idzie nie tak, stosując systematyczne procedury, dochodzi do źródła problemu.

Programowanie to zabawa, czasami stanowiąca wyzwanie, innym razem frustrująca aktywność, a umiejętności nabyte przy tej okazji mogą się przydać zarówno w szkole, jak i w pracy, jeśli nawet zawodowo nie masz nic wspólnego z komputerami.

A tak poza tym, programowanie to świetny sposób na spędzenie wolnego popołudnia, gdy za oknem panuje pogoda pod zdechłym psem.

DLACZEGO WŁAŚNIE PYTHON?

Python to język programowania, którego łatwo się nauczyć i który z punktu widzenia początkującego programisty ma kilka ciekawych właściwości. W porównaniu z innymi językami wyróżnia się stosunkowo przejrzystym kodem, a poza tym ma interaktywną powłokę, w której można wpisywać i wykonywać programy. Oprócz prostej struktury języka i pozwalającej na eksperymenty interaktywnej powłoki, Python ma kilka cech, które usprawniają proces nauki i pozwalają konstruować proste animacje w celu tworzenia własnych gier. Jedną z nich jest moduł turtle, zainspirowany wektorową grafiką Turtle (używaną przez język programowania Logo w latach 60. ubiegłego wieku) i tworzony z myślą o wykorzystaniu w edukacji. Kolejną jest moduł tkinter, graficzny interfejs do przybornika Tk, pozwalający łatwo tworzyć programy z nieco bardziej zaawansowaną grafiką i animacją.

JAK SIĘ UCZYĆ PISANIA KODU

Tak jak w przypadku uczenia się czegokolwiek innego, zawsze najlepiej rozpocząć od podstaw. Radzimy więc przezwyciężyć pokusę przerabiania rozdziałów w środku i na końcu książki, nie zapoznawszy się wpierw z zawartością tych pierwszych. Nikt nie potrafi po pierwszym kontakcie z instrumentem zagrać orkiestrowej symfonii, młodzi piloci nie wznoszą się w powietrze, zanim nie poznają podstawowych zasad sterowania i tak samo gimnastycy (zazwyczaj) nie zaczynają ćwiczeń od salta w tył. Jeśli zbyt szybko będziesz przerabiać materiał, nie tylko zabraknie Ci czasu na to, aby utrwalić najważniejsze pojęcia, ale dodatkowo zawartość kolejnych rozdziałów będzie się wydawała bardziej skomplikowana, niż jest w rzeczywistości.

W trakcie lektury wykonuj wszystkie omawiane przykłady, aby na własne oczy przekonać się, jak działają. Na końcu większości rozdziałów umieszczono również zadania dla ambitnych, które mają pomóc w rozwoju umiejętności programowania. Pamiętaj, że im lepiej zrozumiesz podstawy, tym łatwiej będzie Ci później przyswoić bardziej złożone zagadnienia.

Jeśli jakaś część materiału okaże się dla Ciebie zbyt frustrująca albo wymagająca, spróbuj skorzystać z jednej z moich rad:

1. Podziel problem na mniejsze fragmenty. Spróbuj zrozumieć, za co odpowiedzialny jest mniejszy fragment kodu, albo pomyśl tylko o małej części kłopotliwego obszaru (zamiast próbować zrozumieć od razu całość, skup się na krótszym fragmencie kodu).

2. Jeśli to nie pomoże, czasami najlepiej odłożyć taki problem na jakiś czas. Prześpij się i wróć do niego następnego dnia. To dobry sposób na rozwiązywanie wielu problemów i może być szczególnie przydatny dla programistów.

KTO POWINIEN PRZECZYTAĆ TĘ KSIĄŻKĘ

Jest to książka dla każdej osoby zainteresowanej programowaniem komputerów, niezależnie od tego, czy jest dzieckiem, czy też dorosłym, który w tej dziedzinie stawia swoje pierwsze kroki. Jeśli chcesz nie tylko używać programów tworzonych przez innych, lecz także nauczyć się pisać własne oprogramowanie, Python dla dzieci to świetna pozycja na początek.

W kolejnych rozdziałach znajdziesz informacje, które pomogą Ci zainstalować Pythona, uruchomić powłokę Pythona, wykonywać proste obliczenia, wyświetlać na ekranie tekst i tworzyć listy, a także opanować podstawy sterowania przepływem programu, takie jak instrukcje if i pętle for (a przy okazji dowiesz się, czym są instrukcje if i pętle for!). Nauczysz się, jak wielokrotnie wykorzystywać kod za pomocą funkcji, poznasz podstawowe informacje o klasach i obiektach oraz zapoznasz się z opisami wybranych wbudowanych funkcji i modułów Pythona.

Jeśli chodzi o rysowanie na ekranie komputera, to w książce znajdują się rozdziały poświęcone podstawowej i zaawansowanej grafice żółwia, jak również dotyczące używania modułu tkinter. Na końcu wielu rozdziałów umieszczono zadania o różnym stopniu trudności; ich celem jest ugruntowanie omawianego materiału poprzez zachęcanie Czytelnika do samodzielnego pisania krótkich programów.

Po zdobyciu podstawowej wiedzy na temat programowania dowiesz się, jak pisać własne gry. Napiszesz dwie gry graficzne i uzyskasz podstawowe informacje na temat wykrywania kolizji, zdarzeń i różnych technik animacyjnych.

W większości przykładów w tej książce używamy powłoki IDLE (Integrated DeveLopment Environment) Pythona. IDLE zapewnia wyróżnianie składni, funkcje kopiuj-wklej (podobne do tych znanych z innych aplikacji) oraz okno edycji, w którym można zapisać kod na później, co oznacza, że IDLE działa jednocześnie jako interaktywne środowisko do przeprowadzania prób i jako swoisty edytor tekstu. Wszystkie przykłady będą działały również w standardowej konsoli i zwykłym edytorze tekstu, ale wyróżnianie składni i nieco bardziej przyjazne użytkownikowi środowisko IDLE mogą ułatwić naukę i dlatego w kilku pierwszych rozdziałach dowiesz się, jak je skonfigurować.

CO JEST W TEJ KSIĄŻCE

Oto zwięzły opis zawartości każdego rozdziału.

Rozdział 1 to wprowadzenie do programowania, zawierające instrukcje do pierwszej instalacji Pythona.

W rozdziale 2 wprowadzamy podstawowe obliczenia i zmienne, a rozdział 3 opisuje niektóre podstawowe typy danych w Pythonie, takie jak łańcuchy, listy i krotki.

Rozdział 4 to pierwsze spotkanie z modułem turtle. Od podstaw programowania przechodzimy do przemieszczania na ekranie żółwia (który ma kształt strzałki).

W rozdziale 5 zostaną omówione odmiany warunków i instrukcji if, a w rozdziale 6 – pętle for oraz while.

W rozdziale 7 zaczynamy tworzyć funkcje i ich używać, a następnie w rozdziale 8 omawiamy klasy i obiekty. Przedstawiono tutaj tylko najważniejsze koncepcje, mające związek z technikami programowania, których będziemy potrzebowali do pisania gier w rozdziałach w dalszej części książki. W tym momencie materiał zaczyna być nieco bardziej skomplikowany.

Rozdział 9 przybliża większość wbudowanych funkcji Pythona, a rozdział 10 poświęcony jest omówieniu modułów (można je uznać za kontenery przydatnych funkcji), które w Pythonie są instalowane domyślnie.

W rozdziale 11 powracamy do modułu turtle, zachęcając do eksperymentowania z bardziej skomplikowanymi kształtami. W rozdziale 12 przechodzimy do używania modułu tkinter w celu tworzenia bardziej zaawansowanej grafiki.

W rozdziałach 13 i 14 tworzymy naszą pierwszą grę, Odbij piłkę!, w której wykorzystujemy wiedzę uzyskaną w poprzednich rozdziałach, a w rozdziałach 15–18 tworzymy kolejną grę, Pan Patyczak pędzi do wyjścia. Od rozdziałów poświęconych pisaniu gier mogą się zacząć prawdziwe kłopoty. Jeśli nie potrafisz poradzić sobie inaczej, pobierz kod z internetowej strony poświęconej tej książce (http://python-for-kids.com/) i porównaj swój kod z tymi działającymi przykładami.

W Posłowiu bardzo zwięźle omówiono PyGame oraz kilka popularnych języków programowania.

Na końcu, w Załączniku, zapoznasz się szczegółowo ze słowami kluczowymi Pythona, a w Słowniczku znajdziesz definicje określeń programistycznych używanych w tej książce.

STRONA INTERNETOWA

Jeśli w trakcie lektury okaże się, że potrzebujesz pomocy, zajrzyj na stronę http://python-for-kids.com/. Znajdziesz tu wszystkie przykłady z książki i inne łamigłówki dla programistów, a także – jeśli utkniesz w jakimś momencie albo po prostu chcesz sprawdzić swoją pracę – rozwiązania wszystkich zadań dla ambitnych.

BAW SIĘ DOBRZE!

Czytając tę książkę, przez cały czas pamiętaj, że programowanie może być zabawą. Nie traktuj tego jak pracy. Pomyśl, że programowanie to sposób na tworzenie zabawnych gier lub aplikacji, które możesz udostępniać swoim przyjaciołom i innym osobom.

Nauka programowania to wspaniałe ćwiczenie umysłowe, a efekty mogą być bardzo satysfakcjonujące. Ale przede wszystkim, cokolwiek robisz, baw się dobrze!

WPROWADZENIE DO WYDANIA POLSKIEGO

W polskim wydaniu książki tłumacz starał się spolszczyć programy, zmienne i treść przykładów, uruchamiając wszystkie skrypty w wersji polskiej. Treść przykładów w oryginale opiera się często na anglojęzycznych skojarzeniach i rymowankach, które też zostały spolszczone. Mamy nadzieję, że wprowadzone zmiany ułatwią naukę osobom, które nie znają języka angielskiego.

Warto zwrócić uwagę, że przy pisaniu programów w języku Python istotne są odpowiednie wcięcia. Jeśli nie zawsze dobrze widać to na listingach, to warto zwrócić uwagę na opisane w tekście zasady stosowania odstępów.

Elementy, które nie mieszczą się w wierszu, a ze składni języka wynika, że powinny być w jednej linii, oznaczono znakiem . Język Python na oznaczanie tego typu sytuacji korzysta z lewego ukośnika, który może znajdować się w plikach z kodem, i kod bez problemu działa. Jednak z powodu niekonsekwencji autora w tym względzie oraz lepszej widoczności znaku jest on używany na listingach zamiast lewego ukośnika.

W rozdziale 1 pokazano, jak instalować Pythona w różnych systemach operacyjnych. Ze względu na niewielką liczbę początkujących użytkowników, którzy w Polsce używają systemów Mac OS oraz Ubuntu, odpowiednie okna pozostały w wersji oryginalnej.

UWAGA

Autorzy książki odsyłają Czytelnika do angielskiej strony z przykładami. Polskie przykłady znajdują się pod adresem http://www.smartkids.pwn.pl/Kody_Python. Literatura pomocnicza przywoływana w pracy jest również anglojęzyczna. Książki i internetowe samouczki po polsku można znaleźć w Internecie po wpisaniu odpowiedniego hasła w Google.Program komputerowy to zbiór instrukcji nakazujących komputerowi wykonanie jakiegoś rodzaju działania. W przeciwieństwie do kabli, mikroukładów, kart rozszerzeń, dysków twardych itd., nie jest fizyczną częścią komputera, ale czymś działającym w ukryciu na tym sprzęcie. Program komputerowy, który będę zwykle nazywał po prostu programem, to zbiór poleceń, które mówią tym nierozgarniętym urządzeniom, co mają robić. Oprogramowanie (ang. software) to natomiast zbiór programów komputerowych.

Bez programów komputerowych prawie każde urządzenie, którego używamy na co dzień, albo przestałoby działać, albo byłoby znacznie mniej użyteczne. Programy komputerowe, w takiej czy innej formie, sterują pracą nie tylko komputerów osobistych, lecz także konsol do gier wideo, telefonów komórkowych i samochodowej nawigacji GPS. Mniej osób wie, że oprogramowanie odpowiada również za funkcjonowanie telewizorów LCD (i pilotów do nich), a także nowszych odbiorników radiowych, odtwarzaczy DVD, piekarników i lodówek. Nawet silniki samochodowe, sygnalizacja uliczna, sygnalizacja kolejowa, elektroniczne billboardy i windy są sterowane programami.

Programy można w pewnym sensie porównać do myśli. Gdybym nie miał myśli, to prawdopodobnie siedziałbym na podłodze, gapiąc się bezmyślnie w dal i śliniąc sobie koszulkę. Myśl „wstań z podłogi” to instrukcja, czyli polecenie, które nakazuje ciału powstać. Na tej samej zasadzie programy mówią komputerom, co należy robić.

Jeśli potrafisz pisać programy, możesz robić bardzo wiele pożytecznych rzeczy. Oczywiście, nie nauczysz się od razu pisać programów sterujących samochodami, sygnalizacją świetlną czy lodówką, ale będziesz tworzyć strony internetowe, własne gry, a nawet napiszesz program, który pomoże Ci odrabiać prace domowe.

KILKA SŁÓW NA TEMAT JĘZYKA

Komputery, podobnie jak ludzie, komunikują się za pomocą wielu języków – w tym przypadku są to języki programowania. Język programowania (ang. programming language) to po prostu określony sposób porozumiewania się z komputerem: reguły stosowania instrukcji zrozumiałych zarówno dla ludzi, jak i dla komputerów.

Niektóre języki programowania otrzymały swoje nazwy na cześć osób (jak Ada i Pascal), nazwy innych to akronimy (jak BASIC i FORTRAN), są też nazwy pochodzące od programów telewizyjnych. Do tej ostatniej grupy należy Python: tak, język programowania Python swoją nazwę zawdzięcza nie wężowi, ale programowi Latający Cyrk Monty Pythona.

UWAGA

Latający Cyrk Monty Pythona to niekonwencjonalny brytyjski spektakl komediowy, który zaczęto nadawać w latach siedemdziesiątych XX wieku i który do dziś w pewnych kręgach cieszy się ogromną popularnością. Audycja jest znana z takich skeczów, jak „Ministerstwo głupich kroków”, „Taniec z policzkowaniem rybami” i „Sklep z serem” (który nie sprzedawał żadnego sera).

Kilka cech języka programowania Python sprawia, że jest on niesłychanie przydatny dla początkujących. Co najważniejsze, w Pythonie naprawdę szybko można pisać proste, a zarazem wydajne programy. Język ten nie używa wielu skomplikowanych symboli, takich jak klamry ({}), krzyżyki (#) czy znaki dolara ($), które znacznie utrudniają czytanie, a tym samym naukę innych języków, zwłaszcza osobom początkującym. (Nie oznacza to, że w ogóle nie używa symboli; jest ich po prostu mniej niż w innych językach.)

INSTALOWANIE PYTHONA

Instalacja Pythona jest dość łatwa. Omówimy tutaj przebieg instalacji w systemach Windows 7, Mac OS X i Ubuntu. Instalując Pythona, skonfigurujemy zarazem skrót do programu IDLE, czyli Integrated DeveLopment Environment (zintegrowanie środowisko programistyczne), w którym będziemy pisać programy w Pythonie. Jeśli Python jest już zainstalowany na Twoim komputerze, możesz od razu przejść do punktu „Po zainstalowaniu Pythona” na stronie 10.

INSTALOWANIE PYTHONA W SYSTEMIE WINDOWS 7

Aby zainstalować Pythona w systemie Windows 7, wchodzimy na stronę https://www.python.org/downloads/windows/ i pobieramy najnowszy pakiet instalacyjny Pythona w wersji 3 dla systemu Windows. W menu szukamy sekcji zatytułowanej Quick Links, tak jak to zostało pokazane tutaj:

UWAGA

Nie ma znaczenia, która to będzie dokładnie wersja Pythona, o ile jej numer zaczyna się od cyfry 3.

Po pobraniu instalatora dla systemu Windows dwukrotnie klikamy jego ikonę, a następnie wykonujemy instrukcje, aby zainstalować Pythona w domyślnej lokalizacji:

1. Zaznaczamy Install for All Users (Instaluj dla wszystkich użytkowników), a następnie klikamy Next (Dalej).

2. Domyślny katalog pozostawiamy bez zmian, ale zapamiętujemy jego położenie (najczęściej C:\Python32 albo C:\Python34).

3. Klikamy Next.

Pod koniec tego procesu, w menu Start powinniśmy mieć pozycję Python 3.4:

Następnie wykonujemy te kroki, aby umieścić na pulpicie skrót do Pythona w wersji 3.4:

1. Klikamy prawym przyciskiem myszy pulpit, a następnie z wyskakującego menu wybieramy kolejno Nowy i Skrót.

2. W polu Wpisz lokalizację elementu wpisujemy to, co poniżej (upewniając się, że katalog zgadza się z tym, który zapisaliśmy wcześniej):

------------------------------------------------------------------------

c:\Python34\Lib\idlelib\idle.pyw –n

------------------------------------------------------------------------

Okno dialogowe powinno wyglądać tak:

3. Klikamy Dalej, aby przejść do kolejnego okna dialogowego.

4. Jako nazwę wpisujemy IDLE i klikamy Zakończ, aby utworzyć skrót.

A teraz możemy przejść do punktu „Po zainstalowaniu Pythona” na stronie 10, aby rozpocząć pracę z Pythonem.

INSTALOWANIE PYTHONA W SYSTEMIE MAC OS X

Jeżeli używasz systemu Mac, Python powinien być już zainstalowany, ale prawdopodobnie jest to jakaś starsza wersja języka. Aby używać najnowszej wersji, wpisz w przeglądarce https://www.python.org/downloads/mac-osx/, aby pobrać najnowszą wersję instalatora dla systemu Mac.

Są dwa różne instalatory. To, który z nich należy pobrać, zależy od tego, którą wersję Mac OS X masz zainstalowaną. Dokonaj wyboru w ten sposób:

• Jeśli masz Mac OS X w wersji pomiędzy 10.3 a 10.6, pobierz 32-bitową wersję Python 3 for i386/PPC.

• Jeśli masz Mac OS X w wersji 10.6 lub wyższej, pobierz 64-bitową/32-bitową wersję Python 3 for i386/PPC.

Po pobraniu pliku (który będzie miał rozszerzenie .dmg) dwukrotnie go kliknij. Zobaczysz okno z zawartością tego pliku.

W oknie tym dwukrotnie kliknij Python.mpkg, a następnie wykonuj instrukcje, aby zainstalować oprogramowanie. Przed instalacją musisz podać hasło administratora. (Nie znasz tego hasła? Poproś o pomoc rodziców.)

Następnie musisz dodać na pulpicie skrypt uruchamiający aplikację IDLE. Zrób to w taki sposób:

1. Kliknij ikonę Spotlight, małą lupę w prawym górnym rogu ekranu.

2. W oknie, które się pojawi, wpisz Automator.

3. Kliknij ikonę, która wygląda jak robot. Będzie się znajdowała w kategoriach Najcelniejsze trafienie albo Aplikacje.

4. Gdy Automator zacznie działać, wybierz typ dokumentu Program:

5. Kliknij Wybierz, aby kontynuować.

6. Na liście działań znajdź Run Shell Script (Uruchom skrypt powłoki) i przeciągnij do pustego panelu po prawej stronie.

7. W polu tekstowym zobaczysz słowo cat. Zaznacz je i zastąp poniższym tekstem (wszystko od open do –n):

------------------------------------------------------------------------

open -a "/Applications/Python 3.4/IDLE.app" --args -n

------------------------------------------------------------------------

Zależnie od zainstalowanej wersji Pythona, konieczna może być zmiana katalogu.

8. Wybierz kolejno Plik i Zapisz i jako nazwę podaj IDLE.

9. W oknie dialogowym Where (Wybierz miejsce) wybierz Desktop (Pulpit), a następnie kliknij Save (Zapisz).

Możesz teraz przejść do punktu „Po zainstalowaniu Pythona” na stronie 10, aby rozpocząć pracę z Pythonem.

INSTALOWANIE PYTHONA W SYSTEMIE UBUNTU

W dystrybucji Linux Ubuntu Python jest zainstalowany domyślnie, ale może to być starsza wersja. Aby zainstalować Pythona 3 w systemie Ubuntu 12.x, wykonaj poniższe kroki:

1. Kliknij przycisk Centrum Oprogramowania Ubuntu na pasku bocznym (chodzi o ikonę, która wygląda jak pomarańczowa torba – jeśli jej nie widzisz, zawsze możesz kliknąć ikonę Dash Home i w oknie dialogowym wpisać Software).

2. W polu wyszukiwania w prawym górnym rogu Centrum Oprogramowania wpisz Python.

3. Na przedstawionej liście oprogramowania wybierz ostatnią wersję IDLE. W tym przykładzie jest to IDLE (using Python 3.4):

4. Kliknij Instaluj.

5. Wpisz hasło administratora, aby zainstalować program, a następnie kliknij Uwierzytelnij. (Nie znasz tego hasła? Może rodzice potrafią Ci pomóc.)

UWAGA

W niektórych wersjach Ubuntu można zobaczyć tylko Python (v3.4) w głównym menu (zamiast IDLE) – można wtedy wybrać tę opcję do instalacji.

Skoro masz już zainstalowaną najnowszą wersję Pythona, zacznijmy go używać.

PO ZAINSTALOWANIU PYTHONA

Jeśli używasz systemów Windows lub Mac OS X, na pulpicie powinna zjawić się ikona o nazwie IDLE. W systemie Ubuntu, w menu Programy, zobaczysz nową grupę o nazwie Programowanie z aplikacją IDLE (using Python 3.4) (albo późniejsza wersja).

Po dwukrotnym kliknięciu ikony albo wybraniu opcji z menu powinno pojawić się okno:

To powłoka Pythona (ang. Python shell), która jest częścią zintegrowanego środowiska programistycznego (IDE) Pythona. Trzy znaki większości (>>>) są w tym kontekście nazywane znakiem gotowości (ang. prompt).

Po znaku gotowości wpiszmy teraz kilka poleceń, zaczynając od poniższego:

------------------------------------------------------------------------

>>> print("Hello World")

------------------------------------------------------------------------

Nie zapomnij o cudzysłowie (" "). Gdy skończysz wpisywać ten wiersz, naciśnij na klawiaturze klawisz ENTER. Jeśli polecenie zostało wpisane bez błędów, powinno pojawić się coś podobnego:

------------------------------------------------------------------------

>>> print("Hello World")

Hello World

>>>

------------------------------------------------------------------------

Znak gotowości powinien pojawić się ponownie, co oznacza, że powłoka Pythona jest gotowa na odbiór kolejnych poleceń.

Gratulacje! Właśnie udało Ci się napisać pierwszy program w Pythonie. Słowo print to polecenie Pythona należące do grupy poleceń nazywanych funkcjami, które wyświetla na ekranie to, co znajduje się w nawiasach. Krótko mówiąc, wydaliśmy komputerowi instrukcję wyświetlenia słów „Hello World” – instrukcja ta jest zrozumiała zarówno dla nas, jak i dla komputera.

ZAPISYWANIE PROGRAMÓW NAPISANYCH W PYTHONIE

Z programów napisanych w Pythonie byłoby niewiele pożytku, gdyby trzeba je było wpisywać za każdym razem, gdy chcemy ich użyć, nie mówiąc już o drukowaniu ich, aby można było je przeanalizować. Oczywiście, przepisywanie krótkich programów bywa przydatne, ale długi program, taki jak na przykład procesor tekstu, może zawierać miliony wierszy kodu. Gdyby to wszystko wydrukować, byłoby tego grubo ponad 100 tysięcy stron. Wyobraź sobie tylko, że musisz zanieść coś takiego do domu. Zostaje pomodlić się, żeby nie wiało.

Na szczęście możemy zapisywać nasze programy, aby ich użyć w przyszłości. Aby zapisać nowy program, otwieramy IDLE i wybieramy kolejno File i New File. Pojawi się puste okno z tekstem Untitled w pasku menu. Do nowego okna powłoki wpisujemy:

------------------------------------------------------------------------

print("Hello World")

------------------------------------------------------------------------

A teraz wybieramy kolejno File (Plik) i Save (Zapisz). Zapytani o nazwę pliku wpisujemy hello.py i zapisujemy plik na pulpicie. Następnie wybieramy Run (Uruchom), a następnie Run Module (Uruchom moduł). Przy odrobinie szczęścia zapisany program powinien się uruchomić. Mniej więcej tak:

Jeśli teraz zamkniesz okno powłoki, ale zostawisz otwarte okno hello.py, a następnie wybierzesz kolejno Run i Run Module, ponownie powinna pojawić się powłoka Pythona, a wykonanie programu powinno zostać powtórzone.

Po wykonaniu kodu, na pulpicie znajdzie się nowa ikona podpisana hello.py. Jeśli ją dwukrotnie klikniesz, przelotnie pojawi się czarne okno i natychmiast zniknie. Co się dzieje?

Widzisz właśnie konsolę wiersza poleceń Pythona (podobną do powłoki), która uruchamia się, wyświetla „Hello World”, a następnie się zamyka. Oto, co może w mgnieniu oka zobaczyć ktoś obdarzony wzrokiem komiksowego superbohatera:

Oprócz menu możesz używać również skrótów klawiaturowych, aby utworzyć nowe okno powłoki, zapisać plik i uruchomić program:

• W systemach Windows i Ubuntu otwierasz nowe okno powłoki, naciskając CTRL+N, aby zapisać plik po zakończeniu edycji naciskasz CTRL+S, a naciśnięcie F5 spowoduje wykonanie programu.

• W systemie Mac OS X użyj -N, aby utworzyć nowe okno powłoki, -S, aby zapisać plik, a aby uruchomić program, przytrzymaj wciśnięty klawisz FN (function) i naciśnij F5.

CO JUŻ WIESZ

Rozdział ten rozpoczęliśmy od napisania prostej aplikacji Hello World – programu, od którego zaczyna praktycznie każdy uczący się programowania. W kolejnym rozdziale zrobimy w powłoce Pythona kilka bardziej pożytecznych rzeczy.Python został już zainstalowany i wiesz, jak uruchamiać powłokę, więc możemy się zająć kolejnymi wyzwaniami. Zaczniemy od kilku prostych obliczeń, a następnie przejdziemy do zmiennych. Zmienne (ang. variables) pozwalają przechowywać różne informacje w programie komputerowym i są pomocne przy pisaniu pożytecznych programów.

OBLICZENIA W PYTHONIE

Zwykle poproszeni o znalezienie iloczynu dwóch liczb, na przykład 8 × 3,57, sięgamy po kalkulator lub długopis i kartkę papieru. A co powiesz na to, żeby to Python wykonał obliczenia? Spróbujmy.

Uruchom powłokę Pythona, dwukrotnie klikając ikonę IDLE na pulpicie, albo, jeśli używasz Ubuntu, klikając ikonę IDLE w menu Programy. Po znaku gotowości wpisz to równanie:

------------------------------------------------------------------------

>>> 8 * 3.57

28.56

------------------------------------------------------------------------

Aby wykonać w Pythonie mnożenie, zamiast tradycyjnego symbolu mnożenia (×) używamy gwiazdki (*).

A może spróbujmy zapisać równanie, które jest ciut bardziej przydatne?

Wyobraź sobie, że kopiąc na podwórku, znajdujesz torbę zawierającą 20 złotych monet. Następnego dnia zakradasz się do piwnicy i wciskasz monety do wynalezionej przez Twojego dziadka zasilanej parą wodną maszyny replikacyjnej (tak szczęśliwie się składa, że mieści się w niej dokładnie 20 monet). Słyszysz świst i gwizd, a po kilku godzinach pojawia się 10 kolejnych błyszczących monet.

Ile monet uda Ci się zgromadzić w swoim skarbcu, gdyby można było to robić codziennie przez cały rok? Na papierze obliczenia mogą wyglądać tak:

10 × 365 = 3650

20 + 3650 = 3670

Oczywiście, wykonanie tych obliczeń na kalkulatorze lub papierze to łatwizna, ale możemy to zrobić także w powłoce Pythona. Najpierw mnożymy 10 monet przez 365 dni w roku, aby otrzymać 3650. Następnie dodajemy początkowe 20 monet i uzyskujemy 3670.

------------------------------------------------------------------------

>>> 10 * 365

3650

>>> 20 + 3650

3670

------------------------------------------------------------------------

A co jeśli kruk wypatrzy błyszczące złoto w Twojej sypialni, przyleci raz na tydzień i ukradnie trzy monety?

Ile monet zostanie po upływie roku? Oto jak obliczenia te będą wyglądały w powłoce:

------------------------------------------------------------------------

>>> 3 * 52

156

>>> 3670 - 156

3514

------------------------------------------------------------------------

Najpierw mnożymy 3 monety przez 52 tygodnie w roku. Wynik to 156. Odejmujemy tę liczbę od całkowitej liczby monet (3670) i dowiadujemy się, że po upływie roku zostanie nam 3514 monet.

To bardzo prosty program. W tej książce dowiesz się, jak, rozwijając te pojęcia, pisać jeszcze bardziej przydatne programy.

OPERATORY W PYTHONIE

W powłoce Pythona można wykonywać mnożenie, dodawanie, odejmowanie i dzielenie, a także inne działania matematyczne, którymi teraz nie będziemy się zajmowali. Podstawowe symbole używane w Pythonie do wykonywania działań matematycznych nazywane są operatorami i zostały zebrane w tabeli 2.1.

Tabela 2.1: Podstawowe operatory w Pythonie

-------- -------------
Symbol Działanie
+ dodawanie
- odejmowanie
* mnożenie
/ dzielenie
-------- -------------

Do dzielenia używa się prawego ukośnika (/), ponieważ przypomina on kreskę ułamkową. Gdyby na przykład było 100 piratów i 20 dużych beczek, a Twoim zadaniem byłoby obliczyć, ilu piratów można ukryć w każdej beczce, możesz podzielić 100 piratów przez 20 beczek (100 ÷ 20), wpisując w powłoce Pythona 100 / 20. Pamiętaj tylko, że chodzi o ukośnik, który jest pochylony w prawo, a nie w lewo.

KOLEJNOŚĆ DZIAŁAŃ

Aby ustalić kolejność działań w języku programowania, używamy nawiasów zwykłych. Działanie (ang. operation) to właśnie to, do czego potrzebny jest operator. Mnożenie i dzielenie stoją w hierarchii wyżej niż dodawanie i odejmowanie, a co za tym idzie, są wykonywane w pierwszej kolejności. Innymi słowy, jeśli wpiszesz w Pythonie równanie, mnożenie lub dzielenie zostanie wykonane przed dodawaniem lub odejmowaniem.

Na przykład w poniższym równaniu najpierw wykonywane jest mnożenie 30 razy 20, a następnie do wyniku (iloczynu) dodajemy 5.

------------------------------------------------------------------------

>>> 5 + 30 * 20

605

------------------------------------------------------------------------

To równanie można przeczytać słowami: „pomnóż 30 razy 20, a następnie do otrzymanego wyniku dodaj 5”. Wynik to 605. Kolejność działań możemy zmienić, umieszczając pierwsze działanie w nawiasach:

------------------------------------------------------------------------

>>> (5 + 30) * 20

700

------------------------------------------------------------------------

Wynikiem tego równania jest 700 (a nie 605), ponieważ nakazaliśmy Pythonowi, aby najpierw wykonał działanie w nawiasach, a dopiero później działanie poza nawiasami. Przykład ten można przeczytać: „dodaj 5 do 30, a następnie otrzymany wynik pomnóż przez 20”.

Nawiasy można zagnieżdżać (ang. nest), to znaczy jedne nawiasy mogą się znaleźć w innych, tak jak poniżej:

------------------------------------------------------------------------

>>> ((5 + 30) * 20) / 10

70.0

------------------------------------------------------------------------

W tym przypadku Python najpierw oblicza działanie w nawiasach wewnętrznych, następnie działanie w nawiasach zewnętrznych, a dopiero na końcu wykonuje dzielenie. Innymi słowy, równanie to można przeczytać tak: „dodaj 5 do 30, następnie pomnóż to przez 20, a wynik tego mnożenia podziel przez 10”. Oto kolejność zdarzeń:

• Dodanie 5 do 30 daje 35.

• Pomnożenie 35 razy 20 daje 700.

• Podzielenie 700 przez 10 daje ostateczną odpowiedź, czyli 70.

Gdybyśmy nie użyli nawiasów, wynik byłby trochę inny:

------------------------------------------------------------------------

>>> 5 + 30 * 20 / 10

65.0

------------------------------------------------------------------------

W tym przypadku najpierw mnożymy 30 razy 20 (otrzymując 600), a następnie dzielimy 600 przez 10 (co daje nam 60). Na końcu dodajemy 5, aby otrzymać wynik 65.

OSTRZEŻENIE

Pamiętaj, że jeśli nie użyjesz nawiasów, aby wpłynąć w ten sposób na kolejność działań, mnożenie i dzielenie zawsze mają pierwszeństwo przed dodawaniem i odejmowaniem.

ZMIENNE SĄ JAK ETYKIETY

Słowo zmienna (ang. variable) w programowaniu odnosi się do miejsca, w którym przechowywane są informacje, takie jak liczby, tekst, listy liczb i tekstów itd. Zmienną można też sobie wyobrazić jako etykietę, pod którą coś się kryje.

Na przykład, aby utworzyć zmienną o nazwie fred, używamy znaku równości (=), a następnie mówimy Pythonowi, dla jakiej informacji zmienna ta ma być etykietą (opisem). W tym przypadku tworzymy zmienną fred i mówimy Pythonowi, że jest to etykieta dla liczby 100 (przy czym nie oznacza to, że inna zmienna nie może mieć takiej samej wartości):

------------------------------------------------------------------------

>>> fred = 100

------------------------------------------------------------------------

Aby dowiedzieć się, jaka wartość kryje się pod etykietą, w powłoce wpisujemy print, a następnie w nawiasie zwykłym nazwę zmiennej. W taki sposób:

------------------------------------------------------------------------

>>> print(fred)

100

------------------------------------------------------------------------

Możemy również nakazać Pythonowi modyfikację zmiennej fred, aby stała się etykietą czegoś innego. Tak na przykład można zmienić wartość zmiennej fred na 200:

------------------------------------------------------------------------

>>> fred = 200

>>> print(fred)

200

------------------------------------------------------------------------

W pierwszym wierszu mówimy, że fred oznacza teraz liczbę 200. W drugim wierszu pytamy o to, czego opisem jest zmienna fred – tylko po to, by potwierdzić zmianę. W ostatnim wierszu Python wyświetla wynik.

Możemy też użyć więcej niż jednej etykiety (więcej niż jednej zmiennej) dla tego samego elementu:

------------------------------------------------------------------------

>>> fred = 200

>>> barney = fred

>>> print(barney)

200

------------------------------------------------------------------------

W tym przykładzie, używając znaku równości między barney i fred, mówimy Pythonowi, że chcemy, aby zmienna barney opisywała to samo, co zmienna fred.

Oczywiście fred prawdopodobnie nie jest zbyt przydatną nazwą dla zmiennej, ponieważ niewiele nam mówi o tym, do czego ta zmienna służy. Zmienimy nazwę naszej zmiennej na liczba_monet:

------------------------------------------------------------------------

>>> liczba_monet = 200

>>> print(liczba_monet)

200

------------------------------------------------------------------------

W ten sposób staje się jasne, że chodzi nam o 200 monet.

Nazwy zmiennych mogą zawierać litery, cyfry i znak podkreślenia (_), ale nie mogą zaczynać się od cyfry. Nazwą zmiennej mogą być zarówno pojedyncza litera (np. a), jak i całe długie zdanie. Zmienna nie może zawierać spacji, więc do oddzielenia od siebie słów używamy podkreślenia. Czasami, zwłaszcza jeśli się spieszymy, najlepsza jest krótka nazwa zmiennej. Wybór nazwy powinien zależeć od tego, jak istotny jest dla nas jej walor informacyjny.

Gdy wiemy już, jak tworzyć zmienne, możemy zająć się ich używaniem.

UŻYWANIE ZMIENNYCH

Pamiętasz nasze równanie, w którym obliczaliśmy, ile monet możesz mieć pod koniec roku, tłocząc nowe monety za pomocą znajdującego się w piwnicy magicznego wynalazku Twojego dziadka? Mamy takie równanie:

------------------------------------------------------------------------

>>> 20 + 10 * 365

3670

>>> 3 * 52

156

>>> 3670 - 156

3514

------------------------------------------------------------------------

Możemy przekształcić to na jeden wiersz kodu:

------------------------------------------------------------------------

>>> 20 + 10 * 365 - 3 * 52

3514

------------------------------------------------------------------------

A może przekształcimy liczby na zmienne? Wpisz to, co poniżej:

------------------------------------------------------------------------

>>> monety_znalezione = 20

>>> monety_magiczne = 10

>>> monety_ukradzione = 3

------------------------------------------------------------------------

W ten sposób utworzyliśmy zmienne monety_znalezione, monety_magiczne i monety_ukradzione.

Teraz możemy zapisać powyższe równanie pod taką postacią:

------------------------------------------------------------------------

>>> monety_znalezione + monety_magiczne * 365 - monety_ukradzione * 52

3514

------------------------------------------------------------------------

Jak widać, odpowiedź jest taka sama. Po co więc zmienne? I właśnie tutaj uwidaczniają się ich największe zalety. Bo załóżmy, że od czasu, gdy w oknie postawiliśmy stracha na wróble, kruk kradnie już nie trzy, ale tylko dwie monety. Gdy używamy zmiennej, możemy po prostu zmienić jej wartość na tę nową liczbę i będzie to miało wpływ na resztę równania. Aby zmienić wartość zmiennej monety_ukradzione na 2, wpisujemy:

------------------------------------------------------------------------

>>> monety_ukradzione = 2

------------------------------------------------------------------------

Następnie możemy skopiować i wkleić równanie, aby ponownie obliczyć wynik. Robimy to w taki sposób:

1. Kliknij tekst do skopiowania i przeciągnij zaznaczenie od początku do końca wiersza, tak jak to pokazano poniżej:

2. Przytrzymując wciśnięty klawisz CTRL (albo, jeśli używasz Mac OS, klawisz ), naciśnij C, aby skopiować zaznaczony tekst. (Od tej pory polecenie to będzie pojawiać się w książce jako CTRL+C).

3. Kliknij ostatni wiersz powłoki (za wierszem monety_ukradzione = 2).

4. Przytrzymaj wciśnięty klawisz CTRL i naciśnij V, aby wkleić zaznaczony tekst. (Od tego momentu polecenie to będzie w tej książce jako CTRL+V.)

5. Naciśnij ENTER, aby zobaczyć nowy wynik:

Czyż nie jest to znacznie łatwiejsze niż przepisywanie całego równania? Z pewnością tak.

Możesz poeksperymentować, zmieniając inne zmienne, a następnie, ułatwiając sobie życie metodą kopiuj (CTRL+C) i wklej (CTRL+V), obserwować efekty tych zmian. Jeśli na przykład uda Ci się mocno puknąć w odpowiednie miejsce maszyny Twojego dziadka, w każdym cyklu wyprodukuje ona trzy dodatkowe monety i pod koniec roku będzie już 4661 monet:

------------------------------------------------------------------------

>>> monety_magiczne = 13

>>> monety_znalezione + monety_magiczne * 365 - monety_ukradzione * 52

4661

------------------------------------------------------------------------

Oczywiście używanie zmiennych w równaniach tak prostych jak powyższe nie pokazuje w pełni ich ogromnej przydatności. Ale wszystko w swoim czasie. W tej chwili zapamiętaj, że zmienne to takie etykiety do opisywania informacji, aby można ich było używać później.

CO JUŻ WIESZ

Po przeczytaniu tego rozdziału wiesz już, jak wykonywać proste równania za pomocą operatorów Pythona i używać nawiasów, aby ustalać kolejność działań (kolejność, w jakiej Python oblicza poszczególne fragmenty równań). Poza tym utworzyliśmy zmienne, które opisują wartości i użyliśmy tych etykiet w naszych obliczeniach.