Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00073 005886 13638231 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Python 3. Kompletne wprowadzenie do programowania. Wydanie II - książka
Python 3. Kompletne wprowadzenie do programowania. Wydanie II - książka
Autor: Liczba stron: 640
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-2642-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> python - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Poznaj wspaniałe możliwości języka Python 3
i twórz dowolne programy

Python 3 uznany został za najlepszą dotychczasową wersję tego języka, ponieważ jego możliwości są dziś znacznie większe niż dawniej. Python 3 jest wygodny, spójny i ekspresyjny, a także niezależny od platformy sprzętowej i - co najważniejsze - dostarczany z pełną biblioteką standardową. Można go wykorzystać do programowania proceduralnego, zorientowanego obiektowo oraz (w mniejszym stopniu) do programowania w stylu funkcjonalnym. Autor książki, Mark Summerfield, ekspert w dziedzinie programowania, przedstawia szczegółowe informacje dotyczące tego języka w bardzo przyjazny sposób, co sprawia, że czytelnik szybko i sprawnie może napisać dowolny program.

Książka 'Python 3. Kompletne wprowadzenie do programowania. Wydanie II' została zaprojektowana tak, aby mógł z niej korzystać zarówno ktoś o niewielkim doświadczeniu w programowaniu, jak i profesjonaliści, naukowcy, inżynierowie oraz studenci. Dzięki niej szybko nauczysz się m.in. wykorzystywać zaawansowane rodzaje danych, kolekcje oraz struktury kontrolne. Poznasz techniki analizy składniowej, obejmujące używanie modułów PyParsing i PLY. Dowiesz się, na czym polega rozkładanie obciążenia programu między wiele procesów i wątków, a także zaczniesz używać techniki Test Driven Development, aby uniknąć popełniania błędów. Znajdziesz tu wszelkie niezbędne informacje, dzięki którym będziesz mógł stworzyć solidne i wydajne programy.

Ten podręcznik jest jak Python 3 - spójny, praktyczny i wygodny

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Python 3. Kompletne wprowadzenie do programowania. Wydanie II Autor: Mark Summerfield T³umaczenie: Robert Górczyñski ISBN: 978-83-246-2642-7 Tytu³ orygina³u: Programming in Python 3: A Complete Introduction to the Python Language (2nd Edition) Format: 170×230, stron: 640 Poznaj wspania³e mo¿liwoœci jêzyka Python 3 i twórz dowolne programy Python 3 uznany zosta³ za najlepsz¹ dotychczasow¹ wersjê tego jêzyka, poniewa¿ jego mo¿liwoœci s¹ dziœ znacznie wiêksze ni¿ dawniej. Python 3 jest wygodny, spójny i ekspresyjny, a tak¿e niezale¿ny od platformy sprzêtowej i – co najwa¿niejsze – dostarczany z pe³n¹ bibliotek¹ standardow¹. Mo¿na go wykorzystaæ do programowania proceduralnego, zorientowanego obiektowo oraz (w mniejszym stopniu) do programowania w stylu funkcjonalnym. Autor ksi¹¿ki, Mark Summerfield, ekspert w dziedzinie programowania, przedstawia szczegó³owe informacje dotycz¹ce tego jêzyka w bardzo przyjazny sposób, co sprawia, ¿e czytelnik szybko i sprawnie mo¿e napisaæ dowolny program. Ksi¹¿ka „Python 3. Kompletne wprowadzenie do programowania. Wydanie II” zosta³a zaprojektowana tak, aby móg³ z niej korzystaæ zarówno ktoœ o niewielkim doœwiadczeniu w programowaniu, jak i profesjonaliœci, naukowcy, in¿ynierowie oraz studenci. Dziêki niej szybko nauczysz siê m.in. wykorzystywaæ zaawansowane rodzaje danych, kolekcje oraz struktury kontrolne. Poznasz techniki analizy sk³adniowej, obejmuj¹ce u¿ywanie modu³ów PyParsing i PLY. Dowiesz siê, na czym polega rozk³adanie obci¹¿enia programu miêdzy wiele procesów i w¹tków, a tak¿e zaczniesz u¿ywaæ techniki Test Driven Development, aby unikn¹æ pope³niania b³êdów. Znajdziesz tu wszelkie niezbêdne informacje, dziêki którym bêdziesz móg³ stworzyæ solidne i wydajne programy. (cid:129) Tworzenie i uruchamianie programów Pythona (cid:129) Polecenia kontroli przep³ywu (cid:129) Rodzaje danych (cid:129) Funkcje i struktury kontrolne (cid:129) Modu³y i pakiety (cid:129) Programowanie zorientowane obiektowo (cid:129) Obs³uga plików (cid:129) Zaawansowane techniki programowania (cid:129) Kontrola dostêpu do atrybutów (cid:129) Usuwanie b³êdów, testowanie i profilowanie (cid:129) Wyra¿enia regularne Ten podrêcznik jest jak Python 3 – spójny, praktyczny i wygodny Mark Summerfield jest informatykiem z wieloletnim doœwiadczeniem w dziedzinie programowania. Jest tak¿e wspó³autorem ksi¹¿ki „C++ GUI Programming with Qt 4” oraz autorem ksi¹¿ki „Rapid GUI Programming with Python and Qt: The Definitive Guide to PyQt Programming”. Mark za³o¿y³ firmê Qtrac Ltd., http://www.qtrac.eu, w której pracuje jako niezale¿ny publicysta, redaktor, trener i konsultant specjalizuj¹cy siê w C++, Qt, Pythonie i PyQt. Spis treści O autorze ...........................................................................13 Wprowadzenie ...................................................................15 Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego ......23 Tworzenie i uruchamianie programów Pythona .................................24 „Piökne serce” Pythona .................................................................29 Koncepcja 1. — rodzaje danych ................................................29 Koncepcja 2. — odniesienia do obiektów ..................................31 Koncepcja 3. — kolekcje rodzajów danych .................................33 Koncepcja 4. — operatory logiczne ...........................................36 Koncepcja 5. — polecenia kontroli przepäywu programu ..............40 Koncepcja 6. — operatory arytmetyczne ....................................45 Koncepcja 7. — operacje wejĈcia-wyjĈcia ...................................48 Koncepcja 8. — tworzenie i wywoäywanie funkcji ........................51 Przykäady ......................................................................................53 bigdigits.py ..............................................................................53 generate_grid.py ......................................................................56 Podsumowanie .............................................................................58 çwiczenia .....................................................................................61 Rozdziaä 2. Rodzaje danych ..................................................................65 Identyfikatory i säowa kluczowe .......................................................65 Caäkowite rodzaje danych ...............................................................69 Liczby caäkowite .......................................................................69 WartoĈci boolowskie ................................................................72 Zmiennoprzecinkowe rodzaje danych ..............................................73 Liczby zmiennoprzecinkowe (Float) ............................................74 Liczby zespolone (Complex) ......................................................77 Liczby Decimal .........................................................................78 8 Python 3. Kompletne wprowadzenie do programowania Ciñgi tekstowe ..............................................................................80 Porównywanie ciñgów tekstowych ..............................................83 Segmentowanie i poruszanie siö krokami w ciñgu tekstowym .................................................................84 Operatory i metody dotyczñce ciñgu tekstowego .........................87 Formatowanie ciñgu tekstowego za pomocñ metody str.format() ...............................................95 Kodowanie znaków ................................................................107 Przykäady ....................................................................................111 quadratic.py ..........................................................................111 csv2html.py ...........................................................................114 Podsumowanie ...........................................................................118 çwiczenia ...................................................................................120 Rozdziaä 3. Kolekcje rodzajów danych ................................................123 Rodzaje sekwencji .......................................................................124 Krotki ....................................................................................124 Nazwane krotki ......................................................................127 Listy .....................................................................................129 Rodzaje danych set .....................................................................137 Set (zbiór) .............................................................................138 Rodzaj danych frozenset .........................................................142 Rodzaje mapowania ....................................................................143 Säowniki ................................................................................143 Säowniki domyĈlne .................................................................152 Säowniki uporzñdkowane ........................................................153 Iteracja i kopiowanie kolekcji ........................................................155 Iteratory i operacje oraz funkcje iteracji ....................................155 Kopiowanie kolekcji ...............................................................164 Przykäady ....................................................................................166 generate_usernames.py .........................................................166 statistics.py ..........................................................................169 Podsumowanie ...........................................................................173 çwiczenia ...................................................................................175 Rozdziaä 4. Funkcje i struktury kontrolne ...........................................177 Struktury kontrolne ......................................................................177 Konstrukcje rozgaäöziajñce ......................................................178 Pötle .....................................................................................179 Obsäuga wyjñtków ........................................................................181 Przechwytywanie i obsäuga wyjñtków ........................................181 Wäasne wyjñtki .......................................................................186 Spis treĈci 9 Wäasne funkcje ...........................................................................189 Nazwy i dokumentujñce ciñgi tekstowe ....................................193 Rozpakowywanie argumentu i parametru .................................195 Uzyskiwanie dostöpu do zmiennych w zasiögu globalnym ..........197 Funkcja lambda .....................................................................199 Asercje .................................................................................201 Przykäad: make_html_skeleton.py .................................................202 Podsumowanie ...........................................................................208 çwiczenie ...................................................................................209 Rozdziaä 5. Moduäy ............................................................................213 Moduäy i pakiety ..........................................................................214 Pakiety ..................................................................................217 Wäasne moduäy ......................................................................220 Ogólny opis biblioteki standardowej Pythona .................................230 Obsäuga ciñgów tekstowych ....................................................230 Programowanie wiersza polecenia ...........................................232 Matematyka i liczby ................................................................233 Data i godzina .......................................................................234 Algorytmy i kolekcje rodzajów danych .......................................235 Formaty plików, kodowania znaków i przechowywanie danych ....236 Plik, katalog i obsäuga przetwarzania .......................................240 Praca w sieci i programowanie internetowe ..............................242 XML ......................................................................................244 Inne moduäy ..........................................................................246 Podsumowanie ...........................................................................247 çwiczenie ...................................................................................249 Rozdziaä 6. Programowanie zorientowane obiektowo ...........................251 PodejĈcie zorientowane obiektowo ...............................................252 Koncepcje i terminologia programowania zorientowanego obiektowo ....................................................253 Wäasne klasy ..............................................................................256 Atrybuty i metody ...................................................................257 Dziedziczenie i polimorfizm .....................................................262 UĔywanie wäaĈciwoĈci w celu kontrolowania dostöpu do atrybutów ..........................................................264 Tworzenie w peäni zintegrowanych rodzajów danych ...................266 Wäasne klasy kolekcji ..................................................................279 Tworzenie klas agregujñcych kolekcje ......................................279 Tworzenie klas kolekcji za pomocñ agregacji ............................286 Tworzenie klas kolekcji za pomocñ dziedziczenia ......................292 Podsumowanie ...........................................................................299 çwiczenia ...................................................................................301 10 Python 3. Kompletne wprowadzenie do programowania Rozdziaä 7. Obsäuga plików ................................................................303 Zapis i odczyt danych binarnych ...................................................308 Peklowanie wraz z opcjonalnñ konwersjñ .................................308 Zwykäe dane binarne wraz z opcjonalnñ kompresjñ ....................312 Zapis i przetwarzanie plików tekstowych ........................................321 Zapis tekstu ..........................................................................321 Przetwarzanie tekstu ..............................................................322 Przetwarzanie tekstu za pomocñ wyraĔeþ regularnych ...............325 Zapis i przetwarzanie plików XML .................................................328 Drzewa elementów .................................................................329 Model DOM (Document Object Model) .....................................332 Röczny zapis XML ..................................................................335 Przetwarzanie XML za pomocñ SAX (Simple API dla XML) ..........336 Swobodny dostöp do plików binarnych ..........................................339 Ogólna klasa BinaryRecordFile ................................................339 Przykäad: klasy moduäu BikeStock ...........................................347 Podsumowanie ...........................................................................351 çwiczenia ...................................................................................352 Rozdziaä 8. Zaawansowane techniki programowania ...........................355 Dalsze techniki programowania proceduralnego .............................356 Rozgaäözianie za pomocñ säowników ........................................356 Funkcje i wyraĔenia generatora ...............................................358 Dynamiczne wykonywanie kodu oraz dynamiczne polecenia import .........................................360 Funkcje lokalne i rekurencyjne ................................................368 Dekoratory funkcji i metod ......................................................372 Adnotacje funkcji ...................................................................376 Dalsze techniki programowania zorientowanego obiektowo .............378 Kontrola dostöpu do atrybutów ...............................................379 Funktor .................................................................................382 MenedĔery kontekstu .............................................................384 Deskryptory ...........................................................................388 Dekoratory klas .....................................................................392 Abstrakcyjne klasy bazowe .....................................................395 Dziedziczenie wielokrotne .......................................................402 Metaklasy .............................................................................404 Programowanie funkcjonalne ........................................................408 Funkcje czöĈciowe aplikacji ....................................................411 Wspóäprogramy ......................................................................412 Przykäad: valid.py .........................................................................421 Podsumowanie ...........................................................................423 çwiczenia ...................................................................................424 Spis treĈci 11 Rozdziaä 9. Usuwanie bäödów, testowanie i profilowanie .....................427 Usuwanie bäödów ........................................................................428 Obsäuga bäödów skäadni ..........................................................429 Obsäuga bäödów w trakcie dziaäania programu ..........................430 Naukowy sposób usuwania bäödów ..........................................434 Testy jednostkowe ......................................................................440 Profilowanie ................................................................................446 Podsumowanie ...........................................................................451 Rozdziaä 10. Procesy i wñtkowanie ......................................................453 UĔywanie moduäu Multiprocessing ................................................454 UĔywanie moduäu Threading .........................................................458 Przykäad: program wyszukiwania uĔywajñcy wñtków ...................460 Przykäad: program wyszukujñcy powielone pliki uĔywajñcy wñtkowania ..........................................................463 Podsumowanie ...........................................................................468 çwiczenia ...................................................................................469 Rozdziaä 11. Praca w sieci ..................................................................471 Tworzenie klienta TCP ..................................................................473 Tworzenie serwera TCP ................................................................478 Podsumowanie ...........................................................................485 çwiczenia ...................................................................................485 Rozdziaä 12. Programowanie bazy danych ............................................489 Bazy danych DBM .......................................................................490 Bazy danych SQL ........................................................................494 Podsumowanie ...........................................................................501 çwiczenie ...................................................................................502 Rozdziaä 13. WyraĔenia regularne ........................................................503 Jözyk wyraĔeþ regularnych Pythona ...............................................504 Znaki i klasy znaków ..............................................................505 Kwantyfikatory .......................................................................506 Grupowanie i przechwytywanie ................................................508 Asercje i opcje .......................................................................511 Moduä wyraĔeþ regularnych ..........................................................515 Podsumowanie ...........................................................................526 çwiczenia ...................................................................................526 Rozdziaä 14. Wprowadzenie do analizy skäadniowej ...............................529 Skäadnia BNF i terminologia zwiñzana z analizñ skäadniowñ ............531 Tworzenie wäasnych analizatorów skäadni ......................................535 Prosta analiza skäadniowa danych klucz – wartoĈè ....................536 Analiza skäadniowa listy odtwarzania .......................................539 Analiza skäadniowa bloków jözyka specjalizowanego .................541 12 Python 3. Kompletne wprowadzenie do programowania Analiza skäadniowa za pomocñ moduäu PyParsing ..........................550 Krótkie wprowadzenie do moduäu PyParsing .............................551 Prosta analiza skäadniowa danych klucz – wartoĈè ....................555 Analiza skäadniowa danych listy odtwarzania ............................557 Analiza skäadniowa bloków jözyka specjalizowanego .................559 Analiza skäadni logiki pierwszego rzödu ....................................564 Analiza skäadniowa Lex/Yacc za pomocñ moduäu PLY ....................569 Prosta analiza skäadniowa danych klucz – wartoĈè ....................571 Analiza skäadniowa danych listy odtwarzania ............................573 Analiza skäadniowa bloków jözyka specjalizowanego .................575 Analizator skäadni logiki pierwszego rzödu ................................577 Podsumowanie ...........................................................................582 çwiczenie ...................................................................................583 Rozdziaä 15. Wprowadzenie do programowania GUI ..............................585 Programy w stylu okna dialogowego ..............................................588 Programy w stylu okna gäównego ..................................................594 Tworzenie okna gäównego .......................................................595 Tworzenie wäasnego okna dialogowego ....................................605 Podsumowanie ...........................................................................608 çwiczenia ...................................................................................609 Epilog ..............................................................................611 Wybrana bibliografia ........................................................613 Skorowidz ........................................................................615 1 Szybkie wprowadzenie do programowania proceduralnego W rozdziale: „ Tworzenie i uruchamianie programów Pythona „ „Piękne serce” Pythona W tym rozdziale zostanie omówiona taka ilość materiału, że jej lektura pozwoli czytelnikowi na rozpoczęcie tworzenia programów w języku Python. Jeżeli czytelnik jeszcze nie zainstalował Pythona, gorąco zachęcamy do przeprowadzenia instalacji. Pozwoli to na zdobywanie doświadczenia i utrwalanie poznawanego materiału. (Instalacja Pythona na głównych platformach sprzętowych została omówiona we wcześniejszym rozdziale „Wprowadzenie”, g 19). Pierwszy podrozdział zaprezentuje sposób tworzenia i uruchamiania programów Pythona. Kod Pythona można tworzyć w dowolnym edytorze tekstowym. Omówione w rozdziale środowisko programistyczne IDLE oferuje nie tylko sam edytor kodu źródłowego, ale także funkcje dodatkowe pozwalające na między innymi eksperymentowanie z kodem Pythona oraz usuwanie błędów z kodu. Drugi podrozdział został poświęcony ośmiu kluczowym koncepcjom Pythona, których poznanie wystarczy do tworzenia użytecznych programów. Wszystkie wymienione tutaj konstrukcje będą dokładnie omówione w dalszych rozdziałach książki. W miarę przedstawiania kolejnego materiału koncepcje te zostaną uzupełnione informacjami obejmującymi szerszy zakres języka Python. W ten sposób po przeczytaniu książki czytelnik będzie znał cały język i podczas pracy nad własnymi programami będzie w stanie wykorzystywać wszystkie możliwości języka. 24 Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego Ostatni podrozdział zawiera dwa krótkie programy, w których użyto niektórych funkcji Pythona omówionych w podrozdziale drugim. Dzięki temu czytelnik natychmiast będzie mógł „wypróbować” Pythona. Kodowanie znaków h 107. Tworzenie i uruchamianie programów Pythona Kod Pythona można tworzyć w dowolnym edytorze tekstowym, który umożliwia zapis i odczyt plików tekstowych stosujących kodowanie znaków ASCII lub UTF-8 Unicode. Domyślnie pliki Pythona stosują kodowanie znaków UTF-8 obejmujące większy zbiór znaków niż ASCII. Za pomocą kodowania UTF-8 można przedstawiać każdy znak w każdym języku. Pliki Pythona zwykle mają rozszerzenie .py, chociaż w niektórych systemach z rodziny Unix (na przykład Linux i Mac OS X) pewne aplikacje Pythona nie mają rozszerzenia pliku. Programy Pythona z graficznym interfejsem użytkownika (GUI, czyli Graphical User Interface) zazwyczaj mają rozszerzenie .pyw, zwłaszcza w systemach Windows oraz Mac OS X. W niniejszej książce moduły Pythona oraz programy Pythona działające w konsoli zawsze mają rozszerzenie .py, natomiast programy GUI są oznaczone rozszerzeniem .pyw. Wszystkie przykłady zaprezentowane w książce można w niezmienionej postaci uruchomić na każdej platformie sprzętowej z zainstalowanym Pythonem 3. Aby upewnić się, że wszystko zostało skonfigurowane prawidłowo, oraz przedstawić klasyczny pierwszy przykład, należy w edytorze tekstowym (w systemie Windows można użyć programu Notatnik — wkrótce zaczniemy korzystać z lepszego edytora) utworzyć plik o nazwie hello.py zawierający następujące wiersze: #!/usr/bin/env python3 print( Witaj , Ăwiecie! ) Pierwszy wiersz to komentarz. W Pythonie komentarz rozpoczyna się od znaku # i ciągnie się aż do końca wiersza. (Znaczenie powyższego komentarza wyjaśnimy za chwilę). Drugi wiersz jest pusty — poza ciągami tekstowymi ujętymi w cudzysłów, Python ignoruje puste wiersze. Jednak mają one istotne znaczenie dla programistów, gdyż oddzielają duże bloki kodu, co ułatwia ich odczyt. Wiersz trzeci zawiera kod Pythona. W tym wierszu następuje wywołanie funkcji printf() wraz z dwoma argumentami, z których każdy jest typu str (string — ciąg tekstowy, czyli sekwencja znaków). Każde polecenie napotkane w pliku .py zostaje kolejno wykonane, począwszy od pierwszego i dalej wiersz po wierszu. To zupełnie odmienne podejście niż w innych językach, takich jak C++ bądź Java, gdzie mamy określoną funkcję lub metodę posiadającą nazwę specjalną, która stanowi punkt początkowy programu. Oczywiście, istnieje możliwość sterowania przepływem programu, co zostanie zaprezentowane w kolejnym podrozdziale podczas omawiania struktur kontrolnych Pythona. Przyjmujemy założenie, że użytkownik systemu Windows zapisuje kod Pythona w katalogu C:py3eg, natomiast użytkownik systemu z rodziny Unix (na przykład Unix, Linux lub Mac OS X) przechowuje kod w katalogu $HOME/py3eg. Plik hello.py należy więc zapisać w katalogu py3eg i zamknąć edytor tekstowy. Tworzenie i uruchamianie programów Pythona 25 Mamy więc program, który można uruchomić. Programy w języku Python są wykonywane przez interpreter Pythona, zazwyczaj w oknie konsoli. W systemie Windows konsola nosi nazwę „konsola”, „wiersz polecenia DOS”, „wiersz polecenia MS-DOS” lub podobnie i zwykle znajduje się w menu Start/Wszystkie programy/Akcesoria. W systemie Mac OS X konsola jest dostarczana przez narzędzie Terminal.app (domyślnie znajduje się w katalogu Programy/Narzędzia) dostępne poprzez Findera. W pozostałych systemach Unix można użyć xterm bądź konsoli oferowanej przez menedżera okien, na przykład konsole bądź gnome-terminal. Uruchom konsolę, następnie w systemie Windows wprowadź poniższe polecenia (przyjmujemy założenie, że Python został zainstalowany w lokalizacji domyślnej). Dane wyjściowe konsoli są przedstawione czcionkÈ o staïej szerokoĂci, natomiast wprowadzane polecenia zostały pogrubione: C: cd c:py3eg C:py3eg c:python31python.exe hello.py Ponieważ polecenie cd (change directory, czyli zmień katalog) używa bezwzględnej ścieżki dostępu, katalog, z poziomu którego zostanie uruchomiony program, nie ma żadnego znaczenia. Użytkownicy systemu Unix wydają polecenia pokazane poniżej (przyjmujemy założenie, że odniesienie do Pythona 3 znajduje się w systemowej ścieżce PATH)1: $ cd $HOME/py3eg $ python3 hello.py W obu przypadkach dane wyjściowe prezentują się tak samo: Witaj Ăwiecie! Warto pamiętać, że jeśli nie napisano inaczej, zachowanie języka Python w systemie Mac OS X jest takie samo, jak w każdym innym systemie z rodziny Unix. Możemy więc przyjąć, że kiedy używamy określenia „Unix”, oznacza to system Linux, BSD, Mac OS X oraz większość pozostałych systemów Unix i wywodzących się z rodziny Unix. Chociaż pierwszy program składa się tylko z jednego polecenia wykonywalnego, po jego uruchomieniu możemy wyciągnąć pewne wnioski dotyczące funkcji print(). Przede wszystkim funkcja print() jest elementem wbudowanym w język Python — w celu jej użycia nie musimy jej „importować” ani „dołączać” z biblioteki. Ponadto każdy element wyświetlany przez funkcję jest oddzielony pojedynczą spacją, a po wyświetleniu ostatniego wstawiany jest znak nowego wiersza. To jest zachowanie domyślne funkcji i jak przekonamy się nieco później, możemy je zmienić. Inną ważną informacją dotyczącą funkcji print() jest to, że może pobierać dowolną ilość argumentów. Wprowadzanie przedstawionych powyżej poleceń w celu uruchamiania tworzonych programów w Pythonie bardzo szybko może okazać się uciążliwe. Na szczęście w systemach zarówno Windows, jak i Unix można zastosować znacznie wygodniejsze podejście. 1 Znak zachęty systemu Unix może być odmienny niż przedstawiony w powyższym przykładzie znak dolara ($), to nie ma żadnego znaczenia. Funkcja print() h 198 26 Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego Zakładamy, że znajdujemy się w katalogu py3eg. W systemie Windows można więc po prostu wydać polecenie: C:py3eg hello.py Windows używa rejestru przypisań plików w celu automatycznego wywołania interpretera Pythona za każdym razem, gdy w konsoli zostanie wprowadzona nazwa pliku z rozszerzeniem .py. Niestety, takie wygodne podejście nie zawsze działa, ponieważ pewne wersje systemu Windows mają błąd, który czasami negatywnie wpływa na wykonywanie programów interpretowanych wywoływanych jako wynik odczytania zdefiniowanego przypisania pliku. To nie jest błąd w Pythonie — inne interpretery, a także niektóre pliki .bat także padają ofiarą tego błędu. Jeżeli czytelnik spotka się z tego rodzaju błędem, wówczas należy bezpośrednio wywołać Pythona, zamiast polegać na mechanizmie rozpoznawania przypisań plików. Jeśli w systemie Windows dane wyjściowe mają postać: ( Witaj , Ăwiecie! ) oznacza to, że w systemie znajduje się Python 2 i został wywołany zamiast Pythona 3. Jednym z rozwiązań będzie zmiana przypisania pliku .py z Pythona 2 na Python 3. Inne rozwiązanie (mniej wygodne, lecz bezpieczniejsze) do dodanie Pythona 3 do systemowej ścieżki dostępu (przyjmujemy założenie, że został zainstalowany w lokalizacji domyślnej) i wyraźne wywoływanie Pythona za każdym razem. (Ten sposób powoduje także rozwiązanie wspomnianego wcześniej błędu w Windows, dotyczącego przypisań plików). Przykładowo: C:py3eg path=c:python31; path C:py3eg python hello.py Znacznie wygodniejszym rozwiązaniem może być utworzenie pliku py3.bat zawierającego pojedynczy wiersz kodu path=c:python31; path i zapisanie tego pliku w katalogu C:Windows. Następnie, po każdym włączeniu konsoli w celu uruchamiania programów napisanych w Pythonie, pracę trzeba rozpocząć od wykonania pliku py3.bat. Ewentualnie można skonfigurować system tak, aby plik py3.bat był wykonywany automatycznie. W tym celu należy zmodyfikować właściwości konsoli (odszukaj konsolę w menu Start, a następnie kliknij konsolę prawym przyciskiem myszy i wybierz opcję Właściwości). W wyświetlonym oknie dialogowym przejdź na kartę Skrót, w polu Element docelowy dodaj ciąg tekstowy „ /u /k c:windowspy3.bat” (zwróć uwagę na spację przed, między i po opcjach „/u” oraz „/k” i upewnij się, że ciąg tekstowy znajduje się po poleceniu cmd.exe). W systemie Unix plikowi trzeba w pierwszej kolejności nadać uprawnienia do wykonywania, a dopiero potem można go uruchomić: $ chmod +x hello.py $ ./hello.py Oczywiście polecenie chmod należy wykonać tylko jednokrotnie, później wystarczy po prostu wydać polecenie ./hello.py i program zostanie uruchomiony. Tworzenie i uruchamianie programów Pythona 27 W systemie Unix podczas wywoływania programu w konsoli następuje odczyt dwóch pierwszych bajtów pliku2. Jeżeli odczytane bajty są znakami #! zbioru znaków ASCII, wówczas powłoka przyjmuje założenie, że plik powinien być wykonany przez interpreter, który zresztą jest wskazany w pierwszym wierszu pliku. Ten wiersz nosi nazwę shebang (shell execute, czyli plik wykonywalny powłoki) i jeśli zostaje umieszczony w pliku, to musi być pierwszym wierszem pliku. Wiersz shebang jest zazwyczaj zapisywany w jednej z dwóch możliwych postaci: #!/usr/bin/python3 lub #!/usr/bin/env python3 Jeżeli będzie zapisany w pierwszej formie, użyty zostanie wymieniony interpreter. Użycie tej formy może okazać się konieczne w przypadku programów Pythona uruchamianych przez serwer WWW, choć sama ścieżka dostępu może być odmienna niż przedstawiona w powyższym przykładzie. Jeśli zostanie użyta druga forma, użyty zostanie pierwszy interpreter python3 znaleziony w bieżącym środowisku powłoki. Druga forma jest znacznie elastyczniejsza, ponieważ dopuszcza możliwość, że interpreter Python 3 nie został umieszczony w katalogu /usr/bin (na przykład może być zainstalowany w katalogu /usr/local/bin bądź w $HOME). W systemie Windows wiersz shebang nie jest wymagany (choć równocześnie pozostaje nieszkodliwy). Wszystkie przykłady zaprezentowane w książce zawierają wiersz shebang w drugiej formie, choć nie umieszczono go w listingach. Warto zwrócić uwagę, że dla systemów Unix przyjmujemy założenie, iż nazwa pliku wykonywalnego Pythona 3 (lub dowiązanie symboliczne do niego) w zmiennej systemowej PATH to python3. Jeżeli tak nie jest, w przykładach należy zmodyfikować wiersz shebang i podać odpowiednią nazwę (prawidłową nazwę i ścieżkę dostępu w przypadku używania pierwszej formy wiersza shebang). Ewentualnie trzeba utworzyć dowiązanie symboliczne z pliku wykonywalnego Python 3 do nazwy python3 w zmiennej PATH. Wiele edytorów tekstowych o potężnych możliwościach, na przykład Vim i Ecmacs, jest dostarczanych wraz z wbudowaną obsługą edycji programów w języku Python. Wspominania obsługa zazwyczaj obejmuje kolorowanie składni oraz prawidłowe stosowanie wcięć wierszy. Alternatywnym rozwiązaniem jest używanie środowiska programistycznego dla Pythona, którym jest IDLE. W systemach Windows i Mac OS X środowisko IDLE jest instalowane domyślnie. Z kolei w systemie Unix środowisko IDLE zostaje zbudowane wraz z interpreterem Pythona, o ile jest on budowany z archiwum tarball. W przypadku użycia menedżera pakietów środowisko IDLE zwykle jest dostarczane jako oddzielny pakiet, jak to przedstawiono we wcześniejszym rozdziale „Wprowadzenie”. Na rysunku 1.1 pokazano środowisko IDLE. Jak widać, IDLE charakteryzuje się przestarzałym interfejsem graficznym, który przypomina czasy motywu Motif w systemach Unix bądź systemu Windows 95. Wynika to z faktu używania biblioteki GUI Tkinter 2 Interakcja między użytkownikiem i konsolą jest obsługiwana przez program „powłoka”. Rozróżnienie między programami konsoli i powłoki nie ma tutaj najmniejszego znaczenia, więc oba pojęcia są tu używane zamiennie. Pobieranie i instalacja Pythona 19 g 28 Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego Rysunek 1.1. Konsola Pythona w Ĉrodowisku IDLE bazującej na Tk (omówiona w rozdziale 15.), a nie jednej z nowoczesnych i oferujących potężniejsze możliwości bibliotek takich jak PyGtk, PyQt lub wxPython. Powód stosowania biblioteki Tkinter to połączenie historii, liberalnych warunków licencji oraz faktu, że biblioteka Tkinter jest znacznie mniejsza niż inne biblioteki GUI. Na plus można zaliczyć to, że środowisko IDLE jest dostarczane domyślnie wraz z Pythonem i bardzo łatwo je poznać oraz go używać. Środowisko IDLE zapewnia trzy istotne funkcje: możliwość wprowadzania wyrażeń języka Python oraz kodu źródłowego i obserwowania wyników bezpośrednio w powłoce Pythona, edytor kodu oferujący kolorowanie składni kodu Pythona oraz prawidłowe stosowanie wcięć wierszy, a także moduł usuwania błędów pozwalający na przejście przez kod wiersz po wierszu, znajdywanie i usuwanie błędów. Powłoka Pythona jest szczególnie użyteczna w trakcie wypróbowywania przykładowych algorytmów, fragmentów kodu oraz wyrażeń regularnych. Może być także używana jako oferujący potężne możliwości i bardzo elastyczny kalkulator. Dostępnych jest kilka innych środowisk programistycznych Pythona, ale zalecamy stosowanie środowiska IDLE, przynajmniej na początku. Alternatywą jest tworzenie programów w zwykłym edytorze tekstowym, a następnie usuwanie błędów poprzez stosowanie wywołań funkcji print(). Możliwe jest wywołanie interpretera Pythona bez wskazywania programu w języku Python. W takim przypadku interpreter zostaje uruchomiony w trybie interaktywnym. Podczas pracy w tym trybie można wprowadzać polecenia Pythona i obserwować wyniki dokładnie w taki sam sposób, jak w trakcie używania okna powłoki Pythona środowiska IDLE — wraz z tymi samymi znakami zachęty w postaci . Jednak środowisko IDLE pozostaje znacznie łatwiejsze w użyciu, więc zalecamy stosowanie IDLE podczas eksperymentowania „Piökne serce” Pythona 29 z fragmentami kodu. Gdy prezentujemy krótkie przykłady interaktywne, przyjmujemy wówczas założenie, że są one wprowadzane w interaktywnym interpreterze Python bądź oknie powłoki Pythona środowiska IDLE. Wiemy już, w jaki sposób tworzyć i uruchamiać programy Pythona, ale przecież czytelnicy nie znają jeszcze języka — posiadają jedynie ogólną wiedzę o pojedynczej funkcji. Dzięki lekturze kolejnego rozdziału wyraźnie zwiększy się ich wiedza o języku Python. Przedstawione tu informacje pozwolą na tworzenie krótkich, choć użytecznych programów w Pythonie, co zaprezentujemy w ostatnim podrozdziale niniejszego rozdziału. „Piökne serce” Pythona W tym podrozdziale zostanie omówionych osiem kluczowych koncepcji języka Python, natomiast w kolejnym podrozdziale przedstawimy użycie tych koncepcji podczas tworzenia kilku małych, a jednak użytecznych programów. Na temat zagadnień poruszonych w tym podrozdziale można powiedzieć znacznie więcej. Dlatego też jeśli czytelnik poczuje, że czegoś brakuje w Pythonie bądź że pewne zadania są wykonywane w zbyt długi sposób, wtedy może przejść do znajdującego się w dalszej części książki materiału dotyczącego danego zagadnienia. Wystarczy kierować się podanym w tekście odniesieniem lub skorzystać ze spisu treści bądź skorowidza. W ten sposób łatwo przekonać się, że Python jednak ma funkcję poszukiwaną przez czytelnika. Ponadto bardzo często okaże się, że dana funkcja będzie miała nie tylko znacznie czytelniejsze formy wyrażenia niż zastosowane tutaj, ale także i większe możliwości. Koncepcja 1. — typy danych Podstawową funkcją każdego języka programowania jest możliwość przedstawienia danych. Python oferuje kilka wbudowanych typów danych, ale w chwili obecnej skoncentrujemy się jedynie na dwóch. Liczby całkowite (dodatnie i ujemne) są przedstawiane w Pythonie za pomocą typu int, natomiast ciągi tekstowe (sekwencje znaków Unicode) — za pomocą typu str. Poniżej przedstawiono kilka przykładów liczb całkowitych oraz dosłownych ciągów tekstowych: -973 210624583337114373395836055367340864637790190801098222508621955072 0 Nieskoñczenie wymagajÈcy Szymon Kowalski pozytywne €÷© Nawiasem mówiąc, druga liczba to 2217 — wielkość liczb całkowitych w Pythonie jest ograniczona jedynie przez ilość pamięci zainstalowanej w komputerze, a nie przez odgórnie ustaloną liczbę bajtów. Ciągi tekstowe mogą być ujęte w cudzysłów bądź apostrofy, o ile na obu końcach ciągu tekstowego znajduje się ten sam ogranicznik (znak cudzysłowu lub 30 Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego apostrof). Ponieważ Python używa kodowania znaków Unicode, ciągi tekstowe nie są ograniczone jedynie do zbioru znaków ASCII, co widać wyraźnie w przedostatnim ciągu tekstowym. Pusty ciąg tekstowy składa się po prostu z ograniczników ciągu tekstowego. W celu uzyskania dostępu do elementu w sekwencji, na przykład w ciągu tekstowym, w Pythonie używa się nawiasów kwadratowych ([]). Przykładowo: pracując w powłoce Pythona (albo w interpreterze interaktywnym lub środowisku IDLE), możemy wprowadzić poniższe polecenia. Dane wyjściowe powłoki Pythona są przedstawione czcionkÈ o staïej szerokoĂci, natomiast wprowadzane polecenia zostały pogrubione: Trudne Czasy [7] C ĝyrafa [0] ĝ Tradycyjnie powłoka Pythona jako znaku zachęty używa , choć można to zmienić. Składnia wykorzystująca nawiasy kwadratowe może być stosowana z elementami danych będącymi dowolnego typu sekwencjami, czyli na przykład z ciągami tekstowymi bądź listami. Konsekwencja w składni to jeden z powodów, dla których język Python jest tak piękny. Warto zwrócić uwagę, że wszystkie pozycje indeksu w Pythonie rozpoczynają się od zera. W Pythonie zarówno str, jak i podstawowe typy liczbowe, na przykład int, są niemodyfikowalne — to znaczy, że raz ustalona wartość nie może być zmieniona. W pierwszej chwili wydaje się, że to dziwne ograniczenie, ale składnia Pythona powoduje, że w praktyce nie stanowi ono żadnego problemu. Jedynym powodem, dla którego wspominamy o nim tutaj, jest to, że chociaż składni nawiasów kwadratowych można użyć do pobrania znaku z pozycji o wskazanym indeksie w ciągu tekstowym, to nie można jej wykorzystać do ustawienia nowego znaku. (Warto zwrócić uwagę, że w Pythonie znak jest po prostu ciągiem tekstowym o długości 1). Aby przekonwertować element danych z jednego typu na inny, można użyć składni w postaci typ_danych(element), na przykład: int( 45 ) 45 str(912) 912 Typ konwersji int() jest tolerancyjny, jeśli chodzi o znaki odstępu umieszczone przed lub po elemencie, tak więc polecenie int( 45 ) również działa doskonale. Typ konwersji str() może być zastosowany wobec niemal dowolnego elementu danych. Jak się przekonamy w rozdziale 6., bardzo łatwo możemy utworzyć własny typ danych obsługujący konwersję str(), jak również konwersję int() i każdą inną, o ile ma to sens. Jeżeli konwersja zakończy się niepowodzeniem, wtedy zostanie zgłoszony wyjątek — obsługa błędów będzie pokrótce omówiona w koncepcji 5. Pełne omówienie wyjątków znajduje się w rozdziale 4. Ciągi tekstowe i liczby całkowite zostały szczegółowo omówione w rozdziale 2. wraz z innymi wbudowanymi typami danych oraz wybranymi typami danych dostępnymi w bibliotece standardowej Pythona. W rozdziale 2. przedstawiono także operacje, które można wykonać względem niemodyfikowalnych sekwencji, takich jak ciągi tekstowe. „Piökne serce” Pythona 31 Koncepcja 2. — odniesienia do obiektów Kiedy posiadamy już pewne typy danych, kolejnym potrzebnym elementem są zmienne pozwalające na przechowywanie danych. Python nie posiada zmiennych jako takich, ale ma odniesienia do obiektów. W przypadku niezmiennych obiektów, na przykład typu str lub int, nie ma żadnej widocznej różnicy między zmienną i odniesieniem do obiektu. Natomiast w przypadku obiektów zmiennych taka różnica występuje, choć w praktyce rzadko ma znaczenie. Pojęć zmienna i odniesienie do obiektu będziemy więc używać zamiennie. Spójrzmy na kilka prostych przykładów, które następnie będą dokładnie omówione: x = niebieski y = zielony z = x Składnia to po prostu odniesienie_do_obiektu = wartoĂÊ. Nie ma konieczności podawania wcześniej jakichkolwiek deklaracji bądź określania rodzaju wartości. Kiedy Python wykonuje pierwsze polecenie, tworzy obiekt str wraz z tekstem „niebieski” oraz tworzy odniesienie do obiektu, nazwane x, które po prostu odnosi się do obiektu str. Ze względów praktycznych możemy powiedzieć: „zmiennej x został przypisany ciąg tekstowy niebieski ”. Drugie polecenie jest podobne. Trzecie polecenie tworzy nowe odniesienie do obiektu, nazwane z, i określa, że będzie odnosiło się do tego samego obiektu, do którego odnosi się odniesienie x. W omawianym przykładzie będzie to obiekt str zawierający tekst „niebieski”. Operator = nie ma takiej samej funkcji jak spotykany w niektórych językach operator przypisania funkcji. Operator = łączy w pamięci odniesienie do obiektu wraz z obiektem. Jeżeli odniesienie do obiektu już istnieje, wtedy po prostu nastąpi ponowne dołączenie w celu utworzenia odniesienia do obiektu znajdującego się po prawej stronie operatora =. Natomiast jeśli dane odniesienie jeszcze nie istnieje, zostanie utworzone przez operator =. Kontynuujemy pracę z przykładem x, y, z i dokonujemy ponownych dołączeń. Jak już wcześniej wspomniano, komentarz rozpoczyna się znakiem # i trwa aż do końca wiersza: print(x, y, z) # dane wyjĻciowe: niebieski zielony niebieski z = y print(x, y, z) # dane wyjĻciowe: niebieski zielony zielony x = z print(x, y, z) # dane wyjĻciowe: zielony zielony zielony Po czwartym poleceniu (x = z) wszystkie trzy odniesienia do obiektów odwołują się do tego samego obiektu str. Ponieważ nie ma więcej odniesień do ciągu tekstowego „niebieski”, Python może go usunąć (użyć mechanizmu garbage collection, czyli zbierania nieużytków). Na rysunku 1.2 pokazano schematycznie związki zachodzące między obiektami i odniesieniami do obiektów. Nazwy używane dla odniesień do obiektów (nazywane identyfikatorami) mają kilka ograniczeń. W szczególności nie mogą być takie same jak słowa kluczowe języka Python oraz muszą rozpoczynać się literą bądź znakiem podkreślenia, po którym znajduje się zero lub więcej znaków innych niż znaki odstępu (dozwolone się litery, znaki podkreślenia lub cyfry). Nie ma ograniczenia w długości nazwy, a litery i cyfry to te, które są zdefiniowane Kopiowanie płytkie i głębokie h 164 Identyfika- tory i słowa kluczowe h 65 32 Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego Rysunek 1.2. Odniesienia do obiektów oraz obiekty przez Unicode. Zawierają więc zestaw ASCII, choć nie muszą być ograniczone jedynie do liter i cyfr ASCII („a”, „b”, …, „z”, „A”, „B”, …, „Z”, „0”, „1”, …, „9”). Identyfikatory Pythona rozróżniają wielkość liter, więc LIMIT, Limit i limit to trzy różne identyfikatory. Szczegółowe omówienie identyfikatorów oraz pewne nieco egzotyczne przykłady zostały przedstawione w rozdziale 2. Python stosuje dynamiczną kontrolę typu, co oznacza, że w dowolnej chwili odniesienie do obiektu może być dołączone do innego obiektu, który z kolei może być obiektem innego typu danych. Języki stosujące ścisłą kontrolę typu (na przykład C++ i Java) pozwalają na wykonanie jedynie tych operacji, które zostały zdefiniowane w używanym typie danych. Python także stosuje wymienione ograniczenie, ale w przypadku Pythona nie nazywamy tego ścisłą kontrolą typu, ponieważ dopuszczalne operacje mogą ulegać zmianie — na przykład jeśli odniesienie do obiektu zostanie ponownie utworzone i dołączone do obiektu innego typu danych. Przykładowo: droga = 866 print(droga, type(droga)) # dane wyjĻciowe: 866 class int droga = Póïnoc print(droga, type(droga)) # dane wyjĻciowe: Pó§noc class str W powyższym przykładzie tworzymy nowe odniesienie do obiektu nazwane droga i przypisujemy mu nową wartość 866 typu int. Na tym etapie względem odniesienia droga można użyć operatora /, ponieważ dzielenie jest dopuszczalną i poprawną operacją przeprowadzaną na liczbach całkowitych. Następnie ponownie używamy odniesienia droga w celu utworzenia odniesienia do nowej wartości „Północ” typu str. Obiekt int zostaje skierowany do mechanizmu zbierania nieużytków, ponieważ w chwili obecnej nie ma do niego żadnego odniesienia. Na tym etapie użycie operatora / względem odniesienia droga spowoduje zgłoszenie wyjątku TypeError, ponieważ dzielenie (/) nie jest operacją dopuszczalną do przeprowadzenia względem ciągu tekstowego. Wartością zwrotną funkcji type() jest typ danych (znany także jako „klasa”) wskazanego elementu danych. Funkcja ta może być więc bardzo użyteczna podczas testowania i usuwania błędów w kodzie, ale zazwyczaj nie będzie stosowana w kodzie produkcyjnym — jak się okaże w rozdziale 6., są tutaj inne, lepsze możliwości. Jeżeli czytelnik eksperymentuje z kodem Pythona w interpreterze interaktywnym lub powłoce Pythona, na przykład oferowanej przez środowisko IDLE, wystarczy po prostu podać nazwę odniesienia do obiektu, a Python wyświetli jego wartość. Przykładowo: Funkcja insin ´stance() h 260 „Piökne serce” Pythona 33 x = niebieski y = zielony z = x x niebieski x, y, z ( niebieski , zielony , niebieski ) To znacznie wygodniejsze rozwiązanie niż ciągłe wywoływanie funkcji print(), ale działa jedynie wtedy, gdy Python funkcjonuje w trybie interaktywnym. W celu wyświetlenia danych wyjściowych wszystkie tworzone programy i moduły nadal muszą stosować funkcję print() lub podobną. Warto zwrócić uwagę, że ostatnie dane wyjściowe zostały wyświetlone w nawiasach i rozdzielone przecinkami. Oznacza to typ danych tuple, czyli krotkę — uporządkowaną, niezmienną sekwencję obiektów. Krotki zostaną przedstawione w kolejnej koncepcji. Koncepcja 3. — kolekcje typów danych Bardzo często wygodnym rozwiązaniem jest przechowywanie całej kolekcji elementów danych. Python oferuje kilka kolekcji typów danych, które mogą przechowywać elementy — są to między innymi tablice asocjacyjne i zbiory. W tym miejscu omówimy jednak tylko dwa typy: tuple (krotka) i list (lista). Krotki i listy Pythona mogą być stosowane w celu przechowywania dowolnej liczby elementów danych dowolnego typu danych. Krotki pozostają niezmienne, więc po ich utworzeniu nie ma możliwości wprowadzania zmian. Natomiast listy są zmienne, można więc łatwo wstawiać i usuwać elementy listy według własnego uznania. Jak widać na poniższych przykładach, krotki są tworzone za pomocą przecinków (,). Warto zwrócić uwagę, że poniżej i ogólnie od tej chwili wprowadzane przez użytkownika polecenia nie będą przedstawiane pogrubioną czcionką: Dania , Finlandia , Norwegia , Szwecja ( Dania , Finlandia , Norwegia , Szwecja ) jeden ( jeden ,) Kiedy Python wyświetla krotkę, ujmuje ją w nawias. Wielu programistów naśladuje to rozwiązanie i zawsze ujmują dosłowne krotki w nawiasy. W przypadku krotki jednoelementowej i chęci użycia nawiasu nadal trzeba zastosować przecinek, na przykład (1,). Pusta krotka jest tworzona za pomocą pustego nawiasu (). Przecinek jest wykorzystywany także do rozdzielania argumentów w wywołaniach funkcji. Dlatego też, jeżeli dosłowna krotka ma zostać przekazana jako argument, musi być ujęta w nawias, aby uniknąć zamieszania. Poniżej przedstawiono kilka przykładów list: [1, 4, 9, 16, 25, 36, 49] [ alpha , bravo , charlie , delta , echo ] [ zebra , 49, -879, mrównik , 200] [] Typ danych tuple h 124 Tworzenie i wywoływa- nie funkcji h 51 34 Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego Typ danych list h 129 Kopiowanie płytkie i głębokie h 164 Klasa Sized h 397 Jednym ze sposobów utworzenia listy jest użycie nawiasów kwadratowych ([]) — jak pokazano na powyższym przykładzie. W dalszej części książki zostaną przedstawione inne sposoby. Wiersz czwarty pokazuje pustą listę. Wewnętrznie listy i krotki w ogóle nie przechowują elementów danych, a raczej odniesienia do obiektów. W trakcie tworzenia listy bądź krotki (oraz podczas wstawiania elementów w przypadku listy) kopiują one odniesienia do podanych obiektów. W przypadku dosłownych elementów, na przykład liczb całkowitych i ciągów tekstowych, w pamięci tworzony jest obiekt odpowiedniego typu danych i później jest on inicjalizowany. Następnie tworzone jest odniesienie do tego obiektu i to utworzone odniesienie zostaje umieszczone w krotce bądź na liście. Podobnie jak w przypadku pozostałych konstrukcji Pythona, również kolekcje typów danych są obiektami. Istnieje więc możliwość zagnieżdżania jednej kolekcji typu danych w innej, na przykład w celu utworzenia listy zawierającej inne listy. W pewnych sytuacjach fakt, że listy, krotki i większość pozostałych kolekcji typów danych Pythona przechowuje odniesienia do obiektów zamiast obiektów, powoduje różnicę — zostanie to omówione w rozdziale 3. W programowaniu proceduralnym wywołujemy funkcje i często przekazujemy elementy danych jako argumenty. Przykładowo widzieliśmy już w działaniu funkcję print(). Inna często używana funkcja Pythona to len(), która jako argument pobiera pojedynczy element danych. Wartością zwrotną funkcji jest „długość” elementu podana jako obiekt int. Poniżej przedstawiono kilka wywołań funkcji len(): len(( jeden ,)) 1 len([3, 5, 1, 2, pauza , 5]) 6 len( automatycznie ) 13 Krotki, listy oraz ciągi tekstowe mają „ustaloną wielkość”, to znaczy są typami danych, które muszą mieć podaną wielkość. Elementy takiego typu danych mogą być bez problemów przekazane funkcji len(). (W przypadku przekazania funkcji len() elementu danych bez ustalonej wielkości następuje zgłoszenie wyjątku). Wszystkie elementy danych Pythona są obiektami (nazywane są również egzemplarzami) określonego typu danych (nazywanego także klasą). Pojęć typ danych i klasa będziemy używać zamiennie. Jedną z istotnych różnic między obiektem i zwykłym elementem danych dostarczanym przez niektóre języki (na przykład C++ lub wbudowane typy liczbowe Javy) pozostaje to, że obiekt może mieć metody. Ogólnie rzecz biorąc, metoda to po prostu funkcja, która jest wywoływana dla określonego obiektu. Przykładowo typ list ma metodę append(), która umożliwia dołączenie obiektu do listy w następujący sposób: x = [ zebra , 49, -879, mrównik , 200] x.append( wiÚcej ) x [ zebra , 49, -879, mrównik , 200, wiÚcej ] „Piökne serce” Pythona 35 Obiekt x „wie”, że jest typu list (w Pythonie wszystkie obiekty znają swój typ danych), tak więc nie ma potrzeby wyraźnego wskazywania typu danych. W implementacji metody append() pierwszym argumentem jest sam obiekt x — przekazanie tego obiektu jest przeprowadzane automatycznie przez Pythona jako część syntaktycznej obsługi metod. Metoda append() mutuje, czyli zmienia początkową listę. Jest to możliwe, ponieważ listy są elementami zmiennymi. Zwłaszcza w przypadku bardzo długich list jest to także potencjalnie znacznie efektywniejsze rozwiązanie niż tworzenie nowej listy zawierającej początkowe elementy, dodanie nowych elementów, ponowne dołączenie nowej listy do odniesienia do obiektu. W języku proceduralnym ten sam efekt można uzyskać, stosując metodę append() listy, jak przedstawiono poniżej (to zupełnie prawidłowa składnia Pythona): list.append(x, ekstra ) x [ zebra , 49, -879, mrównik , 200, wiÚcej , ekstra ] Tutaj podajemy typ danych oraz metodę typu danych. Ponadto jako pierwszy argument przekazujemy element danych tego typu danych, którego chcemy użyć w metodzie, a następnie dowolną liczbę argumentów dodatkowych. (W przypadku dziedziczenia istnieje subtelna różnica semantyczna między dwiema przedstawionymi składniami. W praktyce najczęściej spotykana jest pierwsza forma. Dziedziczenie zostanie omówione w rozdziale 6.). Jeżeli czytelnik nie zna programowania zorientowanego obiektowo, w pierwszej chwili powyższe informacje mogą mu wydawać się nieco dziwne. Na chwilę obecną należy zaakceptować fakt, że Python ma funkcje konwencjonalne wywoływane w postaci nazwa_funkcji(argumenty) oraz metody wywoływane w postaci nazwa_obiektu.nazwa_ ´metody(argumenty). (Programowanie zorientowane obiektowo zostanie omówione w rozdziale 6.). Operator kropki („atrybut dostępu”) jest używany w celu uzyskania dostępu do atrybutów obiektu. Wspomniany atrybut może być dowolnego typu obiektem, chociaż jak dotąd widzieliśmy jedynie atrybuty metod. Ponieważ atrybut może być obiektem posiadającym atrybuty, które z kolei mogą mieć swoje atrybuty itd., istnieje możliwość użycia tylu operatorów kropki, ilu potrzeba w celu uzyskania dostępu do żądanego atrybutu. Typ list posiada wiele innych metod, między innymi insert(), która jest używana w celu wstawiania elementu we wskazanej pozycji indeksu. Z kolei metoda remove() usuwa element znajdujący się we wskazanej pozycji indeksu. Jak już wcześniej wspomniano, indeksy Pythona zawsze rozpoczynają się od zera. Wcześniej widzieliśmy, że istnieje możliwość pobierania znaków z ciągu tekstowego za pomocą operatora w postaci nawiasów kwadratowych. Wspomniano także, że wymieniony operator może być używany w dowolnej sekwencji. Ponieważ listy są sekwencjami, więc bez problemu możemy wykonać przedstawione poniżej polecenia: x [ zebra , 49, -879, mrównik , 200, wiÚcej , ekstra ] x[0] 36 Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego zebra x[4] 200 Krotki również są sekwencjami, jeśli więc zmienna x byłaby krotką, moglibyśmy pobrać jej elementy, używając składni nawiasów kwadratowych w dokładnie taki sam sposób, jak w przypadku listy x. Jednak ponieważ listy można zmieniać (w przeciwieństwie do niezmiennych ciągów tekstowych i krotek), w celu ustawienia elementów listy też możemy użyć operatora nawiasów kwadratowych. Przykładowo: x[1] = czterdzieĂci dziewiÚÊ x [ zebra , czterdzieĂci dziewiÚÊ, -879, mrównik , 200, wiÚcej , ekstra ] W przypadku podania pozycji indeksu wykraczającej poza zakres nastąpi zgłoszenie wyjątku. Obsługa błędów będzie pokrótce omówiona w koncepcji 5. Pełne omówienie wyjątków znajduje się w rozdziale 4. Jak dotąd kilkakrotnie użyto pojęcia sekwencja, polegając jedynie na nieoficjalnym przedstawieniu jego znaczenia. Na tym nieformalnym znaczeniu będziemy polegać jeszcze przez jakiś czas. Jednak język Python precyzyjnie definiuje wymagania, które muszą być spełnione przez sekwencję. Podobnie są zdefiniowane funkcje, które muszą być spełnione przez obiekt o ustalonym rozmiarze. Ponadto zdefiniowane jest także wiele innych kategorii, do których może zaliczać się typ danych, o czym przekonamy się w rozdziale 8. Listy, krotki i inne wbudowane kolekcje typów danych Pythona zostaną szczegółowo omówione w rozdziale 3. Koncepcja 4. — operatory logiczne Jedną z podstawowych funkcji dowolnego języka programowania jest obsługa operacji logicznych. Python oferuje cztery zestawy operacji logicznych, w kolejnych sekcjach omówimy podstawy każdego z nich. Operator toĔsamoĈci Ponieważ wszystkie zmienne Pythona tak naprawdę są odniesieniami do obiektów, czasami sensowne jest sprawdzenie, czy dwa bądź większa liczba odniesień odwołuje się do tego samego obiektu. Operator is to operator dwuargumentowy zwracający wartość True, jeśli odniesienie do obiektu znajdujące się po lewej stronie operatora odwołuje się do tego samego obiektu, do którego odwołuje się odniesienie po prawej stronie operatora. Poniżej przedstawiono kilka przykładów: a = [ Retencja , 3, None] b = [ Retencja , 3, None] a is b False b = a a is b True „Piökne serce” Pythona 37 Warto pamiętać, że zazwyczaj nie ma większego sensu używanie operatora is w celu porównywania obiektów int, str oraz większości pozostałych typów danych, ponieważ prawie zawsze chcemy porównywać ich wartości. W rzeczywistości stosowanie operatora is w celu porównywania elementów danych może prowadzić do otrzymania niewiarygodnych wyników, jak mogliśmy zobaczyć na powyższym przykładzie. Tutaj, chociaż a i b miały początkowo ustawione te same wartości listy, same listy były przechowywane jako oddzielne obiekty list. Podczas pierwszego użycia operator is zwrócił więc wartość False. Zaletą operatorów tożsamości jest ich duża szybkość działania. Wynika to z faktu, że obiekty podawane w operatorze nie muszą być analizowane. Operator is porównuje jedynie adresy w pamięci wskazanych obiektów — ten sam adres oznacza ten sam obiekt. Najczęściej spotykaną sytuacją, w której stosuje się operator is, jest porównywanie elementu danych z wbudowanym w język obiektem null (None). Obiekt ten jest często używany jako oznaczenie wartości „nieznany” bądź „nieistniejący”: a = CoĂ b = None a is not None, b is None (True, True) W celu odwrócenia testu tożsamości używamy operatora is not. Celem operatora tożsamości jest sprawdzenie, czy dwa odniesienia do obiektu odwołują się do tego samego obiektu, bądź sprawdzenie, czy którykolwiek z obiektów jest typu None. Jeżeli zachodzi potrzeba porównania wartości obiektu, wtedy należy zastosować operator porównania. Operatory porównania Python oferuje standardowy zestaw binarnych operatorów porównania charakteryzujących się oczekiwaną semantyką: mniejszy niż, = mniejszy niż lub równy, == równy, != nierówny, = większy niż lub równy oraz większy niż. Wymienione operatory porównują wartości obiektów, to znaczy obiektów, do których odniesienia zostały wskazane w operatorze. Poniżej przedstawiono kilka przykładów wprowadzonych w powłoce Pythona: a = 2 b = 6 a == b False a b True a = b, a != b, a = b, a b (True, True, False, False) Podczas pracy z liczbami całkowitymi wszystko przebiega zgodnie z oczekiwaniami. Podobnie w przypadku pracy z ciągami tekstowymi wydaje się, że operatory porównania również działają poprawnie: a = wiele Ăcieĝek b = wiele Ăcieĝek a is b 38 Rozdziaä 1. Szybkie wprowadzenie do programowania proceduralnego False a == b True Chociaż a i b to różne obiekty (mają odmienne tożsamości), to posiadają takie same wartości, więc w trakcie porównywania są uznawane za takie same. Trzeba jednak zachować ostrożność, ponieważ w celu przedstawienia ciągu tekstowego Python używa kodowania znaków Unicode. Dlatego też porównywanie ciągów tekstowych zawierających znaki wykraczające poza zbiór znaków ASCII może być nieco odmienne i bardziej skomplikowane, niż się wydaje w pierwszej chwili — to zagadnienie zostanie dokładnie omówione w rozdziale 2. W pewnych sytuacjach porównywanie tożsamości dwóch ciągów tekstowych bądź liczb — na przykład użycie polecenia a is b — spowoduje wygenerowanie wartości zwrotnej True, nawet jeśli każdy element został przypisany oddzielnie jak w omawianym przypadku. Wynika to z faktu, że pewne implementacje Pythona będą ponownie używały tego samego obiektu (ponieważ wartość pozostaje taka sama, a obiekt jest niezmienny) w celu zwiększenia wydajności. Morał jest taki, aby podczas porównywania wartości stosować operatory == i !=. Z kolei operatory is i is not stosować jedynie w trakcie porównywania z obiektem None, ewentualnie jeśli naprawdę zachodzi potrzeba sprawdzenia, czy dwa odniesienia do obiektów — a nie ich wartości — są takie same. Jedną ze szczególnie użytecznych cech operatorów porównania w Pythonie jest możliwość ich łączenia, na przykład: Porówny- wanie ciągów tekstowych h 83 a = 9 0 = a = 10 True To znacznie ładniejszy sposób sprawdzenia, czy podany element danych mieści się w zakresie, niż stosowanie dwóch oddzielnych operacji porównania połączonych logicznym operatorem and, jak ma to miejsce w większości innych języków programowania. Dodatkową zaletą tego rozwiązania jest sprawdzanie elementu danych tylko jednokrotnie (ponieważ w podanym wyrażeniu pojawia się tylko jednokrotnie). Może mieć to ogromne znaczenie w sytuacji, gdy obliczenie wartości elementu danych jest bardzo kosztowne, bądź jeśli uzyskanie dostępu do elementu danych powoduje powstanie efektu ubocznego. Dzięki „mocnemu” aspektowi Pythona, jakim jest dynamiczna kontrola typu, porównania, które nie mają sensu, będą powodowały zgłoszenie wyjątku. Przykładowo: trzy 4 Traceback (most recent call last): ... TypeError: unorderable types: str() int() Kiedy następuje zgłoszenie wyjątku, który nie jest obsłużony, Python wyświetla komunikaty dotyczące ostatnich wywołań (traceback) wraz z komunikatem błędu wyjątku. W celu
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Python 3. Kompletne wprowadzenie do programowania. Wydanie II
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
79,00 zł
Idź do sklepu »

Opinie na temat publikacji:

Inne popularne pozycje z tej kategorii:

Czytaj również:

Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: