Brain-wiki - Wkład użytkownika [pl]

PPy3/WejścieWyjście

2025-11-28T09:16:24Z

RobertJB: /* Czytanie dowolnych danych z pliku */

=Obsługa wejścia i wyjścia=

Większość sensownych programów służy do przetworzenia jakichś informacji uzyskanych z zewnątrz programu: w najprostszym przypadku,
z pliku na dysku, lub z danych wprowadzonych przez użytkownika za pomocą klawiatury. W przypadku programów wywoływanych z linii poleceń, istnieje też poręczny i łatwy do wykorzystania mechanizm by wskazać programowi, co ma robić - za pomocą tzw. opcji i/lub wartości parametrów wpisanych na linii poleceń, po nazwie wywoływanego programu. Często też chcemy, by wyniki działania programu, np. przetworzone dane lub wyniki obliczeń, znalazły się w pliku na dysku - choć czasami możemy woleć, aby również (lub zamiast tego) zostały one wyświetlone na ekranie. Omówimy teraz krótko, jak to osiągnąć.

==Pliki tekstowe vs. binarne==

Zawartość każdego pliku na dysku to tak naprawdę ''strumień bajtów'' - bajt, czyli grupa ośmiu bitów, może być traktowany jako reprezentacja (w zapisie dwójkowym), jakiejś liczby całkowitej dodatniej z zakresu 0-255. Często jednak zawartość ta ma być traktowana jako reprezentacja tekstu, czyli ciągu znaków stosowanych w zapisie jakiegoś języka - może to być język naturalny (polski, angielski, chiński, ...) lub np. język programowania (Python, Java, C++, ...), język tworzenia stron WWW (HTML), itd. W tym celu stworzono tzw. ''kodowania'', czyli standardy reprezentowania znaków stosowanych w systemach zapisu języków naturalnych za pomocą bajtów lub grup bajtów (języki programowania itp. zasadniczo posługują się tymi samymi zestawami znaków, co języki naturalne - a zwłaszcza angielski).

Nie wchodząc za bardzo w szczegóły, obecnie stosowane reprezentacje cyfrowe tekstu oparte są na standardzie ''Unicode'', który m. in. definiuje tzw. uniwersalny zestaw znaków (UCS) - tablicę, zawierającą wszystkie znaki (alfanumeryczne, przestankowe, ideogramy - właściwe dla języków dalekowschodnich, i szeregu innych kategorii) stosowane w systemach pisma wszystkich żywych języków świata (i wielu języków martwych). Wewnętrzna reprezentacja danych napisowych w Pythonie oparta jest na standardzie Unicode - zatem pythonowy napis może zawierać znaki z wszelkiego rodzaju systemów pisma, w dowolnej kombinacji. Zapis tych danych w pliku dyskowym - i odwrotne, zinterpretowanie strumienia bajtów odczytanego z pliku dyskowego jako reprezentacji pewnego napisu - wymaga przyjęcia jakiegoś konkretnego kodowania. Unicode nie stanowi sam w sobie kodowania - określa on repertuar znaków oraz pozycję każdego z nich w tablicy UCS, nie zaś bajt lub grupę bajtów go reprezentującą.

W Pythonie problem ten rozwiązany jest w sposób następujący: domyślnie, zawartość wczytywana z plików interpretowana jest jako dane tekstowe (chyba, że zażyczymy sobie inaczej), zgodnie z pewnym domyślnym kodowaniem, właściwym dla systemu operacyjnego (chyba, że wskażemy że ma być stosowane inne) - w przypadku Linuxa będzie to prawie zawsze kodowanie o nazwie UTF-8, które się dobrze nadaje do zastosowania dla języków zachodnich, posługujących się systemem pisma opartym na alfabecie łacińskim. Inaczej może być w środowiskach języków posługujących się np. cyrylicą, czy języków azjatyckich (pismo arabskie lub ideograficzne - chińskie, japońskie, koreańskie, itd.). W środowiskach Windows może być inaczej...

Z powyższego widać, że rozróżnienie - plik tekstowy czy binarny - jest dość umowne, i dotyczy raczej interpretacji zawartości pliku (plik zapisany zgodnie z nieznanym nam i/lub nieoczekiwanym kodowaniem jest nie do odróżnienia od pliku binarnego). Co więcej, pliki zapisywane przez programy takie, jak MS Word, lub pliki PDF, nawet zawierające wyłącznie tekst, nie są w tym rozumieniu plikami tekstowymi, tylko binarnymi. W przykładach będziemy mieli do czynienia prawie wyłącznie z plikami tekstowymi - warto jednak wiedzieć, że w Pythonie jest osobny typ danych - ciągi bajtów (''bytes''), o własnościach nieco podobnych do napisów, ale o elementach będących bajtami, a nie znakami pisma.

==Czytanie tekstu z pliku==

<source lang=python>

f = open('nazwa_pliku.txt')
for linia in f:
przetworz(linia)
f.close()

# albo może lepiej:

with open('nazwa_pliku.txt') as f:
for linia in f:
przetworz(linia)

# jeszcze inaczej

tresc = open('nazwa_pliku.txt').read() # wczytujemy od razu całą treść pliku

</source>

*Otwarty do odczytu plik tekstowy dopuszcza iterację, w której kolejnymi elementami są linie tekstu - wraz z kończącym je kodem przejścia do nowej linii; w ostatniej linijce pliku kodu tego może brakować (lub nie);
*Wartość zmiennej <tt>linia</tt> to w każdym obiegu pętli, treść kolejnej linii tekstu jako napis; zawartość (bajtowa) pliku jest interpretowana jako napis zgodnie z domyślnym kodowaniem systemowym (można to zmienić poprzez dodatkowy parametr wywołania <tt>open</tt>);
*Jeżeli zawartość pliku ''nie'' jest zgodna z założeniem, że można go interpretować jako tekst w przyjętym kodowaniu, to w trakcie przetwarzania może wystąpić błąd (wyjątek);
*Po zakończeniu przetwarzania plik należy zamknąć, wywołując metodę <tt>close</tt>; ewentualnie można to pominąć, jeśli wiemy '''na pewno''' że wraz z końcem przetwarzania pliku kończy się cały program - wraz z zakończeniem działania programu otwarte pliki zostaną zamknięte;
*Druga postać wprowadza nową instrukcję złożoną - blok <tt>with</tt>; to, jak on dokładnie działa, zależy od typu obiektu do jakiego odwołujemy się po słowie <tt>with</tt> - jeżeli jest nim otwarty plik, to zostanie on automatycznie zamknięty wraz z końcem bloku;
*Odwoływanie się do pliku, który już został zamknięty, będzie nieskuteczne; żadne operacje się nie powiodą.
*Ostatnia wersja jest odrobinę ryzykowna - jeśli plik jest ''bardzo'' duży, to na jego treść może nie wystarczyć pamięci RAM, i program się wywróci. W dzisiejszych czasach oznacza to jednak, że rozmiar pliku sięga wielu gigabajtów.

==Czytanie dowolnych danych z pliku==

<source lang=python>

f = open('nazwa_pliku', mode='rb')
dane = f.read(1024*1024) # wczytujemy 1 MB danych (lub mniej, jeśli tylu już nie ma)
(...)
f.seek(0) # "przewinąć" do początku pliku (lub innej pozycji, względem początku)
(...)
pos = f.tell() # uzyskać aktualną pozycję
(...)
f.close()

</source>

*To, co odczytamy - czyli <tt>dane</tt>, to będzie łańcuch bajtów;
*Można odpowiednio wykorzystać blok <tt>with</tt>, aby uniknąć ręcznego zamykania pliku;
*Wywołanie <tt>read()</tt> bez argumentu oznacza: wczytaj wszystko;
*Jeśli wywołanie <tt>read</tt> z dodatnim argumentem zwróci łańcuch o długości zero - to dotarliśmy do końca pliku.

==Zapis danych do pliku==

Aby był możliwy zapis danych do pliku dyskowego, należy go otworzyć w trybie do zapisu:
<source lang=python>

f = open('nazwa_pliku.txt', 'w')
(...)
f.write(dane)
(...)
f.close()

</source>

'''UWAGA:''' otwarcie pliku w trybie do zapisu (<tt>'w'</tt>) spowoduje usunięcie poprzedniej zawartości pliku - o ile dotyczy pliku już istniejącego. Jeżeli nazwa odnosi się do pliku jeszcze nieistniejącego, to zostanie on utworzony. Jeżeli chcemy zachować poprzednie dane, dopisując nowe do końca pliku, należy plik otworzyć w trybie <tt>'a'</tt> (''append'').

<blockquote>
Domyślnie plik jest otwierany w trybie zapisu tekstu, zgodnie z domyślnym kodowaniem. A więc <tt>dane</tt> powinny być napisem. Jeżeli chcemy zapisywać surowe bajty, należy użyć trybu <tt>'wb'</tt>. Jeżeli chcemy użyć kodowania innego niż domyślne, możemy w funkcji <tt>open</tt> użyć parametru ''encoding'', w postaci:
<source lang=python>

f = open('nazwa_pliku.txt', 'w', encoding='cp1250')

</source>
w tym przykładzie użyto nazwy kodowania stosowanego do języka polskiego w Windows.
</blockquote>

==Standardowe strumienie i przekierowania==

===Wprowadzenie===

System operacyjny z rodziny unixów (np. Linux lub MacOS) udostępnia każdemu procesowi (uruchomionemu programowi) trzy tzw. standardowe strumienie, mogące być źródłem danych (tzw. standardowy strumień wejściowy, ''stdin'') lub kanałem przekazywania wyników, komunikatów itp. (standardowy strumień wyjściowy, ''stdout'' i standardowy strumień błędów, ''stderr'').

<blockquote>
W systemach z rodziny Windows jest podobnie, w odniesieniu do programów uruchamianych z linii poleceń, czyli okna programu ''cmd.exe''.
</blockquote>

Co to konkretnie znaczy? Domyślnie, zawartością ''stdin'' są dane wprowadzane z klawiatury, natomiast dane wypisywane na ''stdout'' i ''stderr'' pojawiają się na ekranie - w oknie terminalowym, z którego uruchomiono dany program. Przyjęto umowę, że na ''stdout'' wypisuje się dane, stanowiące wynik zgodnej z przewidywaniami pracy programu (oczywiście o ile nie przewidziano zapisu tych wyników bezpośrednio do pliku na dysku), natomiast na ''stderr'' - jedynie komunikaty dotyczące sytuacji nieprzewidzianych, a więc błędów przetwarzania, lub ostrzeżenia - pojawiające się w sytuacjach, gdy wprawdzie kontynuacja pracy programu jest możliwa, ale okoliczności wskazują, że jej wyniki mogą być pod jakimś względem wątpliwe.

Powyższe ma sens, ponieważ domyślne powiązania - ''stdin'' z klawiaturą, a ''stdout'' i ''stderr'' z ekranem można zmienić - poprzez mechanizmy tzw. przekierowania. W szczególności, strumienie wyjścia i błędu można rozdzielić, np. przekierowując treść ''stdout'' do pliku, a pozostawiając ''stderr'' jako związany z ekranem.

W środowisku Python standardowe strumienie dostępne są jako elementy modułu <tt>sys</tt>: <tt>sys.stdin</tt>, <tt>sys.stdout</tt> i <tt>sys.stderr</tt>. Mają one właściwości plików tekstowych, choć bez możliwości przewijania (<tt>seek</tt>).

'''Funkcja <tt>print</tt> w Pythonie domyślnie wypisuje dane do strumienia ''stdout''; można to zmienić, używając parametru wywołania ''file'', którego wartością powinien być plik otwarty do zapisu w trybie tekstowym.'''

===Sposoby przekierowania===

Przekierowanie strumieni dokonuje się na poziomie systemu operacyjnego, całkowicie poza środowiskiem Pythona - program nie ma możliwości wykrycia, czy strumienie standardowe na jakich operuje zostały przekierowane. Przekierowania określa się na linii poleceń w momencie uruchomienia programu.

Przekierowanie ''stdin'' z pliku:
<source lang=bash>
$ program.py < plik_wejsciowy.txt
$ < plik_wejsciowy.txt program.py
</source>

Oba powyższe polecenia są równoważne i skutkują tym, że dane czytane przez program z <tt>sys.stdin</tt> będą tak na prawdę pochodzić z pliku o podanej nazwie (a treść wprowadzana z klawiatury będzie w programie niedostępna).

Przekierowanie ''stdout'' do pliku:
<source lang=bash>
$ program.py > plik_wyjscia.txt
$ > plik_wyjscia.txt program.py
</source>

Dane pisane do <tt>sys.stdout</tt> nie pojawią się w oknie terminala, tylko znajdą się w pliku. Dane pisane do <tt>sys.stderr</tt> dalej będą trafiać na ekran.

Przekierowania równoczesne:
<source lang=bash>
$ program.py < plik_wejsciowy.txt > plik_wyjscia.txt
</source>

Oba poprzednio opisane przekierowania można również wykonać równocześnie. Elementy polecenia również mogą wystąpić w innym porządku.

Przekierowanie ''stderr'':
<source lang=bash>
$ program.py 2> plik_bledow.txt
</source>

Komunikaty o błędach i ostrzeżenia znajdą się w pliku o podanej nazwie, zamiast na ekranie. Analogicznie do <tt>2></tt>, strumieniom ''stdout'' i ''stdin'' przypisane są numerki 1 i 0 - można więc pisać odpowiednio <tt>1></tt> i <tt>0<</tt>, ale tu te wartości numerów strumieni przekierowanych (naprawdę - ''deskryptorów plików'') są domyślne i niemal zawsze się je pomija.

===Potoki===

Oprócz przekierowania do i z plików, istnieje jeszcze analogiczny mechanizm, gdzie np. strumień ''stdout'' jednego procesu łączy się z strumieniem ''stdin'' innego procesu - skutkiem czego dane wyjściowe pierwszego są wprowadzane do drugiego jako dane wejściowe, tworząc to co się nazywa ''potokiem''. Najprostszy przykład:
<source lang=bash>
$ program1.py | program2.py
</source>
tu ''operatorem potoku'' w systemowej linii poleceń jest znak kreski pionowej (<tt>|</tt>), a <tt>program1.py</tt> przekazuje wyniki swojej pracy do dalszego przetwarzania kolejnemu, <tt>program2.py</tt>. Taki potok może mieć więcej niż dwa etapy i może łączyć się z zastosowaniem przekierowań do plików, np.
<source lang=bash>
$ < plik_wejsciowy.txt program1.py 2>bledy.txt | program2.py > plik_wynikow.txt
</source>

Pożytecznym narzędziem do stosowania w potokach jest polecenie (program) o nazwie <tt>tee</tt>:
<source lang=bash>
$ program.py < dane.txt | tee wynik.txt
</source>
w tym przypadku program wczyta zawartość pliku <tt>dane.txt</tt>, a wynik wypisany do <tt>sys.stdout</tt> zarówno pojawi się na ekranie (w oknie terminala, jak i zostanie zapisany w pliku <tt>wynik.txt</tt>.

==Odczyt linii poleceń==

Zawartość linii poleceń dostępna jest w obiekcie <tt>sys.argv</tt> - czyli moduł (standardowy) <tt>sys</tt>, element <tt>argv</tt>. Jest to lista argumentów - ,,słów" jakie wywołujący program umieścił w linii poleceń. Inaczej mówiąc, treść linii poleceń ulega wstępnemu rozbiorowi - na słowa, według reguł zależnych od systemu operacyjnego. Najczęściej poszczególne słowa oddzielają spacje (jedna lub więcej), jeśli chcemy, by ciąg zawierający spacje był potraktowany jako pojedyncze słowo (np. nazwa pliku zawierająca spacje), należy ciąg ten np. umieścić w cudzysłowach (które zostaną usunięte z treści argumentu). Treść linii poleceń na ogół ulega jeszcze innym formom obróbki przez system operacyjny (np. rozwijanie rozmaitych skrótów), ale dzieje się to poza kontrolą Pythona.

<source lang=python>

from sys import argv
for arg in argv:
print(arg)

</source>

Korzystając z powyższego kodu możemy dowiedzieć się, jak wygląda lista argumentów już ''po'' jej obróbce przez system operacyjny.

Na początku listy <tt>argv</tt> czyli w pozycji <tt>argv[0]</tt> znajduje się nazwa uruchomionego programu (tj. nazwa pliku z kodem uruchomionego jako program główny).

===Przykłady===

=1.=
Jeśli przewidujemy, że jedynymi argumentami wywołania naszego programu będą nazwy plików, na każdym z których należy wykonać jakąś czynność, to można to zrealizować tak:
<source lang=python>

#! /usr/bin/python3

from sys import argv

def przetwarzaj(plik):
# tu określamy na czym polega "przetworzenie" pliku

for plik in argv[1:]:
przetwarzaj(plik)

</source>

*Wzięcie wycinku z <tt>argv</tt> służy pominięciu pliku zawierającego kod programu;
*Elementami <tt>argv</tt> są ''nazwy'' plików - napisy.

=2.=
Nieraz jest pożądane, aby program przetwarzający strumień danych mógł działać na dwa sposoby: albo wywołany z argumentami będącymi nazwami plików z danymi wejściowymi wczytuje kolejno zawartość tych plików; albo wywołany bez takich argumentów, czyta dane wejściowe ze standardowego strumienia wejściowego, w którym one znajdują się zazwyczaj w wyniku poprzedniego kroku przetwarzania potokowego. Nota bene w ten sposób działa wiele tradycyjnych narzędzi systemowych w Linuxie.

W standardowej bibliotece Pythona jest moduł <tt>fileinput</tt>, który ułatwia realizację takiego podejścia. W najprostszym przypadku:

<source lang=python>
#! /usr/bin/python3

import fileinput

def przetwarzaj(linia):
# tu określamy na czym polega przetworzenie linii treści

for linia in fileinput.input():
przetwarzaj(linia)
</source>

W pętli w powyższym przykładzie wystąpią kolejno wszystkie linie w treści plików wymienionych na linii poleceń (z pominięciem pliku samego programu), lub jeśli linia poleceń jest pusta — linie w treści <tt>sys.stdin</tt>. Ewentualnie można wywołać funkcję <tt>fileinput.input(pliki)</tt>, tj. zamiast bez argumentów to z argumentem będącym sekwencją nazw plików zawierających dane wejściowe. Może to być np. lista argumentów programu, ale po usunięciu z niej pozycji będących opcjami, a nie nazwami plików. Oczywiście w dokumentacji znajdziemy jeszcze dalsze możliwości.

=Ćwiczenia=

1. Napisać program, który wczyta dany plik linia po linii i znajdzie wśród nich podzbiór linii o maksymalnej długości (w znakach) oraz wartość tej maksymalnej długości. Niech wynikiem działania programu będzie wypisanie liczby oznaczającej maksymalną długość linii występujących w badanym pliku, a następnie - treść tych linii, w kolejności w jakiej pojawiały się w pliku. Wypróbować ten program na pliku ''/usr/share/dict/words''. W końcowej wersji program powinien operować na pliku, którego nazwę podamy jako argument na linii poleceń.

''Wskazówka:'' długość linii nie powinna uwzględniać kodu przejścia do nowej linii, zapisywanego symbolicznie jako <tt>'\n'</tt> kończącego (prawie) każdą linię.

2. Napisać program, który wczyta dany plik linia po linii i znajdzie wśród nich podzbiór linii o danej długości w znakach. Niech wynikiem działania programu będzie wypisanie linii o żądanej długości występujących w treści pliku w takiej kolejności, w jakiej pojawiały się w pliku. Długość szukanych linii podajemy jako pierwszy, a nazwę badanego pliku jako drugi argument na linii poleceń.

3. Napisać program, który wyznaczy rozkład długości linii w treści danego pliku - nazwę pliku podajemy na linii poleceń. Wynikiem działania programu jest wypisanie ciągu linijek postaci <tt>''długość'' : ''ile''</tt>, gdzie liczba ''ile'' opisuje, ile linii o danej długości wystąpiło w treści pliku. Pozycje, w których ''ile'' wynosiłoby 0 nie pojawiają się.

4. Napisać program, który wyznacza częstości występowania w treści pliku określonych znaków. Zestaw znaków, których wystąpienia zamierzamy zliczać podajemy jako pierwszy argument na linii poleceń, nazwę badanego pliku jako drugi. Wynikiem działania programu jest wypisanie ciągu linijek postaci <tt>''znak'' : ''częstość''</tt>.

5. Napisać program, który znajduje w pliku ''/usr/share/dict/words'' wszystkie słowa, składające się z tych samych liter co słowo, podane jako argument na linii poleceń - choć niekoniecznie występujących tę samą liczbę razy. Inaczej mówiąc, każda z liter występujących w podanym słowie występuje również w słowach szukanych, a nie występują w nich żadne inne znaki. Program wypisuje na ekran znalezione słowa, po jednym na linijkę.

6. Niech program znajduje wszystkie słowa, jakie można utworzyć korzystając z danego zestawu liter (podanego jako pierwszy argument na linii poleceń); tzn. tak jak w ''Scrabble'' dysponujemy takimi literami i w takiej liczbie, jakie składają się na to słowo (lub ,,słowo"). Źródłem słów jakie można utworzyć jest plik podany jako drugi argument (domyślnie - ''/usr/share/dict/words''). 
''Wskazówka:'' może się tu przydać operacja <tt>L.remove(x)</tt>, gdzie <tt>L</tt> jest listą; usuwa ona z listy pierwsze z kolei znalezione w niej wystąpienie elementu <tt>x</tt>. 
''Uwaga:'' operacja ta zwróci błąd, jeśli element <tt>x</tt> ''nie'' występuje w <tt>L</tt>.

----

[[PPy3/Moduły|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/NumPy|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 13:26, 4 sie 2016 (CEST)

PPy3/Wprowadzenie

2025-10-02T10:53:49Z

RobertJB: /* Ogólnie o pracy z komputerem */

==Wprowadzenie==

Aby komputer wykonał za nas jakąś pracę, musimy mu przekazać dość precyzyjne instrukcje, mówiące co ma zrobić. Taki zestaw instrukcji nazywa się ''programem'', a proces tworzenia programów - to ''programowanie''. Stworzenie programu wymaga wykonania dwóch zasadniczych zadań:

#wymyślenia algorytmu
#zapisania tegoż algorytmu w sposób możliwy do zinterpretowania przez komputer - a więc w jakimś języku programowania.

Podczas opracowywania algorytmu musimy zastanowić się, jak dojdziemy do poszukiwanego rozwiązania. W jaki sposób z posiadanych danych wejściowych uzyskać możemy oczekiwany wynik? Jakie operacje po drodze muszę wykonać? Ile razy? Co po drodze muszę wiedzieć, a co dodatkowo sprawdzić? Jeśli wiemy już, jakie niezbędne etapy obliczeń musimy wykonać możemy przejść do fazy drugiej, czyli pisania właściwego programu.

Programy piszemy używając specjalnych języków stworzonych do komunikacji z komputerami. Zawierają one pewien zestaw słów — poleceń, które komputer może wykonać. Wybór konkretnego języka może zależeć od rozwiązywanego problemu, ale w wielu wypadkach jest sprawą drugorzędną. Ponieważ, tak jak w przypadku języków obcych, aby porozumieć się z cudzoziemcem musimy nauczyć się obcego języka, tak i tu musimy nauczyć się wybranego języka (języków) programowania.

Dlaczego uczymy się programować akurat w języku Python?

*Jest jednym z najłatwiejszych do opanowania języków programowania, i najbardziej czytelnych dla człowieka.
*Jest narzędziem dojrzałym, rozwijanym od wielu lat i dobrze sprawdzonym.
*Zawiera jako standardowe wyposażenie wiele gotowych rozwiązań, które można wykorzystać jako elementy własnych programów.
*Jest coraz szerzej wykorzystywany do zadań naukowych.
*Jest dostępny bezpłatnie i bez uciążliwych ograniczeń licencyjnych na wiele różnych platform - systemów operacyjnych.

Na początku nauczymy się podstaw języka, aby móc zacząć pisać i uruchamiać pierwsze, na razie proste programy. Następnie przećwiczymy rozwiązywanie rozmaitych zagadnień, wymyślając do tego odpowiednie algorytmy i zapisując je w postaci programów w Pythonie.

<blockquote>
Pracując z komputerem tak jak sekretarz czy księgowy, nie potrzeba w zasadzie nic wiedzieć o programowaniu i wewnętrznym działaniu komputera. Tak jak kurs nauki jazdy nie uczy, jak projektować konstrukcje samochodów, ani nawet jak je naprawiać. Założeniem studiów na fizyce jest jednak przygotowanie absolwenta, który będzie umiał sobie radzić z nowymi zadaniami i rozwiązywać problemy, a nie jedynie wykonywać pewne procedury. Elementarna umiejętność programowania jest jednym z narzędzi do tego celu.
</blockquote>

===Instalacja===

W systemach z rodziny '''Linux''' Python należy do wyposażenie standardowego. Niewykluczone, że dla celów drugiej części kursu będzie potrzeba doinstalowania opcjonalnych składników środowiska Python, m. in. narzędzi do obliczeń numerycznych i wizualizacji danych (tj. wykresów, itp.). Oczywiście na pracowniach dydaktycznych zostało to już za nas wykonane.

Dla systemów z rodziny '''Windows''' możemy np. skorzystać z [https://docs.microsoft.com/en-us/windows/python/beginners dystrybucji] dostępnej ze "sklepu" Microsoft, lub z [https://www.python.org/downloads/windows/ pakietów] dostępnych z oficjalnych stron projektu Python. Dla bardziej zaawansowanych użytkowników, którzy jednak nie chcą opuszczać środowiska Windows, ciekawym rozwiązaniem może być [https://docs.microsoft.com/en-us/windows/wsl/install WSL] — emulacja środowiska Linux wewnątrz Windows.

W systemie '''MacOS''' Python dostępny jest domyślnie, preinstalowana wersja może być jednak niepełna i/lub przestarzała. Pakiety instalacyjne Pythona dostępne są np. [https://www.python.org/downloads/macos/ tu].

Często najlepszym sposobem stworzenia sobie środowiska pracy do programowania w Pythonie jest skorzystanie z narzędzia [https://docs.astral.sh/uv/ uv] — zwłaszcza gdy zachodzi potrzeba użycia najnowszej wersji Pythona (albo innej, ściśle określonej), i/lub wielu składników opcjonalnych (modułów, bibliotek), pomiędzy którymi musi zostać zachowana zgodność wersji. UV jest dostępne dla wszystkich wymienionych systemów, a jego instalacja nie wymaga uprzedniej instalacji Pythona.

===Ogólnie o pracy z komputerem===

Tu jest właściwy moment, aby zapoznać się (o ile jest to komuś obce) z kilkoma podstawowymi faktami dotyczącymi
,,zaawansowanej" pracy z komputerem, a nie dotyczącymi samego Pythona — w tym:

*logiczna organizacja danych na dysku; foldery (katalogi), podfoldery
*prawa dostępu do plików i folderów
*pliki tekstowe i jak je edytować
*co to jest terminal i powłoka systemowa (''shell'')
*co to jest katalog bieżący; podstawowe operacje na plikach w linii poleceń (''ls'', ''pwd'', ''cd'', ''cp'', ''mv'', ''rm'', ...)
*jak uruchomić program w linii poleceń; ścieżka wyszukiwania

----
[["Programowanie_z_Pythonem3"|Strona główna]] | [[PPy3/PierwszeKroki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 12:50, 2 paźdz 2025 (CEST)

PPy3/Wprowadzenie

2025-10-02T10:52:48Z

RobertJB: /* Instalacja */

"Programowanie z Pythonem3"

2025-10-02T10:40:26Z

RobertJB: /* Semestr zimowy 2023/2024 */

[[Grafika:Python-logo.png]]

[[Category:Informatyka]]
== Semestr zimowy 2025/2026 ==

'''''W trakcie opracowania'''''

===Uwagi ogólne===

Zasady zaliczenia ćwiczeń w roku 2025/2026:

* maksymalnie można zdobyć 40 punktów
* w semestrze będą dwa kolokwia, w połowie i pod koniec; na każdym można zdobyć po 15 punktów
* w sesji będzie kolokwium dodatkowe, dla chętnych; wynik z niego (maks. 15 punktów) zastępuje gorszy z wyników kolokwiów z semestru, o ile jest on od niego lepszy
* maksymalnie 10 punktów uzyskuje się na podstawie zadań domowych i kartkówek na ćwiczeniach
* zaliczenie ćwiczeń na pozytywną ocenę wymaga co najmniej 50% punktów (20 p.)
* ocena rośnie o pół stopnia z osiągnięciem progu każdych kolejnych 10%, tj. 4 punktów
* prowadzący może przyznać dodatkowo do 3 punktów "premiowych" na podstawie aktywności na ćwiczeniach

Obecność na ćwiczeniach jest obowiązkowa. Dopuszczalne są '''dwie''' nieobecności nieusprawiedliwione w semestrze. '''Za każdą kolejną nieobecność nieusprawiedliwioną powyżej dwóch odejmujemy od wyniku 5 punktów.'''

Ocena końcowa z przedmiotu składa się z oceny z ćwiczeń, oraz z oceny z egzaminu testowego kończącego wykład, w proporcji 3:2 - z tym, że '''obie te oceny cząstkowe muszą być pozytywne''' aby ocena z całości była pozytywna.

===Spis treści===

#[[PPy3/Wprowadzenie|Wprowadzenie]]
#[[PPy3/PierwszeKroki|Pierwsze kroki]]
#[[PPy3/StałeIZmienne|Stałe i zmienne]]
#[[PPy3/InstrukcjaWarunkowa|Instrukcja warunkowa]]
#[[PPy3/SekwencjeIIteracja|Sekwencje i iteracja]]
#[[PPy3/Funkcje|Funkcje]]
#[[PPy3/Kolekcje|Kolekcje]]
#[[PPy3/Moduły|Moduły i biblioteki]]
#[[PPy3/WejścieWyjście|Obsługa wejścia i wyjścia]]
#[[PPy3/NumPy|NumPy]] - rachunki numeryczne na tablicach liczb
#[[PPy3/Matplotlib|Matplotlib]] - wizualizacja danych
#[[PPy3/TematyDodatkowe|Tematy dodatkowe]] - uzupełnienie
#[[PPy3/DobrePraktyki|Zasady dobrej praktyki]]

===O skrypcie===

Opracowane na nowo przez [[Użytkownik:RobertJB|RobertJB]], częściowo z wykorzystaniem [["Programowanie z Pythonem"|poprzedniej wersji]].

PPy3/PierwszeKroki

2024-10-03T11:44:57Z

RobertJB: /* Używanie linii poleceń interpretera */

= Pierwsze kroki =

==Podstawowe cegiełki==

*Program w Pythonie to tekst, stanowiący ciąg instrukcji; są one wykonywane przez ''interpreter'' (zasadniczo) kolejno jedna po drugiej.
*''Prosta'' instrukcja to (zasadniczo) jedna linijka, kończy się wraz z przejściem do kolejnej linii.
*Instrukcja złożona, to linijka otwierająca '''zawsze zakończona dwukropkiem''', a po niej - '''blok wcięty''', tj. ciąg instrukcji (prostych i/lub złożonych) pisanych z dodatkowym ''wcięciem'' w stosunku do linijki otwierającej; mogą to być dodatkowe (np. dwie lub cztery) spacje, lub kod tabulacji, na początku każdej linijki. Koniec instrukcji złożonej następuje wraz z powrotem do poprzedniego ''poziomu wcięcia''.
*W tekście programu można umieszczać komentarze; komentarz zaczyna się od znaku <tt>#</tt>, a kończy się wraz z końcem bieżącej linii. Komentarze nie są częścią programu, tzn. są ignorowane przy jego wykonaniu.

<blockquote>
*Wyjątki od podanych reguł, istnienie których sygnalizuje słowo ''zasadniczo'', będą przedstawione później.
*Należy się raz zdecydować, jak dokładnie będziemy tworzyć poziomy wcięcia, i konsekwentnie się tego trzymać. Najlepiej po dwie lub cztery spacje (wg. upodobań), i ustawić w opcjach edytora kodu, żeby wciśnięcie klawisza ''Tab'' skutkowało odpowiednią liczbą spacji. Mieszanie w tekście kodu spacji i tabulacji zawsze prowadzi do kłopotów.
</blockquote>

Przykłady instrukcji prostych:

<source lang=python>
x = 1 + 2
y = 2 * x
x = x + 1
print(x, y)
</source>

Przykłady instrukcji złożonych:

<source lang=python>
if x > 0:
print(x)

def dodaj1(x):
return x + 1
</source>

Ważnym elementem są komentarze:

<source lang=python>
# a teraz, powiększę x o 1
x = x + 1
</source>

*Instrukcje budowane są z wyrażeń, a wyrażenia - z nazw, stałych i operatorów.
*'''Nazwa''' może składać się z liter, cyfr i znaku podkreślenia (_). Nie może zaczynać się od cyfry. Litery małe i wielkie są rozróżniane.
*Przykładem stałych są liczby - całkowite i ułamki dziesiętne. Zamiast przecinkiem, część ułamkową oddziela się kropką.
*Inny rodzaj stałych to napisy. Można je budować na kilka sposobów:

<source lang=python>
'to jest napis'
"to jest drugi napis"
'''a to jest...
jeszcze jeden napis'''
</source>

*Ostatni przypadek to wyjątek od zasady że koniec linii kończy instrukcję. Napis podany w pierwszych dwóch postaciach nie może zawierać przejścia do nowej linii.
*Nazwy są po to, aby oznaczać nimi wartości. Wartościami mogą być np. liczby i napisy:

<source lang=python>
pi = 3.14159
komunikat = 'Uwaga!!!'
</source>

'''UWAGA:''' znak równości to nie porównanie, a ''operator przypisania''. Powoduje on, że nazwa po jego lewej stronie będzie odtąd oznaczać wartość zapisaną po prawej. W szczególności, po lewej stronie znaku równości nie może występować np. stała liczba.

*Więcej o stałych i nazwach na następnej stronie, na razie tyle nam wystarczy.
*Inne operatory, to w szczególności arytmetyka:

<source lang=python>
+ - * / // % **
</source>

'*' to mnożenie, '//' to dzielenie całkowitoliczbowe, '%' to reszta z dzielenia (na ogół stosowana do liczb całkowitych, ale niekoniecznie), '**' to potęgowanie.

*Napisy też można "dodawać":

<source lang=python>
imie = 'Jacek'
powitanie = 'witaj ' + imie
print(powitanie)
</source>

Czemu właściwie operację ,,sklejania" napisów oznaczono plusem? W matematyce zazwyczaj plus stosuje się na oznaczenie operacji przemiennych, tzn. takich, których wynik nie zależy od kolejności składników — a sklejanie napisów ewidentnie taką operacją nie jest. Ale cóż, tak się przyjęło.

==Używanie linii poleceń interpretera==

''Interpreter'' to aplikacja, która potrafi czytać tekst kodu w języku Python i wykonać zapisane w nim polecenia. Może on być używany jako samodzielne polecenie, wywoływane w oknie terminala, lub zintegrowany z środowiskiem programistycznym w rodzaju ''Spyder'' lub ''Visual Studio Code''.

Zanim zaczniemy pisać "poważne" programy, nauczymy się korzystać z ''trybu interaktywnego'' interpretera, który pozwala na wpisywanie po jednym poleceniu i natychmiastowe uzyskanie wyniku jego wykonania. Można go używać do podręcznych rachunków - zamiast kalkulatora -- i do eksperymentowania z kodem w Pythonie. Do pracy interaktywnej warto używać "wzbogaconej" wersji interpretera, wywoływanej poleceniem

<source lang=bash>
$ ipython3
</source>

w najprostszych zastosowaniach niewiele się on różni od "zwykłego" interpretera, wywoływanego przez <tt>python3</tt>, ale posiada pewne dodatkowe możliwości, które niedługo się nam przydadzą.

<blockquote>
'''UWAGA:''' polecenie <tt>ipython</tt> (bez 3) wywoła domyślną wersję Pythona — aktualnie wersję 3.
Podobnie, <tt>python</tt> wywoła domyślną wersję (3) "zwykłego" interpretera. Natomiast - <tt>python2</tt> wywołuje starszą wersję "zwykłego" interpretera, z której nie należy już aktualnie korzystać. Jeszcze parę
lat temu wersja 2 była domyślną, więc działało to odwrotnie.
</blockquote>

===Wykonywanie rachunków===

<source lang=python>
$ ipython3
Python 3.5.1+ (default, Mar 30 2016, 22:46:26)
Type "copyright", "credits" or "license" for more information.

IPython 2.4.1 -- An enhanced Interactive Python.
? -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help -> Python's own help system.
object? -> Details about 'object', use 'object??' for extra details.

In [1]: 7 * (3 + 5)
Out[1]: 56

In [2]: 2.81 / (1.25 - .33)
Out[2]: 3.054347826086957

In [3]: 2**128
Out[3]: 340282366920938463463374607431768211456

In [4]: 1/9
Out[4]: 0.1111111111111111

In [5]: 11//9, 11%9
Out[5]: (1, 2)
</source>

Zapis wyrażeń arytmetycznych raczej nie zaskakuje. Drobne uwagi:

*spacje w zapisie wyrażenia, pomiędzy liczbami a operatorami (lub ich brak), nie mają znaczenia
*reguły pierwszeństwa operatorów (najpierw potęgowanie, potem mnożenie i dzielenie, potem odejmowanie i dodawanie,...) są w zasadzie takie, jak należy się spodziewać; kolejność operacji możemy narzucić nawiasami - ale tylko okrągłymi, które można wielokrotnie zagnieżdżać
*pisząc ułamek dziesiętny (liczbę z kropką), można pominąć część całkowitą lub ułamkową, o ile ma ona być zero (nie można jednak pominąć obu);
*liczby całkowite mogą być dowolnie duże (w ramach fizycznych ograniczeń komputera)
*operacje na ułamkach należy zawsze traktować jako przybliżone - w operacjach na liczbach ułamkowych komputer może ogarnąć tylko skończoną liczbę cyfr
*zwykłe dzielenie da zawsze wynik ułamkowy; istnieje jednak operator <tt>//</tt> dzielenia całkowitego, który odrzuca resztę
*gdy chcemy zakończyć "rozmowę" z interpreterem, piszemy <tt>exit()</tt>; jeżeli pracujemy w Linuxie, zadziała również dwukrotne <tt>Ctrl-D</tt> (tzn. trzymając naciśnięty klawisz <tt>Ctrl</tt> stukamy dwukrotnie w klawisz <tt>D</tt>)

==Jak uzyskać pomoc==

W programie IPython mamy w każdej chwili dostęp do pomocy na temat poleceń, funkcji itd. Pythona:

<source lang=python>
In [8]: print?
Type: builtin_function_or_method
String form: <built-in function print>
Namespace: Python builtin
Docstring:
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
</source>

W tym przykładzie uzyskaliśmy szczegółowy opis zastosowania funkcji wbudowanej <tt>print</tt>. Wprawdzie po angielsku, ale mam nadzieję, że nie jest to przeszkoda nie do przeskoczenia. Już niedługo będziemy dokładnie rozumieli to, co jest tu napisane.

<blockquote>
Jeżeli tekst pomocy jest dłuższy, to będzie wyświetlany w trybie pozwalającym m. in. na jego przewijanie z użyciem klawiszy strzałek czy <tt>PgUp</tt>, <tt>PgDn</tt>. Aby wyjść z tego trybu i powrócić do interpretera, wystarczy nacisnąć <tt>q</tt>.
</blockquote>

==Najprostszy program==

Za pomocą ulubionego edytora tekstowego stwórzmy plik o nazwie <tt>hello.py</tt> i następującej treści:

<source lang=python>
#! /usr/bin/python3

print('Witaj świecie!')

</source>

Zgodnie z tradycją, będzie to program wykonujący jedno banalne zadanie: wypisanie komunikatu o ustalonej treści. Zgodnie z zasadą, że programowanie w Pythonie ma być maksymalnie proste - jedynym niezbędnym elementem tego programu jest linijka wywołująca funkcję <tt>print</tt>. W tym przykładzie, uzupełniłem treść programu o pierwszą linijkę, zaczynającą się od znaku kratki (<tt>#</tt>) - istotne jest, aby była to dokładnie pierwsza linijka w pliku, i by zaczynała się od pierwszej pozycji w wierszu. Czyli, aby <tt>#!</tt> były dokładnie dwoma pierwszymi znakami w treści pliku. Z punktu widzenia Pythona, linijka ta jest komentarzem, i przy uruchamianiu pliku jest ignorowana. Pozwala ona jednak, by plik ten był automatycznie rozpoznawany przez system operacyjny (Linux) jako zawierający program w języku Python. Jaki z tego pożytek, dowiemy się za chwilę.

Aby ten program uruchomić, jest parę sposobów. Najprościej:

<source lang=bash>
$ python3 hello.py
</source>

powyższe polecenie wpisujemy w terminalu, w trybie powłoki systemowej (''nie w programie IPython!''). Tutaj musieliśmy jawnie wywołać interpreter Pythona i wskazać mu plik <tt>hello.py</tt> jako zawierający kod do uruchomienia.

Zamiast tego, możemy nadać plikowi <tt>hello.py</tt> atrybut pliku wykonywalnego, czyli programu, i uruchomić go bezpośrednio:

<source lang=bash>
$ chmod +x hello.py
$ ./hello.py
</source>

*Polecenie z pierwszej linijki wystarczy wykonać raz dla danego pliku
*Zamiast z linii poleceń, można w okienku ''Właściwości'' pliku znaleźć odpowiednie pole do kliknięcia
*Postać drugiej linijki tłumaczy się tym, że nasz program <tt>hello.py</tt> nie jest zainstalowany w systemie i nie zostanie odnaleziony przez przeszukanie standardowych lokalizacji programów na dysku. Należy wyraźnie wskazać, że chodzi o plik znajdujący się w bieżącym folderze - i to tu robimy.
*Plik z kodem w Pythonie nie musi mieć nazwy kończącej się na <tt>.py</tt> - jest to jednak wygodne, bo np. edytory tekstu traktują to jako sugestię co do zawartości pliku, i mogą dostosować do tego swoje działanie (np. <tt>gedit</tt>)

==Ćwiczenia==

===Rachunki w linii poleceń===

#Ile wynosi reszta z dzielenia 2999 przez 7?
#Która z tych liczb mniej się różni od pierwiastka kwadratowego z 2: 721/510 czy 722/510?
#Oblicz pierwiastek kwadratowy z 2, a następnie - podnieś go do kwadratu; ile wynosi względny błąd wyniku?

''CDN''

----

[[PPy3/Wprowadzenie|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/StałeIZmienne|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 13:53, 15 cze 2016 (CEST)

"Programowanie z Pythonem3"

2023-09-29T10:48:56Z

RobertJB: /* Semestr zimowy 2022/2023 */

[[Grafika:Python-logo.png]]

[[Category:Informatyka]]
== Semestr zimowy 2023/2024 ==

'''''W trakcie opracowania'''''

===Uwagi ogólne===

Zasady zaliczenia ćwiczeń w roku 2023/2024:

* maksymalnie można zdobyć 40 punktów
* w semestrze będą dwa kolokwia, w połowie i pod koniec; na każdym można zdobyć po 15 punktów
* w sesji będzie kolokwium dodatkowe, dla chętnych; wynik z niego (maks. 15 punktów) zastępuje gorszy z wyników kolokwiów z semestru, o ile jest on od niego lepszy
* maksymalnie 10 punktów uzyskuje się na podstawie zadań domowych i kartkówek na ćwiczeniach
* zaliczenie ćwiczeń na pozytywną ocenę wymaga co najmniej 50% punktów (20 p.)
* ocena rośnie o pół stopnia z osiągnięciem progu każdych kolejnych 10%, tj. 4 punktów
* prowadzący może przyznać dodatkowo do 3 punktów "premiowych" na podstawie aktywności na ćwiczeniach

Obecność na ćwiczeniach jest obowiązkowa. Dopuszczalne są '''dwie''' nieobecności nieusprawiedliwione w semestrze. '''Za każdą kolejną nieobecność nieusprawiedliwioną powyżej dwóch odejmujemy od wyniku 5 punktów.'''

Ocena końcowa z przedmiotu składa się z oceny z ćwiczeń, oraz z oceny z egzaminu testowego kończącego wykład, w proporcji 3:2 - z tym, że '''obie te oceny cząstkowe muszą być pozytywne''' aby ocena z całości była pozytywna.

===Spis treści===

#[[PPy3/Wprowadzenie|Wprowadzenie]]
#[[PPy3/PierwszeKroki|Pierwsze kroki]]
#[[PPy3/StałeIZmienne|Stałe i zmienne]]
#[[PPy3/InstrukcjaWarunkowa|Instrukcja warunkowa]]
#[[PPy3/SekwencjeIIteracja|Sekwencje i iteracja]]
#[[PPy3/Funkcje|Funkcje]]
#[[PPy3/Kolekcje|Kolekcje]]
#[[PPy3/Moduły|Moduły i biblioteki]]
#[[PPy3/WejścieWyjście|Obsługa wejścia i wyjścia]]
#[[PPy3/NumPy|NumPy]] - rachunki numeryczne na tablicach liczb
#[[PPy3/Matplotlib|Matplotlib]] - wizualizacja danych
#[[PPy3/TematyDodatkowe|Tematy dodatkowe]] - uzupełnienie
#[[PPy3/DobrePraktyki|Zasady dobrej praktyki]]

===O skrypcie===

Opracowane na nowo przez [[Użytkownik:RobertJB|RobertJB]], częściowo z wykorzystaniem [["Programowanie z Pythonem"|poprzedniej wersji]].

PPy3/TematyDodatkowe

2023-07-13T11:32:38Z

RobertJB: /* Trochę więcej o klasach i obiektach */

= Tematy dodatkowe =

== Błędy i wyjątki ==

Każdy programista popełnia błędy — jest to nieunikniona część tej działalności.

*Są błędy, które można nazwać banalnymi: literówka w nazwie lub słowie kluczowym, zapomniany dwukropek, niedomknięte nawiasy, itp.
*Są bardziej podstępne błędy logiczne: gdy algorytm, którego zapisem ma być tworzony kod, po prostu nie robi dokładnie tego, co nam się wydaje.
*I w końcu są sytuacje wyjątkowe: gdy w toku pracy programu zachodzą nieoczekiwane okoliczności — użytkownik podał błędną nazwę pliku z danymi, zawartość tego pliku nie jest zgodna z oczekiwaniami programu, połączenie sieciowe ulega przerwaniu w trakcie pobierania lub przesyłania danych, itp.

Wszystkie te sytuacje nazywa się wyjątkami, i tym samym słowem określa się mechanizm, jakiego wiele współczesnych języków programowania (w tym Python) dostarcza programiście, aby mu pomóc określić działania jakie program miałby podjąć w sytuacjach wyjątkowych. Wyjątkowość takich sytuacji generalnie polega na tym, że w przypadku ich wystąpienia program po prostu nie może kontynuować przewidzianego toku działania:

*błąd w składni programu oznacza, że kod nie daje się zinterpretować w sposób jednoznaczny; najlepsze co można zrobić, to w momencie wykrycia błędu przerwać działanie i spróbować dostarczyć programiście (w formie komunikatu) informację ułatwiającą określenie i naprawienie błędu;
*błędne działanie algorytmu można np. spróbować wykrywać za pomocą tzw. asercji (polecenie ''assert'') badających, czy pewne warunki, jakie powinny być spełnione przez dane przetwarzane w programie są istotnie spełnione;
*wyjątki powstałe na skutek okoliczności zachodzących w trakcie działania programu, uniemożliwiających jego normalną kontynuację, można spróbować przewidzieć i przygotować program do odpowiedniego zareagowania, czyli ''obsługi wyjątku''. Na przykład, można spróbować ponowić jeszcze raz (lub kilka razy) próbę łączności sieciowej, i poddać się dopiero po określonej liczbie niepowodzeń; natomiast w sytuacji błędu wynikającego z podania przez użytkownika programu niewłaściwych argumentów uruchomienia, warto postarać się o przekazanie użytkownikowi komunikatu informującego go w sposób dla niego zrozumiały, o właściwym sposobie uruchamiania programu.

=== Błędy składniowe i podobne ===

Jak wspomniano powyżej, w przypadku napotkania błędu składniowego w kodzie programu interpreter natychmiast przerwie wykonywanie programu i wypisze komunikat. Komunikaty te '''warto czytać uważnie''' — w większości przypadków znajduje się w nich cała informacja konieczna dla naprawienia błędu. Przykład: usiłujemy uruchomić program <tt>błąd.py</tt>, którego treść to

<source lang=python>
x = (2 + 3) 4
print x
</source>

Wynik pierwszej próby to:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 1
x = (2 + 3) 4
^
SyntaxError: invalid syntax
</source>

Z komunikatu całkiem jasno wynika, że napotkany został błąd składni (''SyntaxError''), że wykryto ten błąd w linijce 1, a nawet dokładnie — że miejscem, w którym interpreter stwierdził, że ma do czynienia z nieprawidłowy kodem, było wystąpienie cyfry 4 po zamykającym nawiasie. Po prostu zapomnieliśmy, że — inaczej niż w powszechnie stosowanej notacji matematycznej — w Pythonie aby uzyskać mnożenie, konieczne jest napisanie jawnie znaku operatora (gwiazdki).

Po naprawieniu tej pomyłki próbujemy jeszcze raz, i wynik to:
<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 2
print x
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(x)?
</source>

Tutaj już jaśniej być nie może; interpreter nie tylko wskazał nam dokładne miejsce wystąpienia błędu, ale nawet dokładnie opisał, jak go naprawić.

Oczywiście nie zawsze interpreter będzie w stanie wskazać nam błąd aż tak precyzyjnie. Jako przykład weźmy następujący plik:

<source lang=python>
x, y, z = 3, 4, 5
print(max(x, y, z)
print(X * y * z)
</source>

i wynik jego uruchomienia:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 3
print(X * y * z)
^
SyntaxError: invalid syntax
</source>

Dlaczego został wytknięty błąd składniowy w linijce 3? Przecież to w linijce 2 zapomnieliśmy zamknąć jeden z nawiasów.

Otóż jeżeli z końcem linii Python stwierdza, że nie wszystkie dotąd otwarte nawiasy zostały zamknięte, to traktuje to jako oznaczające, że kolejną linijkę należy potraktować jako ciąg dalszy bieżącej. I w tym przypadku dopiero napotykając w kolejnej linijce nazwę <tt>print</tt> — a nie np. przecinek, albo nawias zamykający — stwierdza, że coś musi być nie tak. Miejsce wykrycia błędu niestety nie zawsze się będzie pokrywało z miejscem jego faktycznego wystąpienia.

Po poprawce, czyli zamknięciu nawiasu na linii 2, próbujemy jeszcze raz — z wynikiem

<source lang=bash>
python3 błąd.py
5
Traceback (most recent call last):
File "błąd.py", line 3, in <module>
print(X * y * z)
NameError: name 'X' is not defined
</source>

I tym razem chyba jest wszystko jasne: pojawiła się nazwa <tt>X</tt>, z którą wcześniej nie związano żadnej wartości. Po prostu przez pomyłkę napisaliśmy X wielką literą zamiast małą.

Te przykłady pokazują, że przy wykorzystaniu treści wypisywanych komunikatów proces usunięcia z programu błędów składniowych i formalnych może być dość szybki i bezbolesny.

<blockquote>
Pojawiły się w komunikatach określenia: <tt>SyntaxError</tt>, <tt>NameError</tt>. Są to przykłady nazw tzw. klas wyjątków, czyli ogólnie rozumianych kategorii błędów, jakie są sygnalizowane. Wkrótce spotkamy dalsze klasy wyjątków, takie jak: <tt>TypeError</tt> - związana z przekazaniem wielkości niewłaściwego typu, czy <tt>ValueError</tt> - gdy nie typ. ale wartość wielkości, na której usiłuje się operować, jest niewłaściwa dla danej operacji. Dowiemy się również, dlaczego klasy wyjątków są przydatne — pomimo tego, iż dla ludzkich oczu zwykle bardziej przydatna jest słowna informacja uszczegółowiająca (to co pojawia się po nazwie klasy wyjątku i dwukropku).
</blockquote>

=== Asercje ===

Polecenie <tt>assert</tt> ma następującą postać:

<source lang=python>
assert wyrażenie1
# lub:
assert wyrażenie1, wyrażenie2
</source>

i jest to jak widać polecenie proste (nie zawierające bloku poleceń z wcięciem).

Jego działanie jest takie, że: obliczona zostanie wartość <tt>wyrażenie1</tt>; jeżeli jest ona prawdziwa, nie dzieje się nic (następuje natychmiastowe przejście do kolejnej linijki kodu). Jeżeli okaże się fałszywa, zostanie zasygnalizowany wyjątek, klasy <tt>AssertionError</tt>, co domyślnie przerywa wykonywanie programu i powoduje wypisanie odpowiedniego komunikatu. Jeżeli zastosujemy drugą postać, obliczona zostanie również wartość <tt>wyrażenie2</tt> i wypisana (dokładniej: jej reprezentacja napisowa) jako część komunikatu.

Przyjęło się stosować asercje jako sposób kontroli poprawności działania programu — w tym sensie, aby wykluczyć sytuacje „niemożliwe", tj. powstałe w wyniku błędu programisty. Ze względu na prostotę składni warto też z nich korzystać w kodzie służącym do testowania poprawności innego kodu (czyli np. w funkcjach testujących, czy inne, bardziej złożone funkcje dają poprawne wyniki w prostych sytuacjach próbnych).

=== Wyjątki w trakcie pracy programu ===

Wyjątki występujące w trakcie pracy programu można przechwycić i obsłużyć za pomocą następującej konstrukcji (polecenia złożonego):

<source lang=python>
try:
# operacje mogące spowodować wyjątek
except (KlasaWyjątku1, KlasaWyjątku2, ...):
# co zrobić jeśli wyjątek jednej z tych klas wystąpił
else:
# co zrobić jeśli nie było wyjątku
finally:
# co zrobić w KAŻDYM przypadku
</source>

*bloki <tt>else:</tt> i <tt>finally:</tt> są nieobowiązkowe, tj. możemy je pominąć (wraz z odp. linijką wprowadzającą)
*w bloku <tt>except:</tt> można podać jedną klasę wyjątku (wtedy zbędne są nawiasy), lub żadnej — wtedy przechwycimy ''każdy'' wyjątek; jeśli jednak chcemy, jak w przykładzie, wymienić więcej niż jedną klasę, to nawiasy są konieczne
*skuteczne przechwycenie wyjątku sprawia, że wykonanie programu nie ulegnie przerwaniu w punkcie jego wystąpienia, tyko będzie kontynuowane, również po opuszczeniu bloku <tt>try:</tt>
*można jednak spowodować, aby po wykonaniu czynności obsługi wyjątku, wyjątek został niejako ''wznowiony''; wystarczy w bloku <tt>except:</tt> wywołać instrukcję <tt>raise</tt>. Dla większości klas wyjątków skutkuje to zakończeniem programu
*instrukcję <tt>raise</tt> można wywołać również w dowolnym innym punkcie programu, powinna wówczas w niej wystąpić nazwa klasy wyjątku, jaki chcemy wywołać.

Przykłady:

''CDN.''

== Trochę więcej o klasach i obiektach ==

Warto sobie zdawać sprawę, że każda wartość występująca w programie pythonowym jest obiektem — a więc jest wyposażona w zestaw atrybutów i metod. Dotyczy to nie tylko kolekcji (list, słowników, ...), obiektów takich jak otwarte pliki (wynik wywołania funkcji <tt>open()</tt>), napisów — ale również np. liczb, czy to całkowitych, czy zmiennoprzecinkowych (i zespolonych, o których nie było tutaj mowy).

Przykładowo:

<source lang=python>
(17).bit_length()
→ 5
(17).bit_count()
→ 2
</source>

Co to właściwie znaczy?

Dla liczby 17 wywołaliśmy najpierw metodę, który mówi nam jaka jest długość w bitach reprezentacji dwójkowej tej liczby (<tt>17 == 0b10001</tt>), a następnie metodę, zwracającą liczbę ''ustawionych'' (tj. równych jeden) bitów w tej reprezentacji. Nawiasy okrągłe są konieczne, ponieważ kropka po cyfrach oznaczałaby, że mamy do czynienia z zapisem liczby zmiennoprzecinkowej. Inaczej mówiąc, byłyby niepotrzebne gdybyśmy mieli do czynienia z nazwą oznaczającą liczbę całkowitą, a nie z jej zapisem dziesiętnym.

Każdy obiekt w Pythonie jest ''instancją'' pewnej ''klasy''. Przykłady klas to: <tt>int</tt> (liczby całkowite), <tt>str</tt> (napisy), <tt>list</tt> (listy), <tt>bool</tt> (wartości logiczne), i wiele innych. Klasa to inaczej typ obiektów; charakteryzuje ona zestaw atrybutów i metod związanych z obiektami danej klasy.

<blockquote>
Zazwyczaj różnych obiektów będących instancjami danej klasy może być wiele, potencjalnie nieskończenie wiele. Są jednak wyjątki. Np. klasa <tt>bool</tt> posiada jedynie dwie instancje: (<tt>True</tt> i <tt>False</tt>). A obiekt <tt>None</tt> jest wręcz jedyną instancją swojej klasy.
</blockquote>

Niektóre klasy są ,,szczególnymi przypadkami" innych klas — mówi się, że klasa C ''dziedziczy'' z klasy B, lub że jest ''podklasą'' klasy B. Oznacza to tyle, że instancje klasy C posiadają wszystkie atrybuty i metody jakie posiadają instancje klasy B, ale być może pewne dodatkowe — a być może niektóre z nich zostały w jakiś sposób zmodyfikowane. Przykładowo, klasa <tt>bool</tt> stanowi podklasę klasy <tt>int</tt>; jej jedyne instancje, <tt>True</tt> i <tt>False</tt>, to ,,tak naprawdę" liczby (odpowiednio) 1 i 0 ,,w przebraniu". Są one więc również instancjami klasy <tt>int</tt> i można do nich stosować te same operacje (np. arytmetyczne) co do liczb całkowitych.

<blockquote>
Jeszcze inaczej: jeżeli klasa C jest podklasą klasy B, to każda instancja klasy C jest zarazem instancją klasy B — można to sprawdzić za pomocą funkcji <tt>isinstance(obiekt, klasa)</tt>.

Same klasy są również obiektami, instancjami klasy o nazwie <tt>type</tt>. Wywołana jako funkcja, <tt>type(obiekt)</tt> zwraca klasę danego obiektu.
</blockquote>

Poza tym,że Python posiada całkiem sporo klas, czyli typów obiektów, wbudowanych — sporą część z nich, chociaż nie wszystkie, omówiliśmy w poprzednich rozdziałach — to jest wiele dalszych klas zdefiniowanych w bibliotece standardowej, do których można uzyskać dostęp importując odpowiednie moduły; oczywiście jest też bogactwo modułów i bibliotek poza biblioteką standardową. Większość z nich można znaleźć w dedykowanym ,,magazynie", https://pypi.org/. Pisząc kod w Pythonie można również definiować własne klasy; temat ten został pominięty w tym wstępnym kursie, ale na pewno zasługuje on na pierwsze miejsce w jego dalszym ciągu, kursie dla średnio zaawansowanych.

''CDN''

== O generatorach ==

W jednym z poprzednich rozdziałów [[PPy3/Kolekcje#Przyk.C5.82ad:_suma_cyfr|poznaliśmy wyrażenia generatorowe]]. Przypomnijmy, że stanowią one uproszczony zapis iteracji, pozwalający na uniknięcie w wielu prostych przypadkach pętli <tt>for</tt> i tworzenia zmiennych pomocniczych. Przykładowo:

<source lang=python>
kwadraty = (x**2 for x in range(100))
</source>

tworzy generator, ''produkujący'' w iteracji kwadraty kolejnych liczb naturalnych (od 0 do 99).

Poważnym ograniczeniem wyrażeń generatorowych jest to, że można ich używać do przekształcenia jednego obiektu iterowalnego w drugi — w tym przypadku, ciągu liczb naturalnych w ciąg ich kwadratów, natomiast nie ma jak za pomocą wyrażenia generatorowego stworzyć obiektu iterowalnego ,,od zera". Można to uzyskać, stosując ogólniejszą konstrukcję:

<source lang=python>
def gen_kwadraty(start=0):
k = start
while True:
yield k**2
k += 1

kwadraty = gen_kwadraty()
</source>

To, co napisałem powyżej przypomina bardzo definicję funkcji; jedyną różnicą na poziomie składni jest wystąpienie w definicji słowa <tt>yield</tt> (i brak wystąpienia słowa <tt>return</tt>). W istocie <tt>gen_kwadraty</tt> można uważać za funkcję — której wywołanie zwraca generator: obiekt, którego iteracja dostarczy kwadratów kolejnych liczb naturalnych, począwszy od liczby <tt>start</tt>, argumentu wywołania, o domyślnej wartości zero. Zauważmy, że w budowie definicji nie użyliśmy obiektu <tt>range</tt>; użyliśmy za to jawnej pętli <tt>while</tt>, niejako opakowując ją w generator. Co więc w ten sposób zyskujemy?

Przede wszystkim wielką elastyczność. W pokazanym przykładzie zysk jest niewielki, ale w definicji generatora możemy użyć jakiejkolwiek bądź reguły tworzenia kolejnych elementów iteracji. Nie potrzebujemy utworzyć ich wszystkich zanim zaczniemy z nich korzystać — tak jak byłoby w przypadku, gdybyśmy <tt>gen_kwadraty</tt> zdefiniowali jako funkcję zwracającą listę kwadratów kolejnych liczb. Co więcej, iteracja zapewniona przez <tt>gen_kwadraty</tt> może nam dostarczyć dowolnie wielu elementów (oczywiście w realnym komputerze po dostatecznie długim czasie osiągnięto by liczby, których wielkość przekroczyłaby pojemność dostępnej pamięci operacyjnej). Decyzja o tym, kiedy przerwać iterację pozostawiona jest ,,użytkownikowi", tzn. kodowi odwołującemu się do obiektu <tt>kwadraty</tt>.

----

[[PPy3/Matplotlib|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/DobrePraktyki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:26, 27 mar 2018 (CEST)

PPy3/TematyDodatkowe

2023-06-30T10:53:44Z

RobertJB: /* Trochę więcej o klasach i obiektach */

= Tematy dodatkowe =

== Błędy i wyjątki ==

Każdy programista popełnia błędy — jest to nieunikniona część tej działalności.

*Są błędy, które można nazwać banalnymi: literówka w nazwie lub słowie kluczowym, zapomniany dwukropek, niedomknięte nawiasy, itp.
*Są bardziej podstępne błędy logiczne: gdy algorytm, którego zapisem ma być tworzony kod, po prostu nie robi dokładnie tego, co nam się wydaje.
*I w końcu są sytuacje wyjątkowe: gdy w toku pracy programu zachodzą nieoczekiwane okoliczności — użytkownik podał błędną nazwę pliku z danymi, zawartość tego pliku nie jest zgodna z oczekiwaniami programu, połączenie sieciowe ulega przerwaniu w trakcie pobierania lub przesyłania danych, itp.

Wszystkie te sytuacje nazywa się wyjątkami, i tym samym słowem określa się mechanizm, jakiego wiele współczesnych języków programowania (w tym Python) dostarcza programiście, aby mu pomóc określić działania jakie program miałby podjąć w sytuacjach wyjątkowych. Wyjątkowość takich sytuacji generalnie polega na tym, że w przypadku ich wystąpienia program po prostu nie może kontynuować przewidzianego toku działania:

*błąd w składni programu oznacza, że kod nie daje się zinterpretować w sposób jednoznaczny; najlepsze co można zrobić, to w momencie wykrycia błędu przerwać działanie i spróbować dostarczyć programiście (w formie komunikatu) informację ułatwiającą określenie i naprawienie błędu;
*błędne działanie algorytmu można np. spróbować wykrywać za pomocą tzw. asercji (polecenie ''assert'') badających, czy pewne warunki, jakie powinny być spełnione przez dane przetwarzane w programie są istotnie spełnione;
*wyjątki powstałe na skutek okoliczności zachodzących w trakcie działania programu, uniemożliwiających jego normalną kontynuację, można spróbować przewidzieć i przygotować program do odpowiedniego zareagowania, czyli ''obsługi wyjątku''. Na przykład, można spróbować ponowić jeszcze raz (lub kilka razy) próbę łączności sieciowej, i poddać się dopiero po określonej liczbie niepowodzeń; natomiast w sytuacji błędu wynikającego z podania przez użytkownika programu niewłaściwych argumentów uruchomienia, warto postarać się o przekazanie użytkownikowi komunikatu informującego go w sposób dla niego zrozumiały, o właściwym sposobie uruchamiania programu.

=== Błędy składniowe i podobne ===

Jak wspomniano powyżej, w przypadku napotkania błędu składniowego w kodzie programu interpreter natychmiast przerwie wykonywanie programu i wypisze komunikat. Komunikaty te '''warto czytać uważnie''' — w większości przypadków znajduje się w nich cała informacja konieczna dla naprawienia błędu. Przykład: usiłujemy uruchomić program <tt>błąd.py</tt>, którego treść to

<source lang=python>
x = (2 + 3) 4
print x
</source>

Wynik pierwszej próby to:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 1
x = (2 + 3) 4
^
SyntaxError: invalid syntax
</source>

Z komunikatu całkiem jasno wynika, że napotkany został błąd składni (''SyntaxError''), że wykryto ten błąd w linijce 1, a nawet dokładnie — że miejscem, w którym interpreter stwierdził, że ma do czynienia z nieprawidłowy kodem, było wystąpienie cyfry 4 po zamykającym nawiasie. Po prostu zapomnieliśmy, że — inaczej niż w powszechnie stosowanej notacji matematycznej — w Pythonie aby uzyskać mnożenie, konieczne jest napisanie jawnie znaku operatora (gwiazdki).

Po naprawieniu tej pomyłki próbujemy jeszcze raz, i wynik to:
<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 2
print x
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(x)?
</source>

Tutaj już jaśniej być nie może; interpreter nie tylko wskazał nam dokładne miejsce wystąpienia błędu, ale nawet dokładnie opisał, jak go naprawić.

Oczywiście nie zawsze interpreter będzie w stanie wskazać nam błąd aż tak precyzyjnie. Jako przykład weźmy następujący plik:

<source lang=python>
x, y, z = 3, 4, 5
print(max(x, y, z)
print(X * y * z)
</source>

i wynik jego uruchomienia:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 3
print(X * y * z)
^
SyntaxError: invalid syntax
</source>

Dlaczego został wytknięty błąd składniowy w linijce 3? Przecież to w linijce 2 zapomnieliśmy zamknąć jeden z nawiasów.

Otóż jeżeli z końcem linii Python stwierdza, że nie wszystkie dotąd otwarte nawiasy zostały zamknięte, to traktuje to jako oznaczające, że kolejną linijkę należy potraktować jako ciąg dalszy bieżącej. I w tym przypadku dopiero napotykając w kolejnej linijce nazwę <tt>print</tt> — a nie np. przecinek, albo nawias zamykający — stwierdza, że coś musi być nie tak. Miejsce wykrycia błędu niestety nie zawsze się będzie pokrywało z miejscem jego faktycznego wystąpienia.

Po poprawce, czyli zamknięciu nawiasu na linii 2, próbujemy jeszcze raz — z wynikiem

<source lang=bash>
python3 błąd.py
5
Traceback (most recent call last):
File "błąd.py", line 3, in <module>
print(X * y * z)
NameError: name 'X' is not defined
</source>

I tym razem chyba jest wszystko jasne: pojawiła się nazwa <tt>X</tt>, z którą wcześniej nie związano żadnej wartości. Po prostu przez pomyłkę napisaliśmy X wielką literą zamiast małą.

Te przykłady pokazują, że przy wykorzystaniu treści wypisywanych komunikatów proces usunięcia z programu błędów składniowych i formalnych może być dość szybki i bezbolesny.

<blockquote>
Pojawiły się w komunikatach określenia: <tt>SyntaxError</tt>, <tt>NameError</tt>. Są to przykłady nazw tzw. klas wyjątków, czyli ogólnie rozumianych kategorii błędów, jakie są sygnalizowane. Wkrótce spotkamy dalsze klasy wyjątków, takie jak: <tt>TypeError</tt> - związana z przekazaniem wielkości niewłaściwego typu, czy <tt>ValueError</tt> - gdy nie typ. ale wartość wielkości, na której usiłuje się operować, jest niewłaściwa dla danej operacji. Dowiemy się również, dlaczego klasy wyjątków są przydatne — pomimo tego, iż dla ludzkich oczu zwykle bardziej przydatna jest słowna informacja uszczegółowiająca (to co pojawia się po nazwie klasy wyjątku i dwukropku).
</blockquote>

=== Asercje ===

Polecenie <tt>assert</tt> ma następującą postać:

<source lang=python>
assert wyrażenie1
# lub:
assert wyrażenie1, wyrażenie2
</source>

i jest to jak widać polecenie proste (nie zawierające bloku poleceń z wcięciem).

Jego działanie jest takie, że: obliczona zostanie wartość <tt>wyrażenie1</tt>; jeżeli jest ona prawdziwa, nie dzieje się nic (następuje natychmiastowe przejście do kolejnej linijki kodu). Jeżeli okaże się fałszywa, zostanie zasygnalizowany wyjątek, klasy <tt>AssertionError</tt>, co domyślnie przerywa wykonywanie programu i powoduje wypisanie odpowiedniego komunikatu. Jeżeli zastosujemy drugą postać, obliczona zostanie również wartość <tt>wyrażenie2</tt> i wypisana (dokładniej: jej reprezentacja napisowa) jako część komunikatu.

Przyjęło się stosować asercje jako sposób kontroli poprawności działania programu — w tym sensie, aby wykluczyć sytuacje „niemożliwe", tj. powstałe w wyniku błędu programisty. Ze względu na prostotę składni warto też z nich korzystać w kodzie służącym do testowania poprawności innego kodu (czyli np. w funkcjach testujących, czy inne, bardziej złożone funkcje dają poprawne wyniki w prostych sytuacjach próbnych).

=== Wyjątki w trakcie pracy programu ===

Wyjątki występujące w trakcie pracy programu można przechwycić i obsłużyć za pomocą następującej konstrukcji (polecenia złożonego):

<source lang=python>
try:
# operacje mogące spowodować wyjątek
except (KlasaWyjątku1, KlasaWyjątku2, ...):
# co zrobić jeśli wyjątek jednej z tych klas wystąpił
else:
# co zrobić jeśli nie było wyjątku
finally:
# co zrobić w KAŻDYM przypadku
</source>

*bloki <tt>else:</tt> i <tt>finally:</tt> są nieobowiązkowe, tj. możemy je pominąć (wraz z odp. linijką wprowadzającą)
*w bloku <tt>except:</tt> można podać jedną klasę wyjątku (wtedy zbędne są nawiasy), lub żadnej — wtedy przechwycimy ''każdy'' wyjątek; jeśli jednak chcemy, jak w przykładzie, wymienić więcej niż jedną klasę, to nawiasy są konieczne
*skuteczne przechwycenie wyjątku sprawia, że wykonanie programu nie ulegnie przerwaniu w punkcie jego wystąpienia, tyko będzie kontynuowane, również po opuszczeniu bloku <tt>try:</tt>
*można jednak spowodować, aby po wykonaniu czynności obsługi wyjątku, wyjątek został niejako ''wznowiony''; wystarczy w bloku <tt>except:</tt> wywołać instrukcję <tt>raise</tt>. Dla większości klas wyjątków skutkuje to zakończeniem programu
*instrukcję <tt>raise</tt> można wywołać również w dowolnym innym punkcie programu, powinna wówczas w niej wystąpić nazwa klasy wyjątku, jaki chcemy wywołać.

Przykłady:

''CDN.''

== Trochę więcej o klasach i obiektach ==

Warto sobie zdawać sprawę, że każda wartość występująca w programie pythonowym jest obiektem — a więc jest wyposażona w zestaw atrybutów i metod. Dotyczy to nie tylko kolekcji (list, słowników, ...), obiektów takich jak otwarte pliki (wynik wywołania funkcji <tt>open()</tt>), napisów — ale również np. liczb, czy to całkowitych, czy zmiennoprzecinkowych (i zespolonych, o których nie było tutaj mowy).

Przykładowo:

<source lang=python>
(17).bit_length()
→ 5
(17).bit_count()
→ 2
</source>

Co to właściwie znaczy?

Dla liczby 17 wywołaliśmy najpierw metodę, który mówi nam jaka jest długość w bitach reprezentacji dwójkowej tej liczby (<tt>17 == 0b10001</tt>), a następnie metodę, zwracającą liczbę ''ustawionych'' (tj. równych jeden) bitów w tej reprezentacji. Nawiasy okrągłe są konieczne, ponieważ kropka po cyfrach oznaczałaby, że mamy do czynienia z zapisem liczby zmiennoprzecinkowej. Inaczej mówiąc, byłyby niepotrzebne gdybyśmy mieli do czynienia z nazwą oznaczającą liczbę całkowitą, a nie z jej zapisem dziesiętnym.

Każdy obiekt w Pythonie jest ''instancją'' pewnej ''klasy''. Przykłady klas to: <tt>int</tt> (liczby całkowite), <tt>str</tt> (napisy), <tt>list</tt> (listy), <tt>bool</tt> (wartości logiczne), i wiele innych. Klasa to inaczej typ obiektów; charakteryzuje ona zestaw atrybutów i metod związanych z obiektami danej klasy.

<blockquote>
Zazwyczaj różnych obiektów będących instancjami danej klasy może być wiele, potencjalnie nieskończenie wiele. Są jednak wyjątki. Np. klasa <tt>bool</tt> posiada jedynie dwie instancje: (<tt>True</tt> i <tt>False</tt>). A obiekt <tt>None</tt> jest wręcz jedyną instancją swojej klasy.
</blockquote>

Niektóre klasy są ,,szczególnymi przypadkami" innych klas — mówi się, że klasa C ''dziedziczy'' z klasy B, lub że jest ''podklasą'' klasy B. Oznacza to tyle, że instancje klasy C posiadają wszystkie atrybuty i metody jakie posiadają instancje klasy B, ale być może pewne dodatkowe — a być może niektóre z nich zostały w jakiś sposób zmodyfikowane. Przykładowo, klasa <tt>bool</tt> stanowi podklasę klasy <tt>int</tt>; jej jedyne instancje, <tt>True</tt> i <tt>False</tt>, to ,,tak naprawdę" liczby (odpowiednio) 1 i 0 ,,w przebraniu". Są one więc również instancjami klasy <tt>int</tt> i można do nich stosować te same operacje (np. arytmetyczne) co do liczb całkowitych.

<blockquote>
Jeszcze inaczej: jeżeli klasa C jest podklasą klasy B, to każda instancja klasy C jest zarazem instancją klasy B — można to sprawdzić za pomocą funkcji <tt>isinstance(obiekt, klasa)</tt>.

Same klasy są również obiektami, instancjami klasy o nazwie <tt>type</tt>. Wywołana jako funkcja, <tt>type(obiekt)</tt> zwraca klasę danego obiektu.
</blockquote>

''CDN''

== O generatorach ==

W jednym z poprzednich rozdziałów [[PPy3/Kolekcje#Przyk.C5.82ad:_suma_cyfr|poznaliśmy wyrażenia generatorowe]]. Przypomnijmy, że stanowią one uproszczony zapis iteracji, pozwalający na uniknięcie w wielu prostych przypadkach pętli <tt>for</tt> i tworzenia zmiennych pomocniczych. Przykładowo:

<source lang=python>
kwadraty = (x**2 for x in range(100))
</source>

tworzy generator, ''produkujący'' w iteracji kwadraty kolejnych liczb naturalnych (od 0 do 99).

Poważnym ograniczeniem wyrażeń generatorowych jest to, że można ich używać do przekształcenia jednego obiektu iterowalnego w drugi — w tym przypadku, ciągu liczb naturalnych w ciąg ich kwadratów, natomiast nie ma jak za pomocą wyrażenia generatorowego stworzyć obiektu iterowalnego ,,od zera". Można to uzyskać, stosując ogólniejszą konstrukcję:

<source lang=python>
def gen_kwadraty(start=0):
k = start
while True:
yield k**2
k += 1

kwadraty = gen_kwadraty()
</source>

To, co napisałem powyżej przypomina bardzo definicję funkcji; jedyną różnicą na poziomie składni jest wystąpienie w definicji słowa <tt>yield</tt> (i brak wystąpienia słowa <tt>return</tt>). W istocie <tt>gen_kwadraty</tt> można uważać za funkcję — której wywołanie zwraca generator: obiekt, którego iteracja dostarczy kwadratów kolejnych liczb naturalnych, począwszy od liczby <tt>start</tt>, argumentu wywołania, o domyślnej wartości zero. Zauważmy, że w budowie definicji nie użyliśmy obiektu <tt>range</tt>; użyliśmy za to jawnej pętli <tt>while</tt>, niejako opakowując ją w generator. Co więc w ten sposób zyskujemy?

Przede wszystkim wielką elastyczność. W pokazanym przykładzie zysk jest niewielki, ale w definicji generatora możemy użyć jakiejkolwiek bądź reguły tworzenia kolejnych elementów iteracji. Nie potrzebujemy utworzyć ich wszystkich zanim zaczniemy z nich korzystać — tak jak byłoby w przypadku, gdybyśmy <tt>gen_kwadraty</tt> zdefiniowali jako funkcję zwracającą listę kwadratów kolejnych liczb. Co więcej, iteracja zapewniona przez <tt>gen_kwadraty</tt> może nam dostarczyć dowolnie wielu elementów (oczywiście w realnym komputerze po dostatecznie długim czasie osiągnięto by liczby, których wielkość przekroczyłaby pojemność dostępnej pamięci operacyjnej). Decyzja o tym, kiedy przerwać iterację pozostawiona jest ,,użytkownikowi", tzn. kodowi odwołującemu się do obiektu <tt>kwadraty</tt>.

----

[[PPy3/Matplotlib|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/DobrePraktyki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:26, 27 mar 2018 (CEST)

PPy3/TematyDodatkowe

2023-06-29T12:32:01Z

RobertJB: /* Trochę więcej o klasach i obiektach */

= Tematy dodatkowe =

== Błędy i wyjątki ==

Każdy programista popełnia błędy — jest to nieunikniona część tej działalności.

*Są błędy, które można nazwać banalnymi: literówka w nazwie lub słowie kluczowym, zapomniany dwukropek, niedomknięte nawiasy, itp.
*Są bardziej podstępne błędy logiczne: gdy algorytm, którego zapisem ma być tworzony kod, po prostu nie robi dokładnie tego, co nam się wydaje.
*I w końcu są sytuacje wyjątkowe: gdy w toku pracy programu zachodzą nieoczekiwane okoliczności — użytkownik podał błędną nazwę pliku z danymi, zawartość tego pliku nie jest zgodna z oczekiwaniami programu, połączenie sieciowe ulega przerwaniu w trakcie pobierania lub przesyłania danych, itp.

Wszystkie te sytuacje nazywa się wyjątkami, i tym samym słowem określa się mechanizm, jakiego wiele współczesnych języków programowania (w tym Python) dostarcza programiście, aby mu pomóc określić działania jakie program miałby podjąć w sytuacjach wyjątkowych. Wyjątkowość takich sytuacji generalnie polega na tym, że w przypadku ich wystąpienia program po prostu nie może kontynuować przewidzianego toku działania:

*błąd w składni programu oznacza, że kod nie daje się zinterpretować w sposób jednoznaczny; najlepsze co można zrobić, to w momencie wykrycia błędu przerwać działanie i spróbować dostarczyć programiście (w formie komunikatu) informację ułatwiającą określenie i naprawienie błędu;
*błędne działanie algorytmu można np. spróbować wykrywać za pomocą tzw. asercji (polecenie ''assert'') badających, czy pewne warunki, jakie powinny być spełnione przez dane przetwarzane w programie są istotnie spełnione;
*wyjątki powstałe na skutek okoliczności zachodzących w trakcie działania programu, uniemożliwiających jego normalną kontynuację, można spróbować przewidzieć i przygotować program do odpowiedniego zareagowania, czyli ''obsługi wyjątku''. Na przykład, można spróbować ponowić jeszcze raz (lub kilka razy) próbę łączności sieciowej, i poddać się dopiero po określonej liczbie niepowodzeń; natomiast w sytuacji błędu wynikającego z podania przez użytkownika programu niewłaściwych argumentów uruchomienia, warto postarać się o przekazanie użytkownikowi komunikatu informującego go w sposób dla niego zrozumiały, o właściwym sposobie uruchamiania programu.

=== Błędy składniowe i podobne ===

Jak wspomniano powyżej, w przypadku napotkania błędu składniowego w kodzie programu interpreter natychmiast przerwie wykonywanie programu i wypisze komunikat. Komunikaty te '''warto czytać uważnie''' — w większości przypadków znajduje się w nich cała informacja konieczna dla naprawienia błędu. Przykład: usiłujemy uruchomić program <tt>błąd.py</tt>, którego treść to

<source lang=python>
x = (2 + 3) 4
print x
</source>

Wynik pierwszej próby to:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 1
x = (2 + 3) 4
^
SyntaxError: invalid syntax
</source>

Z komunikatu całkiem jasno wynika, że napotkany został błąd składni (''SyntaxError''), że wykryto ten błąd w linijce 1, a nawet dokładnie — że miejscem, w którym interpreter stwierdził, że ma do czynienia z nieprawidłowy kodem, było wystąpienie cyfry 4 po zamykającym nawiasie. Po prostu zapomnieliśmy, że — inaczej niż w powszechnie stosowanej notacji matematycznej — w Pythonie aby uzyskać mnożenie, konieczne jest napisanie jawnie znaku operatora (gwiazdki).

Po naprawieniu tej pomyłki próbujemy jeszcze raz, i wynik to:
<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 2
print x
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(x)?
</source>

Tutaj już jaśniej być nie może; interpreter nie tylko wskazał nam dokładne miejsce wystąpienia błędu, ale nawet dokładnie opisał, jak go naprawić.

Oczywiście nie zawsze interpreter będzie w stanie wskazać nam błąd aż tak precyzyjnie. Jako przykład weźmy następujący plik:

<source lang=python>
x, y, z = 3, 4, 5
print(max(x, y, z)
print(X * y * z)
</source>

i wynik jego uruchomienia:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 3
print(X * y * z)
^
SyntaxError: invalid syntax
</source>

Dlaczego został wytknięty błąd składniowy w linijce 3? Przecież to w linijce 2 zapomnieliśmy zamknąć jeden z nawiasów.

Otóż jeżeli z końcem linii Python stwierdza, że nie wszystkie dotąd otwarte nawiasy zostały zamknięte, to traktuje to jako oznaczające, że kolejną linijkę należy potraktować jako ciąg dalszy bieżącej. I w tym przypadku dopiero napotykając w kolejnej linijce nazwę <tt>print</tt> — a nie np. przecinek, albo nawias zamykający — stwierdza, że coś musi być nie tak. Miejsce wykrycia błędu niestety nie zawsze się będzie pokrywało z miejscem jego faktycznego wystąpienia.

Po poprawce, czyli zamknięciu nawiasu na linii 2, próbujemy jeszcze raz — z wynikiem

<source lang=bash>
python3 błąd.py
5
Traceback (most recent call last):
File "błąd.py", line 3, in <module>
print(X * y * z)
NameError: name 'X' is not defined
</source>

I tym razem chyba jest wszystko jasne: pojawiła się nazwa <tt>X</tt>, z którą wcześniej nie związano żadnej wartości. Po prostu przez pomyłkę napisaliśmy X wielką literą zamiast małą.

Te przykłady pokazują, że przy wykorzystaniu treści wypisywanych komunikatów proces usunięcia z programu błędów składniowych i formalnych może być dość szybki i bezbolesny.

<blockquote>
Pojawiły się w komunikatach określenia: <tt>SyntaxError</tt>, <tt>NameError</tt>. Są to przykłady nazw tzw. klas wyjątków, czyli ogólnie rozumianych kategorii błędów, jakie są sygnalizowane. Wkrótce spotkamy dalsze klasy wyjątków, takie jak: <tt>TypeError</tt> - związana z przekazaniem wielkości niewłaściwego typu, czy <tt>ValueError</tt> - gdy nie typ. ale wartość wielkości, na której usiłuje się operować, jest niewłaściwa dla danej operacji. Dowiemy się również, dlaczego klasy wyjątków są przydatne — pomimo tego, iż dla ludzkich oczu zwykle bardziej przydatna jest słowna informacja uszczegółowiająca (to co pojawia się po nazwie klasy wyjątku i dwukropku).
</blockquote>

=== Asercje ===

Polecenie <tt>assert</tt> ma następującą postać:

<source lang=python>
assert wyrażenie1
# lub:
assert wyrażenie1, wyrażenie2
</source>

i jest to jak widać polecenie proste (nie zawierające bloku poleceń z wcięciem).

Jego działanie jest takie, że: obliczona zostanie wartość <tt>wyrażenie1</tt>; jeżeli jest ona prawdziwa, nie dzieje się nic (następuje natychmiastowe przejście do kolejnej linijki kodu). Jeżeli okaże się fałszywa, zostanie zasygnalizowany wyjątek, klasy <tt>AssertionError</tt>, co domyślnie przerywa wykonywanie programu i powoduje wypisanie odpowiedniego komunikatu. Jeżeli zastosujemy drugą postać, obliczona zostanie również wartość <tt>wyrażenie2</tt> i wypisana (dokładniej: jej reprezentacja napisowa) jako część komunikatu.

Przyjęło się stosować asercje jako sposób kontroli poprawności działania programu — w tym sensie, aby wykluczyć sytuacje „niemożliwe", tj. powstałe w wyniku błędu programisty. Ze względu na prostotę składni warto też z nich korzystać w kodzie służącym do testowania poprawności innego kodu (czyli np. w funkcjach testujących, czy inne, bardziej złożone funkcje dają poprawne wyniki w prostych sytuacjach próbnych).

=== Wyjątki w trakcie pracy programu ===

Wyjątki występujące w trakcie pracy programu można przechwycić i obsłużyć za pomocą następującej konstrukcji (polecenia złożonego):

<source lang=python>
try:
# operacje mogące spowodować wyjątek
except (KlasaWyjątku1, KlasaWyjątku2, ...):
# co zrobić jeśli wyjątek jednej z tych klas wystąpił
else:
# co zrobić jeśli nie było wyjątku
finally:
# co zrobić w KAŻDYM przypadku
</source>

*bloki <tt>else:</tt> i <tt>finally:</tt> są nieobowiązkowe, tj. możemy je pominąć (wraz z odp. linijką wprowadzającą)
*w bloku <tt>except:</tt> można podać jedną klasę wyjątku (wtedy zbędne są nawiasy), lub żadnej — wtedy przechwycimy ''każdy'' wyjątek; jeśli jednak chcemy, jak w przykładzie, wymienić więcej niż jedną klasę, to nawiasy są konieczne
*skuteczne przechwycenie wyjątku sprawia, że wykonanie programu nie ulegnie przerwaniu w punkcie jego wystąpienia, tyko będzie kontynuowane, również po opuszczeniu bloku <tt>try:</tt>
*można jednak spowodować, aby po wykonaniu czynności obsługi wyjątku, wyjątek został niejako ''wznowiony''; wystarczy w bloku <tt>except:</tt> wywołać instrukcję <tt>raise</tt>. Dla większości klas wyjątków skutkuje to zakończeniem programu
*instrukcję <tt>raise</tt> można wywołać również w dowolnym innym punkcie programu, powinna wówczas w niej wystąpić nazwa klasy wyjątku, jaki chcemy wywołać.

Przykłady:

''CDN.''

== Trochę więcej o klasach i obiektach ==

Warto sobie zdawać sprawę, że każda wartość występująca w programie pythonowym jest obiektem — a więc jest wyposażona w zestaw atrybutów i metod. Dotyczy to nie tylko kolekcji (list, słowników, ...), obiektów takich jak otwarte pliki (wynik wywołania funkcji <tt>open()</tt>), napisów — ale również np. liczb, czy to całkowitych, czy zmiennoprzecinkowych (i zespolonych, o których nie było tutaj mowy).

Przykładowo:

<source lang=python>
(17).bit_length()
→ 5
(17).bit_count()
→ 2
</source>

Co to właściwie znaczy?

Dla liczby 17 wywołaliśmy najpierw metodę, który mówi nam jaka jest długość w bitach reprezentacji dwójkowej tej liczby (<tt>17 == 0b10001</tt>), a następnie metodę, zwracającą liczbę ''ustawionych'' (tj. równych jeden) bitów w tej reprezentacji. Nawiasy okrągłe są konieczne, ponieważ kropka po cyfrach oznaczałaby, że mamy do czynienia z zapisem liczby zmiennoprzecinkowej. Inaczej mówiąc, byłyby niepotrzebne gdybyśmy mieli do czynienia z nazwą oznaczającą liczbę całkowitą, a nie z jej zapisem dziesiętnym.

Każdy obiekt w Pythonie jest ''instancją'' pewnej ''klasy''. Przykłady klas to: <tt>int</tt> (liczby całkowite), <tt>str</tt> (napisy), <tt>list</tt> (listy), <tt>bool</tt> (wartości logiczne), i wiele innych. Klasa to inaczej typ obiektów; charakteryzuje ona zestaw atrybutów i metod związanych z obiektami danej klasy.

<blockquote>
Zazwyczaj różnych obiektów będących instancjami danej klasy może być wiele, potencjalnie nieskończenie wiele. Są jednak wyjątki. Np. klasa <tt>bool</tt> posiada jedynie dwie instancje: (<tt>True</tt> i <tt>False</tt>). A obiekt <tt>None</tt> jest wręcz jedyną instancją swojej klasy.
</blockquote>

Niektóre klasy są ,,szczególnymi przypadkami" innych klas — mówi się, że klasa C ''dziedziczy'' z klasy B, lub że jest ''podklasą'' klasy B. Oznacza to tyle, że instancje klasy C posiadają wszystkie atrybuty i metody jakie posiadają instancje klasy B, ale być może pewne dodatkowe — a być może niektóre z nich zostały w jakiś sposób zmodyfikowane. Przykładowo, klasa <tt>bool</tt> stanowi podklasę klasy <tt>int</tt>; jej jedyne instancje, <tt>True</tt> i <tt>False</tt>, to ,,tak naprawdę" liczby (odpowiednio) 1 i 0 ,,w przebraniu". Są one więc również instancjami klasy <tt>int</tt> i można do nich stosować te same operacje (np. arytmetyczne) co do liczb całkowitych.

''CDN''

== O generatorach ==

W jednym z poprzednich rozdziałów [[PPy3/Kolekcje#Przyk.C5.82ad:_suma_cyfr|poznaliśmy wyrażenia generatorowe]]. Przypomnijmy, że stanowią one uproszczony zapis iteracji, pozwalający na uniknięcie w wielu prostych przypadkach pętli <tt>for</tt> i tworzenia zmiennych pomocniczych. Przykładowo:

<source lang=python>
kwadraty = (x**2 for x in range(100))
</source>

tworzy generator, ''produkujący'' w iteracji kwadraty kolejnych liczb naturalnych (od 0 do 99).

Poważnym ograniczeniem wyrażeń generatorowych jest to, że można ich używać do przekształcenia jednego obiektu iterowalnego w drugi — w tym przypadku, ciągu liczb naturalnych w ciąg ich kwadratów, natomiast nie ma jak za pomocą wyrażenia generatorowego stworzyć obiektu iterowalnego ,,od zera". Można to uzyskać, stosując ogólniejszą konstrukcję:

<source lang=python>
def gen_kwadraty(start=0):
k = start
while True:
yield k**2
k += 1

kwadraty = gen_kwadraty()
</source>

To, co napisałem powyżej przypomina bardzo definicję funkcji; jedyną różnicą na poziomie składni jest wystąpienie w definicji słowa <tt>yield</tt> (i brak wystąpienia słowa <tt>return</tt>). W istocie <tt>gen_kwadraty</tt> można uważać za funkcję — której wywołanie zwraca generator: obiekt, którego iteracja dostarczy kwadratów kolejnych liczb naturalnych, począwszy od liczby <tt>start</tt>, argumentu wywołania, o domyślnej wartości zero. Zauważmy, że w budowie definicji nie użyliśmy obiektu <tt>range</tt>; użyliśmy za to jawnej pętli <tt>while</tt>, niejako opakowując ją w generator. Co więc w ten sposób zyskujemy?

Przede wszystkim wielką elastyczność. W pokazanym przykładzie zysk jest niewielki, ale w definicji generatora możemy użyć jakiejkolwiek bądź reguły tworzenia kolejnych elementów iteracji. Nie potrzebujemy utworzyć ich wszystkich zanim zaczniemy z nich korzystać — tak jak byłoby w przypadku, gdybyśmy <tt>gen_kwadraty</tt> zdefiniowali jako funkcję zwracającą listę kwadratów kolejnych liczb. Co więcej, iteracja zapewniona przez <tt>gen_kwadraty</tt> może nam dostarczyć dowolnie wielu elementów (oczywiście w realnym komputerze po dostatecznie długim czasie osiągnięto by liczby, których wielkość przekroczyłaby pojemność dostępnej pamięci operacyjnej). Decyzja o tym, kiedy przerwać iterację pozostawiona jest ,,użytkownikowi", tzn. kodowi odwołującemu się do obiektu <tt>kwadraty</tt>.

----

[[PPy3/Matplotlib|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/DobrePraktyki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:26, 27 mar 2018 (CEST)

PPy3/TematyDodatkowe

2023-06-29T12:30:10Z

RobertJB: /* Trochę więcej o klasach i obiektach */

= Tematy dodatkowe =

== Błędy i wyjątki ==

Każdy programista popełnia błędy — jest to nieunikniona część tej działalności.

*Są błędy, które można nazwać banalnymi: literówka w nazwie lub słowie kluczowym, zapomniany dwukropek, niedomknięte nawiasy, itp.
*Są bardziej podstępne błędy logiczne: gdy algorytm, którego zapisem ma być tworzony kod, po prostu nie robi dokładnie tego, co nam się wydaje.
*I w końcu są sytuacje wyjątkowe: gdy w toku pracy programu zachodzą nieoczekiwane okoliczności — użytkownik podał błędną nazwę pliku z danymi, zawartość tego pliku nie jest zgodna z oczekiwaniami programu, połączenie sieciowe ulega przerwaniu w trakcie pobierania lub przesyłania danych, itp.

Wszystkie te sytuacje nazywa się wyjątkami, i tym samym słowem określa się mechanizm, jakiego wiele współczesnych języków programowania (w tym Python) dostarcza programiście, aby mu pomóc określić działania jakie program miałby podjąć w sytuacjach wyjątkowych. Wyjątkowość takich sytuacji generalnie polega na tym, że w przypadku ich wystąpienia program po prostu nie może kontynuować przewidzianego toku działania:

*błąd w składni programu oznacza, że kod nie daje się zinterpretować w sposób jednoznaczny; najlepsze co można zrobić, to w momencie wykrycia błędu przerwać działanie i spróbować dostarczyć programiście (w formie komunikatu) informację ułatwiającą określenie i naprawienie błędu;
*błędne działanie algorytmu można np. spróbować wykrywać za pomocą tzw. asercji (polecenie ''assert'') badających, czy pewne warunki, jakie powinny być spełnione przez dane przetwarzane w programie są istotnie spełnione;
*wyjątki powstałe na skutek okoliczności zachodzących w trakcie działania programu, uniemożliwiających jego normalną kontynuację, można spróbować przewidzieć i przygotować program do odpowiedniego zareagowania, czyli ''obsługi wyjątku''. Na przykład, można spróbować ponowić jeszcze raz (lub kilka razy) próbę łączności sieciowej, i poddać się dopiero po określonej liczbie niepowodzeń; natomiast w sytuacji błędu wynikającego z podania przez użytkownika programu niewłaściwych argumentów uruchomienia, warto postarać się o przekazanie użytkownikowi komunikatu informującego go w sposób dla niego zrozumiały, o właściwym sposobie uruchamiania programu.

=== Błędy składniowe i podobne ===

Jak wspomniano powyżej, w przypadku napotkania błędu składniowego w kodzie programu interpreter natychmiast przerwie wykonywanie programu i wypisze komunikat. Komunikaty te '''warto czytać uważnie''' — w większości przypadków znajduje się w nich cała informacja konieczna dla naprawienia błędu. Przykład: usiłujemy uruchomić program <tt>błąd.py</tt>, którego treść to

<source lang=python>
x = (2 + 3) 4
print x
</source>

Wynik pierwszej próby to:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 1
x = (2 + 3) 4
^
SyntaxError: invalid syntax
</source>

Z komunikatu całkiem jasno wynika, że napotkany został błąd składni (''SyntaxError''), że wykryto ten błąd w linijce 1, a nawet dokładnie — że miejscem, w którym interpreter stwierdził, że ma do czynienia z nieprawidłowy kodem, było wystąpienie cyfry 4 po zamykającym nawiasie. Po prostu zapomnieliśmy, że — inaczej niż w powszechnie stosowanej notacji matematycznej — w Pythonie aby uzyskać mnożenie, konieczne jest napisanie jawnie znaku operatora (gwiazdki).

Po naprawieniu tej pomyłki próbujemy jeszcze raz, i wynik to:
<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 2
print x
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(x)?
</source>

Tutaj już jaśniej być nie może; interpreter nie tylko wskazał nam dokładne miejsce wystąpienia błędu, ale nawet dokładnie opisał, jak go naprawić.

Oczywiście nie zawsze interpreter będzie w stanie wskazać nam błąd aż tak precyzyjnie. Jako przykład weźmy następujący plik:

<source lang=python>
x, y, z = 3, 4, 5
print(max(x, y, z)
print(X * y * z)
</source>

i wynik jego uruchomienia:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 3
print(X * y * z)
^
SyntaxError: invalid syntax
</source>

Dlaczego został wytknięty błąd składniowy w linijce 3? Przecież to w linijce 2 zapomnieliśmy zamknąć jeden z nawiasów.

Otóż jeżeli z końcem linii Python stwierdza, że nie wszystkie dotąd otwarte nawiasy zostały zamknięte, to traktuje to jako oznaczające, że kolejną linijkę należy potraktować jako ciąg dalszy bieżącej. I w tym przypadku dopiero napotykając w kolejnej linijce nazwę <tt>print</tt> — a nie np. przecinek, albo nawias zamykający — stwierdza, że coś musi być nie tak. Miejsce wykrycia błędu niestety nie zawsze się będzie pokrywało z miejscem jego faktycznego wystąpienia.

Po poprawce, czyli zamknięciu nawiasu na linii 2, próbujemy jeszcze raz — z wynikiem

<source lang=bash>
python3 błąd.py
5
Traceback (most recent call last):
File "błąd.py", line 3, in <module>
print(X * y * z)
NameError: name 'X' is not defined
</source>

I tym razem chyba jest wszystko jasne: pojawiła się nazwa <tt>X</tt>, z którą wcześniej nie związano żadnej wartości. Po prostu przez pomyłkę napisaliśmy X wielką literą zamiast małą.

Te przykłady pokazują, że przy wykorzystaniu treści wypisywanych komunikatów proces usunięcia z programu błędów składniowych i formalnych może być dość szybki i bezbolesny.

<blockquote>
Pojawiły się w komunikatach określenia: <tt>SyntaxError</tt>, <tt>NameError</tt>. Są to przykłady nazw tzw. klas wyjątków, czyli ogólnie rozumianych kategorii błędów, jakie są sygnalizowane. Wkrótce spotkamy dalsze klasy wyjątków, takie jak: <tt>TypeError</tt> - związana z przekazaniem wielkości niewłaściwego typu, czy <tt>ValueError</tt> - gdy nie typ. ale wartość wielkości, na której usiłuje się operować, jest niewłaściwa dla danej operacji. Dowiemy się również, dlaczego klasy wyjątków są przydatne — pomimo tego, iż dla ludzkich oczu zwykle bardziej przydatna jest słowna informacja uszczegółowiająca (to co pojawia się po nazwie klasy wyjątku i dwukropku).
</blockquote>

=== Asercje ===

Polecenie <tt>assert</tt> ma następującą postać:

<source lang=python>
assert wyrażenie1
# lub:
assert wyrażenie1, wyrażenie2
</source>

i jest to jak widać polecenie proste (nie zawierające bloku poleceń z wcięciem).

Jego działanie jest takie, że: obliczona zostanie wartość <tt>wyrażenie1</tt>; jeżeli jest ona prawdziwa, nie dzieje się nic (następuje natychmiastowe przejście do kolejnej linijki kodu). Jeżeli okaże się fałszywa, zostanie zasygnalizowany wyjątek, klasy <tt>AssertionError</tt>, co domyślnie przerywa wykonywanie programu i powoduje wypisanie odpowiedniego komunikatu. Jeżeli zastosujemy drugą postać, obliczona zostanie również wartość <tt>wyrażenie2</tt> i wypisana (dokładniej: jej reprezentacja napisowa) jako część komunikatu.

Przyjęło się stosować asercje jako sposób kontroli poprawności działania programu — w tym sensie, aby wykluczyć sytuacje „niemożliwe", tj. powstałe w wyniku błędu programisty. Ze względu na prostotę składni warto też z nich korzystać w kodzie służącym do testowania poprawności innego kodu (czyli np. w funkcjach testujących, czy inne, bardziej złożone funkcje dają poprawne wyniki w prostych sytuacjach próbnych).

=== Wyjątki w trakcie pracy programu ===

Wyjątki występujące w trakcie pracy programu można przechwycić i obsłużyć za pomocą następującej konstrukcji (polecenia złożonego):

<source lang=python>
try:
# operacje mogące spowodować wyjątek
except (KlasaWyjątku1, KlasaWyjątku2, ...):
# co zrobić jeśli wyjątek jednej z tych klas wystąpił
else:
# co zrobić jeśli nie było wyjątku
finally:
# co zrobić w KAŻDYM przypadku
</source>

*bloki <tt>else:</tt> i <tt>finally:</tt> są nieobowiązkowe, tj. możemy je pominąć (wraz z odp. linijką wprowadzającą)
*w bloku <tt>except:</tt> można podać jedną klasę wyjątku (wtedy zbędne są nawiasy), lub żadnej — wtedy przechwycimy ''każdy'' wyjątek; jeśli jednak chcemy, jak w przykładzie, wymienić więcej niż jedną klasę, to nawiasy są konieczne
*skuteczne przechwycenie wyjątku sprawia, że wykonanie programu nie ulegnie przerwaniu w punkcie jego wystąpienia, tyko będzie kontynuowane, również po opuszczeniu bloku <tt>try:</tt>
*można jednak spowodować, aby po wykonaniu czynności obsługi wyjątku, wyjątek został niejako ''wznowiony''; wystarczy w bloku <tt>except:</tt> wywołać instrukcję <tt>raise</tt>. Dla większości klas wyjątków skutkuje to zakończeniem programu
*instrukcję <tt>raise</tt> można wywołać również w dowolnym innym punkcie programu, powinna wówczas w niej wystąpić nazwa klasy wyjątku, jaki chcemy wywołać.

Przykłady:

''CDN.''

== Trochę więcej o klasach i obiektach ==

Warto sobie zdawać sprawę, że każda wartość występująca w programie pythonowym jest obiektem — a więc jest wyposażona w zestaw atrybutów i metod. Dotyczy to nie tylko kolekcji (list, słowników, ...), obiektów takich jak otwarte pliki (wynik wywołania funkcji <tt>open()</tt>), napisów — ale również np. liczb, czy to całkowitych, czy zmiennoprzecinkowych (i zespolonych, o których nie było tutaj mowy).

Przykładowo:

<source lang=python>
(17).bit_length()
→ 5
(17).bit_count()
→ 2
</source>

Co to właściwie znaczy?

Dla liczby 17 wywołaliśmy najpierw metodę, który mówi nam jaka jest długość w bitach reprezentacji dwójkowej tej liczby (<tt>17 == 0b10001</tt>), a następnie metodę, zwracającą liczbę ''ustawionych'' (tj. równych jeden) bitów w tej reprezentacji. Nawiasy okrągłe są konieczne, ponieważ kropka po cyfrach oznaczałaby, że mamy do czynienia z zapisem liczby zmiennoprzecinkowej. Inaczej mówiąc, byłyby niepotrzebne gdybyśmy mieli do czynienia z nazwą oznaczającą liczbę całkowitą, a nie z jej zapisem dziesiętnym.

Każdy obiekt w Pythonie jest ''instancją'' pewnej ''klasy''. Przykłady klas to: <tt>int</tt> (liczby całkowite), <tt>str</tt> (napisy), <tt>list</tt> (listy), <tt>bool</tt> (wartości logiczne), i wiele innych. Klasa to inaczej typ obiektów; charakteryzuje ona zestaw atrybutów i metod związanych z obiektami danej klasy.

<blockquote>
Zazwyczaj różnych obiektów będących instancjami danej klasy może być wiele, potencjalnie nieskończenie wiele. Są jednak wyjątki. Np. klasa <tt>bool</tt> posiada jedynie dwie instancje: (<tt>True</tt> i <tt>False</tt>). A obiekt <tt>None</tt> jest wręcz jedyną instancją swojej klasy.
</blockquote>

Niektóre klasy są ,,szczególnymi przypadkami" innych klas — mówi się, że klasa C ''dziedziczy'' z klasy B, lub że jest ''podklasą'' klasy B. Oznacza to tyle, że instancje klasy C posiadają wszystkie atrybuty i metody jakie posiadają instancje klasy B, ale być może pewne dodatkowe — a być może niektóre z nich zostały w jakiś sposób zmodyfikowane. Przykładowo, klasa <tt>bool</tt> stanowi podklasę klasy <tt>int</tt>; jej jedynie instancje, <tt>True</tt> i <tt>False</tt>, to ,,tak naprawdę" liczby (odpowiednio) 1 i 0 ,,w przebraniu". Są one więc również instancjami klasy <tt>int</tt> i można do nich stosować te same operacje (np. arytmetyczne) co do liczb całkowitych.

''CDN''

== O generatorach ==

W jednym z poprzednich rozdziałów [[PPy3/Kolekcje#Przyk.C5.82ad:_suma_cyfr|poznaliśmy wyrażenia generatorowe]]. Przypomnijmy, że stanowią one uproszczony zapis iteracji, pozwalający na uniknięcie w wielu prostych przypadkach pętli <tt>for</tt> i tworzenia zmiennych pomocniczych. Przykładowo:

<source lang=python>
kwadraty = (x**2 for x in range(100))
</source>

tworzy generator, ''produkujący'' w iteracji kwadraty kolejnych liczb naturalnych (od 0 do 99).

Poważnym ograniczeniem wyrażeń generatorowych jest to, że można ich używać do przekształcenia jednego obiektu iterowalnego w drugi — w tym przypadku, ciągu liczb naturalnych w ciąg ich kwadratów, natomiast nie ma jak za pomocą wyrażenia generatorowego stworzyć obiektu iterowalnego ,,od zera". Można to uzyskać, stosując ogólniejszą konstrukcję:

<source lang=python>
def gen_kwadraty(start=0):
k = start
while True:
yield k**2
k += 1

kwadraty = gen_kwadraty()
</source>

To, co napisałem powyżej przypomina bardzo definicję funkcji; jedyną różnicą na poziomie składni jest wystąpienie w definicji słowa <tt>yield</tt> (i brak wystąpienia słowa <tt>return</tt>). W istocie <tt>gen_kwadraty</tt> można uważać za funkcję — której wywołanie zwraca generator: obiekt, którego iteracja dostarczy kwadratów kolejnych liczb naturalnych, począwszy od liczby <tt>start</tt>, argumentu wywołania, o domyślnej wartości zero. Zauważmy, że w budowie definicji nie użyliśmy obiektu <tt>range</tt>; użyliśmy za to jawnej pętli <tt>while</tt>, niejako opakowując ją w generator. Co więc w ten sposób zyskujemy?

Przede wszystkim wielką elastyczność. W pokazanym przykładzie zysk jest niewielki, ale w definicji generatora możemy użyć jakiejkolwiek bądź reguły tworzenia kolejnych elementów iteracji. Nie potrzebujemy utworzyć ich wszystkich zanim zaczniemy z nich korzystać — tak jak byłoby w przypadku, gdybyśmy <tt>gen_kwadraty</tt> zdefiniowali jako funkcję zwracającą listę kwadratów kolejnych liczb. Co więcej, iteracja zapewniona przez <tt>gen_kwadraty</tt> może nam dostarczyć dowolnie wielu elementów (oczywiście w realnym komputerze po dostatecznie długim czasie osiągnięto by liczby, których wielkość przekroczyłaby pojemność dostępnej pamięci operacyjnej). Decyzja o tym, kiedy przerwać iterację pozostawiona jest ,,użytkownikowi", tzn. kodowi odwołującemu się do obiektu <tt>kwadraty</tt>.

----

[[PPy3/Matplotlib|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/DobrePraktyki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:26, 27 mar 2018 (CEST)

PPy3/TematyDodatkowe

2023-06-29T12:29:25Z

RobertJB: /* Trochę więcej o klasach i obiektach */

= Tematy dodatkowe =

== Błędy i wyjątki ==

Każdy programista popełnia błędy — jest to nieunikniona część tej działalności.

*Są błędy, które można nazwać banalnymi: literówka w nazwie lub słowie kluczowym, zapomniany dwukropek, niedomknięte nawiasy, itp.
*Są bardziej podstępne błędy logiczne: gdy algorytm, którego zapisem ma być tworzony kod, po prostu nie robi dokładnie tego, co nam się wydaje.
*I w końcu są sytuacje wyjątkowe: gdy w toku pracy programu zachodzą nieoczekiwane okoliczności — użytkownik podał błędną nazwę pliku z danymi, zawartość tego pliku nie jest zgodna z oczekiwaniami programu, połączenie sieciowe ulega przerwaniu w trakcie pobierania lub przesyłania danych, itp.

Wszystkie te sytuacje nazywa się wyjątkami, i tym samym słowem określa się mechanizm, jakiego wiele współczesnych języków programowania (w tym Python) dostarcza programiście, aby mu pomóc określić działania jakie program miałby podjąć w sytuacjach wyjątkowych. Wyjątkowość takich sytuacji generalnie polega na tym, że w przypadku ich wystąpienia program po prostu nie może kontynuować przewidzianego toku działania:

*błąd w składni programu oznacza, że kod nie daje się zinterpretować w sposób jednoznaczny; najlepsze co można zrobić, to w momencie wykrycia błędu przerwać działanie i spróbować dostarczyć programiście (w formie komunikatu) informację ułatwiającą określenie i naprawienie błędu;
*błędne działanie algorytmu można np. spróbować wykrywać za pomocą tzw. asercji (polecenie ''assert'') badających, czy pewne warunki, jakie powinny być spełnione przez dane przetwarzane w programie są istotnie spełnione;
*wyjątki powstałe na skutek okoliczności zachodzących w trakcie działania programu, uniemożliwiających jego normalną kontynuację, można spróbować przewidzieć i przygotować program do odpowiedniego zareagowania, czyli ''obsługi wyjątku''. Na przykład, można spróbować ponowić jeszcze raz (lub kilka razy) próbę łączności sieciowej, i poddać się dopiero po określonej liczbie niepowodzeń; natomiast w sytuacji błędu wynikającego z podania przez użytkownika programu niewłaściwych argumentów uruchomienia, warto postarać się o przekazanie użytkownikowi komunikatu informującego go w sposób dla niego zrozumiały, o właściwym sposobie uruchamiania programu.

=== Błędy składniowe i podobne ===

Jak wspomniano powyżej, w przypadku napotkania błędu składniowego w kodzie programu interpreter natychmiast przerwie wykonywanie programu i wypisze komunikat. Komunikaty te '''warto czytać uważnie''' — w większości przypadków znajduje się w nich cała informacja konieczna dla naprawienia błędu. Przykład: usiłujemy uruchomić program <tt>błąd.py</tt>, którego treść to

<source lang=python>
x = (2 + 3) 4
print x
</source>

Wynik pierwszej próby to:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 1
x = (2 + 3) 4
^
SyntaxError: invalid syntax
</source>

Z komunikatu całkiem jasno wynika, że napotkany został błąd składni (''SyntaxError''), że wykryto ten błąd w linijce 1, a nawet dokładnie — że miejscem, w którym interpreter stwierdził, że ma do czynienia z nieprawidłowy kodem, było wystąpienie cyfry 4 po zamykającym nawiasie. Po prostu zapomnieliśmy, że — inaczej niż w powszechnie stosowanej notacji matematycznej — w Pythonie aby uzyskać mnożenie, konieczne jest napisanie jawnie znaku operatora (gwiazdki).

Po naprawieniu tej pomyłki próbujemy jeszcze raz, i wynik to:
<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 2
print x
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(x)?
</source>

Tutaj już jaśniej być nie może; interpreter nie tylko wskazał nam dokładne miejsce wystąpienia błędu, ale nawet dokładnie opisał, jak go naprawić.

Oczywiście nie zawsze interpreter będzie w stanie wskazać nam błąd aż tak precyzyjnie. Jako przykład weźmy następujący plik:

<source lang=python>
x, y, z = 3, 4, 5
print(max(x, y, z)
print(X * y * z)
</source>

i wynik jego uruchomienia:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 3
print(X * y * z)
^
SyntaxError: invalid syntax
</source>

Dlaczego został wytknięty błąd składniowy w linijce 3? Przecież to w linijce 2 zapomnieliśmy zamknąć jeden z nawiasów.

Otóż jeżeli z końcem linii Python stwierdza, że nie wszystkie dotąd otwarte nawiasy zostały zamknięte, to traktuje to jako oznaczające, że kolejną linijkę należy potraktować jako ciąg dalszy bieżącej. I w tym przypadku dopiero napotykając w kolejnej linijce nazwę <tt>print</tt> — a nie np. przecinek, albo nawias zamykający — stwierdza, że coś musi być nie tak. Miejsce wykrycia błędu niestety nie zawsze się będzie pokrywało z miejscem jego faktycznego wystąpienia.

Po poprawce, czyli zamknięciu nawiasu na linii 2, próbujemy jeszcze raz — z wynikiem

<source lang=bash>
python3 błąd.py
5
Traceback (most recent call last):
File "błąd.py", line 3, in <module>
print(X * y * z)
NameError: name 'X' is not defined
</source>

I tym razem chyba jest wszystko jasne: pojawiła się nazwa <tt>X</tt>, z którą wcześniej nie związano żadnej wartości. Po prostu przez pomyłkę napisaliśmy X wielką literą zamiast małą.

Te przykłady pokazują, że przy wykorzystaniu treści wypisywanych komunikatów proces usunięcia z programu błędów składniowych i formalnych może być dość szybki i bezbolesny.

<blockquote>
Pojawiły się w komunikatach określenia: <tt>SyntaxError</tt>, <tt>NameError</tt>. Są to przykłady nazw tzw. klas wyjątków, czyli ogólnie rozumianych kategorii błędów, jakie są sygnalizowane. Wkrótce spotkamy dalsze klasy wyjątków, takie jak: <tt>TypeError</tt> - związana z przekazaniem wielkości niewłaściwego typu, czy <tt>ValueError</tt> - gdy nie typ. ale wartość wielkości, na której usiłuje się operować, jest niewłaściwa dla danej operacji. Dowiemy się również, dlaczego klasy wyjątków są przydatne — pomimo tego, iż dla ludzkich oczu zwykle bardziej przydatna jest słowna informacja uszczegółowiająca (to co pojawia się po nazwie klasy wyjątku i dwukropku).
</blockquote>

=== Asercje ===

Polecenie <tt>assert</tt> ma następującą postać:

<source lang=python>
assert wyrażenie1
# lub:
assert wyrażenie1, wyrażenie2
</source>

i jest to jak widać polecenie proste (nie zawierające bloku poleceń z wcięciem).

Jego działanie jest takie, że: obliczona zostanie wartość <tt>wyrażenie1</tt>; jeżeli jest ona prawdziwa, nie dzieje się nic (następuje natychmiastowe przejście do kolejnej linijki kodu). Jeżeli okaże się fałszywa, zostanie zasygnalizowany wyjątek, klasy <tt>AssertionError</tt>, co domyślnie przerywa wykonywanie programu i powoduje wypisanie odpowiedniego komunikatu. Jeżeli zastosujemy drugą postać, obliczona zostanie również wartość <tt>wyrażenie2</tt> i wypisana (dokładniej: jej reprezentacja napisowa) jako część komunikatu.

Przyjęło się stosować asercje jako sposób kontroli poprawności działania programu — w tym sensie, aby wykluczyć sytuacje „niemożliwe", tj. powstałe w wyniku błędu programisty. Ze względu na prostotę składni warto też z nich korzystać w kodzie służącym do testowania poprawności innego kodu (czyli np. w funkcjach testujących, czy inne, bardziej złożone funkcje dają poprawne wyniki w prostych sytuacjach próbnych).

=== Wyjątki w trakcie pracy programu ===

Wyjątki występujące w trakcie pracy programu można przechwycić i obsłużyć za pomocą następującej konstrukcji (polecenia złożonego):

<source lang=python>
try:
# operacje mogące spowodować wyjątek
except (KlasaWyjątku1, KlasaWyjątku2, ...):
# co zrobić jeśli wyjątek jednej z tych klas wystąpił
else:
# co zrobić jeśli nie było wyjątku
finally:
# co zrobić w KAŻDYM przypadku
</source>

*bloki <tt>else:</tt> i <tt>finally:</tt> są nieobowiązkowe, tj. możemy je pominąć (wraz z odp. linijką wprowadzającą)
*w bloku <tt>except:</tt> można podać jedną klasę wyjątku (wtedy zbędne są nawiasy), lub żadnej — wtedy przechwycimy ''każdy'' wyjątek; jeśli jednak chcemy, jak w przykładzie, wymienić więcej niż jedną klasę, to nawiasy są konieczne
*skuteczne przechwycenie wyjątku sprawia, że wykonanie programu nie ulegnie przerwaniu w punkcie jego wystąpienia, tyko będzie kontynuowane, również po opuszczeniu bloku <tt>try:</tt>
*można jednak spowodować, aby po wykonaniu czynności obsługi wyjątku, wyjątek został niejako ''wznowiony''; wystarczy w bloku <tt>except:</tt> wywołać instrukcję <tt>raise</tt>. Dla większości klas wyjątków skutkuje to zakończeniem programu
*instrukcję <tt>raise</tt> można wywołać również w dowolnym innym punkcie programu, powinna wówczas w niej wystąpić nazwa klasy wyjątku, jaki chcemy wywołać.

Przykłady:

''CDN.''

== Trochę więcej o klasach i obiektach ==

Warto sobie zdawać sprawę, że każda wartość występująca w programie pythonowym jest obiektem — a więc jest wyposażona w zestaw atrybutów i metod. Dotyczy to nie tylko kolekcji (list, słowników, ...), obiektów takich jak otwarte pliki (wynik wywołania funkcji <tt>open()</tt>), napisów — ale również np. liczb, czy to całkowitych, czy zmiennoprzecinkowych (i zespolonych, o których nie było tutaj mowy).

Przykładowo:

<source lang=python>
(17).bit_length()
→ 5
(17).bit_count()
→ 2
</source>

Co to właściwie znaczy?

Dla liczby 17 wywołaliśmy najpierw metodę, który mówi nam jak jest długość w bitach reprezentacji dwójkowej tej liczby (<tt>17 == 0b10001</tt>), a następnie metodę, zwracającą liczbę ''ustawionych'' (tj. równych jeden) bitów w tej reprezentacji. Nawiasy okrągłe są konieczne, ponieważ kropka po cyfrach oznaczałaby, że mamy do czynienia z zapisem liczby zmiennoprzecinkowej. Inaczej mówiąc, byłyby niepotrzebne gdybyśmy mieli do czynienia z nazwą oznaczającą liczbę całkowitą, a nie z jej zapisem dziesiętnym.

Każdy obiekt w Pythonie jest ''instancją'' pewnej ''klasy''. Przykłady klas to: <tt>int</tt> (liczby całkowite), <tt>str</tt> (napisy), <tt>list</tt> (listy), <tt>bool</tt> (wartości logiczne), i wiele innych. Klasa to inaczej typ obiektów; charakteryzuje ona zestaw atrybutów i metod związanych z obiektami danej klasy.

<blockquote>
Zazwyczaj różnych obiektów będących instancjami danej klasy może być wiele, potencjalnie nieskończenie wiele. Są jednak wyjątki. Np. klasa <tt>bool</tt> posiada jedynie dwie instancje: (<tt>True</tt> i <tt>False</tt>). A obiekt <tt>None</tt> jest wręcz jedyną instancją swojej klasy.
</blockquote>

Niektóre klasy są ,,szczególnymi przypadkami" innych klas — mówi się, że klasa C ''dziedziczy'' z klasy B, lub że jest ''podklasą'' klasy B. Oznacza to tyle, że instancje klasy C posiadają wszystkie atrybuty i metody jakie posiadają instancje klasy B, ale być może pewne dodatkowe — a być może niektóre z nich zostały w jakiś sposób zmodyfikowane. Przykładowo, klasa <tt>bool</tt> stanowi podklasę klasy <tt>int</tt>; jej jedynie instancje, <tt>True</tt> i <tt>False</tt>, to ,,tak naprawdę" liczby (odpowiednio) 1 i 0 ,,w przebraniu". Są one więc również instancjami klasy <tt>int</tt> i można do nich stosować te same operacje (np. arytmetyczne) co do liczb całkowitych.

''CDN''

== O generatorach ==

W jednym z poprzednich rozdziałów [[PPy3/Kolekcje#Przyk.C5.82ad:_suma_cyfr|poznaliśmy wyrażenia generatorowe]]. Przypomnijmy, że stanowią one uproszczony zapis iteracji, pozwalający na uniknięcie w wielu prostych przypadkach pętli <tt>for</tt> i tworzenia zmiennych pomocniczych. Przykładowo:

<source lang=python>
kwadraty = (x**2 for x in range(100))
</source>

tworzy generator, ''produkujący'' w iteracji kwadraty kolejnych liczb naturalnych (od 0 do 99).

Poważnym ograniczeniem wyrażeń generatorowych jest to, że można ich używać do przekształcenia jednego obiektu iterowalnego w drugi — w tym przypadku, ciągu liczb naturalnych w ciąg ich kwadratów, natomiast nie ma jak za pomocą wyrażenia generatorowego stworzyć obiektu iterowalnego ,,od zera". Można to uzyskać, stosując ogólniejszą konstrukcję:

<source lang=python>
def gen_kwadraty(start=0):
k = start
while True:
yield k**2
k += 1

kwadraty = gen_kwadraty()
</source>

To, co napisałem powyżej przypomina bardzo definicję funkcji; jedyną różnicą na poziomie składni jest wystąpienie w definicji słowa <tt>yield</tt> (i brak wystąpienia słowa <tt>return</tt>). W istocie <tt>gen_kwadraty</tt> można uważać za funkcję — której wywołanie zwraca generator: obiekt, którego iteracja dostarczy kwadratów kolejnych liczb naturalnych, począwszy od liczby <tt>start</tt>, argumentu wywołania, o domyślnej wartości zero. Zauważmy, że w budowie definicji nie użyliśmy obiektu <tt>range</tt>; użyliśmy za to jawnej pętli <tt>while</tt>, niejako opakowując ją w generator. Co więc w ten sposób zyskujemy?

Przede wszystkim wielką elastyczność. W pokazanym przykładzie zysk jest niewielki, ale w definicji generatora możemy użyć jakiejkolwiek bądź reguły tworzenia kolejnych elementów iteracji. Nie potrzebujemy utworzyć ich wszystkich zanim zaczniemy z nich korzystać — tak jak byłoby w przypadku, gdybyśmy <tt>gen_kwadraty</tt> zdefiniowali jako funkcję zwracającą listę kwadratów kolejnych liczb. Co więcej, iteracja zapewniona przez <tt>gen_kwadraty</tt> może nam dostarczyć dowolnie wielu elementów (oczywiście w realnym komputerze po dostatecznie długim czasie osiągnięto by liczby, których wielkość przekroczyłaby pojemność dostępnej pamięci operacyjnej). Decyzja o tym, kiedy przerwać iterację pozostawiona jest ,,użytkownikowi", tzn. kodowi odwołującemu się do obiektu <tt>kwadraty</tt>.

----

[[PPy3/Matplotlib|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/DobrePraktyki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:26, 27 mar 2018 (CEST)

PPy3/TematyDodatkowe

2023-06-29T12:02:41Z

RobertJB: /* Trochę więcej o klasach i obiektach */

= Tematy dodatkowe =

== Błędy i wyjątki ==

Każdy programista popełnia błędy — jest to nieunikniona część tej działalności.

*Są błędy, które można nazwać banalnymi: literówka w nazwie lub słowie kluczowym, zapomniany dwukropek, niedomknięte nawiasy, itp.
*Są bardziej podstępne błędy logiczne: gdy algorytm, którego zapisem ma być tworzony kod, po prostu nie robi dokładnie tego, co nam się wydaje.
*I w końcu są sytuacje wyjątkowe: gdy w toku pracy programu zachodzą nieoczekiwane okoliczności — użytkownik podał błędną nazwę pliku z danymi, zawartość tego pliku nie jest zgodna z oczekiwaniami programu, połączenie sieciowe ulega przerwaniu w trakcie pobierania lub przesyłania danych, itp.

Wszystkie te sytuacje nazywa się wyjątkami, i tym samym słowem określa się mechanizm, jakiego wiele współczesnych języków programowania (w tym Python) dostarcza programiście, aby mu pomóc określić działania jakie program miałby podjąć w sytuacjach wyjątkowych. Wyjątkowość takich sytuacji generalnie polega na tym, że w przypadku ich wystąpienia program po prostu nie może kontynuować przewidzianego toku działania:

*błąd w składni programu oznacza, że kod nie daje się zinterpretować w sposób jednoznaczny; najlepsze co można zrobić, to w momencie wykrycia błędu przerwać działanie i spróbować dostarczyć programiście (w formie komunikatu) informację ułatwiającą określenie i naprawienie błędu;
*błędne działanie algorytmu można np. spróbować wykrywać za pomocą tzw. asercji (polecenie ''assert'') badających, czy pewne warunki, jakie powinny być spełnione przez dane przetwarzane w programie są istotnie spełnione;
*wyjątki powstałe na skutek okoliczności zachodzących w trakcie działania programu, uniemożliwiających jego normalną kontynuację, można spróbować przewidzieć i przygotować program do odpowiedniego zareagowania, czyli ''obsługi wyjątku''. Na przykład, można spróbować ponowić jeszcze raz (lub kilka razy) próbę łączności sieciowej, i poddać się dopiero po określonej liczbie niepowodzeń; natomiast w sytuacji błędu wynikającego z podania przez użytkownika programu niewłaściwych argumentów uruchomienia, warto postarać się o przekazanie użytkownikowi komunikatu informującego go w sposób dla niego zrozumiały, o właściwym sposobie uruchamiania programu.

=== Błędy składniowe i podobne ===

Jak wspomniano powyżej, w przypadku napotkania błędu składniowego w kodzie programu interpreter natychmiast przerwie wykonywanie programu i wypisze komunikat. Komunikaty te '''warto czytać uważnie''' — w większości przypadków znajduje się w nich cała informacja konieczna dla naprawienia błędu. Przykład: usiłujemy uruchomić program <tt>błąd.py</tt>, którego treść to

<source lang=python>
x = (2 + 3) 4
print x
</source>

Wynik pierwszej próby to:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 1
x = (2 + 3) 4
^
SyntaxError: invalid syntax
</source>

Z komunikatu całkiem jasno wynika, że napotkany został błąd składni (''SyntaxError''), że wykryto ten błąd w linijce 1, a nawet dokładnie — że miejscem, w którym interpreter stwierdził, że ma do czynienia z nieprawidłowy kodem, było wystąpienie cyfry 4 po zamykającym nawiasie. Po prostu zapomnieliśmy, że — inaczej niż w powszechnie stosowanej notacji matematycznej — w Pythonie aby uzyskać mnożenie, konieczne jest napisanie jawnie znaku operatora (gwiazdki).

Po naprawieniu tej pomyłki próbujemy jeszcze raz, i wynik to:
<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 2
print x
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(x)?
</source>

Tutaj już jaśniej być nie może; interpreter nie tylko wskazał nam dokładne miejsce wystąpienia błędu, ale nawet dokładnie opisał, jak go naprawić.

Oczywiście nie zawsze interpreter będzie w stanie wskazać nam błąd aż tak precyzyjnie. Jako przykład weźmy następujący plik:

<source lang=python>
x, y, z = 3, 4, 5
print(max(x, y, z)
print(X * y * z)
</source>

i wynik jego uruchomienia:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 3
print(X * y * z)
^
SyntaxError: invalid syntax
</source>

Dlaczego został wytknięty błąd składniowy w linijce 3? Przecież to w linijce 2 zapomnieliśmy zamknąć jeden z nawiasów.

Otóż jeżeli z końcem linii Python stwierdza, że nie wszystkie dotąd otwarte nawiasy zostały zamknięte, to traktuje to jako oznaczające, że kolejną linijkę należy potraktować jako ciąg dalszy bieżącej. I w tym przypadku dopiero napotykając w kolejnej linijce nazwę <tt>print</tt> — a nie np. przecinek, albo nawias zamykający — stwierdza, że coś musi być nie tak. Miejsce wykrycia błędu niestety nie zawsze się będzie pokrywało z miejscem jego faktycznego wystąpienia.

Po poprawce, czyli zamknięciu nawiasu na linii 2, próbujemy jeszcze raz — z wynikiem

<source lang=bash>
python3 błąd.py
5
Traceback (most recent call last):
File "błąd.py", line 3, in <module>
print(X * y * z)
NameError: name 'X' is not defined
</source>

I tym razem chyba jest wszystko jasne: pojawiła się nazwa <tt>X</tt>, z którą wcześniej nie związano żadnej wartości. Po prostu przez pomyłkę napisaliśmy X wielką literą zamiast małą.

Te przykłady pokazują, że przy wykorzystaniu treści wypisywanych komunikatów proces usunięcia z programu błędów składniowych i formalnych może być dość szybki i bezbolesny.

<blockquote>
Pojawiły się w komunikatach określenia: <tt>SyntaxError</tt>, <tt>NameError</tt>. Są to przykłady nazw tzw. klas wyjątków, czyli ogólnie rozumianych kategorii błędów, jakie są sygnalizowane. Wkrótce spotkamy dalsze klasy wyjątków, takie jak: <tt>TypeError</tt> - związana z przekazaniem wielkości niewłaściwego typu, czy <tt>ValueError</tt> - gdy nie typ. ale wartość wielkości, na której usiłuje się operować, jest niewłaściwa dla danej operacji. Dowiemy się również, dlaczego klasy wyjątków są przydatne — pomimo tego, iż dla ludzkich oczu zwykle bardziej przydatna jest słowna informacja uszczegółowiająca (to co pojawia się po nazwie klasy wyjątku i dwukropku).
</blockquote>

=== Asercje ===

Polecenie <tt>assert</tt> ma następującą postać:

<source lang=python>
assert wyrażenie1
# lub:
assert wyrażenie1, wyrażenie2
</source>

i jest to jak widać polecenie proste (nie zawierające bloku poleceń z wcięciem).

Jego działanie jest takie, że: obliczona zostanie wartość <tt>wyrażenie1</tt>; jeżeli jest ona prawdziwa, nie dzieje się nic (następuje natychmiastowe przejście do kolejnej linijki kodu). Jeżeli okaże się fałszywa, zostanie zasygnalizowany wyjątek, klasy <tt>AssertionError</tt>, co domyślnie przerywa wykonywanie programu i powoduje wypisanie odpowiedniego komunikatu. Jeżeli zastosujemy drugą postać, obliczona zostanie również wartość <tt>wyrażenie2</tt> i wypisana (dokładniej: jej reprezentacja napisowa) jako część komunikatu.

Przyjęło się stosować asercje jako sposób kontroli poprawności działania programu — w tym sensie, aby wykluczyć sytuacje „niemożliwe", tj. powstałe w wyniku błędu programisty. Ze względu na prostotę składni warto też z nich korzystać w kodzie służącym do testowania poprawności innego kodu (czyli np. w funkcjach testujących, czy inne, bardziej złożone funkcje dają poprawne wyniki w prostych sytuacjach próbnych).

=== Wyjątki w trakcie pracy programu ===

Wyjątki występujące w trakcie pracy programu można przechwycić i obsłużyć za pomocą następującej konstrukcji (polecenia złożonego):

<source lang=python>
try:
# operacje mogące spowodować wyjątek
except (KlasaWyjątku1, KlasaWyjątku2, ...):
# co zrobić jeśli wyjątek jednej z tych klas wystąpił
else:
# co zrobić jeśli nie było wyjątku
finally:
# co zrobić w KAŻDYM przypadku
</source>

*bloki <tt>else:</tt> i <tt>finally:</tt> są nieobowiązkowe, tj. możemy je pominąć (wraz z odp. linijką wprowadzającą)
*w bloku <tt>except:</tt> można podać jedną klasę wyjątku (wtedy zbędne są nawiasy), lub żadnej — wtedy przechwycimy ''każdy'' wyjątek; jeśli jednak chcemy, jak w przykładzie, wymienić więcej niż jedną klasę, to nawiasy są konieczne
*skuteczne przechwycenie wyjątku sprawia, że wykonanie programu nie ulegnie przerwaniu w punkcie jego wystąpienia, tyko będzie kontynuowane, również po opuszczeniu bloku <tt>try:</tt>
*można jednak spowodować, aby po wykonaniu czynności obsługi wyjątku, wyjątek został niejako ''wznowiony''; wystarczy w bloku <tt>except:</tt> wywołać instrukcję <tt>raise</tt>. Dla większości klas wyjątków skutkuje to zakończeniem programu
*instrukcję <tt>raise</tt> można wywołać również w dowolnym innym punkcie programu, powinna wówczas w niej wystąpić nazwa klasy wyjątku, jaki chcemy wywołać.

Przykłady:

''CDN.''

== Trochę więcej o klasach i obiektach ==

Warto sobie zdawać sprawę, że każda wartość występująca w programie pythonowym jest obiektem — a więc jest wyposażona w zestaw atrybutów i metod. Dotyczy to nie tylko kolekcji (list, słowników, ...), obiektów takich jak otwarte pliki (wynik wywołania funkcji <tt>open()</tt>), napisów — ale również np. liczb, czy to całkowitych, czy zmiennoprzecinkowych (i zespolonych, o których nie było tutaj mowy).

Przykładowo:

<source lang=python>
(17).bit_length()
→ 5
(17).bit_count()
→ 2
</source>

Co to właściwie znaczy?

Dla liczby 17 wywołaliśmy najpierw metodę, który mówi nam jak jest długość w bitach reprezentacji dwójkowej tej liczby (<tt>17 == 0b10001</tt>), a następnie metodę, zwracającą liczbę ''ustawionych'' (tj. równych jeden) bitów w tej reprezentacji. Nawiasy okrągłe są konieczne, ponieważ kropka po cyfrach oznaczałaby, że mamy do czynienia z zapisem liczby zmiennoprzecinkowej. Inaczej mówiąc, byłyby niepotrzebne gdybyśmy mieli do czynienia z nazwą oznaczającą liczbę całkowitą, a nie z jej zapisem dziesiętnym.

== O generatorach ==

W jednym z poprzednich rozdziałów [[PPy3/Kolekcje#Przyk.C5.82ad:_suma_cyfr|poznaliśmy wyrażenia generatorowe]]. Przypomnijmy, że stanowią one uproszczony zapis iteracji, pozwalający na uniknięcie w wielu prostych przypadkach pętli <tt>for</tt> i tworzenia zmiennych pomocniczych. Przykładowo:

<source lang=python>
kwadraty = (x**2 for x in range(100))
</source>

tworzy generator, ''produkujący'' w iteracji kwadraty kolejnych liczb naturalnych (od 0 do 99).

Poważnym ograniczeniem wyrażeń generatorowych jest to, że można ich używać do przekształcenia jednego obiektu iterowalnego w drugi — w tym przypadku, ciągu liczb naturalnych w ciąg ich kwadratów, natomiast nie ma jak za pomocą wyrażenia generatorowego stworzyć obiektu iterowalnego ,,od zera". Można to uzyskać, stosując ogólniejszą konstrukcję:

<source lang=python>
def gen_kwadraty(start=0):
k = start
while True:
yield k**2
k += 1

kwadraty = gen_kwadraty()
</source>

To, co napisałem powyżej przypomina bardzo definicję funkcji; jedyną różnicą na poziomie składni jest wystąpienie w definicji słowa <tt>yield</tt> (i brak wystąpienia słowa <tt>return</tt>). W istocie <tt>gen_kwadraty</tt> można uważać za funkcję — której wywołanie zwraca generator: obiekt, którego iteracja dostarczy kwadratów kolejnych liczb naturalnych, począwszy od liczby <tt>start</tt>, argumentu wywołania, o domyślnej wartości zero. Zauważmy, że w budowie definicji nie użyliśmy obiektu <tt>range</tt>; użyliśmy za to jawnej pętli <tt>while</tt>, niejako opakowując ją w generator. Co więc w ten sposób zyskujemy?

Przede wszystkim wielką elastyczność. W pokazanym przykładzie zysk jest niewielki, ale w definicji generatora możemy użyć jakiejkolwiek bądź reguły tworzenia kolejnych elementów iteracji. Nie potrzebujemy utworzyć ich wszystkich zanim zaczniemy z nich korzystać — tak jak byłoby w przypadku, gdybyśmy <tt>gen_kwadraty</tt> zdefiniowali jako funkcję zwracającą listę kwadratów kolejnych liczb. Co więcej, iteracja zapewniona przez <tt>gen_kwadraty</tt> może nam dostarczyć dowolnie wielu elementów (oczywiście w realnym komputerze po dostatecznie długim czasie osiągnięto by liczby, których wielkość przekroczyłaby pojemność dostępnej pamięci operacyjnej). Decyzja o tym, kiedy przerwać iterację pozostawiona jest ,,użytkownikowi", tzn. kodowi odwołującemu się do obiektu <tt>kwadraty</tt>.

----

[[PPy3/Matplotlib|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/DobrePraktyki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:26, 27 mar 2018 (CEST)

PPy3/TematyDodatkowe

2023-06-29T12:01:53Z

RobertJB: /* Trochę więcej o klasach i obiektach */

= Tematy dodatkowe =

== Błędy i wyjątki ==

Każdy programista popełnia błędy — jest to nieunikniona część tej działalności.

*Są błędy, które można nazwać banalnymi: literówka w nazwie lub słowie kluczowym, zapomniany dwukropek, niedomknięte nawiasy, itp.
*Są bardziej podstępne błędy logiczne: gdy algorytm, którego zapisem ma być tworzony kod, po prostu nie robi dokładnie tego, co nam się wydaje.
*I w końcu są sytuacje wyjątkowe: gdy w toku pracy programu zachodzą nieoczekiwane okoliczności — użytkownik podał błędną nazwę pliku z danymi, zawartość tego pliku nie jest zgodna z oczekiwaniami programu, połączenie sieciowe ulega przerwaniu w trakcie pobierania lub przesyłania danych, itp.

Wszystkie te sytuacje nazywa się wyjątkami, i tym samym słowem określa się mechanizm, jakiego wiele współczesnych języków programowania (w tym Python) dostarcza programiście, aby mu pomóc określić działania jakie program miałby podjąć w sytuacjach wyjątkowych. Wyjątkowość takich sytuacji generalnie polega na tym, że w przypadku ich wystąpienia program po prostu nie może kontynuować przewidzianego toku działania:

*błąd w składni programu oznacza, że kod nie daje się zinterpretować w sposób jednoznaczny; najlepsze co można zrobić, to w momencie wykrycia błędu przerwać działanie i spróbować dostarczyć programiście (w formie komunikatu) informację ułatwiającą określenie i naprawienie błędu;
*błędne działanie algorytmu można np. spróbować wykrywać za pomocą tzw. asercji (polecenie ''assert'') badających, czy pewne warunki, jakie powinny być spełnione przez dane przetwarzane w programie są istotnie spełnione;
*wyjątki powstałe na skutek okoliczności zachodzących w trakcie działania programu, uniemożliwiających jego normalną kontynuację, można spróbować przewidzieć i przygotować program do odpowiedniego zareagowania, czyli ''obsługi wyjątku''. Na przykład, można spróbować ponowić jeszcze raz (lub kilka razy) próbę łączności sieciowej, i poddać się dopiero po określonej liczbie niepowodzeń; natomiast w sytuacji błędu wynikającego z podania przez użytkownika programu niewłaściwych argumentów uruchomienia, warto postarać się o przekazanie użytkownikowi komunikatu informującego go w sposób dla niego zrozumiały, o właściwym sposobie uruchamiania programu.

=== Błędy składniowe i podobne ===

Jak wspomniano powyżej, w przypadku napotkania błędu składniowego w kodzie programu interpreter natychmiast przerwie wykonywanie programu i wypisze komunikat. Komunikaty te '''warto czytać uważnie''' — w większości przypadków znajduje się w nich cała informacja konieczna dla naprawienia błędu. Przykład: usiłujemy uruchomić program <tt>błąd.py</tt>, którego treść to

<source lang=python>
x = (2 + 3) 4
print x
</source>

Wynik pierwszej próby to:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 1
x = (2 + 3) 4
^
SyntaxError: invalid syntax
</source>

Z komunikatu całkiem jasno wynika, że napotkany został błąd składni (''SyntaxError''), że wykryto ten błąd w linijce 1, a nawet dokładnie — że miejscem, w którym interpreter stwierdził, że ma do czynienia z nieprawidłowy kodem, było wystąpienie cyfry 4 po zamykającym nawiasie. Po prostu zapomnieliśmy, że — inaczej niż w powszechnie stosowanej notacji matematycznej — w Pythonie aby uzyskać mnożenie, konieczne jest napisanie jawnie znaku operatora (gwiazdki).

Po naprawieniu tej pomyłki próbujemy jeszcze raz, i wynik to:
<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 2
print x
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(x)?
</source>

Tutaj już jaśniej być nie może; interpreter nie tylko wskazał nam dokładne miejsce wystąpienia błędu, ale nawet dokładnie opisał, jak go naprawić.

Oczywiście nie zawsze interpreter będzie w stanie wskazać nam błąd aż tak precyzyjnie. Jako przykład weźmy następujący plik:

<source lang=python>
x, y, z = 3, 4, 5
print(max(x, y, z)
print(X * y * z)
</source>

i wynik jego uruchomienia:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 3
print(X * y * z)
^
SyntaxError: invalid syntax
</source>

Dlaczego został wytknięty błąd składniowy w linijce 3? Przecież to w linijce 2 zapomnieliśmy zamknąć jeden z nawiasów.

Otóż jeżeli z końcem linii Python stwierdza, że nie wszystkie dotąd otwarte nawiasy zostały zamknięte, to traktuje to jako oznaczające, że kolejną linijkę należy potraktować jako ciąg dalszy bieżącej. I w tym przypadku dopiero napotykając w kolejnej linijce nazwę <tt>print</tt> — a nie np. przecinek, albo nawias zamykający — stwierdza, że coś musi być nie tak. Miejsce wykrycia błędu niestety nie zawsze się będzie pokrywało z miejscem jego faktycznego wystąpienia.

Po poprawce, czyli zamknięciu nawiasu na linii 2, próbujemy jeszcze raz — z wynikiem

<source lang=bash>
python3 błąd.py
5
Traceback (most recent call last):
File "błąd.py", line 3, in <module>
print(X * y * z)
NameError: name 'X' is not defined
</source>

I tym razem chyba jest wszystko jasne: pojawiła się nazwa <tt>X</tt>, z którą wcześniej nie związano żadnej wartości. Po prostu przez pomyłkę napisaliśmy X wielką literą zamiast małą.

Te przykłady pokazują, że przy wykorzystaniu treści wypisywanych komunikatów proces usunięcia z programu błędów składniowych i formalnych może być dość szybki i bezbolesny.

<blockquote>
Pojawiły się w komunikatach określenia: <tt>SyntaxError</tt>, <tt>NameError</tt>. Są to przykłady nazw tzw. klas wyjątków, czyli ogólnie rozumianych kategorii błędów, jakie są sygnalizowane. Wkrótce spotkamy dalsze klasy wyjątków, takie jak: <tt>TypeError</tt> - związana z przekazaniem wielkości niewłaściwego typu, czy <tt>ValueError</tt> - gdy nie typ. ale wartość wielkości, na której usiłuje się operować, jest niewłaściwa dla danej operacji. Dowiemy się również, dlaczego klasy wyjątków są przydatne — pomimo tego, iż dla ludzkich oczu zwykle bardziej przydatna jest słowna informacja uszczegółowiająca (to co pojawia się po nazwie klasy wyjątku i dwukropku).
</blockquote>

=== Asercje ===

Polecenie <tt>assert</tt> ma następującą postać:

<source lang=python>
assert wyrażenie1
# lub:
assert wyrażenie1, wyrażenie2
</source>

i jest to jak widać polecenie proste (nie zawierające bloku poleceń z wcięciem).

Jego działanie jest takie, że: obliczona zostanie wartość <tt>wyrażenie1</tt>; jeżeli jest ona prawdziwa, nie dzieje się nic (następuje natychmiastowe przejście do kolejnej linijki kodu). Jeżeli okaże się fałszywa, zostanie zasygnalizowany wyjątek, klasy <tt>AssertionError</tt>, co domyślnie przerywa wykonywanie programu i powoduje wypisanie odpowiedniego komunikatu. Jeżeli zastosujemy drugą postać, obliczona zostanie również wartość <tt>wyrażenie2</tt> i wypisana (dokładniej: jej reprezentacja napisowa) jako część komunikatu.

Przyjęło się stosować asercje jako sposób kontroli poprawności działania programu — w tym sensie, aby wykluczyć sytuacje „niemożliwe", tj. powstałe w wyniku błędu programisty. Ze względu na prostotę składni warto też z nich korzystać w kodzie służącym do testowania poprawności innego kodu (czyli np. w funkcjach testujących, czy inne, bardziej złożone funkcje dają poprawne wyniki w prostych sytuacjach próbnych).

=== Wyjątki w trakcie pracy programu ===

Wyjątki występujące w trakcie pracy programu można przechwycić i obsłużyć za pomocą następującej konstrukcji (polecenia złożonego):

<source lang=python>
try:
# operacje mogące spowodować wyjątek
except (KlasaWyjątku1, KlasaWyjątku2, ...):
# co zrobić jeśli wyjątek jednej z tych klas wystąpił
else:
# co zrobić jeśli nie było wyjątku
finally:
# co zrobić w KAŻDYM przypadku
</source>

*bloki <tt>else:</tt> i <tt>finally:</tt> są nieobowiązkowe, tj. możemy je pominąć (wraz z odp. linijką wprowadzającą)
*w bloku <tt>except:</tt> można podać jedną klasę wyjątku (wtedy zbędne są nawiasy), lub żadnej — wtedy przechwycimy ''każdy'' wyjątek; jeśli jednak chcemy, jak w przykładzie, wymienić więcej niż jedną klasę, to nawiasy są konieczne
*skuteczne przechwycenie wyjątku sprawia, że wykonanie programu nie ulegnie przerwaniu w punkcie jego wystąpienia, tyko będzie kontynuowane, również po opuszczeniu bloku <tt>try:</tt>
*można jednak spowodować, aby po wykonaniu czynności obsługi wyjątku, wyjątek został niejako ''wznowiony''; wystarczy w bloku <tt>except:</tt> wywołać instrukcję <tt>raise</tt>. Dla większości klas wyjątków skutkuje to zakończeniem programu
*instrukcję <tt>raise</tt> można wywołać również w dowolnym innym punkcie programu, powinna wówczas w niej wystąpić nazwa klasy wyjątku, jaki chcemy wywołać.

Przykłady:

''CDN.''

== Trochę więcej o klasach i obiektach ==

Warto sobie zdawać sprawę, że każda wartość występująca w programie pythonowym jest obiektem — a więc jest wyposażona w zestaw atrybutów i metod. Dotyczy to nie tylko kolekcji (list, słowników, ...), obiektów takich jak otwarte pliki (wynik wywołania funkcji <tt>open()</tt>), napisów — ale również np. liczb, czy to całkowitych, czy zmiennoprzecinkowych (i zespolonych, o których nie było tutaj mowy).

Przykładowo:

<source lang=python>
(17).bit_length()
→ 5
(17).bit_count()
→ 2
</source>

Co to właściwie znaczy?

Dla liczby 17 wywołaliśmy najpierw metodę, który mówi nam jak jest długość w bitach reprezentacji dwójkowej tej liczby (<tt>17 == 0b10001</tt>), a następnie metodę, zwracającą liczbę *ustawionych* (tj. równych jeden) bitów w tej reprezentacji. Nawiasy okrągłe są konieczne, ponieważ kropka po cyfrach oznaczałaby, że mamy do czynienia z zapisem liczby zmiennoprzecinkowej. Inaczej mówiąc, byłyby niepotrzebne gdybyśmy mieli do czynienia z nazwą oznaczającą liczbę całkowitą, a nie z jej zapisem dziesiętnym.

== O generatorach ==

W jednym z poprzednich rozdziałów [[PPy3/Kolekcje#Przyk.C5.82ad:_suma_cyfr|poznaliśmy wyrażenia generatorowe]]. Przypomnijmy, że stanowią one uproszczony zapis iteracji, pozwalający na uniknięcie w wielu prostych przypadkach pętli <tt>for</tt> i tworzenia zmiennych pomocniczych. Przykładowo:

<source lang=python>
kwadraty = (x**2 for x in range(100))
</source>

tworzy generator, ''produkujący'' w iteracji kwadraty kolejnych liczb naturalnych (od 0 do 99).

Poważnym ograniczeniem wyrażeń generatorowych jest to, że można ich używać do przekształcenia jednego obiektu iterowalnego w drugi — w tym przypadku, ciągu liczb naturalnych w ciąg ich kwadratów, natomiast nie ma jak za pomocą wyrażenia generatorowego stworzyć obiektu iterowalnego ,,od zera". Można to uzyskać, stosując ogólniejszą konstrukcję:

<source lang=python>
def gen_kwadraty(start=0):
k = start
while True:
yield k**2
k += 1

kwadraty = gen_kwadraty()
</source>

To, co napisałem powyżej przypomina bardzo definicję funkcji; jedyną różnicą na poziomie składni jest wystąpienie w definicji słowa <tt>yield</tt> (i brak wystąpienia słowa <tt>return</tt>). W istocie <tt>gen_kwadraty</tt> można uważać za funkcję — której wywołanie zwraca generator: obiekt, którego iteracja dostarczy kwadratów kolejnych liczb naturalnych, począwszy od liczby <tt>start</tt>, argumentu wywołania, o domyślnej wartości zero. Zauważmy, że w budowie definicji nie użyliśmy obiektu <tt>range</tt>; użyliśmy za to jawnej pętli <tt>while</tt>, niejako opakowując ją w generator. Co więc w ten sposób zyskujemy?

Przede wszystkim wielką elastyczność. W pokazanym przykładzie zysk jest niewielki, ale w definicji generatora możemy użyć jakiejkolwiek bądź reguły tworzenia kolejnych elementów iteracji. Nie potrzebujemy utworzyć ich wszystkich zanim zaczniemy z nich korzystać — tak jak byłoby w przypadku, gdybyśmy <tt>gen_kwadraty</tt> zdefiniowali jako funkcję zwracającą listę kwadratów kolejnych liczb. Co więcej, iteracja zapewniona przez <tt>gen_kwadraty</tt> może nam dostarczyć dowolnie wielu elementów (oczywiście w realnym komputerze po dostatecznie długim czasie osiągnięto by liczby, których wielkość przekroczyłaby pojemność dostępnej pamięci operacyjnej). Decyzja o tym, kiedy przerwać iterację pozostawiona jest ,,użytkownikowi", tzn. kodowi odwołującemu się do obiektu <tt>kwadraty</tt>.

----

[[PPy3/Matplotlib|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/DobrePraktyki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:26, 27 mar 2018 (CEST)

PPy3/TematyDodatkowe

2023-06-29T12:01:28Z

RobertJB: /* Trochę więcej o klasach i obiektach */

= Tematy dodatkowe =

== Błędy i wyjątki ==

Każdy programista popełnia błędy — jest to nieunikniona część tej działalności.

*Są błędy, które można nazwać banalnymi: literówka w nazwie lub słowie kluczowym, zapomniany dwukropek, niedomknięte nawiasy, itp.
*Są bardziej podstępne błędy logiczne: gdy algorytm, którego zapisem ma być tworzony kod, po prostu nie robi dokładnie tego, co nam się wydaje.
*I w końcu są sytuacje wyjątkowe: gdy w toku pracy programu zachodzą nieoczekiwane okoliczności — użytkownik podał błędną nazwę pliku z danymi, zawartość tego pliku nie jest zgodna z oczekiwaniami programu, połączenie sieciowe ulega przerwaniu w trakcie pobierania lub przesyłania danych, itp.

Wszystkie te sytuacje nazywa się wyjątkami, i tym samym słowem określa się mechanizm, jakiego wiele współczesnych języków programowania (w tym Python) dostarcza programiście, aby mu pomóc określić działania jakie program miałby podjąć w sytuacjach wyjątkowych. Wyjątkowość takich sytuacji generalnie polega na tym, że w przypadku ich wystąpienia program po prostu nie może kontynuować przewidzianego toku działania:

*błąd w składni programu oznacza, że kod nie daje się zinterpretować w sposób jednoznaczny; najlepsze co można zrobić, to w momencie wykrycia błędu przerwać działanie i spróbować dostarczyć programiście (w formie komunikatu) informację ułatwiającą określenie i naprawienie błędu;
*błędne działanie algorytmu można np. spróbować wykrywać za pomocą tzw. asercji (polecenie ''assert'') badających, czy pewne warunki, jakie powinny być spełnione przez dane przetwarzane w programie są istotnie spełnione;
*wyjątki powstałe na skutek okoliczności zachodzących w trakcie działania programu, uniemożliwiających jego normalną kontynuację, można spróbować przewidzieć i przygotować program do odpowiedniego zareagowania, czyli ''obsługi wyjątku''. Na przykład, można spróbować ponowić jeszcze raz (lub kilka razy) próbę łączności sieciowej, i poddać się dopiero po określonej liczbie niepowodzeń; natomiast w sytuacji błędu wynikającego z podania przez użytkownika programu niewłaściwych argumentów uruchomienia, warto postarać się o przekazanie użytkownikowi komunikatu informującego go w sposób dla niego zrozumiały, o właściwym sposobie uruchamiania programu.

=== Błędy składniowe i podobne ===

Jak wspomniano powyżej, w przypadku napotkania błędu składniowego w kodzie programu interpreter natychmiast przerwie wykonywanie programu i wypisze komunikat. Komunikaty te '''warto czytać uważnie''' — w większości przypadków znajduje się w nich cała informacja konieczna dla naprawienia błędu. Przykład: usiłujemy uruchomić program <tt>błąd.py</tt>, którego treść to

<source lang=python>
x = (2 + 3) 4
print x
</source>

Wynik pierwszej próby to:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 1
x = (2 + 3) 4
^
SyntaxError: invalid syntax
</source>

Z komunikatu całkiem jasno wynika, że napotkany został błąd składni (''SyntaxError''), że wykryto ten błąd w linijce 1, a nawet dokładnie — że miejscem, w którym interpreter stwierdził, że ma do czynienia z nieprawidłowy kodem, było wystąpienie cyfry 4 po zamykającym nawiasie. Po prostu zapomnieliśmy, że — inaczej niż w powszechnie stosowanej notacji matematycznej — w Pythonie aby uzyskać mnożenie, konieczne jest napisanie jawnie znaku operatora (gwiazdki).

Po naprawieniu tej pomyłki próbujemy jeszcze raz, i wynik to:
<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 2
print x
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(x)?
</source>

Tutaj już jaśniej być nie może; interpreter nie tylko wskazał nam dokładne miejsce wystąpienia błędu, ale nawet dokładnie opisał, jak go naprawić.

Oczywiście nie zawsze interpreter będzie w stanie wskazać nam błąd aż tak precyzyjnie. Jako przykład weźmy następujący plik:

<source lang=python>
x, y, z = 3, 4, 5
print(max(x, y, z)
print(X * y * z)
</source>

i wynik jego uruchomienia:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 3
print(X * y * z)
^
SyntaxError: invalid syntax
</source>

Dlaczego został wytknięty błąd składniowy w linijce 3? Przecież to w linijce 2 zapomnieliśmy zamknąć jeden z nawiasów.

Otóż jeżeli z końcem linii Python stwierdza, że nie wszystkie dotąd otwarte nawiasy zostały zamknięte, to traktuje to jako oznaczające, że kolejną linijkę należy potraktować jako ciąg dalszy bieżącej. I w tym przypadku dopiero napotykając w kolejnej linijce nazwę <tt>print</tt> — a nie np. przecinek, albo nawias zamykający — stwierdza, że coś musi być nie tak. Miejsce wykrycia błędu niestety nie zawsze się będzie pokrywało z miejscem jego faktycznego wystąpienia.

Po poprawce, czyli zamknięciu nawiasu na linii 2, próbujemy jeszcze raz — z wynikiem

<source lang=bash>
python3 błąd.py
5
Traceback (most recent call last):
File "błąd.py", line 3, in <module>
print(X * y * z)
NameError: name 'X' is not defined
</source>

I tym razem chyba jest wszystko jasne: pojawiła się nazwa <tt>X</tt>, z którą wcześniej nie związano żadnej wartości. Po prostu przez pomyłkę napisaliśmy X wielką literą zamiast małą.

Te przykłady pokazują, że przy wykorzystaniu treści wypisywanych komunikatów proces usunięcia z programu błędów składniowych i formalnych może być dość szybki i bezbolesny.

<blockquote>
Pojawiły się w komunikatach określenia: <tt>SyntaxError</tt>, <tt>NameError</tt>. Są to przykłady nazw tzw. klas wyjątków, czyli ogólnie rozumianych kategorii błędów, jakie są sygnalizowane. Wkrótce spotkamy dalsze klasy wyjątków, takie jak: <tt>TypeError</tt> - związana z przekazaniem wielkości niewłaściwego typu, czy <tt>ValueError</tt> - gdy nie typ. ale wartość wielkości, na której usiłuje się operować, jest niewłaściwa dla danej operacji. Dowiemy się również, dlaczego klasy wyjątków są przydatne — pomimo tego, iż dla ludzkich oczu zwykle bardziej przydatna jest słowna informacja uszczegółowiająca (to co pojawia się po nazwie klasy wyjątku i dwukropku).
</blockquote>

=== Asercje ===

Polecenie <tt>assert</tt> ma następującą postać:

<source lang=python>
assert wyrażenie1
# lub:
assert wyrażenie1, wyrażenie2
</source>

i jest to jak widać polecenie proste (nie zawierające bloku poleceń z wcięciem).

Jego działanie jest takie, że: obliczona zostanie wartość <tt>wyrażenie1</tt>; jeżeli jest ona prawdziwa, nie dzieje się nic (następuje natychmiastowe przejście do kolejnej linijki kodu). Jeżeli okaże się fałszywa, zostanie zasygnalizowany wyjątek, klasy <tt>AssertionError</tt>, co domyślnie przerywa wykonywanie programu i powoduje wypisanie odpowiedniego komunikatu. Jeżeli zastosujemy drugą postać, obliczona zostanie również wartość <tt>wyrażenie2</tt> i wypisana (dokładniej: jej reprezentacja napisowa) jako część komunikatu.

Przyjęło się stosować asercje jako sposób kontroli poprawności działania programu — w tym sensie, aby wykluczyć sytuacje „niemożliwe", tj. powstałe w wyniku błędu programisty. Ze względu na prostotę składni warto też z nich korzystać w kodzie służącym do testowania poprawności innego kodu (czyli np. w funkcjach testujących, czy inne, bardziej złożone funkcje dają poprawne wyniki w prostych sytuacjach próbnych).

=== Wyjątki w trakcie pracy programu ===

Wyjątki występujące w trakcie pracy programu można przechwycić i obsłużyć za pomocą następującej konstrukcji (polecenia złożonego):

<source lang=python>
try:
# operacje mogące spowodować wyjątek
except (KlasaWyjątku1, KlasaWyjątku2, ...):
# co zrobić jeśli wyjątek jednej z tych klas wystąpił
else:
# co zrobić jeśli nie było wyjątku
finally:
# co zrobić w KAŻDYM przypadku
</source>

*bloki <tt>else:</tt> i <tt>finally:</tt> są nieobowiązkowe, tj. możemy je pominąć (wraz z odp. linijką wprowadzającą)
*w bloku <tt>except:</tt> można podać jedną klasę wyjątku (wtedy zbędne są nawiasy), lub żadnej — wtedy przechwycimy ''każdy'' wyjątek; jeśli jednak chcemy, jak w przykładzie, wymienić więcej niż jedną klasę, to nawiasy są konieczne
*skuteczne przechwycenie wyjątku sprawia, że wykonanie programu nie ulegnie przerwaniu w punkcie jego wystąpienia, tyko będzie kontynuowane, również po opuszczeniu bloku <tt>try:</tt>
*można jednak spowodować, aby po wykonaniu czynności obsługi wyjątku, wyjątek został niejako ''wznowiony''; wystarczy w bloku <tt>except:</tt> wywołać instrukcję <tt>raise</tt>. Dla większości klas wyjątków skutkuje to zakończeniem programu
*instrukcję <tt>raise</tt> można wywołać również w dowolnym innym punkcie programu, powinna wówczas w niej wystąpić nazwa klasy wyjątku, jaki chcemy wywołać.

Przykłady:

''CDN.''

== Trochę więcej o klasach i obiektach ==

Warto sobie zdawać sprawę, że każda wartość występująca w programie pythonowym jest obiektem — a więc jest wyposażona w zestaw atrybutów i metod. Dotyczy to nie tylko kolekcji (list, słowników, ...), obiektów takich jak otwarte pliki (wynik wywołania funkcji <tt>open()</tt>), napisów — ale również np. liczb, czy to całkowitych, czy zmiennoprzecinkowych (i zespolonych, o których nie było tutaj mowy).

Przykładowo:

<source lang=python>
(17).bit_length()
→ 5
(17).bit_count()
→ 2
</src>

Co to właściwie znaczy?

Dla liczby 17 wywołaliśmy najpierw metodę, który mówi nam jak jest długość w bitach reprezentacji dwójkowej tej liczby (<tt>17 == 0b10001</tt>), a następnie metodę, zwracającą liczbę *ustawionych* (tj. równych jeden) bitów w tej reprezentacji. Nawiasy okrągłe są konieczne, ponieważ kropka po cyfrach oznaczałaby, że mamy do czynienia z zapisem liczby zmiennoprzecinkowej. Inaczej mówiąc, byłyby niepotrzebne gdybyśmy mieli do czynienia z nazwą oznaczającą liczbę całkowitą, a nie z jej zapisem dziesiętnym.

== O generatorach ==

W jednym z poprzednich rozdziałów [[PPy3/Kolekcje#Przyk.C5.82ad:_suma_cyfr|poznaliśmy wyrażenia generatorowe]]. Przypomnijmy, że stanowią one uproszczony zapis iteracji, pozwalający na uniknięcie w wielu prostych przypadkach pętli <tt>for</tt> i tworzenia zmiennych pomocniczych. Przykładowo:

<source lang=python>
kwadraty = (x**2 for x in range(100))
</source>

tworzy generator, ''produkujący'' w iteracji kwadraty kolejnych liczb naturalnych (od 0 do 99).

Poważnym ograniczeniem wyrażeń generatorowych jest to, że można ich używać do przekształcenia jednego obiektu iterowalnego w drugi — w tym przypadku, ciągu liczb naturalnych w ciąg ich kwadratów, natomiast nie ma jak za pomocą wyrażenia generatorowego stworzyć obiektu iterowalnego ,,od zera". Można to uzyskać, stosując ogólniejszą konstrukcję:

<source lang=python>
def gen_kwadraty(start=0):
k = start
while True:
yield k**2
k += 1

kwadraty = gen_kwadraty()
</source>

To, co napisałem powyżej przypomina bardzo definicję funkcji; jedyną różnicą na poziomie składni jest wystąpienie w definicji słowa <tt>yield</tt> (i brak wystąpienia słowa <tt>return</tt>). W istocie <tt>gen_kwadraty</tt> można uważać za funkcję — której wywołanie zwraca generator: obiekt, którego iteracja dostarczy kwadratów kolejnych liczb naturalnych, począwszy od liczby <tt>start</tt>, argumentu wywołania, o domyślnej wartości zero. Zauważmy, że w budowie definicji nie użyliśmy obiektu <tt>range</tt>; użyliśmy za to jawnej pętli <tt>while</tt>, niejako opakowując ją w generator. Co więc w ten sposób zyskujemy?

Przede wszystkim wielką elastyczność. W pokazanym przykładzie zysk jest niewielki, ale w definicji generatora możemy użyć jakiejkolwiek bądź reguły tworzenia kolejnych elementów iteracji. Nie potrzebujemy utworzyć ich wszystkich zanim zaczniemy z nich korzystać — tak jak byłoby w przypadku, gdybyśmy <tt>gen_kwadraty</tt> zdefiniowali jako funkcję zwracającą listę kwadratów kolejnych liczb. Co więcej, iteracja zapewniona przez <tt>gen_kwadraty</tt> może nam dostarczyć dowolnie wielu elementów (oczywiście w realnym komputerze po dostatecznie długim czasie osiągnięto by liczby, których wielkość przekroczyłaby pojemność dostępnej pamięci operacyjnej). Decyzja o tym, kiedy przerwać iterację pozostawiona jest ,,użytkownikowi", tzn. kodowi odwołującemu się do obiektu <tt>kwadraty</tt>.

----

[[PPy3/Matplotlib|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/DobrePraktyki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:26, 27 mar 2018 (CEST)

PPy3/TematyDodatkowe

2023-06-29T12:00:48Z

RobertJB: /* Klasy własnej produkcji */

= Tematy dodatkowe =

== Błędy i wyjątki ==

Każdy programista popełnia błędy — jest to nieunikniona część tej działalności.

*Są błędy, które można nazwać banalnymi: literówka w nazwie lub słowie kluczowym, zapomniany dwukropek, niedomknięte nawiasy, itp.
*Są bardziej podstępne błędy logiczne: gdy algorytm, którego zapisem ma być tworzony kod, po prostu nie robi dokładnie tego, co nam się wydaje.
*I w końcu są sytuacje wyjątkowe: gdy w toku pracy programu zachodzą nieoczekiwane okoliczności — użytkownik podał błędną nazwę pliku z danymi, zawartość tego pliku nie jest zgodna z oczekiwaniami programu, połączenie sieciowe ulega przerwaniu w trakcie pobierania lub przesyłania danych, itp.

Wszystkie te sytuacje nazywa się wyjątkami, i tym samym słowem określa się mechanizm, jakiego wiele współczesnych języków programowania (w tym Python) dostarcza programiście, aby mu pomóc określić działania jakie program miałby podjąć w sytuacjach wyjątkowych. Wyjątkowość takich sytuacji generalnie polega na tym, że w przypadku ich wystąpienia program po prostu nie może kontynuować przewidzianego toku działania:

*błąd w składni programu oznacza, że kod nie daje się zinterpretować w sposób jednoznaczny; najlepsze co można zrobić, to w momencie wykrycia błędu przerwać działanie i spróbować dostarczyć programiście (w formie komunikatu) informację ułatwiającą określenie i naprawienie błędu;
*błędne działanie algorytmu można np. spróbować wykrywać za pomocą tzw. asercji (polecenie ''assert'') badających, czy pewne warunki, jakie powinny być spełnione przez dane przetwarzane w programie są istotnie spełnione;
*wyjątki powstałe na skutek okoliczności zachodzących w trakcie działania programu, uniemożliwiających jego normalną kontynuację, można spróbować przewidzieć i przygotować program do odpowiedniego zareagowania, czyli ''obsługi wyjątku''. Na przykład, można spróbować ponowić jeszcze raz (lub kilka razy) próbę łączności sieciowej, i poddać się dopiero po określonej liczbie niepowodzeń; natomiast w sytuacji błędu wynikającego z podania przez użytkownika programu niewłaściwych argumentów uruchomienia, warto postarać się o przekazanie użytkownikowi komunikatu informującego go w sposób dla niego zrozumiały, o właściwym sposobie uruchamiania programu.

=== Błędy składniowe i podobne ===

Jak wspomniano powyżej, w przypadku napotkania błędu składniowego w kodzie programu interpreter natychmiast przerwie wykonywanie programu i wypisze komunikat. Komunikaty te '''warto czytać uważnie''' — w większości przypadków znajduje się w nich cała informacja konieczna dla naprawienia błędu. Przykład: usiłujemy uruchomić program <tt>błąd.py</tt>, którego treść to

<source lang=python>
x = (2 + 3) 4
print x
</source>

Wynik pierwszej próby to:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 1
x = (2 + 3) 4
^
SyntaxError: invalid syntax
</source>

Z komunikatu całkiem jasno wynika, że napotkany został błąd składni (''SyntaxError''), że wykryto ten błąd w linijce 1, a nawet dokładnie — że miejscem, w którym interpreter stwierdził, że ma do czynienia z nieprawidłowy kodem, było wystąpienie cyfry 4 po zamykającym nawiasie. Po prostu zapomnieliśmy, że — inaczej niż w powszechnie stosowanej notacji matematycznej — w Pythonie aby uzyskać mnożenie, konieczne jest napisanie jawnie znaku operatora (gwiazdki).

Po naprawieniu tej pomyłki próbujemy jeszcze raz, i wynik to:
<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 2
print x
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(x)?
</source>

Tutaj już jaśniej być nie może; interpreter nie tylko wskazał nam dokładne miejsce wystąpienia błędu, ale nawet dokładnie opisał, jak go naprawić.

Oczywiście nie zawsze interpreter będzie w stanie wskazać nam błąd aż tak precyzyjnie. Jako przykład weźmy następujący plik:

<source lang=python>
x, y, z = 3, 4, 5
print(max(x, y, z)
print(X * y * z)
</source>

i wynik jego uruchomienia:

<source lang=bash>
$ python3 błąd.py
File "błąd.py", line 3
print(X * y * z)
^
SyntaxError: invalid syntax
</source>

Dlaczego został wytknięty błąd składniowy w linijce 3? Przecież to w linijce 2 zapomnieliśmy zamknąć jeden z nawiasów.

Otóż jeżeli z końcem linii Python stwierdza, że nie wszystkie dotąd otwarte nawiasy zostały zamknięte, to traktuje to jako oznaczające, że kolejną linijkę należy potraktować jako ciąg dalszy bieżącej. I w tym przypadku dopiero napotykając w kolejnej linijce nazwę <tt>print</tt> — a nie np. przecinek, albo nawias zamykający — stwierdza, że coś musi być nie tak. Miejsce wykrycia błędu niestety nie zawsze się będzie pokrywało z miejscem jego faktycznego wystąpienia.

Po poprawce, czyli zamknięciu nawiasu na linii 2, próbujemy jeszcze raz — z wynikiem

<source lang=bash>
python3 błąd.py
5
Traceback (most recent call last):
File "błąd.py", line 3, in <module>
print(X * y * z)
NameError: name 'X' is not defined
</source>

I tym razem chyba jest wszystko jasne: pojawiła się nazwa <tt>X</tt>, z którą wcześniej nie związano żadnej wartości. Po prostu przez pomyłkę napisaliśmy X wielką literą zamiast małą.

Te przykłady pokazują, że przy wykorzystaniu treści wypisywanych komunikatów proces usunięcia z programu błędów składniowych i formalnych może być dość szybki i bezbolesny.

<blockquote>
Pojawiły się w komunikatach określenia: <tt>SyntaxError</tt>, <tt>NameError</tt>. Są to przykłady nazw tzw. klas wyjątków, czyli ogólnie rozumianych kategorii błędów, jakie są sygnalizowane. Wkrótce spotkamy dalsze klasy wyjątków, takie jak: <tt>TypeError</tt> - związana z przekazaniem wielkości niewłaściwego typu, czy <tt>ValueError</tt> - gdy nie typ. ale wartość wielkości, na której usiłuje się operować, jest niewłaściwa dla danej operacji. Dowiemy się również, dlaczego klasy wyjątków są przydatne — pomimo tego, iż dla ludzkich oczu zwykle bardziej przydatna jest słowna informacja uszczegółowiająca (to co pojawia się po nazwie klasy wyjątku i dwukropku).
</blockquote>

=== Asercje ===

Polecenie <tt>assert</tt> ma następującą postać:

<source lang=python>
assert wyrażenie1
# lub:
assert wyrażenie1, wyrażenie2
</source>

i jest to jak widać polecenie proste (nie zawierające bloku poleceń z wcięciem).

Jego działanie jest takie, że: obliczona zostanie wartość <tt>wyrażenie1</tt>; jeżeli jest ona prawdziwa, nie dzieje się nic (następuje natychmiastowe przejście do kolejnej linijki kodu). Jeżeli okaże się fałszywa, zostanie zasygnalizowany wyjątek, klasy <tt>AssertionError</tt>, co domyślnie przerywa wykonywanie programu i powoduje wypisanie odpowiedniego komunikatu. Jeżeli zastosujemy drugą postać, obliczona zostanie również wartość <tt>wyrażenie2</tt> i wypisana (dokładniej: jej reprezentacja napisowa) jako część komunikatu.

Przyjęło się stosować asercje jako sposób kontroli poprawności działania programu — w tym sensie, aby wykluczyć sytuacje „niemożliwe", tj. powstałe w wyniku błędu programisty. Ze względu na prostotę składni warto też z nich korzystać w kodzie służącym do testowania poprawności innego kodu (czyli np. w funkcjach testujących, czy inne, bardziej złożone funkcje dają poprawne wyniki w prostych sytuacjach próbnych).

=== Wyjątki w trakcie pracy programu ===

Wyjątki występujące w trakcie pracy programu można przechwycić i obsłużyć za pomocą następującej konstrukcji (polecenia złożonego):

<source lang=python>
try:
# operacje mogące spowodować wyjątek
except (KlasaWyjątku1, KlasaWyjątku2, ...):
# co zrobić jeśli wyjątek jednej z tych klas wystąpił
else:
# co zrobić jeśli nie było wyjątku
finally:
# co zrobić w KAŻDYM przypadku
</source>

*bloki <tt>else:</tt> i <tt>finally:</tt> są nieobowiązkowe, tj. możemy je pominąć (wraz z odp. linijką wprowadzającą)
*w bloku <tt>except:</tt> można podać jedną klasę wyjątku (wtedy zbędne są nawiasy), lub żadnej — wtedy przechwycimy ''każdy'' wyjątek; jeśli jednak chcemy, jak w przykładzie, wymienić więcej niż jedną klasę, to nawiasy są konieczne
*skuteczne przechwycenie wyjątku sprawia, że wykonanie programu nie ulegnie przerwaniu w punkcie jego wystąpienia, tyko będzie kontynuowane, również po opuszczeniu bloku <tt>try:</tt>
*można jednak spowodować, aby po wykonaniu czynności obsługi wyjątku, wyjątek został niejako ''wznowiony''; wystarczy w bloku <tt>except:</tt> wywołać instrukcję <tt>raise</tt>. Dla większości klas wyjątków skutkuje to zakończeniem programu
*instrukcję <tt>raise</tt> można wywołać również w dowolnym innym punkcie programu, powinna wówczas w niej wystąpić nazwa klasy wyjątku, jaki chcemy wywołać.

Przykłady:

''CDN.''

== Trochę więcej o klasach i obiektach ==

Warto sobie zdawać sprawę, że każda wartość występująca w programie pythonowym jest obiektem — a więc jest wyposażona w zestaw atrybutów i metod. Dotyczy to nie tylko kolekcji (list, słowników, ...), obiektów takich jak otwarte pliki (wynik wywołania funkcji <tt>open()</tt>), napisów — ale również np. liczb, czy to całkowitych, czy zmiennoprzecinkowych (i zespolonych, o których nie było tutaj mowy).

Przykładowo:

<src lang=python>
(17).bit_length()
→ 5
(17).bit_count()
→ 2
</src>

Co to właściwie znaczy?

Dla liczby 17 wywołaliśmy najpierw metodę, który mówi nam jak jest długość w bitach reprezentacji dwójkowej tej liczby (<tt>17 == 0b10001</tt>), a następnie metodę, zwracającą liczbę *ustawionych* (tj. równych jeden) bitów w tej reprezentacji. Nawiasy okrągłe są konieczne, ponieważ kropka po cyfrach oznaczałaby, że mamy do czynienia z zapisem liczby zmiennoprzecinkowej. Inaczej mówiąc, byłyby niepotrzebne gdybyśmy mieli do czynienia z nazwą oznaczającą liczbę całkowitą, a nie z jej zapisem dziesiętnym.

== O generatorach ==

W jednym z poprzednich rozdziałów [[PPy3/Kolekcje#Przyk.C5.82ad:_suma_cyfr|poznaliśmy wyrażenia generatorowe]]. Przypomnijmy, że stanowią one uproszczony zapis iteracji, pozwalający na uniknięcie w wielu prostych przypadkach pętli <tt>for</tt> i tworzenia zmiennych pomocniczych. Przykładowo:

<source lang=python>
kwadraty = (x**2 for x in range(100))
</source>

tworzy generator, ''produkujący'' w iteracji kwadraty kolejnych liczb naturalnych (od 0 do 99).

Poważnym ograniczeniem wyrażeń generatorowych jest to, że można ich używać do przekształcenia jednego obiektu iterowalnego w drugi — w tym przypadku, ciągu liczb naturalnych w ciąg ich kwadratów, natomiast nie ma jak za pomocą wyrażenia generatorowego stworzyć obiektu iterowalnego ,,od zera". Można to uzyskać, stosując ogólniejszą konstrukcję:

<source lang=python>
def gen_kwadraty(start=0):
k = start
while True:
yield k**2
k += 1

kwadraty = gen_kwadraty()
</source>

To, co napisałem powyżej przypomina bardzo definicję funkcji; jedyną różnicą na poziomie składni jest wystąpienie w definicji słowa <tt>yield</tt> (i brak wystąpienia słowa <tt>return</tt>). W istocie <tt>gen_kwadraty</tt> można uważać za funkcję — której wywołanie zwraca generator: obiekt, którego iteracja dostarczy kwadratów kolejnych liczb naturalnych, począwszy od liczby <tt>start</tt>, argumentu wywołania, o domyślnej wartości zero. Zauważmy, że w budowie definicji nie użyliśmy obiektu <tt>range</tt>; użyliśmy za to jawnej pętli <tt>while</tt>, niejako opakowując ją w generator. Co więc w ten sposób zyskujemy?

Przede wszystkim wielką elastyczność. W pokazanym przykładzie zysk jest niewielki, ale w definicji generatora możemy użyć jakiejkolwiek bądź reguły tworzenia kolejnych elementów iteracji. Nie potrzebujemy utworzyć ich wszystkich zanim zaczniemy z nich korzystać — tak jak byłoby w przypadku, gdybyśmy <tt>gen_kwadraty</tt> zdefiniowali jako funkcję zwracającą listę kwadratów kolejnych liczb. Co więcej, iteracja zapewniona przez <tt>gen_kwadraty</tt> może nam dostarczyć dowolnie wielu elementów (oczywiście w realnym komputerze po dostatecznie długim czasie osiągnięto by liczby, których wielkość przekroczyłaby pojemność dostępnej pamięci operacyjnej). Decyzja o tym, kiedy przerwać iterację pozostawiona jest ,,użytkownikowi", tzn. kodowi odwołującemu się do obiektu <tt>kwadraty</tt>.

----

[[PPy3/Matplotlib|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/DobrePraktyki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:26, 27 mar 2018 (CEST)

PPy3/Kolekcje

2023-05-15T11:15:39Z

RobertJB: /* Ćwiczenia */

=Kolekcje=

'''Kolekcje''' to są takie typy danych, które składają się z elementów. Szczególnym przypadkiem, [[PPy3/SekwencjeIIteracja|omawianym już wcześniej]] przy okazji wprowadzenia pętli, są sekwencje - kolekcje uporządkowane. Rozmaite typy kolekcji różnią się sposobem dostępu do elementów, modyfikowalnością - lub przeciwnie, optymalizacją pod względem różnych zastosowań.

*Szereg typów kolekcji jest ,,wbudowanych" w pythonie - to znaczy, że można z nich swobodnie korzystać bez żadnych dodatkowych zabiegów;
*niektóre inne są zaimplementowane w modułach biblioteki standardowej - a więc korzystanie z nich wymaga wcześniejszego polecenia <tt>import</tt> (p. [[PPy3/Moduły|Moduły]]);
*ważne dla zastosowań do obliczeń naukowych typy tablicowe są zaimplementowane w bibliotece [[PPy3/NumPy|NumPy]], która '''nie''' jest częścią biblioteki standardowej, i na ogół np. nie znajdzie się w domyślnym zestawie pakietów typowej dystrybucji Linuxa. Na pewno będzie jednak dostępna jako opcjonalny element instalacji;
*na każdym typie kolekcji umie działać funkcja <tt>len</tt>, zwracająca liczbę elementów kolekcji będącej jej argumentem.

Omówimy tu kolejno w skrócie najważniejsze i najbardziej przydatne wg. nas typy kolekcji, z pominięciem tablic NumPy - którym będzie poświęcony [[PPy3/NumPy|osobny rozdział]].

==Listy==

O listach już nieco wiemy. Lista to kolekcja uporządkowana, i modyfikowalna. Elementem listy może być cokolwiek - również inna lista. A nawet ta sama lista - tak, lista może być elementem samej siebie, jednak sztuczka taka nie jest chyba przydatna, choć legalna.

O adresowaniu elementów przez pozycję (lub ''indeks'') oraz o pobieraniu (i podstawianiu do) wycinków już było. Dodamy tu jeszcze parę użytecznych operacji na listach:

<source lang=python>
L = [0, 1, 3]
L.append(5) # dołączamy element do końca, przedłużając listę
→ L == [0, 1, 3, 5]
L.extend(['a', 'b']) # przedłużamy od razu o całą listę dodatkowych elementów
→ L == [0, 1, 3, 5, 'a', 'b']
L.insert(2, 'dwa') # pierwszy argument to pozycja, drugi to element wstawiany; dalsze elementy przesuwają się
→ L == [0, 1, 'dwa', 3, 5, 'a', 'b']
x = L.pop() # usuwamy ostatni element i zwracamy go jako wynik
→ teraz x == 'b', a L == [0, 1, 'dwa', 3, 5, 'a']
y = L.pop(2) # możemy zrobić to samo, wskazując inną pozycję zamiast ostatniej
→ teraz y == 'dwa', a L == [0, 1, 3, 5, 'a']
L.reverse() # odwrócenie porządku elementów
→ teraz L == ['a', 5, 3, 1, 0]
L.sort() # uporządkowanie elementów listy
→ BŁĄD - nie zadziała, gdyż lista zawiera elementy nieporównywalne (liczby i napis)
L.pop(0) # usuwamy napis, stojący w pozycji 0
L.sort()
→ teraz L == [0, 1, 3, 5]
</source>

Oprócz operacji <tt>L.sort()</tt> istnieje jeszcze funkcja <tt>sorted(L)</tt> - różniąca się tym, że pozostawia niezmienioną listę <tt>L</tt>, zamiast tego tworząc '''nową''' listę uporządkowaną, zawierającą te same elementy, co <tt>L</tt>.

Notację postaci <tt>L.append(5)</tt> można czytać tak: zastosuj ''metodę'' obiektu <tt>L</tt>, o nazwie <tt>append</tt>, do liczby 5. Metoda jest to operacja związana z pewnym obiektem (w tym przypadku - listą) - tym, do którego odnosi się nazwa stojąca przed kropką. Metodę można uważać za pewien rodzaj funkcji - takiej , która oprócz ewentualnych argumentów umieszczonych w nawiasach po jej nazwie, ,,wie" jeszcze o tym, z jakiego obiektu została wywołana.

<blockquote>
W Pythonie każda dana jest obiektem jakiegoś rodzaju (''klasy''), nawet liczba; i każdy obiekt posiada właściwe sobie metody (na ogół wyznaczone przez klasę, do jakiej przynależy). Programista może zresztą sam tworzyć klasy obiektów na potrzeby swojego programu. Więcej na ten temat później.
</blockquote>

Funkcja <tt>list</tt> tworzy listę z dowolnej sekwencji (np. z napisu). Wywołanie bez argumentów <tt>list()</tt> zwraca pustą listę; wywołanie <tt>list(s)</tt>, gdzie <tt>s</tt> jest napisem, zwraca listę znaków (napisów jednoelementowych), z których składa się napis <tt>s</tt>. Wywołanie, gdzie argumentem jest lista, zwraca duplikat tej listy - tzn. listę o tych samych elementach (i w tym samym porządku), ale nie tożsamą.

===Przykład: suma cyfr===

Spróbujmy policzyć sumę cyfr, z jakich składa się zapis liczby naturalnej <tt>n</tt> - a wyrażając się precyzyjniej, sumę liczb reprezentowanych przez cyfry zapisu dziesiętnego liczby <tt>n</tt> (cyfra to znak, a więc w rozumieniu Pythona pewien napis jednoelementowy - a nie liczba; ponadto, ten sam problem można by postawić dla zapisu pozycyjnego o dowolnej podstawie, np. dwójkowego lub szesnastkowego).

Pierwszym rozwiązaniem tego problemu jest takie, jakie można by nazwać arytmetycznym:

<source lang=python>
def sumacyfr(n):
suma = 0
while n:
suma += n % 10
n = n // 10
return suma
</source>

Proste: ostatnią cyfrę zapisu liczby <tt>n</tt> (a wyrażając się pedantycznie: odpowiadającą jej liczbę między 0 a 9) otrzymujemy jako resztę z dzielenia <tt>n</tt> przez 10; następnie ,,skracamy" <tt>n</tt> o tę ostatnią cyfrę, zastępując <tt>n</tt> przez jej iloraz całkowitoliczbowy przez 10. I tak do skutku, aż zabraknie cyfr.

Można jednak napisać znacznie krótszą wersję tej funkcji, korzystając z tego, że Python ,,sam" umie wyznaczyć cyfry zapisu dziesiętnego każdej liczby i nie musimy do tego pisać własnego kodu. Robi to funkcja <tt>str(n)</tt> - zastosowana do liczby całkowitej, zwraca ona napis składający się z cyfr dziesiętnych, reprezentujący tę liczbę. Rozwiązanie uproszczone wygląda więc tak:

<source lang=python>
def sumacyfr(n):
suma = 0
for c in str(n):
suma += int(c)
return suma
</source>

Dalsze uproszczenie otrzymujemy zastępując pętlę tzw. ''wyrażeniem generatorowym'', i korzystając z wbudowanej funkcji <tt>sum</tt>:

<source lang=python>
def sumacyfr(n):
return sum(int(c) for c in str(n))
</source>

Wyrażenia generatorowe to jakby odwrotny zapis pętli <tt>for</tt>. Notacja ta definiuje obiekt (''generator'') będący odpowiednikiem i uogólnieniem obiektu, jaki produkuje funkcja <tt>range</tt>: jest to ''niby-sekwencja'', która może zastąpić sekwencję (np. listę) w pętli <tt>for</tt>, a także w funkcjach (takich jak <tt>sum</tt> lub <tt>sorted</tt>), które jako argumentu oczekują sekwencji. W odróżnieniu od sekwencji, generator nie ma z góry ustalonego ciągu elementów, można powiedzieć, że produkuje kolejne elementy ,,na żądanie'', np. gdy są potrzebne dla kolejnego obiegu pętli <tt>for</tt>. Wyrażenie generatorowe określa generator na podstawie elementów podawanych przez inny generator (lub sekwencję), poddając je jakiemuś przekształceniu i/lub selekcji:

<source lang=python>
gen = (f(x) for x in elementy if w(x))
</source>

tu: <tt>elementy</tt> to sekwencja lub generator, <tt>w(x)</tt> to warunek decydujący o uwzględnieniu lub pominięciu elementu <tt>x</tt>, a <tt>f(x)</tt> to w ogólności wyrażenie, którego wartość będzie kolejnym elementem podawanym przez generator <tt>gen</tt>.

''Uwaga:'' nawiasy okrągłe otaczające wyrażenie generatorowe są obowiązkowe. Jeśli wyrażenie to wstawiamy bezpośrednio pod wywołanie funkcji jako jej jedyny argument, to wystarczają nawiasy zawarte w składni wywołania funkcji - nie potrzeba ich podwajać. Jeśli w miejsce nawiasów okrągłych napiszemy kwadratowe, otrzymamy nie generator - a listę o tych samych elementach.

==Krotki==

Krotki to prawie listy; zasadnicza różnica polega na tym, że krotki są '''niemodyfikowalne'''. Podobnie jak napisy - krotki raz stworzonej nie można zmienić, w sensie zmiany jej zawartości (elementów), a tym bardziej - jej długości. Można ją najwyżej zastąpić inną krotką. W związku z tym, krotki pozbawione są metod modyfikujących zawartość, jakie posiadają listy. Inne operacje, jak adresowanie elementów i wycinków, dodawanie (sklejanie) i mnożenie (powielanie) działają analogicznie jak dla list.

Literalne krotki zapisuje się zwykle używając nawiasów okrągłych:

<source lang=python>
T = (3, 5, 8)
</source>

chociaż tak naprawdę, to nawiasy są opcjonalne, a krotkę tworzą ''przecinki'' stojące pomiędzy elementami. Pominięcie nawiasów powoduje jednak, że musimy pamiętać o tym jaka jest kolejność operacji, jeżeli literalny zapis krotki jest elementem większego wyrażenia. Zwykle prościej i czytelniej jest użyć nawiasów.

Krotka może oczywiście składać się z jednego elementu, a nawet być pusta:

<source lang=python>
T1 = 1, # krotka o jednym elemencie - liczbie 1
T0 = () # krotka pusta
</source>

w tym ostatnim przypadku nie można się obyć bez nawiasów. Oczywiście tworzenie takich krotek rzadko bywa przydatne; mogą się one jednak pojawiać jako wyniki rozmaitych operacji.

Po co są w ogóle krotki, skoro to tylko jakby ,,słabsze" listy?

*Czasami warto użyć typu niemodyfikowalnego, aby próba zmiany zawartości kolekcji (np. w wyniku błędu) nie mogła się udać;
*optymalizacja - krotki są ,,lżejsze" od list, co może mieć znaczenie jeśli potrzebujemy je tworzyć w dużej liczbie;
*w niektórych przypadkach użycie niemodyfikowalnego typu danych jest konieczne; o tym dalej.

Warto jednak pamiętać, że choć sama krotka jest niemodyfikowalna - to jej elementem może być np. lista, której zawartość może być zmieniona niezależnie od tego, że jest elementem krotki.

Każdą sekwencję (a i pewne inne obiekty — np. generatory) można ,,zrzutować" na krotkę, za pomocą funkcji <tt>tuple</tt>. Wyrażając się precyzyjniej, wyrażenie <tt>tuple(s)</tt> jest krotką o tej samej zawartości (i w tym samym porządku) co sekwencja (lub inny obiekt iterowalny) <tt>s</tt>.

==Słowniki==

Słownik (''dictionary'') to taka kolekcja, której elementy - zamiast być uporządkowane - są powiązane z ''kluczami''. Kluczem może być liczba (całkowita lub ułamkowa), napis, ale również dana szeregu innych typów (chociaż nie każdego). Pobranie elementu słownika wiąże się z podaniem odpowiadającego mu klucza. Klucze w słowniku są niepowtarzalne - a więc każdy z nich jest związany z dokładnie jedną wartością. Wartości za to mogą się powtarzać, i nie podlegają żadnym ograniczeniom co do typu. Zapis literalny słowników posługuje się nawiasami klamrowymi:

<source lang=python>
slownik = {'jeden' : 1, 'dwa' : 2, 'trzy' : 3}
slownik['dwa']
→ 2
slownik['cztery']

KeyError Traceback (most recent call last)
<ipython-input-2-22c7b016c2c6> in <module>()
----> 1 slownik['cztery']

KeyError: 'cztery'
slownik['cztery'] = 4
slownik['cztery'] == 4
→ True
</source>

W notacji literalnej w nawiasach stoją, oddzielone przecinkami, pary klucz-wartość, a klucz od wartości oddziela dwukropek.
Nazwa ''słownik'' bierze się stąd, że jednym z możliwych zastosowań jest przekład kluczy (tu: słowa oznaczające liczby) na odpowiadające im wartości (tu: liczby). Widzimy też, że próba pobrania wartości odpowiadającej kluczowi, którego w słowniku nie ma, kończy się błędem. Z drugiej strony, w każdej chwili można do słownika dodać następną parę klucz-wartość; analogicznie, można wymienić wartość związaną z kluczem już istniejącym na inną.

Warto podkreślić jeszcze raz, że pary klucz-wartość w słowniku nie charakteryzują się w zasadzie określonym porządkiem. Niemniej w nowszych wersjach Pythona obowiązuje zasada, że pozycje słownika zachowują porządek, w jakim były tworzone — i np. w iteracji będą się pojawiać zgodnie z tym porządkiem.

Dalsze podstawowe operacje na słowniku to sprawdzenie występowania klucza, oraz iteracja:

<source lang=python>
'cztery' in slownik # operator `in' sprawdza przynależność do zbioru kluczy
→ True
'zero' in slownik
→ False
for klucz in slownik:
print(klucz, slownik[klucz])
→
jeden 1
dwa 2
trzy 3
cztery 4
</source>

Jak widać, w iteracji klucze słownika pojawiają się w porządku, w którym je dodawano. Takie zachowanie jest przepisane w definicji języka Python od wersji 3.7. Mając do czynienia z wersjami wcześniejszymi należy się liczyć z tym, że ten porządek nie będzie zachowany. Natomiast gwarantuje się, że każdy klucz pojawi się w iteracji dokładnie jeden raz.

W iteracjach (tzn. pętlach <tt>for</tt>) bardzo przydatne są kolekcje zwracane przez metody słowników: <tt>items</tt>, <tt>values</tt> i (rzadziej przydatna) <tt>keys</tt>. Zwracają one obiekty ,,listo-podobne"; jeżeli potrzebne są nam one w postaci dosłownych list, to wystarczy zastosować do nich funkcję <tt>list</tt>; jeżeli natomiast zamierzamy je wykorzystać w pętli <tt>for</tt>, to nie jest to potrzebne. Zawartość to odpowiednio:

*<tt>slownik.items()</tt>: pary (dwuelementowe krotki) postaci ''(klucz, wartość)''
*<tt>slownik.values()</tt>: same wartości występujące w słowniku
*<tt>slownik.keys()</tt>: same klucze występujące w słowniku.

Uwaga dotycząca porządku pozycji słownika stosuje się również do wyników zwracanych przez te metody.

Funkcją - konstruktorem słownika jest funkcja <tt>dict</tt>. Zamienia ona np. sekwencję par ''(klucz, wartość)'' w odpowiedni słownik. Jeżeli klucze w tej sekwencji się powtarzają, ,,wygrywa" ostatnie wystąpienie.

Wspomnieliśmy wcześniej, że nie każdy typ wartości może być kluczem słownika. Dokładniej - kluczami w słowniku mogą być tylko wartości typów niemodyfikowalnych, a więc nie listy ani same słowniki. Mogą nimi natomiast być napisy, liczby i krotki. ''Nota bene'': ponieważ liczby ułamkowe należy traktować jako przybliżone, używanie ich jako kluczy słownika na ogół nie jest dobrym pomysłem. Nie ma ograniczeń co do mieszania różnych typów kluczy (ani wartości) w jednym słowniku.

==Zbiory==

Zbiory w Pythonie mają sens taki, jak zbiory w matematyce (teorii mnogości). Mówiąc po prostu, zbiór jest kolekcją nieuporządkowaną i nie dopuszczającą powtórzeń: dany element albo do zbioru należy, albo nie; nie może należeć ''dwukrotnie'' (ani więcej razy). Standardowe zbiory są obiektami modyfikowalnymi.

Zbiór literalny zapisuje się za pomocą nawiasów klamrowych — łatwo odróżnić, że nie chodzi o słownik, gdyż zapis dla zbiorów nie zawiera dwukropków.

<blockquote>
Wiąże się z tym jednak jeden problem: czy <tt>{}</tt> oznacza zbiór pusty, czy pusty słownik? Dość arbitralnie przyjęto, że jednak pusty słownik (notację dla zbiorów wprowadzono później niż dla słowników).</blockquote>

Przykłady:

<source lang=python>
zbior = {'a', 'b', 'c'}
'a' in zbior
→ True
6 in zbior
→ False
zbior.add('d')
→ zbior == {'a', 'b', 'c', 'd'}
zbior.remove('a')
→ zbior == {'b', 'c', 'd'}
innyzb = {1, 2, 'b'}
zbior | innyzb # suma zbiorów
→ {'a', 1, 2, 'c', 'd', 'b'}
zbior & innyzb # iloczyn (część wspólna) zbiorów
→ {'b'}
zbior - innyzb # różnica zbiorów
→ {'a', 'c', 'd'}
zbior ^ innyzb == (zbior | innyzb) - (zbior & innyzb) # definicja różnicy symetrycznej zbiorów
→ True
innyzb <= zbior # pierwszy jest podzbiorem drugiego?
→ False
{'b', 'c'} <= zbior
→ True
{'b', 'c'} < zbior # podzbiór właściwy?
→ True
# znaki nierówności mogą być skierowane odwrotnie, z odp. zamianą argumentów
</source>

Elementy zbiorów podlegają analogicznemu ograniczeniu co do typów danych, co klucze słownika: nie mogą być to obiekty modyfikowalne.

Konstruktorem zbioru jest funkcja <tt>set</tt>: można jej podać jako argument dowolną kolekcję, a ona zwróci zbiór jej elementów (z dokładnością do ograniczeń co do typów danych tych elementów). Na przykład, typowy chwyt na usunięcie powtórzeń elementów: aby uzyskać uporządkowaną listę znaków, z jaki składa się napis <tt>s</tt>:

<source lang=python>
znaki = sorted(set(napis))
</source>

Podobnie jak lista ma swój odpowiednik niemodyfikowalny (krotkę), tak niemodyfikowalnym odpowiednikiem zbioru jest ''zbiór zamrożony'' (''frozenset''). Można taki wyprodukować za pomocą funkcji <tt>frozenset</tt>, analogu funkcji <tt>set</tt>. Zbiory zamrożone dopuszczają wszystkie te same operacje, co zwykłe zbiory - za wyjątkiem operacji zmieniających skład (jak <tt>add</tt> i <tt>remove</tt>).

==Napisy (jeszcze raz)==

O napisach już nieco było wcześniej, ale dla kompletności przypomnijmy.

*Napis to niemodyfikowalna sekwencja
*Jej elementami są znaki - napisy o długości 1
*Operatorem <tt>in</tt> można badać nie tylko, czy dany znak występuje w napisie, ale również czy jeden napis jest fragmentem drugiego:
<source lang=python>
s = 'abc XYZ'
'abc' in s
→ True
</source>
*Napisy mają szereg użytecznych metod; ale ''żadna z tych metod nie zmienia napisu, którego dotyczy'' - może jedynie tworzyć (i zwracać) nowy napis, utworzony na podstawie istniejącego. Przykłady:
<source lang=python>
s.lower()
→ 'abc xyz'
s.upper()
→ 'ABC XYZ'
s.replace(' ', ';')
→ 'abc;XYZ'
s.find('XY') # znajduje pozycję, na jakiej występuje podany fragment w napisie s
→ 4
s.find('q') # szukamy fragmentu, którego w s nie ma..
→ -1
</source>
*Metod tych jest więcej, poznamy je w przykładach
*Funkcją - konstruktorem napisu jest <tt>str</tt>; np. liczbę - zamienia w napis będący jej zapisem (najbardziej ,,standardowym"), i podobnie z innymi typami danych - zwraca najbardziej ,,standardową" ich reprezentację za pomocą napisu
*Szczególnie ważną i przydatną operacją napisową jest metoda <tt>format</tt>, o niej zaraz.

===Formatowanie===

Idea formatowania jest następująca: mamy pewien napis, który służy jako szablon do tworzenia napisów, w ten sposób, że określone miejsca w szablonie wypełniane są wartościami (a dokładniej - ich przedstawieniami napisowymi), które zazwyczaj nie są z góry znane i są wyliczane dopiero w wyniku działania programu. Najczęściej chodzi po prostu o przedstawienie uzyskanych wyników w postaci komunikatów lub zapisów w plikach, o określonej przez programistę postaci.

Gdy korzystamy z metody <tt>format</tt>, napis pełniący rolę szablonu (literalny lub przywołany poprzez nazwę) stoi przed kropką, tzn. wywołujemy metodę <tt>format</tt> tegoż napisu - szablonu, natomiast argumentami tego wywołania są wartości, które mają być wstawione w przeznaczone na to pozycje w szablonie.

Język opisu szablonów jest stosunkowo złożony i kryje w sobie szereg możliwości, na razie wprowadzimy najprostsze przypadki.

<source lang=python>
# Najprostsze formatowanie: wartości wstawiane są kolejno w miejsca zaznaczone poprzez {}
'x = {}, y = {}'.format(1.2, 9)
→ 'x = 1.2, y = 9'
# Numerowanie pozycji (ten sam numerek może występować więcej niż raz w szablonie
'x1 = {1}, x0 = {0}'.format(3, 15)
→ 'x1 = 15, x0 = 3'
# Obcięcie przedstawienia liczby ułamkowej do określonej liczby cyfr po kropce
'{0:.4f}'.format(3.141592653589793)
→ '3.1416'
# Bardziej szczegółowa kontrola formatowania
'{:4s}{:4s}{:*>4s}'.format('a', 'b', 'c')
→ 'a b ***c'
</source>
W tym ostatnim przykładzie, liczby 4 specyfikują ''minimalną'' szerokość pól przeznaczonych na wypełnienie podanymi wartościami, natomiast <tt>*></tt> oznacza, że gwiazdka ma być ,,wypełniaczem" pustego miejsca, jeżeli takie pozostanie w zadanej wielkości pola po wstawieniu wartości, a znak <tt>></tt> oznacza wyrównanie (wewnątrz pola) do strony prawej. Więcej szczegółów - w [https://docs.python.org/3/library/string.html#formatstrings dokumentacji].

Począwszy od wersji 3.6 języka Python wprowadzono uproszczoną składnię formatowania napisów. Poprzedzając w zapisie napisu literalnego otwierający cudzysłów (lub apostrof) literą <tt>f</tt> (lub <tt>F</tt>), możemy w tym napisie skorzystać z sekwencji w parach nawiasów klamrowych, gdzie wewnątrz nawiasów umieszczamy (zamiast jak wyżej — numeru pozycji w liście argumentów wywołania <tt>format()</tt>) po prostu zapis wyrażenia w Pythonie, którego aktualna wartość znajdzie się w tym miejscu w wyniku ewaluacji, plus ewentualnie dwukropek a po nim dyrektywy formatowania, jak wyżej. Przykłady:

<source lang=python>
x, y = 1.2, 9
f'x = {x}, y = {y}'
→ x = 1.2, y = 9
f'wynik działania arytmetycznego: {2 * x + y}'
→ wynik działania arytmetycznego: 11.4
</source>
Jeżeli chcemy, aby w wyniku wystąpiły dosłowne nawiasy klamrowe, a nie zostały one zinterpretowane jako pole do wypełnienia wartością wyrażenia, to musimy je podwoić (<tt>f'{{'</tt> → { itd.)

=Ćwiczenia=

1. Napisz funkcję, która wśród elementów sekwencji (lub generatora) napisów (drugi argument wywołania) znajdzie i zwróci te, które są permutacjami danego napisu (pierwszy argument), ale nie są z nim identyczne - bez rozróżniania wielkości liter. Przykładowo:

<source lang=python>
permutacje('Three', ['Ether', 'one', 'there', 'two', 'three'])
→ ['Ether', 'there']
</source>

2. Napisz funkcję <tt>czy_palindrom(s)</tt>, która dla napisu <tt>s</tt> stwierdzi, czy jest on palindromem - tzn. czy pisany wspak jest identyczny z oryginałem, i zwróci wynik tego badania (<tt>True</tt> lub <tt>False</tt>); oraz drugą funkcję <tt>palindromy(words)</tt>, która mając daną sekwencję (lub generator) <tt>words</tt> zwróci generator zawierający jedynie palindromy występujące wśród elementów <tt>words</tt>:

<source lang=python>
for word in palindromy(['Ala', 'ma', 'psa', 'Asa']):
print(word)
→
Ala
Asa
</source>

3. Napisz funkcję <tt>slowa_podobne(s, words)</tt>, która podobnie jak funkcja z poprzedniego przykładu ,,przefiltruje" sekwencję lub generator <tt>words</tt>, ale pozostawiając w wyniku jedynie napisy ,,podobne" do napisu <tt>s</tt> w tym sensie, że składające się z tych samych znaków — ale ewentualnie występujących inną liczbę razy (lecz nie identyczne z <tt>s</s>):

<source lang=python>
for word in slowa_podobne('one', ['one', 'two', 'None', 'three', 'neon', 'eon']):
print(word)
→
None
neon
eon
</source>

''CDN''

----

[[PPy3/Funkcje|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/Moduły|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 16:06, 5 lip 2016 (CEST)

PPy3/WejścieWyjście

2023-05-11T09:33:49Z

RobertJB: /* Odczyt linii poleceń */

=Obsługa wejścia i wyjścia=

Większość sensownych programów służy do przetworzenia jakichś informacji uzyskanych z zewnątrz programu: w najprostszym przypadku,
z pliku na dysku, lub z danych wprowadzonych przez użytkownika za pomocą klawiatury. W przypadku programów wywoływanych z linii poleceń, istnieje też poręczny i łatwy do wykorzystania mechanizm by wskazać programowi, co ma robić - za pomocą tzw. opcji i/lub wartości parametrów wpisanych na linii poleceń, po nazwie wywoływanego programu. Często też chcemy, by wyniki działania programu, np. przetworzone dane lub wyniki obliczeń, znalazły się w pliku na dysku - choć czasami możemy woleć, aby również (lub zamiast tego) zostały one wyświetlone na ekranie. Omówimy teraz krótko, jak to osiągnąć.

==Pliki tekstowe vs. binarne==

Zawartość każdego pliku na dysku to tak naprawdę ''strumień bajtów'' - bajt, czyli grupa ośmiu bitów, może być traktowany jako reprezentacja (w zapisie dwójkowym), jakiejś liczby całkowitej dodatniej z zakresu 0-255. Często jednak zawartość ta ma być traktowana jako reprezentacja tekstu, czyli ciągu znaków stosowanych w zapisie jakiegoś języka - może to być język naturalny (polski, angielski, chiński, ...) lub np. język programowania (Python, Java, C++, ...), język tworzenia stron WWW (HTML), itd. W tym celu stworzono tzw. ''kodowania'', czyli standardy reprezentowania znaków stosowanych w systemach zapisu języków naturalnych za pomocą bajtów lub grup bajtów (języki programowania itp. zasadniczo posługują się tymi samymi zestawami znaków, co języki naturalne - a zwłaszcza angielski).

Nie wchodząc za bardzo w szczegóły, obecnie stosowane reprezentacje cyfrowe tekstu oparte są na standardzie ''Unicode'', który m. in. definiuje tzw. uniwersalny zestaw znaków (UCS) - tablicę, zawierającą wszystkie znaki (alfanumeryczne, przestankowe, ideogramy - właściwe dla języków dalekowschodnich, i szeregu innych kategorii) stosowane w systemach pisma wszystkich żywych języków świata (i wielu języków martwych). Wewnętrzna reprezentacja danych napisowych w Pythonie oparta jest na standardzie Unicode - zatem pythonowy napis może zawierać znaki z wszelkiego rodzaju systemów pisma, w dowolnej kombinacji. Zapis tych danych w pliku dyskowym - i odwrotne, zinterpretowanie strumienia bajtów odczytanego z pliku dyskowego jako reprezentacji pewnego napisu - wymaga przyjęcia jakiegoś konkretnego kodowania. Unicode nie stanowi sam w sobie kodowania - określa on repertuar znaków oraz pozycję każdego z nich w tablicy UCS, nie zaś bajt lub grupę bajtów go reprezentującą.

W Pythonie problem ten rozwiązany jest w sposób następujący: domyślnie, zawartość wczytywana z plików interpretowana jest jako dane tekstowe (chyba, że zażyczymy sobie inaczej), zgodnie z pewnym domyślnym kodowaniem, właściwym dla systemu operacyjnego (chyba, że wskażemy że ma być stosowane inne) - w przypadku Linuxa będzie to prawie zawsze kodowanie o nazwie UTF-8, które się dobrze nadaje do zastosowania dla języków zachodnich, posługujących się systemem pisma opartym na alfabecie łacińskim. Inaczej może być w środowiskach języków posługujących się np. cyrylicą, czy języków azjatyckich (pismo arabskie lub ideograficzne - chińskie, japońskie, koreańskie, itd.). W środowiskach Windows może być inaczej...

Z powyższego widać, że rozróżnienie - plik tekstowy czy binarny - jest dość umowne, i dotyczy raczej interpretacji zawartości pliku (plik zapisany zgodnie z nieznanym nam i/lub nieoczekiwanym kodowaniem jest nie do odróżnienia od pliku binarnego). Co więcej, pliki zapisywane przez programy takie, jak MS Word, lub pliki PDF, nawet zawierające wyłącznie tekst, nie są w tym rozumieniu plikami tekstowymi, tylko binarnymi. W przykładach będziemy mieli do czynienia prawie wyłącznie z plikami tekstowymi - warto jednak wiedzieć, że w Pythonie jest osobny typ danych - ciągi bajtów (''bytes''), o własnościach nieco podobnych do napisów, ale o elementach będących bajtami, a nie znakami pisma.

==Czytanie tekstu z pliku==

<source lang=python>

f = open('nazwa_pliku.txt')
for linia in f:
przetworz(linia)
f.close()

# albo może lepiej:

with open('nazwa_pliku.txt') as f:
for linia in f:
przetworz(linia)

# jeszcze inaczej

tresc = open('nazwa_pliku.txt').read() # wczytujemy od razu całą treść pliku

</source>

*Otwarty do odczytu plik tekstowy dopuszcza iterację, w której kolejnymi elementami są linie tekstu - wraz z kończącym je kodem przejścia do nowej linii; w ostatniej linijce pliku kodu tego może brakować (lub nie);
*Wartość zmiennej <tt>linia</tt> to w każdym obiegu pętli, treść kolejnej linii tekstu jako napis; zawartość (bajtowa) pliku jest interpretowana jako napis zgodnie z domyślnym kodowaniem systemowym (można to zmienić poprzez dodatkowy parametr wywołania <tt>open</tt>);
*Jeżeli zawartość pliku ''nie'' jest zgodna z założeniem, że można go interpretować jako tekst w przyjętym kodowaniu, to w trakcie przetwarzania może wystąpić błąd (wyjątek);
*Po zakończeniu przetwarzania plik należy zamknąć, wywołując metodę <tt>close</tt>; ewentualnie można to pominąć, jeśli wiemy '''na pewno''' że wraz z końcem przetwarzania pliku kończy się cały program - wraz z zakończeniem działania programu otwarte pliki zostaną zamknięte;
*Druga postać wprowadza nową instrukcję złożoną - blok <tt>with</tt>; to, jak on dokładnie działa, zależy od typu obiektu do jakiego odwołujemy się po słowie <tt>with</tt> - jeżeli jest nim otwarty plik, to zostanie on automatycznie zamknięty wraz z końcem bloku;
*Odwoływanie się do pliku, który już został zamknięty, będzie nieskuteczne; żadne operacje się nie powiodą.
*Ostatnia wersja jest odrobinę ryzykowna - jeśli plik jest ''bardzo'' duży, to na jego treść może nie wystarczyć pamięci RAM, i program się wywróci. W dzisiejszych czasach oznacza to jednak, że rozmiar pliku sięga wielu gigabajtów.

==Czytanie dowolnych danych z pliku==

<source lang=python>

f = open('nazwa_pliku', mode='b')
dane = f.read(1024*1024) # wczytujemy 1 MB danych (lub mniej, jeśli tylu już nie ma)
(...)
f.seek(0) # "przewinąć" do początku pliku (lub innej pozycji, względem początku)
(...)
pos = f.tell() # uzyskać aktualną pozycję
(...)
f.close()

</source>

*To, co odczytamy - czyli <tt>dane</tt>, to będzie łańcuch bajtów;
*Można odpowiednio wykorzystać blok <tt>with</tt>, aby uniknąć ręcznego zamykania pliku;
*Wywołanie <tt>read()</tt> bez argumentu oznacza: wczytaj wszystko;
*Jeśli wywołanie <tt>read</tt> z dodatnim argumentem zwróci łańcuch o długości zero - to dotarliśmy do końca pliku.

==Zapis danych do pliku==

Aby był możliwy zapis danych do pliku dyskowego, należy go otworzyć w trybie do zapisu:
<source lang=python>

f = open('nazwa_pliku.txt', 'w')
(...)
f.write(dane)
(...)
f.close()

</source>

'''UWAGA:''' otwarcie pliku w trybie do zapisu (<tt>'w'</tt>) spowoduje usunięcie poprzedniej zawartości pliku - o ile dotyczy pliku już istniejącego. Jeżeli nazwa odnosi się do pliku jeszcze nieistniejącego, to zostanie on utworzony. Jeżeli chcemy zachować poprzednie dane, dopisując nowe do końca pliku, należy plik otworzyć w trybie <tt>'a'</tt> (''append'').

<blockquote>
Domyślnie plik jest otwierany w trybie zapisu tekstu, zgodnie z domyślnym kodowaniem. A więc <tt>dane</tt> powinny być napisem. Jeżeli chcemy zapisywać surowe bajty, należy użyć trybu <tt>'wb'</tt>. Jeżeli chcemy użyć kodowania innego niż domyślne, możemy w funkcji <tt>open</tt> użyć parametru ''encoding'', w postaci:
<source lang=python>

f = open('nazwa_pliku.txt', 'w', encoding='cp1250')

</source>
w tym przykładzie użyto nazwy kodowania stosowanego do języka polskiego w Windows.
</blockquote>

==Standardowe strumienie i przekierowania==

===Wprowadzenie===

System operacyjny z rodziny unixów (np. Linux lub MacOS) udostępnia każdemu procesowi (uruchomionemu programowi) trzy tzw. standardowe strumienie, mogące być źródłem danych (tzw. standardowy strumień wejściowy, ''stdin'') lub kanałem przekazywania wyników, komunikatów itp. (standardowy strumień wyjściowy, ''stdout'' i standardowy strumień błędów, ''stderr'').

<blockquote>
W systemach z rodziny Windows jest podobnie, w odniesieniu do programów uruchamianych z linii poleceń, czyli okna programu ''cmd.exe''.
</blockquote>

Co to konkretnie znaczy? Domyślnie, zawartością ''stdin'' są dane wprowadzane z klawiatury, natomiast dane wypisywane na ''stdout'' i ''stderr'' pojawiają się na ekranie - w oknie terminalowym, z którego uruchomiono dany program. Przyjęto umowę, że na ''stdout'' wypisuje się dane, stanowiące wynik zgodnej z przewidywaniami pracy programu (oczywiście o ile nie przewidziano zapisu tych wyników bezpośrednio do pliku na dysku), natomiast na ''stderr'' - jedynie komunikaty dotyczące sytuacji nieprzewidzianych, a więc błędów przetwarzania, lub ostrzeżenia - pojawiające się w sytuacjach, gdy wprawdzie kontynuacja pracy programu jest możliwa, ale okoliczności wskazują, że jej wyniki mogą być pod jakimś względem wątpliwe.

Powyższe ma sens, ponieważ domyślne powiązania - ''stdin'' z klawiaturą, a ''stdout'' i ''stderr'' z ekranem można zmienić - poprzez mechanizmy tzw. przekierowania. W szczególności, strumienie wyjścia i błędu można rozdzielić, np. przekierowując treść ''stdout'' do pliku, a pozostawiając ''stderr'' jako związany z ekranem.

W środowisku Python standardowe strumienie dostępne są jako elementy modułu <tt>sys</tt>: <tt>sys.stdin</tt>, <tt>sys.stdout</tt> i <tt>sys.stderr</tt>. Mają one właściwości plików tekstowych, choć bez możliwości przewijania (<tt>seek</tt>).

'''Funkcja <tt>print</tt> w Pythonie domyślnie wypisuje dane do strumienia ''stdout''; można to zmienić, używając parametru wywołania ''file'', którego wartością powinien być plik otwarty do zapisu w trybie tekstowym.'''

===Sposoby przekierowania===

Przekierowanie strumieni dokonuje się na poziomie systemu operacyjnego, całkowicie poza środowiskiem Pythona - program nie ma możliwości wykrycia, czy strumienie standardowe na jakich operuje zostały przekierowane. Przekierowania określa się na linii poleceń w momencie uruchomienia programu.

Przekierowanie ''stdin'' z pliku:
<source lang=bash>
$ program.py < plik_wejsciowy.txt
$ < plik_wejsciowy.txt program.py
</source>

Oba powyższe polecenia są równoważne i skutkują tym, że dane czytane przez program z <tt>sys.stdin</tt> będą tak na prawdę pochodzić z pliku o podanej nazwie (a treść wprowadzana z klawiatury będzie w programie niedostępna).

Przekierowanie ''stdout'' do pliku:
<source lang=bash>
$ program.py > plik_wyjscia.txt
$ > plik_wyjscia.txt program.py
</source>

Dane pisane do <tt>sys.stdout</tt> nie pojawią się w oknie terminala, tylko znajdą się w pliku. Dane pisane do <tt>sys.stderr</tt> dalej będą trafiać na ekran.

Przekierowania równoczesne:
<source lang=bash>
$ program.py < plik_wejsciowy.txt > plik_wyjscia.txt
</source>

Oba poprzednio opisane przekierowania można również wykonać równocześnie. Elementy polecenia również mogą wystąpić w innym porządku.

Przekierowanie ''stderr'':
<source lang=bash>
$ program.py 2> plik_bledow.txt
</source>

Komunikaty o błędach i ostrzeżenia znajdą się w pliku o podanej nazwie, zamiast na ekranie. Analogicznie do <tt>2></tt>, strumieniom ''stdout'' i ''stdin'' przypisane są numerki 1 i 0 - można więc pisać odpowiednio <tt>1></tt> i <tt>0<</tt>, ale tu te wartości numerów strumieni przekierowanych (naprawdę - ''deskryptorów plików'') są domyślne i niemal zawsze się je pomija.

===Potoki===

Oprócz przekierowania do i z plików, istnieje jeszcze analogiczny mechanizm, gdzie np. strumień ''stdout'' jednego procesu łączy się z strumieniem ''stdin'' innego procesu - skutkiem czego dane wyjściowe pierwszego są wprowadzane do drugiego jako dane wejściowe, tworząc to co się nazywa ''potokiem''. Najprostszy przykład:
<source lang=bash>
$ program1.py | program2.py
</source>
tu ''operatorem potoku'' w systemowej linii poleceń jest znak kreski pionowej (<tt>|</tt>), a <tt>program1.py</tt> przekazuje wyniki swojej pracy do dalszego przetwarzania kolejnemu, <tt>program2.py</tt>. Taki potok może mieć więcej niż dwa etapy i może łączyć się z zastosowaniem przekierowań do plików, np.
<source lang=bash>
$ < plik_wejsciowy.txt program1.py 2>bledy.txt | program2.py > plik_wynikow.txt
</source>

Pożytecznym narzędziem do stosowania w potokach jest polecenie (program) o nazwie <tt>tee</tt>:
<source lang=bash>
$ program.py < dane.txt | tee wynik.txt
</source>
w tym przypadku program wczyta zawartość pliku <tt>dane.txt</tt>, a wynik wypisany do <tt>sys.stdout</tt> zarówno pojawi się na ekranie (w oknie terminala, jak i zostanie zapisany w pliku <tt>wynik.txt</tt>.

==Odczyt linii poleceń==

Zawartość linii poleceń dostępna jest w obiekcie <tt>sys.argv</tt> - czyli moduł (standardowy) <tt>sys</tt>, element <tt>argv</tt>. Jest to lista argumentów - ,,słów" jakie wywołujący program umieścił w linii poleceń. Inaczej mówiąc, treść linii poleceń ulega wstępnemu rozbiorowi - na słowa, według reguł zależnych od systemu operacyjnego. Najczęściej poszczególne słowa oddzielają spacje (jedna lub więcej), jeśli chcemy, by ciąg zawierający spacje był potraktowany jako pojedyncze słowo (np. nazwa pliku zawierająca spacje), należy ciąg ten np. umieścić w cudzysłowach (które zostaną usunięte z treści argumentu). Treść linii poleceń na ogół ulega jeszcze innym formom obróbki przez system operacyjny (np. rozwijanie rozmaitych skrótów), ale dzieje się to poza kontrolą Pythona.

<source lang=python>

from sys import argv
for arg in argv:
print(arg)

</source>

Korzystając z powyższego kodu możemy dowiedzieć się, jak wygląda lista argumentów już ''po'' jej obróbce przez system operacyjny.

Na początku listy <tt>argv</tt> czyli w pozycji <tt>argv[0]</tt> znajduje się nazwa uruchomionego programu (tj. nazwa pliku z kodem uruchomionego jako program główny).

===Przykłady===

=1.=
Jeśli przewidujemy, że jedynymi argumentami wywołania naszego programu będą nazwy plików, na każdym z których należy wykonać jakąś czynność, to można to zrealizować tak:
<source lang=python>

#! /usr/bin/python3

from sys import argv

def przetwarzaj(plik):
# tu określamy na czym polega "przetworzenie" pliku

for plik in argv[1:]:
przetwarzaj(plik)

</source>

*Wzięcie wycinku z <tt>argv</tt> służy pominięciu pliku zawierającego kod programu;
*Elementami <tt>argv</tt> są ''nazwy'' plików - napisy.

=2.=
Nieraz jest pożądane, aby program przetwarzający strumień danych mógł działać na dwa sposoby: albo wywołany z argumentami będącymi nazwami plików z danymi wejściowymi wczytuje kolejno zawartość tych plików; albo wywołany bez takich argumentów, czyta dane wejściowe ze standardowego strumienia wejściowego, w którym one znajdują się zazwyczaj w wyniku poprzedniego kroku przetwarzania potokowego. Nota bene w ten sposób działa wiele tradycyjnych narzędzi systemowych w Linuxie.

W standardowej bibliotece Pythona jest moduł <tt>fileinput</tt>, który ułatwia realizację takiego podejścia. W najprostszym przypadku:

<source lang=python>
#! /usr/bin/python3

import fileinput

def przetwarzaj(linia):
# tu określamy na czym polega przetworzenie linii treści

for linia in fileinput.input():
przetwarzaj(linia)
</source>

W pętli w powyższym przykładzie wystąpią kolejno wszystkie linie w treści plików wymienionych na linii poleceń (z pominięciem pliku samego programu), lub jeśli linia poleceń jest pusta — linie w treści <tt>sys.stdin</tt>. Ewentualnie można wywołać funkcję <tt>fileinput.input(pliki)</tt>, tj. zamiast bez argumentów to z argumentem będącym sekwencją nazw plików zawierających dane wejściowe. Może to być np. lista argumentów programu, ale po usunięciu z niej pozycji będących opcjami, a nie nazwami plików. Oczywiście w dokumentacji znajdziemy jeszcze dalsze możliwości.

=Ćwiczenia=

1. Napisać program, który wczyta dany plik linia po linii i znajdzie wśród nich podzbiór linii o maksymalnej długości (w znakach) oraz wartość tej maksymalnej długości. Niech wynikiem działania programu będzie wypisanie liczby oznaczającej maksymalną długość linii występujących w badanym pliku, a następnie - treść tych linii, w kolejności w jakiej pojawiały się w pliku. Wypróbować ten program na pliku ''/usr/share/dict/words''. W końcowej wersji program powinien operować na pliku, którego nazwę podamy jako argument na linii poleceń.

''Wskazówka:'' długość linii nie powinna uwzględniać kodu przejścia do nowej linii, zapisywanego symbolicznie jako <tt>'\n'</tt> kończącego (prawie) każdą linię.

2. Napisać program, który wczyta dany plik linia po linii i znajdzie wśród nich podzbiór linii o danej długości w znakach. Niech wynikiem działania programu będzie wypisanie linii o żądanej długości występujących w treści pliku w takiej kolejności, w jakiej pojawiały się w pliku. Długość szukanych linii podajemy jako pierwszy, a nazwę badanego pliku jako drugi argument na linii poleceń.

3. Napisać program, który wyznaczy rozkład długości linii w treści danego pliku - nazwę pliku podajemy na linii poleceń. Wynikiem działania programu jest wypisanie ciągu linijek postaci <tt>''długość'' : ''ile''</tt>, gdzie liczba ''ile'' opisuje, ile linii o danej długości wystąpiło w treści pliku. Pozycje, w których ''ile'' wynosiłoby 0 nie pojawiają się.

4. Napisać program, który wyznacza częstości występowania w treści pliku określonych znaków. Zestaw znaków, których wystąpienia zamierzamy zliczać podajemy jako pierwszy argument na linii poleceń, nazwę badanego pliku jako drugi. Wynikiem działania programu jest wypisanie ciągu linijek postaci <tt>''znak'' : ''częstość''</tt>.

5. Napisać program, który znajduje w pliku ''/usr/share/dict/words'' wszystkie słowa, składające się z tych samych liter co słowo, podane jako argument na linii poleceń - choć niekoniecznie występujących tę samą liczbę razy. Inaczej mówiąc, każda z liter występujących w podanym słowie występuje również w słowach szukanych, a nie występują w nich żadne inne znaki. Program wypisuje na ekran znalezione słowa, po jednym na linijkę.

6. Niech program znajduje wszystkie słowa, jakie można utworzyć korzystając z danego zestawu liter (podanego jako pierwszy argument na linii poleceń); tzn. tak jak w ''Scrabble'' dysponujemy takimi literami i w takiej liczbie, jakie składają się na to słowo (lub ,,słowo"). Źródłem słów jakie można utworzyć jest plik podany jako drugi argument (domyślnie - ''/usr/share/dict/words''). 
''Wskazówka:'' może się tu przydać operacja <tt>L.remove(x)</tt>, gdzie <tt>L</tt> jest listą; usuwa ona z listy pierwsze z kolei znalezione w niej wystąpienie elementu <tt>x</tt>. 
''Uwaga:'' operacja ta zwróci błąd, jeśli element <tt>x</tt> ''nie'' występuje w <tt>L</tt>.

----

[[PPy3/Moduły|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/NumPy|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 13:26, 4 sie 2016 (CEST)

PPy3/WejścieWyjście

2023-05-11T09:32:42Z

RobertJB: /* Przykład */ https://wyborcza.pl/duzyformat/7,127290,25087636,co-kozacy-maja-wspolnego-z-anna-walentynowicz.html#S.embed_article-K.C-B.1-L.1.zw

=Obsługa wejścia i wyjścia=

Większość sensownych programów służy do przetworzenia jakichś informacji uzyskanych z zewnątrz programu: w najprostszym przypadku,
z pliku na dysku, lub z danych wprowadzonych przez użytkownika za pomocą klawiatury. W przypadku programów wywoływanych z linii poleceń, istnieje też poręczny i łatwy do wykorzystania mechanizm by wskazać programowi, co ma robić - za pomocą tzw. opcji i/lub wartości parametrów wpisanych na linii poleceń, po nazwie wywoływanego programu. Często też chcemy, by wyniki działania programu, np. przetworzone dane lub wyniki obliczeń, znalazły się w pliku na dysku - choć czasami możemy woleć, aby również (lub zamiast tego) zostały one wyświetlone na ekranie. Omówimy teraz krótko, jak to osiągnąć.

==Pliki tekstowe vs. binarne==

Zawartość każdego pliku na dysku to tak naprawdę ''strumień bajtów'' - bajt, czyli grupa ośmiu bitów, może być traktowany jako reprezentacja (w zapisie dwójkowym), jakiejś liczby całkowitej dodatniej z zakresu 0-255. Często jednak zawartość ta ma być traktowana jako reprezentacja tekstu, czyli ciągu znaków stosowanych w zapisie jakiegoś języka - może to być język naturalny (polski, angielski, chiński, ...) lub np. język programowania (Python, Java, C++, ...), język tworzenia stron WWW (HTML), itd. W tym celu stworzono tzw. ''kodowania'', czyli standardy reprezentowania znaków stosowanych w systemach zapisu języków naturalnych za pomocą bajtów lub grup bajtów (języki programowania itp. zasadniczo posługują się tymi samymi zestawami znaków, co języki naturalne - a zwłaszcza angielski).

Nie wchodząc za bardzo w szczegóły, obecnie stosowane reprezentacje cyfrowe tekstu oparte są na standardzie ''Unicode'', który m. in. definiuje tzw. uniwersalny zestaw znaków (UCS) - tablicę, zawierającą wszystkie znaki (alfanumeryczne, przestankowe, ideogramy - właściwe dla języków dalekowschodnich, i szeregu innych kategorii) stosowane w systemach pisma wszystkich żywych języków świata (i wielu języków martwych). Wewnętrzna reprezentacja danych napisowych w Pythonie oparta jest na standardzie Unicode - zatem pythonowy napis może zawierać znaki z wszelkiego rodzaju systemów pisma, w dowolnej kombinacji. Zapis tych danych w pliku dyskowym - i odwrotne, zinterpretowanie strumienia bajtów odczytanego z pliku dyskowego jako reprezentacji pewnego napisu - wymaga przyjęcia jakiegoś konkretnego kodowania. Unicode nie stanowi sam w sobie kodowania - określa on repertuar znaków oraz pozycję każdego z nich w tablicy UCS, nie zaś bajt lub grupę bajtów go reprezentującą.

W Pythonie problem ten rozwiązany jest w sposób następujący: domyślnie, zawartość wczytywana z plików interpretowana jest jako dane tekstowe (chyba, że zażyczymy sobie inaczej), zgodnie z pewnym domyślnym kodowaniem, właściwym dla systemu operacyjnego (chyba, że wskażemy że ma być stosowane inne) - w przypadku Linuxa będzie to prawie zawsze kodowanie o nazwie UTF-8, które się dobrze nadaje do zastosowania dla języków zachodnich, posługujących się systemem pisma opartym na alfabecie łacińskim. Inaczej może być w środowiskach języków posługujących się np. cyrylicą, czy języków azjatyckich (pismo arabskie lub ideograficzne - chińskie, japońskie, koreańskie, itd.). W środowiskach Windows może być inaczej...

Z powyższego widać, że rozróżnienie - plik tekstowy czy binarny - jest dość umowne, i dotyczy raczej interpretacji zawartości pliku (plik zapisany zgodnie z nieznanym nam i/lub nieoczekiwanym kodowaniem jest nie do odróżnienia od pliku binarnego). Co więcej, pliki zapisywane przez programy takie, jak MS Word, lub pliki PDF, nawet zawierające wyłącznie tekst, nie są w tym rozumieniu plikami tekstowymi, tylko binarnymi. W przykładach będziemy mieli do czynienia prawie wyłącznie z plikami tekstowymi - warto jednak wiedzieć, że w Pythonie jest osobny typ danych - ciągi bajtów (''bytes''), o własnościach nieco podobnych do napisów, ale o elementach będących bajtami, a nie znakami pisma.

==Czytanie tekstu z pliku==

<source lang=python>

f = open('nazwa_pliku.txt')
for linia in f:
przetworz(linia)
f.close()

# albo może lepiej:

with open('nazwa_pliku.txt') as f:
for linia in f:
przetworz(linia)

# jeszcze inaczej

tresc = open('nazwa_pliku.txt').read() # wczytujemy od razu całą treść pliku

</source>

*Otwarty do odczytu plik tekstowy dopuszcza iterację, w której kolejnymi elementami są linie tekstu - wraz z kończącym je kodem przejścia do nowej linii; w ostatniej linijce pliku kodu tego może brakować (lub nie);
*Wartość zmiennej <tt>linia</tt> to w każdym obiegu pętli, treść kolejnej linii tekstu jako napis; zawartość (bajtowa) pliku jest interpretowana jako napis zgodnie z domyślnym kodowaniem systemowym (można to zmienić poprzez dodatkowy parametr wywołania <tt>open</tt>);
*Jeżeli zawartość pliku ''nie'' jest zgodna z założeniem, że można go interpretować jako tekst w przyjętym kodowaniu, to w trakcie przetwarzania może wystąpić błąd (wyjątek);
*Po zakończeniu przetwarzania plik należy zamknąć, wywołując metodę <tt>close</tt>; ewentualnie można to pominąć, jeśli wiemy '''na pewno''' że wraz z końcem przetwarzania pliku kończy się cały program - wraz z zakończeniem działania programu otwarte pliki zostaną zamknięte;
*Druga postać wprowadza nową instrukcję złożoną - blok <tt>with</tt>; to, jak on dokładnie działa, zależy od typu obiektu do jakiego odwołujemy się po słowie <tt>with</tt> - jeżeli jest nim otwarty plik, to zostanie on automatycznie zamknięty wraz z końcem bloku;
*Odwoływanie się do pliku, który już został zamknięty, będzie nieskuteczne; żadne operacje się nie powiodą.
*Ostatnia wersja jest odrobinę ryzykowna - jeśli plik jest ''bardzo'' duży, to na jego treść może nie wystarczyć pamięci RAM, i program się wywróci. W dzisiejszych czasach oznacza to jednak, że rozmiar pliku sięga wielu gigabajtów.

==Czytanie dowolnych danych z pliku==

<source lang=python>

f = open('nazwa_pliku', mode='b')
dane = f.read(1024*1024) # wczytujemy 1 MB danych (lub mniej, jeśli tylu już nie ma)
(...)
f.seek(0) # "przewinąć" do początku pliku (lub innej pozycji, względem początku)
(...)
pos = f.tell() # uzyskać aktualną pozycję
(...)
f.close()

</source>

*To, co odczytamy - czyli <tt>dane</tt>, to będzie łańcuch bajtów;
*Można odpowiednio wykorzystać blok <tt>with</tt>, aby uniknąć ręcznego zamykania pliku;
*Wywołanie <tt>read()</tt> bez argumentu oznacza: wczytaj wszystko;
*Jeśli wywołanie <tt>read</tt> z dodatnim argumentem zwróci łańcuch o długości zero - to dotarliśmy do końca pliku.

==Zapis danych do pliku==

Aby był możliwy zapis danych do pliku dyskowego, należy go otworzyć w trybie do zapisu:
<source lang=python>

f = open('nazwa_pliku.txt', 'w')
(...)
f.write(dane)
(...)
f.close()

</source>

'''UWAGA:''' otwarcie pliku w trybie do zapisu (<tt>'w'</tt>) spowoduje usunięcie poprzedniej zawartości pliku - o ile dotyczy pliku już istniejącego. Jeżeli nazwa odnosi się do pliku jeszcze nieistniejącego, to zostanie on utworzony. Jeżeli chcemy zachować poprzednie dane, dopisując nowe do końca pliku, należy plik otworzyć w trybie <tt>'a'</tt> (''append'').

<blockquote>
Domyślnie plik jest otwierany w trybie zapisu tekstu, zgodnie z domyślnym kodowaniem. A więc <tt>dane</tt> powinny być napisem. Jeżeli chcemy zapisywać surowe bajty, należy użyć trybu <tt>'wb'</tt>. Jeżeli chcemy użyć kodowania innego niż domyślne, możemy w funkcji <tt>open</tt> użyć parametru ''encoding'', w postaci:
<source lang=python>

f = open('nazwa_pliku.txt', 'w', encoding='cp1250')

</source>
w tym przykładzie użyto nazwy kodowania stosowanego do języka polskiego w Windows.
</blockquote>

==Standardowe strumienie i przekierowania==

===Wprowadzenie===

System operacyjny z rodziny unixów (np. Linux lub MacOS) udostępnia każdemu procesowi (uruchomionemu programowi) trzy tzw. standardowe strumienie, mogące być źródłem danych (tzw. standardowy strumień wejściowy, ''stdin'') lub kanałem przekazywania wyników, komunikatów itp. (standardowy strumień wyjściowy, ''stdout'' i standardowy strumień błędów, ''stderr'').

<blockquote>
W systemach z rodziny Windows jest podobnie, w odniesieniu do programów uruchamianych z linii poleceń, czyli okna programu ''cmd.exe''.
</blockquote>

Co to konkretnie znaczy? Domyślnie, zawartością ''stdin'' są dane wprowadzane z klawiatury, natomiast dane wypisywane na ''stdout'' i ''stderr'' pojawiają się na ekranie - w oknie terminalowym, z którego uruchomiono dany program. Przyjęto umowę, że na ''stdout'' wypisuje się dane, stanowiące wynik zgodnej z przewidywaniami pracy programu (oczywiście o ile nie przewidziano zapisu tych wyników bezpośrednio do pliku na dysku), natomiast na ''stderr'' - jedynie komunikaty dotyczące sytuacji nieprzewidzianych, a więc błędów przetwarzania, lub ostrzeżenia - pojawiające się w sytuacjach, gdy wprawdzie kontynuacja pracy programu jest możliwa, ale okoliczności wskazują, że jej wyniki mogą być pod jakimś względem wątpliwe.

Powyższe ma sens, ponieważ domyślne powiązania - ''stdin'' z klawiaturą, a ''stdout'' i ''stderr'' z ekranem można zmienić - poprzez mechanizmy tzw. przekierowania. W szczególności, strumienie wyjścia i błędu można rozdzielić, np. przekierowując treść ''stdout'' do pliku, a pozostawiając ''stderr'' jako związany z ekranem.

W środowisku Python standardowe strumienie dostępne są jako elementy modułu <tt>sys</tt>: <tt>sys.stdin</tt>, <tt>sys.stdout</tt> i <tt>sys.stderr</tt>. Mają one właściwości plików tekstowych, choć bez możliwości przewijania (<tt>seek</tt>).

'''Funkcja <tt>print</tt> w Pythonie domyślnie wypisuje dane do strumienia ''stdout''; można to zmienić, używając parametru wywołania ''file'', którego wartością powinien być plik otwarty do zapisu w trybie tekstowym.'''

===Sposoby przekierowania===

Przekierowanie strumieni dokonuje się na poziomie systemu operacyjnego, całkowicie poza środowiskiem Pythona - program nie ma możliwości wykrycia, czy strumienie standardowe na jakich operuje zostały przekierowane. Przekierowania określa się na linii poleceń w momencie uruchomienia programu.

Przekierowanie ''stdin'' z pliku:
<source lang=bash>
$ program.py < plik_wejsciowy.txt
$ < plik_wejsciowy.txt program.py
</source>

Oba powyższe polecenia są równoważne i skutkują tym, że dane czytane przez program z <tt>sys.stdin</tt> będą tak na prawdę pochodzić z pliku o podanej nazwie (a treść wprowadzana z klawiatury będzie w programie niedostępna).

Przekierowanie ''stdout'' do pliku:
<source lang=bash>
$ program.py > plik_wyjscia.txt
$ > plik_wyjscia.txt program.py
</source>

Dane pisane do <tt>sys.stdout</tt> nie pojawią się w oknie terminala, tylko znajdą się w pliku. Dane pisane do <tt>sys.stderr</tt> dalej będą trafiać na ekran.

Przekierowania równoczesne:
<source lang=bash>
$ program.py < plik_wejsciowy.txt > plik_wyjscia.txt
</source>

Oba poprzednio opisane przekierowania można również wykonać równocześnie. Elementy polecenia również mogą wystąpić w innym porządku.

Przekierowanie ''stderr'':
<source lang=bash>
$ program.py 2> plik_bledow.txt
</source>

Komunikaty o błędach i ostrzeżenia znajdą się w pliku o podanej nazwie, zamiast na ekranie. Analogicznie do <tt>2></tt>, strumieniom ''stdout'' i ''stdin'' przypisane są numerki 1 i 0 - można więc pisać odpowiednio <tt>1></tt> i <tt>0<</tt>, ale tu te wartości numerów strumieni przekierowanych (naprawdę - ''deskryptorów plików'') są domyślne i niemal zawsze się je pomija.

===Potoki===

Oprócz przekierowania do i z plików, istnieje jeszcze analogiczny mechanizm, gdzie np. strumień ''stdout'' jednego procesu łączy się z strumieniem ''stdin'' innego procesu - skutkiem czego dane wyjściowe pierwszego są wprowadzane do drugiego jako dane wejściowe, tworząc to co się nazywa ''potokiem''. Najprostszy przykład:
<source lang=bash>
$ program1.py | program2.py
</source>
tu ''operatorem potoku'' w systemowej linii poleceń jest znak kreski pionowej (<tt>|</tt>), a <tt>program1.py</tt> przekazuje wyniki swojej pracy do dalszego przetwarzania kolejnemu, <tt>program2.py</tt>. Taki potok może mieć więcej niż dwa etapy i może łączyć się z zastosowaniem przekierowań do plików, np.
<source lang=bash>
$ < plik_wejsciowy.txt program1.py 2>bledy.txt | program2.py > plik_wynikow.txt
</source>

Pożytecznym narzędziem do stosowania w potokach jest polecenie (program) o nazwie <tt>tee</tt>:
<source lang=bash>
$ program.py < dane.txt | tee wynik.txt
</source>
w tym przypadku program wczyta zawartość pliku <tt>dane.txt</tt>, a wynik wypisany do <tt>sys.stdout</tt> zarówno pojawi się na ekranie (w oknie terminala, jak i zostanie zapisany w pliku <tt>wynik.txt</tt>.

==Odczyt linii poleceń==

Zawartość linii poleceń dostępna jest w obiekcie <tt>sys.argv</tt> - czyli moduł (standardowy) <tt>sys</tt>, element <tt>argv</tt>. Jest to lista argumentów - ,,słów" jakie wywołujący program umieścił w linii poleceń. Inaczej mówiąc, treść linii poleceń ulega wstępnemu rozbiorowi - na słowa, według reguł zależnych od systemu operacyjnego. Najczęściej poszczególne słowa oddzielają spacje (jedna lub więcej), jeśli chcemy, by ciąg zawierający spacje był potraktowany jako pojedyncze słowo (np. nazwa pliku zawierająca spacje), należy ciąg ten np. umieścić w cudzysłowach (które zostaną usunięte z treści argumentu). Treść linii poleceń na ogół ulega jeszcze innym formom obróbki przez system operacyjny (np. rozwijanie rozmaitych skrótów), ale dzieje się to poza kontrolą Pythona.

<source lang=python>

from sys import argv
for arg in argv:
print(arg)

</source>

Korzystając z powyższego kodu możemy dowiedzieć się, jak wygląda lista argumentów już ''po'' jej obróbce przez system operacyjny.

Na początku listy <tt>argv</tt> czyli w pozycji <tt>arv[0]</tt> znajduje się nazwa uruchomionego programu (tj. nazwa pliku z kodem uruchomionego jako program główny).

===Przykłady===

=1.=
Jeśli przewidujemy, że jedynymi argumentami wywołania naszego programu będą nazwy plików, na każdym z których należy wykonać jakąś czynność, to można to zrealizować tak:
<source lang=python>

#! /usr/bin/python3

from sys import argv

def przetwarzaj(plik):
# tu określamy na czym polega "przetworzenie" pliku

for plik in argv[1:]:
przetwarzaj(plik)

</source>

*Wzięcie wycinku z <tt>argv</tt> służy pominięciu pliku zawierającego kod programu;
*Elementami <tt>argv</tt> są ''nazwy'' plików - napisy.

=2.=
Nieraz jest pożądane, aby program przetwarzający strumień danych mógł działać na dwa sposoby: albo wywołany z argumentami będącymi nazwami plików z danymi wejściowymi wczytuje kolejno zawartość tych plików; albo wywołany bez takich argumentów, czyta dane wejściowe ze standardowego strumienia wejściowego, w którym one znajdują się zazwyczaj w wyniku poprzedniego kroku przetwarzania potokowego. Nota bene w ten sposób działa wiele tradycyjnych narzędzi systemowych w Linuxie.

W standardowej bibliotece Pythona jest moduł <tt>fileinput</tt>, który ułatwia realizację takiego podejścia. W najprostszym przypadku:

<source lang=python>
#! /usr/bin/python3

import fileinput

def przetwarzaj(linia):
# tu określamy na czym polega przetworzenie linii treści

for linia in fileinput.input():
przetwarzaj(linia)
</source>

W pętli w powyższym przykładzie wystąpią kolejno wszystkie linie w treści plików wymienionych na linii poleceń (z pominięciem pliku samego programu), lub jeśli linia poleceń jest pusta — linie w treści <tt>sys.stdin</tt>. Ewentualnie można wywołać funkcję <tt>fileinput.input(pliki)</tt>, tj. zamiast bez argumentów to z argumentem będącym sekwencją nazw plików zawierających dane wejściowe. Może to być np. lista argumentów programu, ale po usunięciu z niej pozycji będących opcjami, a nie nazwami plików. Oczywiście w dokumentacji znajdziemy jeszcze dalsze możliwości.

=Ćwiczenia=

1. Napisać program, który wczyta dany plik linia po linii i znajdzie wśród nich podzbiór linii o maksymalnej długości (w znakach) oraz wartość tej maksymalnej długości. Niech wynikiem działania programu będzie wypisanie liczby oznaczającej maksymalną długość linii występujących w badanym pliku, a następnie - treść tych linii, w kolejności w jakiej pojawiały się w pliku. Wypróbować ten program na pliku ''/usr/share/dict/words''. W końcowej wersji program powinien operować na pliku, którego nazwę podamy jako argument na linii poleceń.

''Wskazówka:'' długość linii nie powinna uwzględniać kodu przejścia do nowej linii, zapisywanego symbolicznie jako <tt>'\n'</tt> kończącego (prawie) każdą linię.

2. Napisać program, który wczyta dany plik linia po linii i znajdzie wśród nich podzbiór linii o danej długości w znakach. Niech wynikiem działania programu będzie wypisanie linii o żądanej długości występujących w treści pliku w takiej kolejności, w jakiej pojawiały się w pliku. Długość szukanych linii podajemy jako pierwszy, a nazwę badanego pliku jako drugi argument na linii poleceń.

3. Napisać program, który wyznaczy rozkład długości linii w treści danego pliku - nazwę pliku podajemy na linii poleceń. Wynikiem działania programu jest wypisanie ciągu linijek postaci <tt>''długość'' : ''ile''</tt>, gdzie liczba ''ile'' opisuje, ile linii o danej długości wystąpiło w treści pliku. Pozycje, w których ''ile'' wynosiłoby 0 nie pojawiają się.

4. Napisać program, który wyznacza częstości występowania w treści pliku określonych znaków. Zestaw znaków, których wystąpienia zamierzamy zliczać podajemy jako pierwszy argument na linii poleceń, nazwę badanego pliku jako drugi. Wynikiem działania programu jest wypisanie ciągu linijek postaci <tt>''znak'' : ''częstość''</tt>.

5. Napisać program, który znajduje w pliku ''/usr/share/dict/words'' wszystkie słowa, składające się z tych samych liter co słowo, podane jako argument na linii poleceń - choć niekoniecznie występujących tę samą liczbę razy. Inaczej mówiąc, każda z liter występujących w podanym słowie występuje również w słowach szukanych, a nie występują w nich żadne inne znaki. Program wypisuje na ekran znalezione słowa, po jednym na linijkę.

6. Niech program znajduje wszystkie słowa, jakie można utworzyć korzystając z danego zestawu liter (podanego jako pierwszy argument na linii poleceń); tzn. tak jak w ''Scrabble'' dysponujemy takimi literami i w takiej liczbie, jakie składają się na to słowo (lub ,,słowo"). Źródłem słów jakie można utworzyć jest plik podany jako drugi argument (domyślnie - ''/usr/share/dict/words''). 
''Wskazówka:'' może się tu przydać operacja <tt>L.remove(x)</tt>, gdzie <tt>L</tt> jest listą; usuwa ona z listy pierwsze z kolei znalezione w niej wystąpienie elementu <tt>x</tt>. 
''Uwaga:'' operacja ta zwróci błąd, jeśli element <tt>x</tt> ''nie'' występuje w <tt>L</tt>.

----

[[PPy3/Moduły|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/NumPy|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 13:26, 4 sie 2016 (CEST)

PPy3/Funkcje

2023-05-10T13:32:11Z

RobertJB: /* Definiowanie funkcji */

=Funkcje=

Gdy raz wymyślimy jakiś sprytny algorytm, to nie ma co go za każdym razem odkrywać na nowo. Żeby było łatwiej pisać raz, a korzystać wielokrotnie - wymyślono funkcje.

==Definiowanie funkcji==

<source lang=python>
def funkcja(x, y):
BLOK INSTRUKCJI
</source>

*Definicja funkcji to instrukcja złożona, podobna w strukturze do tych, które już znamy - instrukcji warunkowej i pętli.
*Wykonanie definicji funkcji ''nie wiąże się z natychmiastowym wykonaniem zawartego w niej bloku''.
*W definicji funkcji (przykładowej) <tt>x</tt> i <tt>y</tt> to ''parametry formalne''; nie mają one w tym momencie określonych wartości, są miejscami do wypełnienia konkretnymi wartościami, gdy funkcję postanowimy użyć. Może ich być (niemal) dowolnie wiele, w tym — zero. W tym ostatnim przypadku piszemy pustą parę nawiasów.
*Wykonanie definicji funkcji polega na nadaniu znaczenia jej nazwie, która odtąd będzie oznaczała ciąg instrukcji stanowiących wewnętrzny blok.
*Użycie czyli ''wywołanie'' funkcji to wyrażenie postaci

<source lang=python>
funkcja(x, y)
</source>

gdzie <tt>x</tt> i <tt>y</tt> mają już konkretne wartości (w tym miejscu mogą stać również wyrażenia złożone), które będą użyte w instrukcjach stanowiących definicję.

*W definicji na ogół występuje (raz lub więcej razy) słowo (instrukcja) <tt>return</tt>. Oznacza ono, że w tym miejscu wykonanie funkcji się kończy - funkcja powraca. Wartość wyrażenia po słowie <tt>return</tt> stanowi wynik zwracany przez funkcję - czyli wartość wyrażenia, będącego wywołaniem funkcji.
*Jeśli <tt>return</tt> nie ma, albo nie ma po nim wartości zwracanej, albo wykonanie funkcji kończy się ,,wypadnięciem" przez koniec bloku, wartością zwracaną jest <tt>None</tt> — która w zasadzie do niczego się specjalnie nie nadaje, poza sprawdzeniem, czy mamy do czynienia z właśnie tą wartością.
*''funkcja'' w Pythonie (i większości języków programowania) to coś nieco podobnego do funkcji (odwzorowania) w matematyce, ale '''to nie jest to samo pojęcie''':
**w Pythonie wywołanie funkcji może mieć skutki uboczne;
**wynik funkcji, w tym skutki uboczne, może zależeć nie tylko od argumentów wywołania.
Skutkami ubocznymi wywołania nazywamy jakiekolwiek efekty tej instrukcji, które nie sprowadzają się do wartości zwracanej. A więc, zmianę wartości innych zmiennych, czy np. wysłanie jakichś danych siecią, lub wypisanie czegoś na ekran.
*Funkcja może być wartością zmiennej; inaczej mówiąc, funkcja może być znana pod dodatkowymi nazwami (aliasami), może być włożona do listy na którąś z jej pozycji itp.

<source lang=python>
ff = funkcja
...
wynik = ff(x)
</source>

*,,Oryginalna" nazwa funkcji, czyli występująca w jej definicji, jest jednak w pewnym sensie uprzywilejowana.
*Zmienne (nazwy) '''powołane do życia''' wewnątrz funkcji są lokalne; ich wartości ,,żyją" tylko póki wykonuje się funkcja.
*Zmienne lokalne powielające nazwy ,,zewnętrzne" względem funkcji przesłaniają te zewnętrzne. Chyba, że użyjemy deklaracji <tt>global</tt>:
<source lang=python>
x = 1
def podwojx(): # to nie zadziała:
x = x * 2
podwojx()
UnboundLocalError Traceback (most recent call last)
<ipython-input-3-6edd575e5cda> in <module>()
----> 1 podwojx()

<ipython-input-1-1da635f42ffa> in podwojx()
1 def podwojx():
----> 2 x *= 2
3

UnboundLocalError: local variable 'x' referenced before assignment
</source>

Jak widzimy, komunikat o błędzie pojawił się dopiero w wyniku wywołania błędnej funkcji.

<source lang=python>
x = 1
def podwojx(): # to zadziała - co nie znaczy, że jest mądre...
global x
x = x * 2
podwojx()
print x
→ 2
</source>

Należy unikać takich sztuczek, jak powyżej; jeśli już, to:

<source lang=python>
def podwoj(x):
return 2 * x
liczba = 1
print podwoj(liczba)
→ 2
</source>

''Wskazówka:'' każde użycie deklaracji <tt>global</tt> w programie powinno być dobrze uzasadnione. Jeżeli używamy jej więcej niż sporadycznie, to coś jest nie tak.

Funkcja może być

*zeroargumentowa — wówczas zarówno w definicji, jak i w wywołaniu po nazwie występuje pusta para nawiasów,
*jednoargumentowa (jak powyższa <tt>podwoj</tt>),
*dwuargumentowa (jak przykładowa),
*trzy-, cztero-, ... itd.
*o zmiennej liczbie argumentów, z wartościami domyślnymi dla brakujących:

<source lang=python>
def dodaj(x, y=1):
return x + y
dodaj(2, 3)
→ 5
dodaj(2)
→ 3
</source>

Parametry z wartościami domyślnymi muszą występować na końcu listy parametrów.
*o zmiennej liczbie argumentów, ale bez wartości domyślnych, np.:

<source lang=python>
def ile(*args):
return len(args)
</source>

Działa to tak: <tt>'*'</tt> postawiona przed nazwą argumentu oznacza, że wszystkie (ew. dalsze) argumenty
zostaną zebrane w jedną listę, która dostępna jest wewnątrz funkcji pod nazwą, jaką postawiliśmy po gwiazdce. W powyższym przykładzie, funkcja <tt>ile</tt> zwraca jako swój wynik po prostu liczbę argumentów, z jakimi funkcja została wywołana. Operator <tt>'*'</tt> nie ma tu wiele wspólnego z mnożeniem. Odróżniamy go od mnożenia po tym, że po jego lewej stronie nie stoi żaden czynnik. Ten sam operator może wystąpić również w roli poniekąd odwrotnej, np.:

<source lang=python>
lista = [*range(5)]
print(*lista)
→ 0 1 2 3 4
</source>

W pierwszej linii, gwiazdka niejako ,,rozwija" sekwencję <tt>range(5)</tt> w ciąg wartości (kolejnych liczb) wstawionych pod operator <tt>[...]</tt>; w linii drugiej, <tt>lista</tt> jest również ,,rozpakowana" w
ciąg oddzielnych argumentów wywołania funkcji <tt>print</tt> — sprawdź, że wynik <tt>print(lista)</tt> wyglądałby nieco inaczej.

=Ćwiczenia=

1. Napisz funkcję <tt>pierwiastki(a, b, c)</tt>, która wypisuje na ekran (za pomocą wywołania <tt>print</tt>) pierwiastki równania kwadratowego o wspołczynnikach ''a'', ''b'' i ''c'': <tt>a * x**2 + b * x + c == 0</tt>. W przypadku, gdy pierwiastków nie ma, wypisuje komunikat ''Równanie nie ma pierwiastków.'' W przypadku, gdy ''a=0'', wypisuje komunikat ''Błędne dane: a==0'' i kończy działanie.

2. Napisz analogiczną funkcję, która zamiast bezpośrednio wypisywać rozwiązania, zwraca je jako wynik swojego działania. Wypisaniem ich na ekran zajmuje się odrębna instrukcja. W przypadku, gdy pierwiastków nie ma, zwraca wartość <tt>None</tt>. Nie sprawdzaj warunku ''a!=0'' - co się dzieje, gdy nie jest spełniony przez argumenty wywołania funkcji?

3. Napisz funkcję <tt>silnia(n)</tt>, która oblicza i zwraca wartość silni: <tt>n! := 1 * 2 * 3 * ... (n - 1) * n</tt>. Uwzględnij, że przyjmuje się że <tt>0! = 1</tt>, natomiast dla liczb ujemnych silnia nie jest określona - co można zasygnalizować zwracając jako wynik <tt>None</tt>. Użyj pętli <tt>for</tt> i funkcji <tt>range</tt>.

4. Funkcję silnia można zdefiniować w sposób rekurencyjny - za pomocą następujących warunków:
<blockquote>
<tt>n! == None</tt> dla <tt>n < 0</tt> 
<tt>0! == 1</tt> 
<tt>n! == n * (n - 1)!</tt>
</blockquote>
Napisz kod funkcji <tt>silnia(n)</tt> realizujący powyższą definicję. Porównaj działanie tego kodu z realizacją tej funkcji z poprzedniego przykładu dla dużych wartości <tt>n</tt>.

----

[[PPy3/SekwencjeIIteracja|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/Kolekcje|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 16:10, 30 cze 2016 (CEST)

PPy3/InstrukcjaWarunkowa

2023-05-10T11:20:13Z

RobertJB: /* Wyrażenie warunkowe */

=Instrukcja warunkowa=

Zasadniczo każdy program w Pythonie składa się z ciągu instrukcji, które są wykonywane w kolejności, w jakiej zostały zapisane. W programowaniu potrzebna jest jednak możliwość podejmowania decyzji o przyjęciu różnych kursów postępowania, w zależności od danych z jakimi mamy do czynienia. Umożliwiają to instrukcje złożone, a szczególnie - instrukcja warunkowa.

Instrukcja warunkowa to pierwszy przykład instrukcji złożonej. W najprostszej postaci składa się ona z ciągu (jednej lub więcej) instrukcji ujętych w blok, który jako całość będzie wykonany lub nie, w zależności od tego, czy spełniony jest pewien warunek - co zależy zazwyczaj od aktualnych wartości pewnych zmiennych. Warunek ten zapisuje się w postaci wyrażenia logicznego.

<blockquote>
Wśród instrukcji tworzących blok warunkowy mogą oczywiście się pojawić również instrukcje złożone, nie tylko instrukcje proste. Na przykład, kolejne instrukcje warunkowe.
</blockquote>

==Przykład minimalny:==

<source lang=python>
x1, x2 = None, None
if delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print(x1, x2)
</source>

Linijka z wywołaniem <tt>print</tt> nie jest już częścią instrukcji warunkowej, tylko kolejną instrukcją.

'''Do zapamiętania''':
*wiersz otwierający instrukcję złożoną (czyli tu: zaczynająca się od <tt>if</tt>) zawsze kończy się dwukropkiem
*instrukcje tworzące blok w instrukcji złożonej są pisane z wcięciem, które musi być jednolite — oczywiście jeżeli częścią bloku jest kolejna instrukcja złożona, to dodaje ona swoje, kolejne wcięcie
*koniec bloku rozpoznaje się po powrocie do uprzedniego poziomu wcięcia
*blok instrukcji pod <tt>if ...</tt> nie może być pusty. Instrukcja <tt>if</tt> z pustym blokiem warunkowym jest nie tylko nieprzydatna, ale jest również błędem składniowym. Jeżeli (tymczasowo?) chcemy pozostawić instrukcję warunkową bez wnętrza, to możemy tam wpisać instrukcję <tt>pass</tt> — jest to instrukcja pusta (,,nie rób nic").

==Przykład bardziej złożony:==

<source lang=python>
if a == 0:
print('Równanie nie jest kwadratowe.')
elif delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print('Są dwa pierwiastki: x1 =', x1, 'x2 =', x2)
elif delta == 0:
x = -b / 2 / a
print('Jest tylko jeden pierwiastek: x =', x)
else: # delta < 0:
print('Nie ma pierwiastków rzeczywistych.')
</source>

Jak to działa?

*Jeżeli spełniony jest warunek <tt>a == 0</tt>, wykonany zostanie blok poniżej <tt>if ...</tt>, a reszta instrukcji zostanie pominięta;
*Jeżeli warunek ten jest nieprawdziwy (i tylko wtedy), to sprawdzane są kolejno warunki umieszczone w wierszach zaczynających się od <tt>elif</tt>. Jeśli któryś z nich okaże się prawdziwy, to blok poniżej tej linijki zostanie wykonany, a cała reszta - pominięta;
*Jeżeli żaden z warunków - tych po <tt>if</tt>, i tych po wszystkich <tt>elif</tt> - nie okazał się prawdziwy, wykonany zostanie blok związany z <tt>else</tt>.
*Bloków <tt>elif</tt> może być w instrukcji dowolnie wiele (w tym - wcale), <tt>if</tt> jest obowiązkowy (inaczej nie byłoby instrukcji warunkowej) i tylko jeden, <tt>else</tt> może wystąpić wyłącznie na końcu - jeden raz, lub wcale.
*Komentarz po <tt>else:</tt> jest podpowiedzią dla czytającego, że skoro już zbadano warunki <tt>delta == 0</tt> oraz <tt>delta > 0</tt>, a wykonanie dotarło do tej linijki, to <tt>delta < 0</tt> jest jedyną pozostałą możliwością (o ile możemy założyć, że <tt>delta</tt> jest na pewno liczbą!). Jest on przeznaczony wyłącznie dla ludzkich oczu - interpreter go zignoruje, jak każdy komentarz.

<blockquote>
Mam nadzieję, że czytający już zauważył, że <tt>and not a == 0</tt> w trzeciej linijce jest niepotrzebne. Dlaczego?
</blockquote>

==Wyrażenie warunkowe==

Innym sposobem uzależnienia wyniku działania od jakiegoś warunku jest tzw. ''wyrażenie warunkowe''. Jest ono szczególnie wygodne w prostych przypadkach, i pozwala zapisać pewne działania w bardziej zwięzły sposób.

Przykład: chcemy, aby z nazwą <tt>wbx</tt> wiązała się wartość bezwzględna (moduł) aktualnej wartości (liczby) <tt>x</tt>. Za pomocą instrukcji warunkowej można to zrealizować tak:

<source lang=python>
if x < 0:
wbx = -x
else:
wbx = x
</source>

Ten sam wynik można osiągnąć za pomocą wyrażenia warunkowego:

<source lang=python>
wbx = -x if x < 0 else x
</source>

W wyrażeniu warunkowym nie ma opcji uwzględnienia dodatkowych możliwości za pomocą <tt>elif</tt>.

=Ćwiczenia=

W programach ćwiczebnych nieraz przyda nam się funkcja <tt>input()</tt>. Działa ona w sposób następujący: argumentem wywołania powinien być jakiś napis (np. w postaci stałej napisowej): <tt>input('podaj jakąś liczbę całkowitą: ')</tt>. Gdy w programie przyjdzie kolej na wykonanie takiego wywołania, program wypisze ten napis do terminalu i będzie oczekiwał na reakcję użytkownika, czyli wpisanie czegoś z klawiatury (i zakończenie naciśnięciem klawisza ''Enter''). Gdy to nastąpi, wynikiem wywołania funkcji <tt>input</tt> w programie będzie treść wpisana prze użytkownika (bez końcowego znaku nowej linii).

''Uwaga:'' wartość zwracana przez <tt>input()</tt> zawsze jest napisem, a nie liczbą - choćby się składał z samych cyfr.

1. Napisz program, którego uruchomienie ma następujący skutek:
*program wita użytkownika (komunikatem w terminalu),
*prosi o wprowadzenie liczby całkowitej,
*sprawdza, czy liczba ta jest podzielna przez 7, i informuje o wyniku tego sprawdzenia

2. Napisz program, którego uruchomienie ma następujący skutek:
* program prosi użytkownika o podanie swojego (lub czyjegoś) wieku w latach
* jeśli wiek jest ujemny, odpowiada ,,Nieprawidłowy wiek"
* jeśli wiek wynosi 0, odpowiada ,,niemowlę"
* jeśli wiek jest poniżej 18, odpowiada ,,dziecko"
* jeśli wiek jest pomiędzy 18 a 120 (włącznie), odpowiada ,,dorosły"
* jeśli wiek przekracza 120, odpowiada ,,ludzie tyle nie żyją"

''CDN''

----

[[PPy3/StałeIZmienne|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/SekwencjeIIteracja|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 15:42, 28 cze 2016 (CEST)

PPy3/InstrukcjaWarunkowa

2023-05-10T11:18:55Z

RobertJB: /* Przykład minimalny: */

=Instrukcja warunkowa=

Zasadniczo każdy program w Pythonie składa się z ciągu instrukcji, które są wykonywane w kolejności, w jakiej zostały zapisane. W programowaniu potrzebna jest jednak możliwość podejmowania decyzji o przyjęciu różnych kursów postępowania, w zależności od danych z jakimi mamy do czynienia. Umożliwiają to instrukcje złożone, a szczególnie - instrukcja warunkowa.

Instrukcja warunkowa to pierwszy przykład instrukcji złożonej. W najprostszej postaci składa się ona z ciągu (jednej lub więcej) instrukcji ujętych w blok, który jako całość będzie wykonany lub nie, w zależności od tego, czy spełniony jest pewien warunek - co zależy zazwyczaj od aktualnych wartości pewnych zmiennych. Warunek ten zapisuje się w postaci wyrażenia logicznego.

<blockquote>
Wśród instrukcji tworzących blok warunkowy mogą oczywiście się pojawić również instrukcje złożone, nie tylko instrukcje proste. Na przykład, kolejne instrukcje warunkowe.
</blockquote>

==Przykład minimalny:==

<source lang=python>
x1, x2 = None, None
if delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print(x1, x2)
</source>

Linijka z wywołaniem <tt>print</tt> nie jest już częścią instrukcji warunkowej, tylko kolejną instrukcją.

'''Do zapamiętania''':
*wiersz otwierający instrukcję złożoną (czyli tu: zaczynająca się od <tt>if</tt>) zawsze kończy się dwukropkiem
*instrukcje tworzące blok w instrukcji złożonej są pisane z wcięciem, które musi być jednolite — oczywiście jeżeli częścią bloku jest kolejna instrukcja złożona, to dodaje ona swoje, kolejne wcięcie
*koniec bloku rozpoznaje się po powrocie do uprzedniego poziomu wcięcia
*blok instrukcji pod <tt>if ...</tt> nie może być pusty. Instrukcja <tt>if</tt> z pustym blokiem warunkowym jest nie tylko nieprzydatna, ale jest również błędem składniowym. Jeżeli (tymczasowo?) chcemy pozostawić instrukcję warunkową bez wnętrza, to możemy tam wpisać instrukcję <tt>pass</tt> — jest to instrukcja pusta (,,nie rób nic").

==Przykład bardziej złożony:==

<source lang=python>
if a == 0:
print('Równanie nie jest kwadratowe.')
elif delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print('Są dwa pierwiastki: x1 =', x1, 'x2 =', x2)
elif delta == 0:
x = -b / 2 / a
print('Jest tylko jeden pierwiastek: x =', x)
else: # delta < 0:
print('Nie ma pierwiastków rzeczywistych.')
</source>

Jak to działa?

*Jeżeli spełniony jest warunek <tt>a == 0</tt>, wykonany zostanie blok poniżej <tt>if ...</tt>, a reszta instrukcji zostanie pominięta;
*Jeżeli warunek ten jest nieprawdziwy (i tylko wtedy), to sprawdzane są kolejno warunki umieszczone w wierszach zaczynających się od <tt>elif</tt>. Jeśli któryś z nich okaże się prawdziwy, to blok poniżej tej linijki zostanie wykonany, a cała reszta - pominięta;
*Jeżeli żaden z warunków - tych po <tt>if</tt>, i tych po wszystkich <tt>elif</tt> - nie okazał się prawdziwy, wykonany zostanie blok związany z <tt>else</tt>.
*Bloków <tt>elif</tt> może być w instrukcji dowolnie wiele (w tym - wcale), <tt>if</tt> jest obowiązkowy (inaczej nie byłoby instrukcji warunkowej) i tylko jeden, <tt>else</tt> może wystąpić wyłącznie na końcu - jeden raz, lub wcale.
*Komentarz po <tt>else:</tt> jest podpowiedzią dla czytającego, że skoro już zbadano warunki <tt>delta == 0</tt> oraz <tt>delta > 0</tt>, a wykonanie dotarło do tej linijki, to <tt>delta < 0</tt> jest jedyną pozostałą możliwością (o ile możemy założyć, że <tt>delta</tt> jest na pewno liczbą!). Jest on przeznaczony wyłącznie dla ludzkich oczu - interpreter go zignoruje, jak każdy komentarz.

<blockquote>
Mam nadzieję, że czytający już zauważył, że <tt>and not a == 0</tt> w trzeciej linijce jest niepotrzebne. Dlaczego?
</blockquote>

==Wyrażenie warunkowe==

Innym sposobem uzależnienia wyniku działania od jakiegoś warunku jest tzw. ''wyrażenie warunkowe''. Jest ono szczególnie wygodne w prostych przypadkach, i pozwala zapisać pewne działania w bardziej zwięzły sposób.

Przykład: chcemy, aby z nazwą <tt>wbx</tt> wiązała się wartość bezwzględna (moduł) aktualnej wartości (liczby) <tt>x</tt>. Za pomocą instrukcji warunkowej można to zrealizować tak:

<source lang=python>
if x < 0:
wbx = -x
else:
wbx = x
</source>

Ten sam wynik można osiągnąć za pomocą wyrażenia warunkowego:

<source lang=python>
wbx = -x if x < 0 else x
</source>

W wyrażeniu warunkowym nie ma opcji uwzględnienie dodatkowych możliwości za pomocą <tt>elif</tt>.

=Ćwiczenia=

W programach ćwiczebnych nieraz przyda nam się funkcja <tt>input()</tt>. Działa ona w sposób następujący: argumentem wywołania powinien być jakiś napis (np. w postaci stałej napisowej): <tt>input('podaj jakąś liczbę całkowitą: ')</tt>. Gdy w programie przyjdzie kolej na wykonanie takiego wywołania, program wypisze ten napis do terminalu i będzie oczekiwał na reakcję użytkownika, czyli wpisanie czegoś z klawiatury (i zakończenie naciśnięciem klawisza ''Enter''). Gdy to nastąpi, wynikiem wywołania funkcji <tt>input</tt> w programie będzie treść wpisana prze użytkownika (bez końcowego znaku nowej linii).

''Uwaga:'' wartość zwracana przez <tt>input()</tt> zawsze jest napisem, a nie liczbą - choćby się składał z samych cyfr.

1. Napisz program, którego uruchomienie ma następujący skutek:
*program wita użytkownika (komunikatem w terminalu),
*prosi o wprowadzenie liczby całkowitej,
*sprawdza, czy liczba ta jest podzielna przez 7, i informuje o wyniku tego sprawdzenia

2. Napisz program, którego uruchomienie ma następujący skutek:
* program prosi użytkownika o podanie swojego (lub czyjegoś) wieku w latach
* jeśli wiek jest ujemny, odpowiada ,,Nieprawidłowy wiek"
* jeśli wiek wynosi 0, odpowiada ,,niemowlę"
* jeśli wiek jest poniżej 18, odpowiada ,,dziecko"
* jeśli wiek jest pomiędzy 18 a 120 (włącznie), odpowiada ,,dorosły"
* jeśli wiek przekracza 120, odpowiada ,,ludzie tyle nie żyją"

''CDN''

----

[[PPy3/StałeIZmienne|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/SekwencjeIIteracja|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 15:42, 28 cze 2016 (CEST)

PPy3/StałeIZmienne

2023-05-10T11:11:23Z

RobertJB: /* Inne wyrażenia */

=Stałe i zmienne=

==Stałe dosłowne (literalne)==

Stałe dosłowne to takie, których wartości wprost wpisano do pliku z kodem (lub w linii poleceń interpretera). Mogą to być liczby (paru rodzajów) lub napisy, ale również różne złożone rodzaje (typy) danych, z którymi zapoznamy się nieco później.

'''Zapamiętajmy''' od razu: ''liczba'' dla komputera to zupełnie co innego, niż ''napis'' składający się z cyfr. Na napisie nie wykonamy operacji arytmetycznych - a na liczbie, operacji właściwych dla napisów (takich jak np. wyjęcie z niego znaku stojącego na określonej pozycji). Istnieją jednak operacje przekształcające każdy z tych typów danych w drugi.

===Liczby===

Dobrze jest pamiętać, że nieco odmiennie traktowane są liczby całkowite, a inaczej - liczby ułamkowe, zwykle zwane ''zmiennoprzecinkowymi'' (po angielsku ''floating point'', jako że Amerykanie piszą kropkę dziesiętną a nie - jak my - przecinek, przez co i w Pythonie używa się w tym celu kropki).

*Liczby całkowite w zapisie dziesiętnym: <tt>1024</tt>, <tt>0</tt>, <tt>-666</tt>, ...
*Liczby ułamkowe: <tt>1.0</tt>, <tt>.99</tt>, <tt>98.6</tt>, <tt>-37.43</tt>, ...
*Liczby ułamkowe w zapisie wykładniczym: <tt>1.024e3</tt>, <tt>96.9E-12</tt>, ...

Notacja <tt>e3</tt>, <tt>E-12</tt> itp. (wielka i mała litera <tt>e</tt> są tu równoważne) oznacza pomnożenie poprzedzającej liczby przez odpowiednio 103, 10-12, ... i służy ułatwieniu zapisu liczb bardzo dużych lub bardzo małych. Nie można tam wtrącać dodatkowych odstępów, podobnie jak pomiędzy cyframi.

Jeśli część całkowita (lub ułamkowa) liczby zmiennoprzecinkowej wynosi zero, to można to zero pominąć. Oczywiście nie można pominąć obu, zapisując liczbę zero! (można napisać: <tt>0.</tt> albo <tt>.0</tt>, ale nie samotną kropkę).

Podstawowa różnica pomiędzy sposobem traktowania liczb całkowitych i zmiennoprzecinkowych polega na tym, że:

*liczby całkowite mogą być dowolnie duże, a rachunki całkowitoliczbowe wykonywane są dokładnie,
*liczby ułamkowe oraz wyniki rachunków na liczbach ułamkowych należy zawsze traktować jako przybliżone (oczywiście dla szczególnych wartości zdarza się, że są one dokładne); zakres wielkości liczb ułamkowych jest ograniczony.

<blockquote>
Python zna też liczby ''zespolone'' oraz operacje na nich, ale tego zdaje się nie było w szkole...
</blockquote>

Liczby całkowite można pisać również w podstawach innych niż 10:

*dwójkowe: <tt>0b101 == 5</tt>
*ósemkowe: <tt>0o123 == 83</tt>
*szesnastkowe: <tt>0x1f == 31</tt>

(podwojony znak równości oznacza: lewa strona jest równa prawej; litery b, o, x mogą być zarówno małe jak i wielkie).

W zapisie szesnastkowym, wymagającym 16 różnych cyfr, w roli "brakujących" cyfr oznaczających liczby od 10 do 15 przyjmuje się początkowe litery alfabetu (a-f), można równoważnie używać liter małych lub wielkich.

===Napisy===

Napis (ang. ''string'') to po prostu ciąg znaków.

<blockquote>
OK, nic nie jest tak proste, jak się wydaje. Pytanie: co to jest znak? Odpowiedzi dostarcza standard ''Unicode'', w skład którego chodzi m. in. katalog wszystkich znaków, używanych przez systemy pisma wszystkich w zasadzie języków świata (języków żywych, i co ważniejszych spośród martwych). Nie będziemy się w tej chwili zastanawiać nad tym, jak dokładnie znaki te są reprezentowane w komputerze. Warto jednak pamiętać, że napisy nie muszą ograniczać się do znaków znanych z zapisu języków europejskich.
</blockquote>

Literalne stałe napisowe, czyli napisy "na twardo" wpisane do kodu, mogą być podane w paru różnych postaciach:

<source lang=python>
napis1 = 'jedna z postaci napisu'
napis2 = "nieco inna postać napisu"
napis3 = '''tak też może wyglądać napis,
i w tej postaci może zawierać przejścia do nowego wiersza
(w poprzednich nie może)'''
napis4 = """zamiast apostrofów, mogą być cudzysłowy - wychodzi na to samo,
również w postaci takiej, jak napis1 i napis2 są one równoważne"""
napis5 = "korzyść z tego pojawia się np. gdy w treści napisu potrzebujemy umieścić znak taki jak ' "
napis6 = 'w treści napisów można użyć kilku specjalnych sekwencji:\nTo powoduje przejście do nowego wiersza..'
napis7 = 'jeśli dwa napisy (lub więcej) postawimy ' 'jeden obok drugiego ' 'to zostaną połączone w jeden'
napis8 = 'lecz uwaga: pomiędzy sklejone napisy nie zostanie wstawiona żadna spacja ani w ogóle nic.'
</source>

'''Sekwencje specjalne w napisach'''

{| class="wikitable"
|-
|<tt>\\</tt>||dosłowny znak <tt>\</tt>
|-
|<tt>\'</tt>||apostrof: <tt>'</tt>
|-
|<tt>\"</tt>||cudzysłów: <tt>"</tt>
|-
|<tt>\a</tt>||kod BEL
|-
|<tt>\b</tt>||kod BS ('backspace')
|-
|<tt>\f</tt>||kod FF ('formfeed')
|-
|<tt>\n</tt>||kod LF ('linefeed')
|-
|<tt>\r</tt>||kod CR ('carriage return')
|-
|<tt>\t</tt>||kod HT ('horizontal tab')
|-
|<tt>\v</tt>||kod VT ('vertical tab')
|-
|<tt>\nnn</tt>||znak o kodzie 'nnn' w zapisie ósemkowym
|-
|<tt>\xnn</tt>||znak o kodzie 'nn' w zapisie szesnastkowym
|-
|<tt>\N{nazwa}</tt>||znak o danej nazwie symbolicznej w tabeli Unicode
|-
|<tt>\unnnn</tt>||znak o pozycji '0xnnnn' w 16-bitowej tabeli Unicode
|-
|<tt>\Unnnnnnnn</tt>||znak o pozycji '0xnnnnnnnn' w 32-bitowej tabeli Unicode
|}

To co określam tutaj nazwą ''kod'' to są szczególne ,,znaki", które nie posiadają reprezentacji graficznej, ale mogą wystąpić w strumieniu tekstowym pełniąc jakiegoś rodzaju rolę sterującą (p. poniżej). Czasami stosuje się określenie ''znaki niedrukowalne''. Jest ich więcej, niż występuje w powyższej tabeli — pozostałym nie nadano specjalnego zapisu i dostępne są np. przez notację <tt>\nnn</tt> albo <tt>\xnn</tt>, ale niezwykle rzadko bywają potrzebne.

* Wypisanie kodu BEL na terminal najczęściej skutkuje sygnałem akustycznym (''BIP!'') lub wizualnym (błysk), zależy to od ustawień emulatora terminala
* Kod BS cofa kursor o jedną pozycję, umożliwiając nadpisanie ostatniego wypisanego znaku
* Kod FF stosowano w tekście przeznaczonym do wydrukowania na drukarce wierszowej, powodował przejście do następnej strony. Obecnie ze względu na wymarcie drukarek wierszowych w zasadzie nie ma zastosowania
* Kod LF to przejście do nowej linii, inaczej - znacznik końca linii w strumieniu tekstowym
* Kod CR czyli powrót karetki cofa kursor do początku aktualnej linii
* Kod HT to ten, który zwykle nazywa się po prostu kodem tabulacji. Jego interpretacja zależy od ustawień terminala lub innego programu renderującego tekst, zwykle oznacza przeskok do pozycji będącej kolejną całkowitą wielokrotnością 4 lub 8 w bieżącej linii
* Kod VT z założenia działa analogicznie jak HT, ale w kierunku pionowym. Obecnie rzadko stosowany
* W zapisie <tt>\nnn</tt> może wystąpić jedna, dwie lub trzy cyfry ósemkowe ''n''
* W zapisie <tt>\xnn</tt> należy użyć dokładnie dwóch cyfr szesnatkowych ''n''
* W zapisie <tt>\unnnn</tt> należy użyć dokładnie czterech cyfr szesnastkowych ''n''
* W zapisie <tt>\Unnnnnnnn</tt> należy użyć dokładnie ośmiu cyfr szesnastkowych ''n''

<blockquote>
'''Uwaga:''' w plikach tekstowych utworzonych w systemie Windows linie zwykle kończą się sekwencją dwuznakową CR LF (<tt>'\r\n'</tt>) - inaczej niż w systemie Linux, gdzie znakiem końca linii jest LF. Python nie ma z tym problemu, interpretując pliki z kodem ,,łyka" obie konwencje. Ale np. jeśli w systemie Windows zapiszemy plik zaczynający się ,,magiczną" sekwencją <tt>#! /usr/bin/python3</tt>, to po przeniesieniu go na Linux nie będzie się on uruchamiał zgodnie z oczekiwaniami, gdyż Linux odczyta nazwę interpretera jak <tt>'python3\r'</tt>... Co inteligentniejsze edytory tekstu pozwalają na wybór konwencji końca linii.
</blockquote>

Jeżeli chcemy zapisać napis obfitujący w znaki <tt>\</tt>, możemy użyć notacji takiej:

<source lang="python">
napis1 = r'oto\napis\z\bakslaszami'
napis2 = R'tu\znak"\"nie\będzie\nigdy\oznaczał\początku\specjalnej\sekwencji'
</source>

Wielkość użytej na początku litery <tt>R</tt> nie ma znaczenia.

==Zmienne, czyli nazwy==

Programy oczywiście nie operują jedynie na stałych. Potrzebny jest w nich sposób odnoszenia się do wartości, które nie są znane z góry (w chwili pisania programu) - albo dlatego, że zostaną dostarczone dopiero przy uruchomieniu lub w trakcie pracy programu, jako dane wejściowe (później zobaczymy, na jakie sposoby można tego dokonać), albo dlatego, że będą wynikiem obliczeń lub przekształceń danych wykonywanych przez program.

Do tego w Pythonie służą ''zmienne'' - można je uważać za nazwy, z jakimi wiążemy pewne wartości (liczby, napisy, itd.), poprzez ''instrukcję podstawienia''. Do zapisu instrukcji podstawienia służy znak równości (<tt>=</tt>), po jego lewej stronie stawiamy nazwę (zmiennej), po drugiej - ''wyrażenie'', np. literalną stałą, ale również może być to wyrażenie zbudowane ze stałych, operatorów (np. arytmetycznych), nazw zmiennych (reprezentujących w wyrażeniu związane z nimi aktualnie wartości), i szereg innych elementów które dopiero poznamy.

'''Do zapamiętania''': pojedynczy znak równości <tt>=</tt> w Pythonie (i wielu innych językach programowania) nie tworzy ''równania'', czyli stwierdzenia, że lewa strona jest równa prawej; tylko ''podstawienie'', a więc operację powodującą, że z nazwą stojącą po stronie lewej zostaje związana obliczona wartość wyrażenie stojącego po prawej. Zauważmy, że jest to operacja niesymetryczna (stron nie można bezkarne zamienić miejscami):

<source lang=python>
i = 0 # pierwsze użycie nazwy, w tym przypadku 'i', tworzy zmienną i wiąże z nią wartość
i = i + 2 # to jest legalne, i oznacza, że wartość związana z 'i' rośnie o 2
i + 2 = i # to jest błędne, po lewej stronie nie może stać wyrażenie złożone
</source>

Pojawienie się w wyrażeniu stojącym po prawej stronie podstawienia tej samej nazwy, która stoi po lewej stronie, nie tworzy jakiejkolwiek niejednoznaczności: zasadą jest, że ''wpierw'' obliczana jest wartość wyrażenia z prawej strony, z wykorzystaniem aktualnych wartości zmiennych, a ''potem'' następuje związanie nazwy zmiennej stojącej po lewej z wynikiem.

Zauważmy, że błędem byłoby użycie nazwy po raz pierwszy ''bez'' uprzedniego nadania jej wartości, np. w wyrażeniu arytmetycznym.

===Reguły tworzenia nazw===

Aktualnie reguły określające, co jest poprawną nazwą w Pythonie, dopuszczają użycie całkiem szerokiego podzbioru znaków Unicode i są dość trudne do opisania w zrozumiały sposób. Pomijając jednak taką możliwość, że ktoś zechce użyć w nazwie zmiennej znaków pisma Kanji lub perskiego, można w dużym uproszczeniu powiedzieć tak:

*nazwy można budować z liter (wielkich i małych), cyfr, i znaku podkreślenia (<tt>_</tt>)
*z zastrzeżeniem, że pierwszym znakiem nazwy nie może być cyfra
*litery wielkie i małe są rozróżniane, tak więc nazwy różniące się jedynie wielkością liter ''są różne''
*długość nazwy nie podlega ograniczeniu
*zabronione jest użycie jako nazwy któregokolwiek z tzw. słów zastrzeżonych, które mają specjalne znaczenie w składni języka Python.[https://docs.python.org/3/reference/lexical_analysis.html#keywords Tutaj można znaleźć ich wykaz].

W szczególności, nazwy (zmiennych i innych obiektów) mogą jak najbardziej zawierać litery właściwe dla języka polskiego (oraz dla innych języków). Z rozmaitych względów nie jest to jednak szczególnie rekomendowane, lepiej (przynajmniej na razie) ograniczyć się do liter podstawowego alfabetu łacińskiego.

Oprócz twardych reguł zawartych w definicji języka, w tworzeniu nazw programiści trzymają się na ogół pewnych konwencji - które nie są w żaden sposób egzekwowane przez interpreter, ale ułatwiają czytanie kodu — zwłaszcza, gdy się nim dzielimy z innymi:

*w nazwach zmiennych używamy małych liter (a nie wielkich)
*wielkie litery rezerwujemy dla nazw oznaczających wartości stałe, które nie mają prawa się zmienić w trakcie pracy programu
*staramy się, by nazwy coś znaczyły i ułatwiały zrozumienie kodu programu
*nie unikamy nazw składających się z dwóch lub nawet kilku słów; ponieważ spacja jako składnik nazwy nie jest dozwolona, zastępujemy ją znakiem podkreślenia
*unikamy jednak nazw przesadnie długich, a nazwy zmiennych, które są potrzebne jedynie "chwilowo" mogą wręcz być jednoliterowe
*nazwy zaczynające się od podkreślenia (<tt>_</tt>) mają pewne specjalne znaczenia i nie tworzymy takich nazw, chyba że całkiem świadomie.

=Wyrażenia=

==Arytmetyczne==

Wyrażenia arytmetyczne tworzymy z udziałem znanych już operatorów arytmetycznych <tt>+, -, /, *, **, //, %, ...</tt>, ale również wywołań funkcji zwracających wartości liczbowe (więcej o tym dalej), z wykorzystaniem literalnych liczb i nazw oznaczających zmienne, których aktualne wartości powinny być liczbami. Możemy również używać nawiasów (wyłącznie okrągłych!) do grupowania podwyrażeń, aby wymusić określoną kolejność operacji. Każdy na ogół pamięta, że dzielenie i mnożenie mają pierwszeństwo przed dodawaniem i odejmowaniem; potęgowanie ma jeszcze wyższy priorytet. Gdy mamy do czynienia z operatorami o równym priorytecie, to operacje wykonywane są zgodnie z kolejnością czytania, od lewej do prawej. Jeżeli mamy wątpliwości, to użycie nawiasów nie będzie błędem. Przykłady:

<source lang=python>
a + b * c == a + (b * c)
a / b / c == (a / b) / c
a * b ** c == a * (b ** c)
a ** b ** c == a ** (b ** c)
a ** - b == a ** (-b)
a ** b / c == (a ** b) / c
</source>

Zachowanie operatora potęgowania jest tu nieco szczególne, i zgadza się z umową przyjętą w matematyce.

Operatory arytmetyczne znajdują również czasem zastosowanie do obiektów nie będących liczbami, mają wtedy oczywiście nieco inne znaczenie. Np. suma dwóch napisów jest ich sklejeniem (mówi się też: ''konkatenacją'').

W przypadku, gdy będziemy mieszać w jednym wyrażeniu liczby całkowite i zmiennoprzecinkowe, to wynik będzie liczbą zmiennoprzecinkową. Wyjątkiem jest dzielenie: <tt>a / b</tt> zawsze da w wyniku liczbę zmiennoprzecinkową, natomiast <tt>a // b</tt> - całkowitą, jeśli oba argumenty są całkowite; w przeciwnym razie, zmiennoprzecinkową (ale o zerowej części ułamkowej).

===Rozszerzone operatory przypisania===

Z dwuargumentowymi operatorami arytmetycznymi związane są tzw. ''rozszerzone operatory przypisania'', stanowiące drobne udogodnienie pozwalające w sposób bardziej zwięzły zapisać dość często występujące operacje - takie, jak powiększenie aktualnej wartości <tt>x</tt> o 1 i zapamiętanie tej nowej, powiększonej wartości pod nazwą <tt>x</tt>:

<source lang=python>
# poniższe instrukcje są parami równoważne
x = x + a
x += a
#
x = x * a
x *= a
#
x = x - a
x -= a
#
x = x / a
x /= a
#
x **= a
x = x**a
</source>

Wersja np. z potęgowaniem może jest niezbyt często przydatna, ale wprowadzono ją choćby po to, by było konsekwentnie.

==Logiczne==

Wyrażenia logiczne mogą mieć jedną z dwu wartości: Prawda (<tt>True</tt>) lub Fałsz (<tt>False</tt>). Literalne wartości <tt>True</tt> i <tt>False</tt> są też przykładami wyrażeń logicznych, choć dość mało przydatnymi. Prawdziwe lub fałszywe mogą być np. porównania dwóch wartości, tworzone za pomocą operatorów <tt>></tt>, <tt><</tt>, <tt>>=</tt>, <tt><=</tt>, <tt>==</tt>, <tt>!=</tt> (to ostatnie, to sposób w jaki w Pythonie pisze się znak nierówności). Jak już wspomniano, podwojony znak równości jest operatorem porównania (w odróżnieniu od pojedynczego - przypisania). Porównywać można przede wszystkim liczby (a więc - dowolne wyrażenia o wartościach liczbowych), ale również np. napisy - wówczas większy oznacza tyle, co dalszy w porządku leksykograficznym. Porównania mają priorytet niższy, niż operatory arytmetyczne.

<blockquote>
Przy bliższym poznaniu okazuje się, że wartości <tt>True</tt> i <tt>False</tt> są tak naprawdę w pewnym sensie liczbami: odpowiednio 1 i 0. Dozwolone jest więc np. stosowanie do nich operacji arytmetycznych.
</blockquote>

Z elementarnych wyrażeń logicznych (porównań) można tworzyć złożone wyrażenia logiczne za pomocą operatorów (spójników) logicznych, pisanych <tt>and</tt>, <tt>or</tt> i <tt>not</tt>. Mają one następujące właśności:

<source lang=python>
(a and b) == (b and a)
(False and False) == False
(False and True) == False
(True and True) == True
(a or b) == (b or a)
(False or False) == False
(False or True) == True
(True or True) == True
(not True) == False
(not False) == True
</source>

Spójniki logiczne mają priorytet jeszcze niższy, niż porównania - stąd nawiasy w powyższym. Wśród nich najwyższy priorytet ma <tt>not</tt>, następnie <tt>and</tt>, na końcu <tt>or</tt>.

Wyrażenia logiczne mają tę szczególną własność, że wartość wyrażenia można często określić obliczając jedynie część jego elementów. Np. <tt>a and b</tt>, jeżeli wartością <tt>a</tt> jest <tt>False</tt>, jest na pewno <tt>False</tt> - niezależnie od wartości <tt>b</tt>. W takich przypadkach Python przerywa obliczanie (od lewej do prawej, z uwzględnieniem nawiasów) gdy tylko wartość jest określona. Fakt ten czasami może mieć znaczenie - jeżeli np. obliczenie któregoś z członów wyrażenia logicznego jest szczególnie czasochłonne, lub ma tzw. skutki uboczne.

Wyrażenia logiczne znajdują zastosowanie przede wszystkim w instrukcji warunkowej - pozwalają określić warunki, pod jakimi pewne operacje będą wykonane, lub nie - o tym dalej.

Warto wiedzieć, że w Pythonie '''każde wyrażenie może służyć jako wyrażenie logiczne'''. Inaczej mówiąc, każda wartość (napis, liczba, lista, itd.) może być wykorzystana w charakterze wartości logicznej. Obowiązują tu proste reguły:

* liczba <tt>0</tt> jest fałszywa (równoważna <tt>False</tt>); obojętne, czy całkowita czy zmiennoprzecinkowa;
* każda liczba różna od zera jest prawdziwa (równoważna <tt>True</tt>);
* napis pusty (o długości 0) jest fałszywy, każdy inny napis jest prawdziwy (również np. zawierający wyłącznie spacje);
* ogólniej — dowolnego typu kolekcja (lista, słownik, zbiór, ...) jest prawdziwa, o ile jest niepusta; każda kolekcja pusta (0-elementowa) jest fałszywa;
* wartość pusta czyli <tt>None</tt> jest, jak nietrudno zgadnąć, fałszywa.

W przypadku ogólniejszych typów danych (obiektów klas złożonych) sytuacja może już nie być taka prosta, ponieważ twórca klasy ma moc określenia reguły decydującej o prawdziwości / nieprawdziwości obiektów danej klasy. Ten temat jest na razie poza zakresem naszego kursu.

Jeżeli chcemy wymusić, aby dana wartość stała się dosłownie wartością logiczną, tzn. jedną z (<tt>True</tt>, <tt>False</tt>) w sposób zgodny z powyższymi regułami, można to osiągnąć przykładając funkcję <tt>bool</tt>: a więc <tt>bool(wyrażenie)</tt>. Rzadko jednak bywa to potrzebne.

Reguła „skrótowej" ewaluacji wyrażeń logicznych, w połączeniu z regułami prawdziwości innych typów danych, pozwala na dość popularne idiomy, jak np.:

<source lang=python>
# jeśli `wynik' jest niepustą listą to wypisze jej zawartość
# jeśli natomiast pustą, pojawi się komunikat
print(wynik or "wynik jest pusty!")
</source>

które pozwalają uniknąć używania instrukcji złożonych w wielu prostych przypadkach. Działa to dzięki temu, że spójniki <tt>and</tt> i <tt>or</tt> nie wymuszają aby wynik był wartością logiczną:

* jeżeli <tt>a</tt> jest prawdziwe, to <tt>a or b == a</tt>, i <tt>a and b == b</tt> dla każdego <tt>b</tt>;
* jeżeli <tt>a</tt> jest fałszywe, to <tt>a and b == a</tt>, i <tt>a or b == b</tt> dla każdego <tt>b</tt>.

Inaczej w przypadku operatora <tt>not</tt>: wynikiem jego działania jest zawsze jedna z wartości logicznych, podobnie jak w przypadku funkcji <tt>bool()</tt> — tyle, że przeciwna.

==Napisowe==

Wartością wyrażenia może być również napis. Na przykład, <tt>a + b</tt>, jeżeli <tt>a</tt> i <tt>b</tt> są napisami, jest napisem utworzonym przez ich sklejenie (zauważmy, że w odróżnieniu od dodawania liczb nie jest to operacja przemienna).

<blockquote>
Wcześniej wspomniano, że dwa napisy literalne postawione obok siebie zostaną automatycznie sklejone w jeden: np. <tt>'abc' "123"</tt> jest równoważne <tt>'abc123'</tt>. Nie stosuje się to jednak np. do zmiennych o wartościach napisowych: napisanie dwóch nazw obok siebie bez operatora pomiędzy nimi jest błędem składniowym. Jest tak, ponieważ wspomniane sklejenie napisów literalnych ma miejsce na etapie ''kompilacji'' kodu - tzn. wtedy, gdy interpreter analizuje zapis programu i przekłada go na instrukcje, jakie zostaną wykonane w etapie uruchomienia - a wartości stojące za nazwami zmiennych nie są na tym etapie jednoznacznie określone.
</blockquote>

Bogatszy repertuar operacji tworzących wyrażenia o wartościach będących napisami poznamy dalej.

==Inne wyrażenia==

Oprócz liczb, napisów i wartości logicznych, Python posiada szereg dalszych, złożonych typów danych, które również mogą być wartościami wyrażeń. Wspomniano już przelotnie o kolekcjach (listy, słowniki, zbiory, ...) — służą one jako ,,pojemniki" do gromadzenia obiektów w zasadzie dowolnych typów, i zostaną omówione w dalszym ciągu. Istnieje też specjalny typ ''obiektu pustego'', mający dokładnie jednego reprezentanta: wartość specjalną <tt>None</tt>. Jeszcze innym typem danych są funkcje, z którymi się już zaraz zapoznamy.

Każdy typ obiektu w Pythonie może być wartością odpowiednio zbudowanego wyrażenia. Gdy poznamy kolejne typy danych, wprowadzimy również operacje tworzące takie wyrażenia.

=Ćwiczenia=

1. Które z następujących są poprawnymi nazwami według reguł Pythona:
nazwa1
9sił
dluga-nazwa
wykonaj_rachunki
_
to&owo
if

2. Wykazać, że poniższe równości są równoważnościami -- tzn. że zachodzą dla dowolnej kombinacji wartości <tt>a</tt> i <tt>b</tt>:

not (a or b) == not a and not b
not (a and b) == not a or not b
a or not a == True

''Wskazówka:'' stworzyć tabelki wartości wyrażeń po lewej i prawej stronie operatora porównania <tt>==</tt> dla wszystkich możliwych kombinacji wartości <tt>a</tt> i <tt>b</tt>.

3. Które z poniższych równości są tożsamościami, w wyniku działania reguł pierwszeństwa operatorów?

a / b / c == a / (b / c)
a ** b / c == (a ** b) / c
-a ** b == (-a) ** b

''CDN...''

----

[[PPy3/PierwszeKroki|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/InstrukcjaWarunkowa|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:22, 21 cze 2016 (CEST)

PPy3/StałeIZmienne

2023-05-10T10:51:40Z

RobertJB: /* Napisy */

=Stałe i zmienne=

==Stałe dosłowne (literalne)==

Stałe dosłowne to takie, których wartości wprost wpisano do pliku z kodem (lub w linii poleceń interpretera). Mogą to być liczby (paru rodzajów) lub napisy, ale również różne złożone rodzaje (typy) danych, z którymi zapoznamy się nieco później.

'''Zapamiętajmy''' od razu: ''liczba'' dla komputera to zupełnie co innego, niż ''napis'' składający się z cyfr. Na napisie nie wykonamy operacji arytmetycznych - a na liczbie, operacji właściwych dla napisów (takich jak np. wyjęcie z niego znaku stojącego na określonej pozycji). Istnieją jednak operacje przekształcające każdy z tych typów danych w drugi.

===Liczby===

Dobrze jest pamiętać, że nieco odmiennie traktowane są liczby całkowite, a inaczej - liczby ułamkowe, zwykle zwane ''zmiennoprzecinkowymi'' (po angielsku ''floating point'', jako że Amerykanie piszą kropkę dziesiętną a nie - jak my - przecinek, przez co i w Pythonie używa się w tym celu kropki).

*Liczby całkowite w zapisie dziesiętnym: <tt>1024</tt>, <tt>0</tt>, <tt>-666</tt>, ...
*Liczby ułamkowe: <tt>1.0</tt>, <tt>.99</tt>, <tt>98.6</tt>, <tt>-37.43</tt>, ...
*Liczby ułamkowe w zapisie wykładniczym: <tt>1.024e3</tt>, <tt>96.9E-12</tt>, ...

Notacja <tt>e3</tt>, <tt>E-12</tt> itp. (wielka i mała litera <tt>e</tt> są tu równoważne) oznacza pomnożenie poprzedzającej liczby przez odpowiednio 103, 10-12, ... i służy ułatwieniu zapisu liczb bardzo dużych lub bardzo małych. Nie można tam wtrącać dodatkowych odstępów, podobnie jak pomiędzy cyframi.

Jeśli część całkowita (lub ułamkowa) liczby zmiennoprzecinkowej wynosi zero, to można to zero pominąć. Oczywiście nie można pominąć obu, zapisując liczbę zero! (można napisać: <tt>0.</tt> albo <tt>.0</tt>, ale nie samotną kropkę).

Podstawowa różnica pomiędzy sposobem traktowania liczb całkowitych i zmiennoprzecinkowych polega na tym, że:

*liczby całkowite mogą być dowolnie duże, a rachunki całkowitoliczbowe wykonywane są dokładnie,
*liczby ułamkowe oraz wyniki rachunków na liczbach ułamkowych należy zawsze traktować jako przybliżone (oczywiście dla szczególnych wartości zdarza się, że są one dokładne); zakres wielkości liczb ułamkowych jest ograniczony.

<blockquote>
Python zna też liczby ''zespolone'' oraz operacje na nich, ale tego zdaje się nie było w szkole...
</blockquote>

Liczby całkowite można pisać również w podstawach innych niż 10:

*dwójkowe: <tt>0b101 == 5</tt>
*ósemkowe: <tt>0o123 == 83</tt>
*szesnastkowe: <tt>0x1f == 31</tt>

(podwojony znak równości oznacza: lewa strona jest równa prawej; litery b, o, x mogą być zarówno małe jak i wielkie).

W zapisie szesnastkowym, wymagającym 16 różnych cyfr, w roli "brakujących" cyfr oznaczających liczby od 10 do 15 przyjmuje się początkowe litery alfabetu (a-f), można równoważnie używać liter małych lub wielkich.

===Napisy===

Napis (ang. ''string'') to po prostu ciąg znaków.

<blockquote>
OK, nic nie jest tak proste, jak się wydaje. Pytanie: co to jest znak? Odpowiedzi dostarcza standard ''Unicode'', w skład którego chodzi m. in. katalog wszystkich znaków, używanych przez systemy pisma wszystkich w zasadzie języków świata (języków żywych, i co ważniejszych spośród martwych). Nie będziemy się w tej chwili zastanawiać nad tym, jak dokładnie znaki te są reprezentowane w komputerze. Warto jednak pamiętać, że napisy nie muszą ograniczać się do znaków znanych z zapisu języków europejskich.
</blockquote>

Literalne stałe napisowe, czyli napisy "na twardo" wpisane do kodu, mogą być podane w paru różnych postaciach:

<source lang=python>
napis1 = 'jedna z postaci napisu'
napis2 = "nieco inna postać napisu"
napis3 = '''tak też może wyglądać napis,
i w tej postaci może zawierać przejścia do nowego wiersza
(w poprzednich nie może)'''
napis4 = """zamiast apostrofów, mogą być cudzysłowy - wychodzi na to samo,
również w postaci takiej, jak napis1 i napis2 są one równoważne"""
napis5 = "korzyść z tego pojawia się np. gdy w treści napisu potrzebujemy umieścić znak taki jak ' "
napis6 = 'w treści napisów można użyć kilku specjalnych sekwencji:\nTo powoduje przejście do nowego wiersza..'
napis7 = 'jeśli dwa napisy (lub więcej) postawimy ' 'jeden obok drugiego ' 'to zostaną połączone w jeden'
napis8 = 'lecz uwaga: pomiędzy sklejone napisy nie zostanie wstawiona żadna spacja ani w ogóle nic.'
</source>

'''Sekwencje specjalne w napisach'''

{| class="wikitable"
|-
|<tt>\\</tt>||dosłowny znak <tt>\</tt>
|-
|<tt>\'</tt>||apostrof: <tt>'</tt>
|-
|<tt>\"</tt>||cudzysłów: <tt>"</tt>
|-
|<tt>\a</tt>||kod BEL
|-
|<tt>\b</tt>||kod BS ('backspace')
|-
|<tt>\f</tt>||kod FF ('formfeed')
|-
|<tt>\n</tt>||kod LF ('linefeed')
|-
|<tt>\r</tt>||kod CR ('carriage return')
|-
|<tt>\t</tt>||kod HT ('horizontal tab')
|-
|<tt>\v</tt>||kod VT ('vertical tab')
|-
|<tt>\nnn</tt>||znak o kodzie 'nnn' w zapisie ósemkowym
|-
|<tt>\xnn</tt>||znak o kodzie 'nn' w zapisie szesnastkowym
|-
|<tt>\N{nazwa}</tt>||znak o danej nazwie symbolicznej w tabeli Unicode
|-
|<tt>\unnnn</tt>||znak o pozycji '0xnnnn' w 16-bitowej tabeli Unicode
|-
|<tt>\Unnnnnnnn</tt>||znak o pozycji '0xnnnnnnnn' w 32-bitowej tabeli Unicode
|}

To co określam tutaj nazwą ''kod'' to są szczególne ,,znaki", które nie posiadają reprezentacji graficznej, ale mogą wystąpić w strumieniu tekstowym pełniąc jakiegoś rodzaju rolę sterującą (p. poniżej). Czasami stosuje się określenie ''znaki niedrukowalne''. Jest ich więcej, niż występuje w powyższej tabeli — pozostałym nie nadano specjalnego zapisu i dostępne są np. przez notację <tt>\nnn</tt> albo <tt>\xnn</tt>, ale niezwykle rzadko bywają potrzebne.

* Wypisanie kodu BEL na terminal najczęściej skutkuje sygnałem akustycznym (''BIP!'') lub wizualnym (błysk), zależy to od ustawień emulatora terminala
* Kod BS cofa kursor o jedną pozycję, umożliwiając nadpisanie ostatniego wypisanego znaku
* Kod FF stosowano w tekście przeznaczonym do wydrukowania na drukarce wierszowej, powodował przejście do następnej strony. Obecnie ze względu na wymarcie drukarek wierszowych w zasadzie nie ma zastosowania
* Kod LF to przejście do nowej linii, inaczej - znacznik końca linii w strumieniu tekstowym
* Kod CR czyli powrót karetki cofa kursor do początku aktualnej linii
* Kod HT to ten, który zwykle nazywa się po prostu kodem tabulacji. Jego interpretacja zależy od ustawień terminala lub innego programu renderującego tekst, zwykle oznacza przeskok do pozycji będącej kolejną całkowitą wielokrotnością 4 lub 8 w bieżącej linii
* Kod VT z założenia działa analogicznie jak HT, ale w kierunku pionowym. Obecnie rzadko stosowany
* W zapisie <tt>\nnn</tt> może wystąpić jedna, dwie lub trzy cyfry ósemkowe ''n''
* W zapisie <tt>\xnn</tt> należy użyć dokładnie dwóch cyfr szesnatkowych ''n''
* W zapisie <tt>\unnnn</tt> należy użyć dokładnie czterech cyfr szesnastkowych ''n''
* W zapisie <tt>\Unnnnnnnn</tt> należy użyć dokładnie ośmiu cyfr szesnastkowych ''n''

<blockquote>
'''Uwaga:''' w plikach tekstowych utworzonych w systemie Windows linie zwykle kończą się sekwencją dwuznakową CR LF (<tt>'\r\n'</tt>) - inaczej niż w systemie Linux, gdzie znakiem końca linii jest LF. Python nie ma z tym problemu, interpretując pliki z kodem ,,łyka" obie konwencje. Ale np. jeśli w systemie Windows zapiszemy plik zaczynający się ,,magiczną" sekwencją <tt>#! /usr/bin/python3</tt>, to po przeniesieniu go na Linux nie będzie się on uruchamiał zgodnie z oczekiwaniami, gdyż Linux odczyta nazwę interpretera jak <tt>'python3\r'</tt>... Co inteligentniejsze edytory tekstu pozwalają na wybór konwencji końca linii.
</blockquote>

Jeżeli chcemy zapisać napis obfitujący w znaki <tt>\</tt>, możemy użyć notacji takiej:

<source lang="python">
napis1 = r'oto\napis\z\bakslaszami'
napis2 = R'tu\znak"\"nie\będzie\nigdy\oznaczał\początku\specjalnej\sekwencji'
</source>

Wielkość użytej na początku litery <tt>R</tt> nie ma znaczenia.

==Zmienne, czyli nazwy==

Programy oczywiście nie operują jedynie na stałych. Potrzebny jest w nich sposób odnoszenia się do wartości, które nie są znane z góry (w chwili pisania programu) - albo dlatego, że zostaną dostarczone dopiero przy uruchomieniu lub w trakcie pracy programu, jako dane wejściowe (później zobaczymy, na jakie sposoby można tego dokonać), albo dlatego, że będą wynikiem obliczeń lub przekształceń danych wykonywanych przez program.

Do tego w Pythonie służą ''zmienne'' - można je uważać za nazwy, z jakimi wiążemy pewne wartości (liczby, napisy, itd.), poprzez ''instrukcję podstawienia''. Do zapisu instrukcji podstawienia służy znak równości (<tt>=</tt>), po jego lewej stronie stawiamy nazwę (zmiennej), po drugiej - ''wyrażenie'', np. literalną stałą, ale również może być to wyrażenie zbudowane ze stałych, operatorów (np. arytmetycznych), nazw zmiennych (reprezentujących w wyrażeniu związane z nimi aktualnie wartości), i szereg innych elementów które dopiero poznamy.

'''Do zapamiętania''': pojedynczy znak równości <tt>=</tt> w Pythonie (i wielu innych językach programowania) nie tworzy ''równania'', czyli stwierdzenia, że lewa strona jest równa prawej; tylko ''podstawienie'', a więc operację powodującą, że z nazwą stojącą po stronie lewej zostaje związana obliczona wartość wyrażenie stojącego po prawej. Zauważmy, że jest to operacja niesymetryczna (stron nie można bezkarne zamienić miejscami):

<source lang=python>
i = 0 # pierwsze użycie nazwy, w tym przypadku 'i', tworzy zmienną i wiąże z nią wartość
i = i + 2 # to jest legalne, i oznacza, że wartość związana z 'i' rośnie o 2
i + 2 = i # to jest błędne, po lewej stronie nie może stać wyrażenie złożone
</source>

Pojawienie się w wyrażeniu stojącym po prawej stronie podstawienia tej samej nazwy, która stoi po lewej stronie, nie tworzy jakiejkolwiek niejednoznaczności: zasadą jest, że ''wpierw'' obliczana jest wartość wyrażenia z prawej strony, z wykorzystaniem aktualnych wartości zmiennych, a ''potem'' następuje związanie nazwy zmiennej stojącej po lewej z wynikiem.

Zauważmy, że błędem byłoby użycie nazwy po raz pierwszy ''bez'' uprzedniego nadania jej wartości, np. w wyrażeniu arytmetycznym.

===Reguły tworzenia nazw===

Aktualnie reguły określające, co jest poprawną nazwą w Pythonie, dopuszczają użycie całkiem szerokiego podzbioru znaków Unicode i są dość trudne do opisania w zrozumiały sposób. Pomijając jednak taką możliwość, że ktoś zechce użyć w nazwie zmiennej znaków pisma Kanji lub perskiego, można w dużym uproszczeniu powiedzieć tak:

*nazwy można budować z liter (wielkich i małych), cyfr, i znaku podkreślenia (<tt>_</tt>)
*z zastrzeżeniem, że pierwszym znakiem nazwy nie może być cyfra
*litery wielkie i małe są rozróżniane, tak więc nazwy różniące się jedynie wielkością liter ''są różne''
*długość nazwy nie podlega ograniczeniu
*zabronione jest użycie jako nazwy któregokolwiek z tzw. słów zastrzeżonych, które mają specjalne znaczenie w składni języka Python.[https://docs.python.org/3/reference/lexical_analysis.html#keywords Tutaj można znaleźć ich wykaz].

W szczególności, nazwy (zmiennych i innych obiektów) mogą jak najbardziej zawierać litery właściwe dla języka polskiego (oraz dla innych języków). Z rozmaitych względów nie jest to jednak szczególnie rekomendowane, lepiej (przynajmniej na razie) ograniczyć się do liter podstawowego alfabetu łacińskiego.

Oprócz twardych reguł zawartych w definicji języka, w tworzeniu nazw programiści trzymają się na ogół pewnych konwencji - które nie są w żaden sposób egzekwowane przez interpreter, ale ułatwiają czytanie kodu — zwłaszcza, gdy się nim dzielimy z innymi:

*w nazwach zmiennych używamy małych liter (a nie wielkich)
*wielkie litery rezerwujemy dla nazw oznaczających wartości stałe, które nie mają prawa się zmienić w trakcie pracy programu
*staramy się, by nazwy coś znaczyły i ułatwiały zrozumienie kodu programu
*nie unikamy nazw składających się z dwóch lub nawet kilku słów; ponieważ spacja jako składnik nazwy nie jest dozwolona, zastępujemy ją znakiem podkreślenia
*unikamy jednak nazw przesadnie długich, a nazwy zmiennych, które są potrzebne jedynie "chwilowo" mogą wręcz być jednoliterowe
*nazwy zaczynające się od podkreślenia (<tt>_</tt>) mają pewne specjalne znaczenia i nie tworzymy takich nazw, chyba że całkiem świadomie.

=Wyrażenia=

==Arytmetyczne==

Wyrażenia arytmetyczne tworzymy z udziałem znanych już operatorów arytmetycznych <tt>+, -, /, *, **, //, %, ...</tt>, ale również wywołań funkcji zwracających wartości liczbowe (więcej o tym dalej), z wykorzystaniem literalnych liczb i nazw oznaczających zmienne, których aktualne wartości powinny być liczbami. Możemy również używać nawiasów (wyłącznie okrągłych!) do grupowania podwyrażeń, aby wymusić określoną kolejność operacji. Każdy na ogół pamięta, że dzielenie i mnożenie mają pierwszeństwo przed dodawaniem i odejmowaniem; potęgowanie ma jeszcze wyższy priorytet. Gdy mamy do czynienia z operatorami o równym priorytecie, to operacje wykonywane są zgodnie z kolejnością czytania, od lewej do prawej. Jeżeli mamy wątpliwości, to użycie nawiasów nie będzie błędem. Przykłady:

<source lang=python>
a + b * c == a + (b * c)
a / b / c == (a / b) / c
a * b ** c == a * (b ** c)
a ** b ** c == a ** (b ** c)
a ** - b == a ** (-b)
a ** b / c == (a ** b) / c
</source>

Zachowanie operatora potęgowania jest tu nieco szczególne, i zgadza się z umową przyjętą w matematyce.

Operatory arytmetyczne znajdują również czasem zastosowanie do obiektów nie będących liczbami, mają wtedy oczywiście nieco inne znaczenie. Np. suma dwóch napisów jest ich sklejeniem (mówi się też: ''konkatenacją'').

W przypadku, gdy będziemy mieszać w jednym wyrażeniu liczby całkowite i zmiennoprzecinkowe, to wynik będzie liczbą zmiennoprzecinkową. Wyjątkiem jest dzielenie: <tt>a / b</tt> zawsze da w wyniku liczbę zmiennoprzecinkową, natomiast <tt>a // b</tt> - całkowitą, jeśli oba argumenty są całkowite; w przeciwnym razie, zmiennoprzecinkową (ale o zerowej części ułamkowej).

===Rozszerzone operatory przypisania===

Z dwuargumentowymi operatorami arytmetycznymi związane są tzw. ''rozszerzone operatory przypisania'', stanowiące drobne udogodnienie pozwalające w sposób bardziej zwięzły zapisać dość często występujące operacje - takie, jak powiększenie aktualnej wartości <tt>x</tt> o 1 i zapamiętanie tej nowej, powiększonej wartości pod nazwą <tt>x</tt>:

<source lang=python>
# poniższe instrukcje są parami równoważne
x = x + a
x += a
#
x = x * a
x *= a
#
x = x - a
x -= a
#
x = x / a
x /= a
#
x **= a
x = x**a
</source>

Wersja np. z potęgowaniem może jest niezbyt często przydatna, ale wprowadzono ją choćby po to, by było konsekwentnie.

==Logiczne==

Wyrażenia logiczne mogą mieć jedną z dwu wartości: Prawda (<tt>True</tt>) lub Fałsz (<tt>False</tt>). Literalne wartości <tt>True</tt> i <tt>False</tt> są też przykładami wyrażeń logicznych, choć dość mało przydatnymi. Prawdziwe lub fałszywe mogą być np. porównania dwóch wartości, tworzone za pomocą operatorów <tt>></tt>, <tt><</tt>, <tt>>=</tt>, <tt><=</tt>, <tt>==</tt>, <tt>!=</tt> (to ostatnie, to sposób w jaki w Pythonie pisze się znak nierówności). Jak już wspomniano, podwojony znak równości jest operatorem porównania (w odróżnieniu od pojedynczego - przypisania). Porównywać można przede wszystkim liczby (a więc - dowolne wyrażenia o wartościach liczbowych), ale również np. napisy - wówczas większy oznacza tyle, co dalszy w porządku leksykograficznym. Porównania mają priorytet niższy, niż operatory arytmetyczne.

<blockquote>
Przy bliższym poznaniu okazuje się, że wartości <tt>True</tt> i <tt>False</tt> są tak naprawdę w pewnym sensie liczbami: odpowiednio 1 i 0. Dozwolone jest więc np. stosowanie do nich operacji arytmetycznych.
</blockquote>

Z elementarnych wyrażeń logicznych (porównań) można tworzyć złożone wyrażenia logiczne za pomocą operatorów (spójników) logicznych, pisanych <tt>and</tt>, <tt>or</tt> i <tt>not</tt>. Mają one następujące właśności:

<source lang=python>
(a and b) == (b and a)
(False and False) == False
(False and True) == False
(True and True) == True
(a or b) == (b or a)
(False or False) == False
(False or True) == True
(True or True) == True
(not True) == False
(not False) == True
</source>

Spójniki logiczne mają priorytet jeszcze niższy, niż porównania - stąd nawiasy w powyższym. Wśród nich najwyższy priorytet ma <tt>not</tt>, następnie <tt>and</tt>, na końcu <tt>or</tt>.

Wyrażenia logiczne mają tę szczególną własność, że wartość wyrażenia można często określić obliczając jedynie część jego elementów. Np. <tt>a and b</tt>, jeżeli wartością <tt>a</tt> jest <tt>False</tt>, jest na pewno <tt>False</tt> - niezależnie od wartości <tt>b</tt>. W takich przypadkach Python przerywa obliczanie (od lewej do prawej, z uwzględnieniem nawiasów) gdy tylko wartość jest określona. Fakt ten czasami może mieć znaczenie - jeżeli np. obliczenie któregoś z członów wyrażenia logicznego jest szczególnie czasochłonne, lub ma tzw. skutki uboczne.

Wyrażenia logiczne znajdują zastosowanie przede wszystkim w instrukcji warunkowej - pozwalają określić warunki, pod jakimi pewne operacje będą wykonane, lub nie - o tym dalej.

Warto wiedzieć, że w Pythonie '''każde wyrażenie może służyć jako wyrażenie logiczne'''. Inaczej mówiąc, każda wartość (napis, liczba, lista, itd.) może być wykorzystana w charakterze wartości logicznej. Obowiązują tu proste reguły:

* liczba <tt>0</tt> jest fałszywa (równoważna <tt>False</tt>); obojętne, czy całkowita czy zmiennoprzecinkowa;
* każda liczba różna od zera jest prawdziwa (równoważna <tt>True</tt>);
* napis pusty (o długości 0) jest fałszywy, każdy inny napis jest prawdziwy (również np. zawierający wyłącznie spacje);
* ogólniej — dowolnego typu kolekcja (lista, słownik, zbiór, ...) jest prawdziwa, o ile jest niepusta; każda kolekcja pusta (0-elementowa) jest fałszywa;
* wartość pusta czyli <tt>None</tt> jest, jak nietrudno zgadnąć, fałszywa.

W przypadku ogólniejszych typów danych (obiektów klas złożonych) sytuacja może już nie być taka prosta, ponieważ twórca klasy ma moc określenia reguły decydującej o prawdziwości / nieprawdziwości obiektów danej klasy. Ten temat jest na razie poza zakresem naszego kursu.

Jeżeli chcemy wymusić, aby dana wartość stała się dosłownie wartością logiczną, tzn. jedną z (<tt>True</tt>, <tt>False</tt>) w sposób zgodny z powyższymi regułami, można to osiągnąć przykładając funkcję <tt>bool</tt>: a więc <tt>bool(wyrażenie)</tt>. Rzadko jednak bywa to potrzebne.

Reguła „skrótowej" ewaluacji wyrażeń logicznych, w połączeniu z regułami prawdziwości innych typów danych, pozwala na dość popularne idiomy, jak np.:

<source lang=python>
# jeśli `wynik' jest niepustą listą to wypisze jej zawartość
# jeśli natomiast pustą, pojawi się komunikat
print(wynik or "wynik jest pusty!")
</source>

które pozwalają uniknąć używania instrukcji złożonych w wielu prostych przypadkach. Działa to dzięki temu, że spójniki <tt>and</tt> i <tt>or</tt> nie wymuszają aby wynik był wartością logiczną:

* jeżeli <tt>a</tt> jest prawdziwe, to <tt>a or b == a</tt>, i <tt>a and b == b</tt> dla każdego <tt>b</tt>;
* jeżeli <tt>a</tt> jest fałszywe, to <tt>a and b == a</tt>, i <tt>a or b == b</tt> dla każdego <tt>b</tt>.

Inaczej w przypadku operatora <tt>not</tt>: wynikiem jego działania jest zawsze jedna z wartości logicznych, podobnie jak w przypadku funkcji <tt>bool()</tt> — tyle, że przeciwna.

==Napisowe==

Wartością wyrażenia może być również napis. Na przykład, <tt>a + b</tt>, jeżeli <tt>a</tt> i <tt>b</tt> są napisami, jest napisem utworzonym przez ich sklejenie (zauważmy, że w odróżnieniu od dodawania liczb nie jest to operacja przemienna).

<blockquote>
Wcześniej wspomniano, że dwa napisy literalne postawione obok siebie zostaną automatycznie sklejone w jeden: np. <tt>'abc' "123"</tt> jest równoważne <tt>'abc123'</tt>. Nie stosuje się to jednak np. do zmiennych o wartościach napisowych: napisanie dwóch nazw obok siebie bez operatora pomiędzy nimi jest błędem składniowym. Jest tak, ponieważ wspomniane sklejenie napisów literalnych ma miejsce na etapie ''kompilacji'' kodu - tzn. wtedy, gdy interpreter analizuje zapis programu i przekłada go na instrukcje, jakie zostaną wykonane w etapie uruchomienia - a wartości stojące za nazwami zmiennych nie są na tym etapie jednoznacznie określone.
</blockquote>

Bogatszy repertuar operacji tworzących wyrażenia o wartościach będących napisami poznamy dalej.

==Inne wyrażenia==

Oprócz liczb, napisów i wartości logicznych, Python posiada szereg dalszych, złożonych typów danych, które również mogą być wartościami wyrażeń. Wspomniano już przelotnie o kolekcjach (listy, słowniki, zbiory, ...) — służą one jako ,,pojemniki" do gromadzenia obiektów w zasadzie dowolnych typów, i zostaną omówione w dalszym ciągu. Istnieje też specjalny typ ''obiektu pustego'', mający dokładnie jednego reprezentanta: wartość specjalną <tt>None</tt>.

Każdy typ obiektu w Pythonie może być wartością odpowiednio zbudowanego wyrażenia. Gdy poznamy kolejne typy danych, wprowadzimy również operacje tworzące takie wyrażenia.

=Ćwiczenia=

1. Które z następujących są poprawnymi nazwami według reguł Pythona:
nazwa1
9sił
dluga-nazwa
wykonaj_rachunki
_
to&owo
if

2. Wykazać, że poniższe równości są równoważnościami -- tzn. że zachodzą dla dowolnej kombinacji wartości <tt>a</tt> i <tt>b</tt>:

not (a or b) == not a and not b
not (a and b) == not a or not b
a or not a == True

''Wskazówka:'' stworzyć tabelki wartości wyrażeń po lewej i prawej stronie operatora porównania <tt>==</tt> dla wszystkich możliwych kombinacji wartości <tt>a</tt> i <tt>b</tt>.

3. Które z poniższych równości są tożsamościami, w wyniku działania reguł pierwszeństwa operatorów?

a / b / c == a / (b / c)
a ** b / c == (a ** b) / c
-a ** b == (-a) ** b

''CDN...''

----

[[PPy3/PierwszeKroki|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/InstrukcjaWarunkowa|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:22, 21 cze 2016 (CEST)

PPy3/PierwszeKroki

2023-05-10T10:07:07Z

RobertJB: /* Używanie linii poleceń interpretera */

= Pierwsze kroki =

==Podstawowe cegiełki==

*Program w Pythonie to tekst, stanowiący ciąg instrukcji; są one wykonywane przez ''interpreter'' (zasadniczo) kolejno jedna po drugiej.
*''Prosta'' instrukcja to (zasadniczo) jedna linijka, kończy się wraz z przejściem do kolejnej linii.
*Instrukcja złożona, to linijka otwierająca '''zawsze zakończona dwukropkiem''', a po niej - '''blok wcięty''', tj. ciąg instrukcji (prostych i/lub złożonych) pisanych z dodatkowym ''wcięciem'' w stosunku do linijki otwierającej; mogą to być dodatkowe (np. dwie lub cztery) spacje, lub kod tabulacji, na początku każdej linijki. Koniec instrukcji złożonej następuje wraz z powrotem do poprzedniego ''poziomu wcięcia''.
*W tekście programu można umieszczać komentarze; komentarz zaczyna się od znaku <tt>#</tt>, a kończy się wraz z końcem bieżącej linii. Komentarze nie są częścią programu, tzn. są ignorowane przy jego wykonaniu.

<blockquote>
*Wyjątki od podanych reguł, istnienie których sygnalizuje słowo ''zasadniczo'', będą przedstawione później.
*Należy się raz zdecydować, jak dokładnie będziemy tworzyć poziomy wcięcia, i konsekwentnie się tego trzymać. Najlepiej po dwie lub cztery spacje (wg. upodobań), i ustawić w opcjach edytora kodu, żeby wciśnięcie klawisza ''Tab'' skutkowało odpowiednią liczbą spacji. Mieszanie w tekście kodu spacji i tabulacji zawsze prowadzi do kłopotów.
</blockquote>

Przykłady instrukcji prostych:

<source lang=python>
x = 1 + 2
y = 2 * x
x = x + 1
print(x, y)
</source>

Przykłady instrukcji złożonych:

<source lang=python>
if x > 0:
print(x)

def dodaj1(x):
return x + 1
</source>

Ważnym elementem są komentarze:

<source lang=python>
# a teraz, powiększę x o 1
x = x + 1
</source>

*Instrukcje budowane są z wyrażeń, a wyrażenia - z nazw, stałych i operatorów.
*'''Nazwa''' może składać się z liter, cyfr i znaku podkreślenia (_). Nie może zaczynać się od cyfry. Litery małe i wielkie są rozróżniane.
*Przykładem stałych są liczby - całkowite i ułamki dziesiętne. Zamiast przecinkiem, część ułamkową oddziela się kropką.
*Inny rodzaj stałych to napisy. Można je budować na kilka sposobów:

<source lang=python>
'to jest napis'
"to jest drugi napis"
'''a to jest...
jeszcze jeden napis'''
</source>

*Ostatni przypadek to wyjątek od zasady że koniec linii kończy instrukcję. Napis podany w pierwszych dwóch postaciach nie może zawierać przejścia do nowej linii.
*Nazwy są po to, aby oznaczać nimi wartości. Wartościami mogą być np. liczby i napisy:

<source lang=python>
pi = 3.14159
komunikat = 'Uwaga!!!'
</source>

'''UWAGA:''' znak równości to nie porównanie, a ''operator przypisania''. Powoduje on, że nazwa po jego lewej stronie będzie odtąd oznaczać wartość zapisaną po prawej. W szczególności, po lewej stronie znaku równości nie może występować np. stała liczba.

*Więcej o stałych i nazwach na następnej stronie, na razie tyle nam wystarczy.
*Inne operatory, to w szczególności arytmetyka:

<source lang=python>
+ - * / // % **
</source>

'*' to mnożenie, '//' to dzielenie całkowitoliczbowe, '%' to reszta z dzielenia (na ogół stosowana do liczb całkowitych, ale niekoniecznie), '**' to potęgowanie.

*Napisy też można "dodawać":

<source lang=python>
imie = 'Jacek'
powitanie = 'witaj ' + imie
print(powitanie)
</source>

Czemu właściwie operację ,,sklejania" napisów oznaczono plusem? W matematyce zazwyczaj plus stosuje się na oznaczenie operacji przemiennych, tzn. takich, których wynik nie zależy od kolejności składników — a sklejanie napisów ewidentnie taką operacją nie jest. Ale cóż, tak się przyjęło.

==Używanie linii poleceń interpretera==

''Interpreter'' to aplikacja, która potrafi czytać tekst kodu w języku Python i wykonać zapisane w nim polecenia. Może on być używany jako samodzielne polecenie, wywoływane w oknie terminala, lub zintegrowany z środowiskiem programistycznym w rodzaju ''Spyder'' lub ''Visual Studio Code''.

Zanim zaczniemy pisać "poważne" programy, nauczymy się korzystać z ''trybu interaktywnego'' interpretera, który pozwala na wpisywanie po jednym poleceniu i natychmiastowe uzyskanie wyniku jego wykonania. Można go używać do podręcznych rachunków - zamiast kalkulatora -- i do eksperymentowania z kodem w Pythonie. Do pracy interaktywnej warto używać "wzbogaconej" wersji interpretera, wywoływanej poleceniem

<source lang=bash>
$ ipython3
</source>

w najprostszych zastosowaniach niewiele się on różni od "zwykłego" interpretera, wywoływanego przez <tt>python3</tt>, ale posiada pewne dodatkowe możliwości, które niedługo się nam przydadzą.

<blockquote>
'''UWAGA:''' polecenie <tt>ipython</tt> (bez 3) wywoła starszą wersję Pythona. I odpowiednio - <tt>python</tt> wywołuje starszą wersję "zwykłego" interpretera, a <tt>python3</tt> - wersję aktualną.
</blockquote>

===Wykonywanie rachunków===

<source lang=python>
$ ipython3
Python 3.5.1+ (default, Mar 30 2016, 22:46:26)
Type "copyright", "credits" or "license" for more information.

IPython 2.4.1 -- An enhanced Interactive Python.
? -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help -> Python's own help system.
object? -> Details about 'object', use 'object??' for extra details.

In [1]: 7 * (3 + 5)
Out[1]: 56

In [2]: 2.81 / (1.25 - .33)
Out[2]: 3.054347826086957

In [3]: 2**128
Out[3]: 340282366920938463463374607431768211456

In [4]: 1/9
Out[4]: 0.1111111111111111

In [5]: 11//9, 11%9
Out[5]: (1, 2)
</source>

Zapis wyrażeń arytmetycznych raczej nie zaskakuje. Drobne uwagi:

*spacje w zapisie wyrażenia, pomiędzy liczbami a operatorami (lub ich brak), nie mają znaczenia
*reguły pierwszeństwa operatorów (najpierw potęgowanie, potem mnożenie i dzielenie, potem odejmowanie i dodawanie,...) są w zasadzie takie, jak należy się spodziewać; kolejność operacji możemy narzucić nawiasami - ale tylko okrągłymi, które można wielokrotnie zagnieżdżać
*pisząc ułamek dziesiętny (liczbę z kropką), można pominąć część całkowitą lub ułamkową, o ile ma ona być zero (nie można jednak pominąć obu);
*liczby całkowite mogą być dowolnie duże (w ramach fizycznych ograniczeń komputera)
*operacje na ułamkach należy zawsze traktować jako przybliżone - w operacjach na liczbach ułamkowych komputer może ogarnąć tylko skończoną liczbę cyfr
*zwykłe dzielenie da zawsze wynik ułamkowy; istnieje jednak operator <tt>//</tt> dzielenia całkowitego, który odrzuca resztę
*gdy chcemy zakończyć "rozmowę" z interpreterem, piszemy <tt>exit()</tt>; jeżeli pracujemy w Linuxie, zadziała również dwukrotne <tt>Ctrl-D</tt> (tzn. trzymając naciśnięty klawisz <tt>Ctrl</tt> stukamy dwukrotnie w klawisz <tt>D</tt>)

==Jak uzyskać pomoc==

W programie IPython mamy w każdej chwili dostęp do pomocy na temat poleceń, funkcji itd. Pythona:

<source lang=python>
In [8]: print?
Type: builtin_function_or_method
String form: <built-in function print>
Namespace: Python builtin
Docstring:
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
</source>

W tym przykładzie uzyskaliśmy szczegółowy opis zastosowania funkcji wbudowanej <tt>print</tt>. Wprawdzie po angielsku, ale mam nadzieję, że nie jest to przeszkoda nie do przeskoczenia. Już niedługo będziemy dokładnie rozumieli to, co jest tu napisane.

<blockquote>
Jeżeli tekst pomocy jest dłuższy, to będzie wyświetlany w trybie pozwalającym m. in. na jego przewijanie z użyciem klawiszy strzałek czy <tt>PgUp</tt>, <tt>PgDn</tt>. Aby wyjść z tego trybu i powrócić do interpretera, wystarczy nacisnąć <tt>q</tt>.
</blockquote>

==Najprostszy program==

Za pomocą ulubionego edytora tekstowego stwórzmy plik o nazwie <tt>hello.py</tt> i następującej treści:

<source lang=python>
#! /usr/bin/python3

print('Witaj świecie!')

</source>

Zgodnie z tradycją, będzie to program wykonujący jedno banalne zadanie: wypisanie komunikatu o ustalonej treści. Zgodnie z zasadą, że programowanie w Pythonie ma być maksymalnie proste - jedynym niezbędnym elementem tego programu jest linijka wywołująca funkcję <tt>print</tt>. W tym przykładzie, uzupełniłem treść programu o pierwszą linijkę, zaczynającą się od znaku kratki (<tt>#</tt>) - istotne jest, aby była to dokładnie pierwsza linijka w pliku, i by zaczynała się od pierwszej pozycji w wierszu. Czyli, aby <tt>#!</tt> były dokładnie dwoma pierwszymi znakami w treści pliku. Z punktu widzenia Pythona, linijka ta jest komentarzem, i przy uruchamianiu pliku jest ignorowana. Pozwala ona jednak, by plik ten był automatycznie rozpoznawany przez system operacyjny (Linux) jako zawierający program w języku Python. Jaki z tego pożytek, dowiemy się za chwilę.

Aby ten program uruchomić, jest parę sposobów. Najprościej:

<source lang=bash>
$ python3 hello.py
</source>

powyższe polecenie wpisujemy w terminalu, w trybie powłoki systemowej (''nie w programie IPython!''). Tutaj musieliśmy jawnie wywołać interpreter Pythona i wskazać mu plik <tt>hello.py</tt> jako zawierający kod do uruchomienia.

Zamiast tego, możemy nadać plikowi <tt>hello.py</tt> atrybut pliku wykonywalnego, czyli programu, i uruchomić go bezpośrednio:

<source lang=bash>
$ chmod +x hello.py
$ ./hello.py
</source>

*Polecenie z pierwszej linijki wystarczy wykonać raz dla danego pliku
*Zamiast z linii poleceń, można w okienku ''Właściwości'' pliku znaleźć odpowiednie pole do kliknięcia
*Postać drugiej linijki tłumaczy się tym, że nasz program <tt>hello.py</tt> nie jest zainstalowany w systemie i nie zostanie odnaleziony przez przeszukanie standardowych lokalizacji programów na dysku. Należy wyraźnie wskazać, że chodzi o plik znajdujący się w bieżącym folderze - i to tu robimy.
*Plik z kodem w Pythonie nie musi mieć nazwy kończącej się na <tt>.py</tt> - jest to jednak wygodne, bo np. edytory tekstu traktują to jako sugestię co do zawartości pliku, i mogą dostosować do tego swoje działanie (np. <tt>gedit</tt>)

==Ćwiczenia==

===Rachunki w linii poleceń===

#Ile wynosi reszta z dzielenia 2999 przez 7?
#Która z tych liczb mniej się różni od pierwiastka kwadratowego z 2: 721/510 czy 722/510?
#Oblicz pierwiastek kwadratowy z 2, a następnie - podnieś go do kwadratu; ile wynosi względny błąd wyniku?

''CDN''

----

[[PPy3/Wprowadzenie|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/StałeIZmienne|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 13:53, 15 cze 2016 (CEST)

PPy3/PierwszeKroki

2023-05-10T09:55:43Z

RobertJB: /* Podstawowe cegiełki */

= Pierwsze kroki =

==Podstawowe cegiełki==

*Program w Pythonie to tekst, stanowiący ciąg instrukcji; są one wykonywane przez ''interpreter'' (zasadniczo) kolejno jedna po drugiej.
*''Prosta'' instrukcja to (zasadniczo) jedna linijka, kończy się wraz z przejściem do kolejnej linii.
*Instrukcja złożona, to linijka otwierająca '''zawsze zakończona dwukropkiem''', a po niej - '''blok wcięty''', tj. ciąg instrukcji (prostych i/lub złożonych) pisanych z dodatkowym ''wcięciem'' w stosunku do linijki otwierającej; mogą to być dodatkowe (np. dwie lub cztery) spacje, lub kod tabulacji, na początku każdej linijki. Koniec instrukcji złożonej następuje wraz z powrotem do poprzedniego ''poziomu wcięcia''.
*W tekście programu można umieszczać komentarze; komentarz zaczyna się od znaku <tt>#</tt>, a kończy się wraz z końcem bieżącej linii. Komentarze nie są częścią programu, tzn. są ignorowane przy jego wykonaniu.

<blockquote>
*Wyjątki od podanych reguł, istnienie których sygnalizuje słowo ''zasadniczo'', będą przedstawione później.
*Należy się raz zdecydować, jak dokładnie będziemy tworzyć poziomy wcięcia, i konsekwentnie się tego trzymać. Najlepiej po dwie lub cztery spacje (wg. upodobań), i ustawić w opcjach edytora kodu, żeby wciśnięcie klawisza ''Tab'' skutkowało odpowiednią liczbą spacji. Mieszanie w tekście kodu spacji i tabulacji zawsze prowadzi do kłopotów.
</blockquote>

Przykłady instrukcji prostych:

<source lang=python>
x = 1 + 2
y = 2 * x
x = x + 1
print(x, y)
</source>

Przykłady instrukcji złożonych:

<source lang=python>
if x > 0:
print(x)

def dodaj1(x):
return x + 1
</source>

Ważnym elementem są komentarze:

<source lang=python>
# a teraz, powiększę x o 1
x = x + 1
</source>

*Instrukcje budowane są z wyrażeń, a wyrażenia - z nazw, stałych i operatorów.
*'''Nazwa''' może składać się z liter, cyfr i znaku podkreślenia (_). Nie może zaczynać się od cyfry. Litery małe i wielkie są rozróżniane.
*Przykładem stałych są liczby - całkowite i ułamki dziesiętne. Zamiast przecinkiem, część ułamkową oddziela się kropką.
*Inny rodzaj stałych to napisy. Można je budować na kilka sposobów:

<source lang=python>
'to jest napis'
"to jest drugi napis"
'''a to jest...
jeszcze jeden napis'''
</source>

*Ostatni przypadek to wyjątek od zasady że koniec linii kończy instrukcję. Napis podany w pierwszych dwóch postaciach nie może zawierać przejścia do nowej linii.
*Nazwy są po to, aby oznaczać nimi wartości. Wartościami mogą być np. liczby i napisy:

<source lang=python>
pi = 3.14159
komunikat = 'Uwaga!!!'
</source>

'''UWAGA:''' znak równości to nie porównanie, a ''operator przypisania''. Powoduje on, że nazwa po jego lewej stronie będzie odtąd oznaczać wartość zapisaną po prawej. W szczególności, po lewej stronie znaku równości nie może występować np. stała liczba.

*Więcej o stałych i nazwach na następnej stronie, na razie tyle nam wystarczy.
*Inne operatory, to w szczególności arytmetyka:

<source lang=python>
+ - * / // % **
</source>

'*' to mnożenie, '//' to dzielenie całkowitoliczbowe, '%' to reszta z dzielenia (na ogół stosowana do liczb całkowitych, ale niekoniecznie), '**' to potęgowanie.

*Napisy też można "dodawać":

<source lang=python>
imie = 'Jacek'
powitanie = 'witaj ' + imie
print(powitanie)
</source>

Czemu właściwie operację ,,sklejania" napisów oznaczono plusem? W matematyce zazwyczaj plus stosuje się na oznaczenie operacji przemiennych, tzn. takich, których wynik nie zależy od kolejności składników — a sklejanie napisów ewidentnie taką operacją nie jest. Ale cóż, tak się przyjęło.

==Używanie linii poleceń interpretera==

''Interpreter'' to aplikacja, która potrafi czytać tekst kodu w języku Python i wykonać zapisane w nim polecenia. Może on być używany jako samodzielne polecenie, wywoływane w oknie terminala, lub zintegrowany z środowiskiem programistycznym w rodzaju ''Spyder''.

Zanim zaczniemy pisać "poważne" programy, nauczymy się korzystać z ''trybu interaktywnego'' interpretera, który pozwala na wpisywanie po jednym poleceniu i natychmiastowe uzyskanie wyniku jego wykonania. Można go używać do podręcznych rachunków - zamiast kalkulatora -- i do eksperymentowania z kodem w Pythonie. Do pracy interaktywnej warto używać "wzbogaconej" wersji interpretera, wywoływanej poleceniem

<source lang=bash>
$ ipython3
</source>

w najprostszych zastosowaniach niewiele się on różni od "zwykłego" interpretera, wywoływanego przez <tt>python3</tt>, ale posiada pewne dodatkowe możliwości, które niedługo się nam przydadzą.

<blockquote>
'''UWAGA:''' polecenie <tt>ipython</tt> (bez 3) wywoła starszą wersję Pythona. I odpowiednio - <tt>python</tt> wywołuje starszą wersję "zwykłego" interpretera, a <tt>python3</tt> - wersję aktualną.
</blockquote>

===Wykonywanie rachunków===

<source lang=python>
$ ipython3
Python 3.5.1+ (default, Mar 30 2016, 22:46:26)
Type "copyright", "credits" or "license" for more information.

IPython 2.4.1 -- An enhanced Interactive Python.
? -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help -> Python's own help system.
object? -> Details about 'object', use 'object??' for extra details.

In [1]: 7 * (3 + 5)
Out[1]: 56

In [2]: 2.81 / (1.25 - .33)
Out[2]: 3.054347826086957

In [3]: 2**128
Out[3]: 340282366920938463463374607431768211456

In [4]: 1/9
Out[4]: 0.1111111111111111

In [5]: 11//9, 11%9
Out[5]: (1, 2)
</source>

Zapis wyrażeń arytmetycznych raczej nie zaskakuje. Drobne uwagi:

*spacje w zapisie wyrażenia, pomiędzy liczbami a operatorami (lub ich brak), nie mają znaczenia
*reguły pierwszeństwa operatorów (najpierw potęgowanie, potem mnożenie i dzielenie, potem odejmowanie i dodawanie,...) są w zasadzie takie, jak należy się spodziewać; kolejność operacji możemy narzucić nawiasami - ale tylko okrągłymi, które można wielokrotnie zagnieżdżać
*pisząc ułamek dziesiętny (liczbę z kropką), można pominąć część całkowitą lub ułamkową, o ile ma ona być zero (nie można jednak pominąć obu);
*liczby całkowite mogą być dowolnie duże (w ramach fizycznych ograniczeń komputera)
*operacje na ułamkach należy zawsze traktować jako przybliżone - komputer może ogarnąć tylko skończoną liczbę cyfr
*zwykłe dzielenie da zawsze wynik ułamkowy; istnieje jednak operator <tt>//</tt> dzielenia całkowitego
*gdy chcemy zakończyć "rozmowę" z interpreterem, piszemy <tt>exit()</tt>; jeżeli pracujemy w Linuxie, zadziała również dwukrotne <tt>Ctrl-D</tt> (tzn. trzymając naciśnięty klawisz <tt>Ctrl</tt> stukamy dwukrotnie w klawisz <tt>D</tt>)

==Jak uzyskać pomoc==

W programie IPython mamy w każdej chwili dostęp do pomocy na temat poleceń, funkcji itd. Pythona:

<source lang=python>
In [8]: print?
Type: builtin_function_or_method
String form: <built-in function print>
Namespace: Python builtin
Docstring:
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
</source>

W tym przykładzie uzyskaliśmy szczegółowy opis zastosowania funkcji wbudowanej <tt>print</tt>. Wprawdzie po angielsku, ale mam nadzieję, że nie jest to przeszkoda nie do przeskoczenia. Już niedługo będziemy dokładnie rozumieli to, co jest tu napisane.

<blockquote>
Jeżeli tekst pomocy jest dłuższy, to będzie wyświetlany w trybie pozwalającym m. in. na jego przewijanie z użyciem klawiszy strzałek czy <tt>PgUp</tt>, <tt>PgDn</tt>. Aby wyjść z tego trybu i powrócić do interpretera, wystarczy nacisnąć <tt>q</tt>.
</blockquote>

==Najprostszy program==

Za pomocą ulubionego edytora tekstowego stwórzmy plik o nazwie <tt>hello.py</tt> i następującej treści:

<source lang=python>
#! /usr/bin/python3

print('Witaj świecie!')

</source>

Zgodnie z tradycją, będzie to program wykonujący jedno banalne zadanie: wypisanie komunikatu o ustalonej treści. Zgodnie z zasadą, że programowanie w Pythonie ma być maksymalnie proste - jedynym niezbędnym elementem tego programu jest linijka wywołująca funkcję <tt>print</tt>. W tym przykładzie, uzupełniłem treść programu o pierwszą linijkę, zaczynającą się od znaku kratki (<tt>#</tt>) - istotne jest, aby była to dokładnie pierwsza linijka w pliku, i by zaczynała się od pierwszej pozycji w wierszu. Czyli, aby <tt>#!</tt> były dokładnie dwoma pierwszymi znakami w treści pliku. Z punktu widzenia Pythona, linijka ta jest komentarzem, i przy uruchamianiu pliku jest ignorowana. Pozwala ona jednak, by plik ten był automatycznie rozpoznawany przez system operacyjny (Linux) jako zawierający program w języku Python. Jaki z tego pożytek, dowiemy się za chwilę.

Aby ten program uruchomić, jest parę sposobów. Najprościej:

<source lang=bash>
$ python3 hello.py
</source>

powyższe polecenie wpisujemy w terminalu, w trybie powłoki systemowej (''nie w programie IPython!''). Tutaj musieliśmy jawnie wywołać interpreter Pythona i wskazać mu plik <tt>hello.py</tt> jako zawierający kod do uruchomienia.

Zamiast tego, możemy nadać plikowi <tt>hello.py</tt> atrybut pliku wykonywalnego, czyli programu, i uruchomić go bezpośrednio:

<source lang=bash>
$ chmod +x hello.py
$ ./hello.py
</source>

*Polecenie z pierwszej linijki wystarczy wykonać raz dla danego pliku
*Zamiast z linii poleceń, można w okienku ''Właściwości'' pliku znaleźć odpowiednie pole do kliknięcia
*Postać drugiej linijki tłumaczy się tym, że nasz program <tt>hello.py</tt> nie jest zainstalowany w systemie i nie zostanie odnaleziony przez przeszukanie standardowych lokalizacji programów na dysku. Należy wyraźnie wskazać, że chodzi o plik znajdujący się w bieżącym folderze - i to tu robimy.
*Plik z kodem w Pythonie nie musi mieć nazwy kończącej się na <tt>.py</tt> - jest to jednak wygodne, bo np. edytory tekstu traktują to jako sugestię co do zawartości pliku, i mogą dostosować do tego swoje działanie (np. <tt>gedit</tt>)

==Ćwiczenia==

===Rachunki w linii poleceń===

#Ile wynosi reszta z dzielenia 2999 przez 7?
#Która z tych liczb mniej się różni od pierwiastka kwadratowego z 2: 721/510 czy 722/510?
#Oblicz pierwiastek kwadratowy z 2, a następnie - podnieś go do kwadratu; ile wynosi względny błąd wyniku?

''CDN''

----

[[PPy3/Wprowadzenie|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/StałeIZmienne|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 13:53, 15 cze 2016 (CEST)

PPy3/InstrukcjaWarunkowa

2022-10-19T07:16:48Z

RobertJB: /* Ćwiczenia */

=Instrukcja warunkowa=

Zasadniczo każdy program w Pythonie składa się z ciągu instrukcji, które są wykonywane w kolejności, w jakiej zostały zapisane. W programowaniu potrzebna jest jednak możliwość podejmowania decyzji o przyjęciu różnych kursów postępowania, w zależności od danych z jakimi mamy do czynienia. Umożliwiają to instrukcje złożone, a szczególnie - instrukcja warunkowa.

Instrukcja warunkowa to pierwszy przykład instrukcji złożonej. W najprostszej postaci składa się ona z ciągu (jednej lub więcej) instrukcji ujętych w blok, który jako całość będzie wykonany lub nie, w zależności od tego, czy spełniony jest pewien warunek - co zależy zazwyczaj od aktualnych wartości pewnych zmiennych. Warunek ten zapisuje się w postaci wyrażenia logicznego.

<blockquote>
Wśród instrukcji tworzących blok warunkowy mogą oczywiście się pojawić również instrukcje złożone, nie tylko instrukcje proste. Na przykład, kolejne instrukcje warunkowe.
</blockquote>

==Przykład minimalny:==

<source lang=python>
x1, x2 = None, None
if delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print(x1, x2)
</source>

Linijka z wywołaniem <tt>print</tt> nie jest już częścią instrukcji warunkowej, tylko kolejną instrukcją.

'''Do zapamiętania''':
*wiersz otwierający instrukcję złożoną (czyli tu: zaczynająca się od <tt>if</tt>) zawsze kończy się dwukropkiem
*instrukcje tworzące blok w instrukcji złożonej są pisane z wcięciem, które musi być jednolite
*koniec bloku rozpoznaje się po powrocie do uprzedniego poziomu wcięcia
*blok instrukcji pod <tt>if ...</tt> nie może być pusty. Instrukcja <tt>if</tt> z pustym blokiem warunkowym jest nie tylko nieprzydatna, ale jest również błędem składniowym.

==Przykład bardziej złożony:==

<source lang=python>
if a == 0:
print('Równanie nie jest kwadratowe.')
elif delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print('Są dwa pierwiastki: x1 =', x1, 'x2 =', x2)
elif delta == 0:
x = -b / 2 / a
print('Jest tylko jeden pierwiastek: x =', x)
else: # delta < 0:
print('Nie ma pierwiastków rzeczywistych.')
</source>

Jak to działa?

*Jeżeli spełniony jest warunek <tt>a == 0</tt>, wykonany zostanie blok poniżej <tt>if ...</tt>, a reszta instrukcji zostanie pominięta;
*Jeżeli warunek ten jest nieprawdziwy (i tylko wtedy), to sprawdzane są kolejno warunki umieszczone w wierszach zaczynających się od <tt>elif</tt>. Jeśli któryś z nich okaże się prawdziwy, to blok poniżej tej linijki zostanie wykonany, a cała reszta - pominięta;
*Jeżeli żaden z warunków - tych po <tt>if</tt>, i tych po wszystkich <tt>elif</tt> - nie okazał się prawdziwy, wykonany zostanie blok związany z <tt>else</tt>.
*Bloków <tt>elif</tt> może być w instrukcji dowolnie wiele (w tym - wcale), <tt>if</tt> jest obowiązkowy (inaczej nie byłoby instrukcji warunkowej) i tylko jeden, <tt>else</tt> może wystąpić wyłącznie na końcu - jeden raz, lub wcale.
*Komentarz po <tt>else:</tt> jest podpowiedzią dla czytającego, że skoro już zbadano warunki <tt>delta == 0</tt> oraz <tt>delta > 0</tt>, a wykonanie dotarło do tej linijki, to <tt>delta < 0</tt> jest jedyną pozostałą możliwością (o ile możemy założyć, że <tt>delta</tt> jest na pewno liczbą!). Jest on przeznaczony wyłącznie dla ludzkich oczu - interpreter go zignoruje, jak każdy komentarz.

<blockquote>
Mam nadzieję, że czytający już zauważył, że <tt>and not a == 0</tt> w trzeciej linijce jest niepotrzebne. Dlaczego?
</blockquote>

==Wyrażenie warunkowe==

Innym sposobem uzależnienia wyniku działania od jakiegoś warunku jest tzw. ''wyrażenie warunkowe''. Jest ono szczególnie wygodne w prostych przypadkach, i pozwala zapisać pewne działania w bardziej zwięzły sposób.

Przykład: chcemy, aby z nazwą <tt>wbx</tt> wiązała się wartość bezwzględna (moduł) aktualnej wartości (liczby) <tt>x</tt>. Za pomocą instrukcji warunkowej można to zrealizować tak:

<source lang=python>
if x < 0:
wbx = -x
else:
wbx = x
</source>

Ten sam wynik można osiągnąć za pomocą wyrażenia warunkowego:

<source lang=python>
wbx = -x if x < 0 else x
</source>

W wyrażeniu warunkowym nie ma opcji uwzględnienie dodatkowych możliwości za pomocą <tt>elif</tt>.

=Ćwiczenia=

W programach ćwiczebnych nieraz przyda nam się funkcja <tt>input()</tt>. Działa ona w sposób następujący: argumentem wywołania powinien być jakiś napis (np. w postaci stałej napisowej): <tt>input('podaj jakąś liczbę całkowitą: ')</tt>. Gdy w programie przyjdzie kolej na wykonanie takiego wywołania, program wypisze ten napis do terminalu i będzie oczekiwał na reakcję użytkownika, czyli wpisanie czegoś z klawiatury (i zakończenie naciśnięciem klawisza ''Enter''). Gdy to nastąpi, wynikiem wywołania funkcji <tt>input</tt> w programie będzie treść wpisana prze użytkownika (bez końcowego znaku nowej linii).

''Uwaga:'' wartość zwracana przez <tt>input()</tt> zawsze jest napisem, a nie liczbą - choćby się składał z samych cyfr.

1. Napisz program, którego uruchomienie ma następujący skutek:
*program wita użytkownika (komunikatem w terminalu),
*prosi o wprowadzenie liczby całkowitej,
*sprawdza, czy liczba ta jest podzielna przez 7, i informuje o wyniku tego sprawdzenia

2. Napisz program, którego uruchomienie ma następujący skutek:
* program prosi użytkownika o podanie swojego (lub czyjegoś) wieku w latach
* jeśli wiek jest ujemny, odpowiada ,,Nieprawidłowy wiek"
* jeśli wiek wynosi 0, odpowiada ,,niemowlę"
* jeśli wiek jest poniżej 18, odpowiada ,,dziecko"
* jeśli wiek jest pomiędzy 18 a 120 (włącznie), odpowiada ,,dorosły"
* jeśli wiek przekracza 120, odpowiada ,,ludzie tyle nie żyją"

''CDN''

----

[[PPy3/StałeIZmienne|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/SekwencjeIIteracja|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 15:42, 28 cze 2016 (CEST)

"Programowanie z Pythonem3"

2022-09-27T14:54:36Z

RobertJB: /* Uwagi ogólne */

[[Grafika:Python-logo.png]]

[[Category:Informatyka]]
== Semestr zimowy 2022/2023 ==

'''''W trakcie opracowania'''''

===Uwagi ogólne===

Zasady zaliczenia ćwiczeń w roku 2022/2023:

* maksymalnie można zdobyć 40 punktów
* w semestrze będą dwa kolokwia, w połowie i pod koniec; na każdym można zdobyć po 15 punktów
* w sesji będzie kolokwium dodatkowe, dla chętnych; wynik z niego (maks. 15 punktów) zastępuje gorszy z wyników kolokwiów z semestru, o ile jest on od niego lepszy
* maksymalnie 10 punktów uzyskuje się na podstawie zadań domowych i kartkówek na ćwiczeniach
* zaliczenie ćwiczeń na pozytywną ocenę wymaga co najmniej 50% punktów (20 p.)
* ocena rośnie o pół stopnia z osiągnięciem progu każdych kolejnych 10%, tj. 4 punktów
* prowadzący może przyznać dodatkowo do 3 punktów "premiowych" na podstawie aktywności na ćwiczeniach

Obecność na ćwiczeniach jest obowiązkowa. Dopuszczalne są '''dwie''' nieobecności nieusprawiedliwione w semestrze. '''Za każdą kolejną nieobecność nieusprawiedliwioną powyżej dwóch odejmujemy od wyniku 5 punktów.'''

Ocena końcowa z przedmiotu składa się z oceny z ćwiczeń, oraz z oceny z egzaminu testowego kończącego wykład, w proporcji 3:2 - z tym, że '''obie te oceny cząstkowe muszą być pozytywne''' aby ocena z całości była pozytywna.

===Spis treści===

#[[PPy3/Wprowadzenie|Wprowadzenie]]
#[[PPy3/PierwszeKroki|Pierwsze kroki]]
#[[PPy3/StałeIZmienne|Stałe i zmienne]]
#[[PPy3/InstrukcjaWarunkowa|Instrukcja warunkowa]]
#[[PPy3/SekwencjeIIteracja|Sekwencje i iteracja]]
#[[PPy3/Funkcje|Funkcje]]
#[[PPy3/Kolekcje|Kolekcje]]
#[[PPy3/Moduły|Moduły i biblioteki]]
#[[PPy3/WejścieWyjście|Obsługa wejścia i wyjścia]]
#[[PPy3/NumPy|NumPy]] - rachunki numeryczne na tablicach liczb
#[[PPy3/Matplotlib|Matplotlib]] - wizualizacja danych
#[[PPy3/TematyDodatkowe|Tematy dodatkowe]] - uzupełnienie
#[[PPy3/DobrePraktyki|Zasady dobrej praktyki]]

===O skrypcie===

Opracowane na nowo przez [[Użytkownik:RobertJB|RobertJB]], częściowo z wykorzystaniem [["Programowanie z Pythonem"|poprzedniej wersji]].

PPy3/Kolekcje

2022-08-01T12:11:12Z

RobertJB: /* Napisy (jeszcze raz) */

=Kolekcje=

'''Kolekcje''' to są takie typy danych, które składają się z elementów. Szczególnym przypadkiem, [[PPy3/SekwencjeIIteracja|omawianym już wcześniej]] przy okazji wprowadzenia pętli, są sekwencje - kolekcje uporządkowane. Rozmaite typy kolekcji różnią się sposobem dostępu do elementów, modyfikowalnością - lub przeciwnie, optymalizacją pod względem różnych zastosowań.

*Szereg typów kolekcji jest ,,wbudowanych" w pythonie - to znaczy, że można z nich swobodnie korzystać bez żadnych dodatkowych zabiegów;
*niektóre inne są zaimplementowane w modułach biblioteki standardowej - a więc korzystanie z nich wymaga wcześniejszego polecenia <tt>import</tt> (p. [[PPy3/Moduły|Moduły]]);
*ważne dla zastosowań do obliczeń naukowych typy tablicowe są zaimplementowane w bibliotece [[PPy3/NumPy|NumPy]], która '''nie''' jest częścią biblioteki standardowej, i na ogół np. nie znajdzie się w domyślnym zestawie pakietów typowej dystrybucji Linuxa. Na pewno będzie jednak dostępna jako opcjonalny element instalacji;
*na każdym typie kolekcji umie działać funkcja <tt>len</tt>, zwracająca liczbę elementów kolekcji będącej jej argumentem.

Omówimy tu kolejno w skrócie najważniejsze i najbardziej przydatne wg. nas typy kolekcji, z pominięciem tablic NumPy - którym będzie poświęcony [[PPy3/NumPy|osobny rozdział]].

==Listy==

O listach już nieco wiemy. Lista to kolekcja uporządkowana, i modyfikowalna. Elementem listy może być cokolwiek - również inna lista. A nawet ta sama lista - tak, lista może być elementem samej siebie, jednak sztuczka taka nie jest chyba przydatna, choć legalna.

O adresowaniu elementów przez pozycję (lub ''indeks'') oraz o pobieraniu (i podstawianiu do) wycinków już było. Dodamy tu jeszcze parę użytecznych operacji na listach:

<source lang=python>
L = [0, 1, 3]
L.append(5) # dołączamy element do końca, przedłużając listę
→ L == [0, 1, 3, 5]
L.extend(['a', 'b']) # przedłużamy od razu o całą listę dodatkowych elementów
→ L == [0, 1, 3, 5, 'a', 'b']
L.insert(2, 'dwa') # pierwszy argument to pozycja, drugi to element wstawiany; dalsze elementy przesuwają się
→ L == [0, 1, 'dwa', 3, 5, 'a', 'b']
x = L.pop() # usuwamy ostatni element i zwracamy go jako wynik
→ teraz x == 'b', a L == [0, 1, 'dwa', 3, 5, 'a']
y = L.pop(2) # możemy zrobić to samo, wskazując inną pozycję zamiast ostatniej
→ teraz y == 'dwa', a L == [0, 1, 3, 5, 'a']
L.reverse() # odwrócenie porządku elementów
→ teraz L == ['a', 5, 3, 1, 0]
L.sort() # uporządkowanie elementów listy
→ BŁĄD - nie zadziała, gdyż lista zawiera elementy nieporównywalne (liczby i napis)
L.pop(0) # usuwamy napis, stojący w pozycji 0
L.sort()
→ teraz L == [0, 1, 3, 5]
</source>

Oprócz operacji <tt>L.sort()</tt> istnieje jeszcze funkcja <tt>sorted(L)</tt> - różniąca się tym, że pozostawia niezmienioną listę <tt>L</tt>, zamiast tego tworząc '''nową''' listę uporządkowaną, zawierającą te same elementy, co <tt>L</tt>.

Notację postaci <tt>L.append(5)</tt> można czytać tak: zastosuj ''metodę'' obiektu <tt>L</tt>, o nazwie <tt>append</tt>, do liczby 5. Metoda jest to operacja związana z pewnym obiektem (w tym przypadku - listą) - tym, do którego odnosi się nazwa stojąca przed kropką. Metodę można uważać za pewien rodzaj funkcji - takiej , która oprócz ewentualnych argumentów umieszczonych w nawiasach po jej nazwie, ,,wie" jeszcze o tym, z jakiego obiektu została wywołana.

<blockquote>
W Pythonie każda dana jest obiektem jakiegoś rodzaju (''klasy''), nawet liczba; i każdy obiekt posiada właściwe sobie metody (na ogół wyznaczone przez klasę, do jakiej przynależy). Programista może zresztą sam tworzyć klasy obiektów na potrzeby swojego programu. Więcej na ten temat później.
</blockquote>

Funkcja <tt>list</tt> tworzy listę z dowolnej sekwencji (np. z napisu). Wywołanie bez argumentów <tt>list()</tt> zwraca pustą listę; wywołanie <tt>list(s)</tt>, gdzie <tt>s</tt> jest napisem, zwraca listę znaków (napisów jednoelementowych), z których składa się napis <tt>s</tt>. Wywołanie, gdzie argumentem jest lista, zwraca duplikat tej listy - tzn. listę o tych samych elementach (i w tym samym porządku), ale nie tożsamą.

===Przykład: suma cyfr===

Spróbujmy policzyć sumę cyfr, z jakich składa się zapis liczby naturalnej <tt>n</tt> - a wyrażając się precyzyjniej, sumę liczb reprezentowanych przez cyfry zapisu dziesiętnego liczby <tt>n</tt> (cyfra to znak, a więc w rozumieniu Pythona pewien napis jednoelementowy - a nie liczba; ponadto, ten sam problem można by postawić dla zapisu pozycyjnego o dowolnej podstawie, np. dwójkowego lub szesnastkowego).

Pierwszym rozwiązaniem tego problemu jest takie, jakie można by nazwać arytmetycznym:

<source lang=python>
def sumacyfr(n):
suma = 0
while n:
suma += n % 10
n = n // 10
return suma
</source>

Proste: ostatnią cyfrę zapisu liczby <tt>n</tt> (a wyrażając się pedantycznie: odpowiadającą jej liczbę między 0 a 9) otrzymujemy jako resztę z dzielenia <tt>n</tt> przez 10; następnie ,,skracamy" <tt>n</tt> o tę ostatnią cyfrę, zastępując <tt>n</tt> przez jej iloraz całkowitoliczbowy przez 10. I tak do skutku, aż zabraknie cyfr.

Można jednak napisać znacznie krótszą wersję tej funkcji, korzystając z tego, że Python ,,sam" umie wyznaczyć cyfry zapisu dziesiętnego każdej liczby i nie musimy do tego pisać własnego kodu. Robi to funkcja <tt>str(n)</tt> - zastosowana do liczby całkowitej, zwraca ona napis składający się z cyfr dziesiętnych, reprezentujący tę liczbę. Rozwiązanie uproszczone wygląda więc tak:

<source lang=python>
def sumacyfr(n):
suma = 0
for c in str(n):
suma += int(c)
return suma
</source>

Dalsze uproszczenie otrzymujemy zastępując pętlę tzw. ''wyrażeniem generatorowym'', i korzystając z wbudowanej funkcji <tt>sum</tt>:

<source lang=python>
def sumacyfr(n):
return sum(int(c) for c in str(n))
</source>

Wyrażenia generatorowe to jakby odwrotny zapis pętli <tt>for</tt>. Notacja ta definiuje obiekt (''generator'') będący odpowiednikiem i uogólnieniem obiektu, jaki produkuje funkcja <tt>range</tt>: jest to ''niby-sekwencja'', która może zastąpić sekwencję (np. listę) w pętli <tt>for</tt>, a także w funkcjach (takich jak <tt>sum</tt> lub <tt>sorted</tt>), które jako argumentu oczekują sekwencji. W odróżnieniu od sekwencji, generator nie ma z góry ustalonego ciągu elementów, można powiedzieć, że produkuje kolejne elementy ,,na żądanie'', np. gdy są potrzebne dla kolejnego obiegu pętli <tt>for</tt>. Wyrażenie generatorowe określa generator na podstawie elementów podawanych przez inny generator (lub sekwencję), poddając je jakiemuś przekształceniu i/lub selekcji:

<source lang=python>
gen = (f(x) for x in elementy if w(x))
</source>

tu: <tt>elementy</tt> to sekwencja lub generator, <tt>w(x)</tt> to warunek decydujący o uwzględnieniu lub pominięciu elementu <tt>x</tt>, a <tt>f(x)</tt> to w ogólności wyrażenie, którego wartość będzie kolejnym elementem podawanym przez generator <tt>gen</tt>.

''Uwaga:'' nawiasy okrągłe otaczające wyrażenie generatorowe są obowiązkowe. Jeśli wyrażenie to wstawiamy bezpośrednio pod wywołanie funkcji jako jej jedyny argument, to wystarczają nawiasy zawarte w składni wywołania funkcji - nie potrzeba ich podwajać. Jeśli w miejsce nawiasów okrągłych napiszemy kwadratowe, otrzymamy nie generator - a listę o tych samych elementach.

==Krotki==

Krotki to prawie listy; zasadnicza różnica polega na tym, że krotki są '''niemodyfikowalne'''. Podobnie jak napisy - krotki raz stworzonej nie można zmienić, w sensie zmiany jej zawartości (elementów), a tym bardziej - jej długości. Można ją najwyżej zastąpić inną krotką. W związku z tym, krotki pozbawione są metod modyfikujących zawartość, jakie posiadają listy. Inne operacje, jak adresowanie elementów i wycinków, dodawanie (sklejanie) i mnożenie (powielanie) działają analogicznie jak dla list.

Literalne krotki zapisuje się zwykle używając nawiasów okrągłych:

<source lang=python>
T = (3, 5, 8)
</source>

chociaż tak naprawdę, to nawiasy są opcjonalne, a krotkę tworzą ''przecinki'' stojące pomiędzy elementami. Pominięcie nawiasów powoduje jednak, że musimy pamiętać o tym jaka jest kolejność operacji, jeżeli literalny zapis krotki jest elementem większego wyrażenia. Zwykle prościej i czytelniej jest użyć nawiasów.

Krotka może oczywiście składać się z jednego elementu, a nawet być pusta:

<source lang=python>
T1 = 1, # krotka o jednym elemencie - liczbie 1
T0 = () # krotka pusta
</source>

w tym ostatnim przypadku nie można się obyć bez nawiasów. Oczywiście tworzenie takich krotek rzadko bywa przydatne; mogą się one jednak pojawiać jako wyniki rozmaitych operacji.

Po co są w ogóle krotki, skoro to tylko jakby ,,słabsze" listy?

*Czasami warto użyć typu niemodyfikowalnego, aby próba zmiany zawartości kolekcji (np. w wyniku błędu) nie mogła się udać;
*optymalizacja - krotki są ,,lżejsze" od list, co może mieć znaczenie jeśli potrzebujemy je tworzyć w dużej liczbie;
*w niektórych przypadkach użycie niemodyfikowalnego typu danych jest konieczne; o tym dalej.

Warto jednak pamiętać, że choć sama krotka jest niemodyfikowalna - to jej elementem może być np. lista, której zawartość może być zmieniona niezależnie od tego, że jest elementem krotki.

Każdą sekwencję (a i pewne inne obiekty — np. generatory) można ,,zrzutować" na krotkę, za pomocą funkcji <tt>tuple</tt>. Wyrażając się precyzyjniej, wyrażenie <tt>tuple(s)</tt> jest krotką o tej samej zawartości (i w tym samym porządku) co sekwencja (lub inny obiekt iterowalny) <tt>s</tt>.

==Słowniki==

Słownik (''dictionary'') to taka kolekcja, której elementy - zamiast być uporządkowane - są powiązane z ''kluczami''. Kluczem może być liczba (całkowita lub ułamkowa), napis, ale również dana szeregu innych typów (chociaż nie każdego). Pobranie elementu słownika wiąże się z podaniem odpowiadającego mu klucza. Klucze w słowniku są niepowtarzalne - a więc każdy z nich jest związany z dokładnie jedną wartością. Wartości za to mogą się powtarzać, i nie podlegają żadnym ograniczeniom co do typu. Zapis literalny słowników posługuje się nawiasami klamrowymi:

<source lang=python>
slownik = {'jeden' : 1, 'dwa' : 2, 'trzy' : 3}
slownik['dwa']
→ 2
slownik['cztery']

KeyError Traceback (most recent call last)
<ipython-input-2-22c7b016c2c6> in <module>()
----> 1 slownik['cztery']

KeyError: 'cztery'
slownik['cztery'] = 4
slownik['cztery'] == 4
→ True
</source>

W notacji literalnej w nawiasach stoją, oddzielone przecinkami, pary klucz-wartość, a klucz od wartości oddziela dwukropek.
Nazwa ''słownik'' bierze się stąd, że jednym z możliwych zastosowań jest przekład kluczy (tu: słowa oznaczające liczby) na odpowiadające im wartości (tu: liczby). Widzimy też, że próba pobrania wartości odpowiadającej kluczowi, którego w słowniku nie ma, kończy się błędem. Z drugiej strony, w każdej chwili można do słownika dodać następną parę klucz-wartość; analogicznie, można wymienić wartość związaną z kluczem już istniejącym na inną.

Warto podkreślić jeszcze raz, że pary klucz-wartość w słowniku nie charakteryzują się w zasadzie określonym porządkiem. Niemniej w nowszych wersjach Pythona obowiązuje zasada, że pozycje słownika zachowują porządek, w jakim były tworzone — i np. w iteracji będą się pojawiać zgodnie z tym porządkiem.

Dalsze podstawowe operacje na słowniku to sprawdzenie występowania klucza, oraz iteracja:

<source lang=python>
'cztery' in slownik # operator `in' sprawdza przynależność do zbioru kluczy
→ True
'zero' in slownik
→ False
for klucz in slownik:
print(klucz, slownik[klucz])
→
jeden 1
dwa 2
trzy 3
cztery 4
</source>

Jak widać, w iteracji klucze słownika pojawiają się w porządku, w którym je dodawano. Takie zachowanie jest przepisane w definicji języka Python od wersji 3.7. Mając do czynienia z wersjami wcześniejszymi należy się liczyć z tym, że ten porządek nie będzie zachowany. Natomiast gwarantuje się, że każdy klucz pojawi się w iteracji dokładnie jeden raz.

W iteracjach (tzn. pętlach <tt>for</tt>) bardzo przydatne są kolekcje zwracane przez metody słowników: <tt>items</tt>, <tt>values</tt> i (rzadziej przydatna) <tt>keys</tt>. Zwracają one obiekty ,,listo-podobne"; jeżeli potrzebne są nam one w postaci dosłownych list, to wystarczy zastosować do nich funkcję <tt>list</tt>; jeżeli natomiast zamierzamy je wykorzystać w pętli <tt>for</tt>, to nie jest to potrzebne. Zawartość to odpowiednio:

*<tt>slownik.items()</tt>: pary (dwuelementowe krotki) postaci ''(klucz, wartość)''
*<tt>slownik.values()</tt>: same wartości występujące w słowniku
*<tt>slownik.keys()</tt>: same klucze występujące w słowniku.

Uwaga dotycząca porządku pozycji słownika stosuje się również do wyników zwracanych przez te metody.

Funkcją - konstruktorem słownika jest funkcja <tt>dict</tt>. Zamienia ona np. sekwencję par ''(klucz, wartość)'' w odpowiedni słownik. Jeżeli klucze w tej sekwencji się powtarzają, ,,wygrywa" ostatnie wystąpienie.

Wspomnieliśmy wcześniej, że nie każdy typ wartości może być kluczem słownika. Dokładniej - kluczami w słowniku mogą być tylko wartości typów niemodyfikowalnych, a więc nie listy ani same słowniki. Mogą nimi natomiast być napisy, liczby i krotki. ''Nota bene'': ponieważ liczby ułamkowe należy traktować jako przybliżone, używanie ich jako kluczy słownika na ogół nie jest dobrym pomysłem. Nie ma ograniczeń co do mieszania różnych typów kluczy (ani wartości) w jednym słowniku.

==Zbiory==

Zbiory w Pythonie mają sens taki, jak zbiory w matematyce (teorii mnogości). Mówiąc po prostu, zbiór jest kolekcją nieuporządkowaną i nie dopuszczającą powtórzeń: dany element albo do zbioru należy, albo nie; nie może należeć ''dwukrotnie'' (ani więcej razy). Standardowe zbiory są obiektami modyfikowalnymi.

Zbiór literalny zapisuje się za pomocą nawiasów klamrowych — łatwo odróżnić, że nie chodzi o słownik, gdyż zapis dla zbiorów nie zawiera dwukropków.

<blockquote>
Wiąże się z tym jednak jeden problem: czy <tt>{}</tt> oznacza zbiór pusty, czy pusty słownik? Dość arbitralnie przyjęto, że jednak pusty słownik (notację dla zbiorów wprowadzono później niż dla słowników).</blockquote>

Przykłady:

<source lang=python>
zbior = {'a', 'b', 'c'}
'a' in zbior
→ True
6 in zbior
→ False
zbior.add('d')
→ zbior == {'a', 'b', 'c', 'd'}
zbior.remove('a')
→ zbior == {'b', 'c', 'd'}
innyzb = {1, 2, 'b'}
zbior | innyzb # suma zbiorów
→ {'a', 1, 2, 'c', 'd', 'b'}
zbior & innyzb # iloczyn (część wspólna) zbiorów
→ {'b'}
zbior - innyzb # różnica zbiorów
→ {'a', 'c', 'd'}
zbior ^ innyzb == (zbior | innyzb) - (zbior & innyzb) # definicja różnicy symetrycznej zbiorów
→ True
innyzb <= zbior # pierwszy jest podzbiorem drugiego?
→ False
{'b', 'c'} <= zbior
→ True
{'b', 'c'} < zbior # podzbiór właściwy?
→ True
# znaki nierówności mogą być skierowane odwrotnie, z odp. zamianą argumentów
</source>

Elementy zbiorów podlegają analogicznemu ograniczeniu co do typów danych, co klucze słownika: nie mogą być to obiekty modyfikowalne.

Konstruktorem zbioru jest funkcja <tt>set</tt>: można jej podać jako argument dowolną kolekcję, a ona zwróci zbiór jej elementów (z dokładnością do ograniczeń co do typów danych tych elementów). Na przykład, typowy chwyt na usunięcie powtórzeń elementów: aby uzyskać uporządkowaną listę znaków, z jaki składa się napis <tt>s</tt>:

<source lang=python>
znaki = sorted(set(napis))
</source>

Podobnie jak lista ma swój odpowiednik niemodyfikowalny (krotkę), tak niemodyfikowalnym odpowiednikiem zbioru jest ''zbiór zamrożony'' (''frozenset''). Można taki wyprodukować za pomocą funkcji <tt>frozenset</tt>, analogu funkcji <tt>set</tt>. Zbiory zamrożone dopuszczają wszystkie te same operacje, co zwykłe zbiory - za wyjątkiem operacji zmieniających skład (jak <tt>add</tt> i <tt>remove</tt>).

==Napisy (jeszcze raz)==

O napisach już nieco było wcześniej, ale dla kompletności przypomnijmy.

*Napis to niemodyfikowalna sekwencja
*Jej elementami są znaki - napisy o długości 1
*Operatorem <tt>in</tt> można badać nie tylko, czy dany znak występuje w napisie, ale również czy jeden napis jest fragmentem drugiego:
<source lang=python>
s = 'abc XYZ'
'abc' in s
→ True
</source>
*Napisy mają szereg użytecznych metod; ale ''żadna z tych metod nie zmienia napisu, którego dotyczy'' - może jedynie tworzyć (i zwracać) nowy napis, utworzony na podstawie istniejącego. Przykłady:
<source lang=python>
s.lower()
→ 'abc xyz'
s.upper()
→ 'ABC XYZ'
s.replace(' ', ';')
→ 'abc;XYZ'
s.find('XY') # znajduje pozycję, na jakiej występuje podany fragment w napisie s
→ 4
s.find('q') # szukamy fragmentu, którego w s nie ma..
→ -1
</source>
*Metod tych jest więcej, poznamy je w przykładach
*Funkcją - konstruktorem napisu jest <tt>str</tt>; np. liczbę - zamienia w napis będący jej zapisem (najbardziej ,,standardowym"), i podobnie z innymi typami danych - zwraca najbardziej ,,standardową" ich reprezentację za pomocą napisu
*Szczególnie ważną i przydatną operacją napisową jest metoda <tt>format</tt>, o niej zaraz.

===Formatowanie===

Idea formatowania jest następująca: mamy pewien napis, który służy jako szablon do tworzenia napisów, w ten sposób, że określone miejsca w szablonie wypełniane są wartościami (a dokładniej - ich przedstawieniami napisowymi), które zazwyczaj nie są z góry znane i są wyliczane dopiero w wyniku działania programu. Najczęściej chodzi po prostu o przedstawienie uzyskanych wyników w postaci komunikatów lub zapisów w plikach, o określonej przez programistę postaci.

Gdy korzystamy z metody <tt>format</tt>, napis pełniący rolę szablonu (literalny lub przywołany poprzez nazwę) stoi przed kropką, tzn. wywołujemy metodę <tt>format</tt> tegoż napisu - szablonu, natomiast argumentami tego wywołania są wartości, które mają być wstawione w przeznaczone na to pozycje w szablonie.

Język opisu szablonów jest stosunkowo złożony i kryje w sobie szereg możliwości, na razie wprowadzimy najprostsze przypadki.

<source lang=python>
# Najprostsze formatowanie: wartości wstawiane są kolejno w miejsca zaznaczone poprzez {}
'x = {}, y = {}'.format(1.2, 9)
→ 'x = 1.2, y = 9'
# Numerowanie pozycji (ten sam numerek może występować więcej niż raz w szablonie
'x1 = {1}, x0 = {0}'.format(3, 15)
→ 'x1 = 15, x0 = 3'
# Obcięcie przedstawienia liczby ułamkowej do określonej liczby cyfr po kropce
'{0:.4f}'.format(3.141592653589793)
→ '3.1416'
# Bardziej szczegółowa kontrola formatowania
'{:4s}{:4s}{:*>4s}'.format('a', 'b', 'c')
→ 'a b ***c'
</source>
W tym ostatnim przykładzie, liczby 4 specyfikują ''minimalną'' szerokość pól przeznaczonych na wypełnienie podanymi wartościami, natomiast <tt>*></tt> oznacza, że gwiazdka ma być ,,wypełniaczem" pustego miejsca, jeżeli takie pozostanie w zadanej wielkości pola po wstawieniu wartości, a znak <tt>></tt> oznacza wyrównanie (wewnątrz pola) do strony prawej. Więcej szczegółów - w [https://docs.python.org/3/library/string.html#formatstrings dokumentacji].

Począwszy od wersji 3.6 języka Python wprowadzono uproszczoną składnię formatowania napisów. Poprzedzając w zapisie napisu literalnego otwierający cudzysłów (lub apostrof) literą <tt>f</tt> (lub <tt>F</tt>), możemy w tym napisie skorzystać z sekwencji w parach nawiasów klamrowych, gdzie wewnątrz nawiasów umieszczamy (zamiast jak wyżej — numeru pozycji w liście argumentów wywołania <tt>format()</tt>) po prostu zapis wyrażenia w Pythonie, którego aktualna wartość znajdzie się w tym miejscu w wyniku ewaluacji, plus ewentualnie dwukropek a po nim dyrektywy formatowania, jak wyżej. Przykłady:

<source lang=python>
x, y = 1.2, 9
f'x = {x}, y = {y}'
→ x = 1.2, y = 9
f'wynik działania arytmetycznego: {2 * x + y}'
→ wynik działania arytmetycznego: 11.4
</source>
Jeżeli chcemy, aby w wyniku wystąpiły dosłowne nawiasy klamrowe, a nie zostały one zinterpretowane jako pole do wypełnienia wartością wyrażenia, to musimy je podwoić (<tt>f'{{'</tt> → { itd.)

=Ćwiczenia=

1. Ile wynosi najmniejsza liczba <tt>N</tt>, dla której <tt>S_N = 1 + 2**3 + 3**3 + ... + N**3</tt>
jest liczbą której zapis dziesiętny ma więcej niż M cyfr? Napisać funkcję <tt>znajdzN(M)</tt>, która wyznacza i zwraca tę liczbę.

''CDN''

----

[[PPy3/Funkcje|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/Moduły|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 16:06, 5 lip 2016 (CEST)

PPy3/Kolekcje

2022-08-01T12:10:00Z

RobertJB: /* Kolekcje */

=Kolekcje=

'''Kolekcje''' to są takie typy danych, które składają się z elementów. Szczególnym przypadkiem, [[PPy3/SekwencjeIIteracja|omawianym już wcześniej]] przy okazji wprowadzenia pętli, są sekwencje - kolekcje uporządkowane. Rozmaite typy kolekcji różnią się sposobem dostępu do elementów, modyfikowalnością - lub przeciwnie, optymalizacją pod względem różnych zastosowań.

*Szereg typów kolekcji jest ,,wbudowanych" w pythonie - to znaczy, że można z nich swobodnie korzystać bez żadnych dodatkowych zabiegów;
*niektóre inne są zaimplementowane w modułach biblioteki standardowej - a więc korzystanie z nich wymaga wcześniejszego polecenia <tt>import</tt> (p. [[PPy3/Moduły|Moduły]]);
*ważne dla zastosowań do obliczeń naukowych typy tablicowe są zaimplementowane w bibliotece [[PPy3/NumPy|NumPy]], która '''nie''' jest częścią biblioteki standardowej, i na ogół np. nie znajdzie się w domyślnym zestawie pakietów typowej dystrybucji Linuxa. Na pewno będzie jednak dostępna jako opcjonalny element instalacji;
*na każdym typie kolekcji umie działać funkcja <tt>len</tt>, zwracająca liczbę elementów kolekcji będącej jej argumentem.

Omówimy tu kolejno w skrócie najważniejsze i najbardziej przydatne wg. nas typy kolekcji, z pominięciem tablic NumPy - którym będzie poświęcony [[PPy3/NumPy|osobny rozdział]].

==Listy==

O listach już nieco wiemy. Lista to kolekcja uporządkowana, i modyfikowalna. Elementem listy może być cokolwiek - również inna lista. A nawet ta sama lista - tak, lista może być elementem samej siebie, jednak sztuczka taka nie jest chyba przydatna, choć legalna.

O adresowaniu elementów przez pozycję (lub ''indeks'') oraz o pobieraniu (i podstawianiu do) wycinków już było. Dodamy tu jeszcze parę użytecznych operacji na listach:

<source lang=python>
L = [0, 1, 3]
L.append(5) # dołączamy element do końca, przedłużając listę
→ L == [0, 1, 3, 5]
L.extend(['a', 'b']) # przedłużamy od razu o całą listę dodatkowych elementów
→ L == [0, 1, 3, 5, 'a', 'b']
L.insert(2, 'dwa') # pierwszy argument to pozycja, drugi to element wstawiany; dalsze elementy przesuwają się
→ L == [0, 1, 'dwa', 3, 5, 'a', 'b']
x = L.pop() # usuwamy ostatni element i zwracamy go jako wynik
→ teraz x == 'b', a L == [0, 1, 'dwa', 3, 5, 'a']
y = L.pop(2) # możemy zrobić to samo, wskazując inną pozycję zamiast ostatniej
→ teraz y == 'dwa', a L == [0, 1, 3, 5, 'a']
L.reverse() # odwrócenie porządku elementów
→ teraz L == ['a', 5, 3, 1, 0]
L.sort() # uporządkowanie elementów listy
→ BŁĄD - nie zadziała, gdyż lista zawiera elementy nieporównywalne (liczby i napis)
L.pop(0) # usuwamy napis, stojący w pozycji 0
L.sort()
→ teraz L == [0, 1, 3, 5]
</source>

Oprócz operacji <tt>L.sort()</tt> istnieje jeszcze funkcja <tt>sorted(L)</tt> - różniąca się tym, że pozostawia niezmienioną listę <tt>L</tt>, zamiast tego tworząc '''nową''' listę uporządkowaną, zawierającą te same elementy, co <tt>L</tt>.

Notację postaci <tt>L.append(5)</tt> można czytać tak: zastosuj ''metodę'' obiektu <tt>L</tt>, o nazwie <tt>append</tt>, do liczby 5. Metoda jest to operacja związana z pewnym obiektem (w tym przypadku - listą) - tym, do którego odnosi się nazwa stojąca przed kropką. Metodę można uważać za pewien rodzaj funkcji - takiej , która oprócz ewentualnych argumentów umieszczonych w nawiasach po jej nazwie, ,,wie" jeszcze o tym, z jakiego obiektu została wywołana.

<blockquote>
W Pythonie każda dana jest obiektem jakiegoś rodzaju (''klasy''), nawet liczba; i każdy obiekt posiada właściwe sobie metody (na ogół wyznaczone przez klasę, do jakiej przynależy). Programista może zresztą sam tworzyć klasy obiektów na potrzeby swojego programu. Więcej na ten temat później.
</blockquote>

Funkcja <tt>list</tt> tworzy listę z dowolnej sekwencji (np. z napisu). Wywołanie bez argumentów <tt>list()</tt> zwraca pustą listę; wywołanie <tt>list(s)</tt>, gdzie <tt>s</tt> jest napisem, zwraca listę znaków (napisów jednoelementowych), z których składa się napis <tt>s</tt>. Wywołanie, gdzie argumentem jest lista, zwraca duplikat tej listy - tzn. listę o tych samych elementach (i w tym samym porządku), ale nie tożsamą.

===Przykład: suma cyfr===

Spróbujmy policzyć sumę cyfr, z jakich składa się zapis liczby naturalnej <tt>n</tt> - a wyrażając się precyzyjniej, sumę liczb reprezentowanych przez cyfry zapisu dziesiętnego liczby <tt>n</tt> (cyfra to znak, a więc w rozumieniu Pythona pewien napis jednoelementowy - a nie liczba; ponadto, ten sam problem można by postawić dla zapisu pozycyjnego o dowolnej podstawie, np. dwójkowego lub szesnastkowego).

Pierwszym rozwiązaniem tego problemu jest takie, jakie można by nazwać arytmetycznym:

<source lang=python>
def sumacyfr(n):
suma = 0
while n:
suma += n % 10
n = n // 10
return suma
</source>

Proste: ostatnią cyfrę zapisu liczby <tt>n</tt> (a wyrażając się pedantycznie: odpowiadającą jej liczbę między 0 a 9) otrzymujemy jako resztę z dzielenia <tt>n</tt> przez 10; następnie ,,skracamy" <tt>n</tt> o tę ostatnią cyfrę, zastępując <tt>n</tt> przez jej iloraz całkowitoliczbowy przez 10. I tak do skutku, aż zabraknie cyfr.

Można jednak napisać znacznie krótszą wersję tej funkcji, korzystając z tego, że Python ,,sam" umie wyznaczyć cyfry zapisu dziesiętnego każdej liczby i nie musimy do tego pisać własnego kodu. Robi to funkcja <tt>str(n)</tt> - zastosowana do liczby całkowitej, zwraca ona napis składający się z cyfr dziesiętnych, reprezentujący tę liczbę. Rozwiązanie uproszczone wygląda więc tak:

<source lang=python>
def sumacyfr(n):
suma = 0
for c in str(n):
suma += int(c)
return suma
</source>

Dalsze uproszczenie otrzymujemy zastępując pętlę tzw. ''wyrażeniem generatorowym'', i korzystając z wbudowanej funkcji <tt>sum</tt>:

<source lang=python>
def sumacyfr(n):
return sum(int(c) for c in str(n))
</source>

Wyrażenia generatorowe to jakby odwrotny zapis pętli <tt>for</tt>. Notacja ta definiuje obiekt (''generator'') będący odpowiednikiem i uogólnieniem obiektu, jaki produkuje funkcja <tt>range</tt>: jest to ''niby-sekwencja'', która może zastąpić sekwencję (np. listę) w pętli <tt>for</tt>, a także w funkcjach (takich jak <tt>sum</tt> lub <tt>sorted</tt>), które jako argumentu oczekują sekwencji. W odróżnieniu od sekwencji, generator nie ma z góry ustalonego ciągu elementów, można powiedzieć, że produkuje kolejne elementy ,,na żądanie'', np. gdy są potrzebne dla kolejnego obiegu pętli <tt>for</tt>. Wyrażenie generatorowe określa generator na podstawie elementów podawanych przez inny generator (lub sekwencję), poddając je jakiemuś przekształceniu i/lub selekcji:

<source lang=python>
gen = (f(x) for x in elementy if w(x))
</source>

tu: <tt>elementy</tt> to sekwencja lub generator, <tt>w(x)</tt> to warunek decydujący o uwzględnieniu lub pominięciu elementu <tt>x</tt>, a <tt>f(x)</tt> to w ogólności wyrażenie, którego wartość będzie kolejnym elementem podawanym przez generator <tt>gen</tt>.

''Uwaga:'' nawiasy okrągłe otaczające wyrażenie generatorowe są obowiązkowe. Jeśli wyrażenie to wstawiamy bezpośrednio pod wywołanie funkcji jako jej jedyny argument, to wystarczają nawiasy zawarte w składni wywołania funkcji - nie potrzeba ich podwajać. Jeśli w miejsce nawiasów okrągłych napiszemy kwadratowe, otrzymamy nie generator - a listę o tych samych elementach.

==Krotki==

Krotki to prawie listy; zasadnicza różnica polega na tym, że krotki są '''niemodyfikowalne'''. Podobnie jak napisy - krotki raz stworzonej nie można zmienić, w sensie zmiany jej zawartości (elementów), a tym bardziej - jej długości. Można ją najwyżej zastąpić inną krotką. W związku z tym, krotki pozbawione są metod modyfikujących zawartość, jakie posiadają listy. Inne operacje, jak adresowanie elementów i wycinków, dodawanie (sklejanie) i mnożenie (powielanie) działają analogicznie jak dla list.

Literalne krotki zapisuje się zwykle używając nawiasów okrągłych:

<source lang=python>
T = (3, 5, 8)
</source>

chociaż tak naprawdę, to nawiasy są opcjonalne, a krotkę tworzą ''przecinki'' stojące pomiędzy elementami. Pominięcie nawiasów powoduje jednak, że musimy pamiętać o tym jaka jest kolejność operacji, jeżeli literalny zapis krotki jest elementem większego wyrażenia. Zwykle prościej i czytelniej jest użyć nawiasów.

Krotka może oczywiście składać się z jednego elementu, a nawet być pusta:

<source lang=python>
T1 = 1, # krotka o jednym elemencie - liczbie 1
T0 = () # krotka pusta
</source>

w tym ostatnim przypadku nie można się obyć bez nawiasów. Oczywiście tworzenie takich krotek rzadko bywa przydatne; mogą się one jednak pojawiać jako wyniki rozmaitych operacji.

Po co są w ogóle krotki, skoro to tylko jakby ,,słabsze" listy?

*Czasami warto użyć typu niemodyfikowalnego, aby próba zmiany zawartości kolekcji (np. w wyniku błędu) nie mogła się udać;
*optymalizacja - krotki są ,,lżejsze" od list, co może mieć znaczenie jeśli potrzebujemy je tworzyć w dużej liczbie;
*w niektórych przypadkach użycie niemodyfikowalnego typu danych jest konieczne; o tym dalej.

Warto jednak pamiętać, że choć sama krotka jest niemodyfikowalna - to jej elementem może być np. lista, której zawartość może być zmieniona niezależnie od tego, że jest elementem krotki.

Każdą sekwencję (a i pewne inne obiekty — np. generatory) można ,,zrzutować" na krotkę, za pomocą funkcji <tt>tuple</tt>. Wyrażając się precyzyjniej, wyrażenie <tt>tuple(s)</tt> jest krotką o tej samej zawartości (i w tym samym porządku) co sekwencja (lub inny obiekt iterowalny) <tt>s</tt>.

==Słowniki==

Słownik (''dictionary'') to taka kolekcja, której elementy - zamiast być uporządkowane - są powiązane z ''kluczami''. Kluczem może być liczba (całkowita lub ułamkowa), napis, ale również dana szeregu innych typów (chociaż nie każdego). Pobranie elementu słownika wiąże się z podaniem odpowiadającego mu klucza. Klucze w słowniku są niepowtarzalne - a więc każdy z nich jest związany z dokładnie jedną wartością. Wartości za to mogą się powtarzać, i nie podlegają żadnym ograniczeniom co do typu. Zapis literalny słowników posługuje się nawiasami klamrowymi:

<source lang=python>
slownik = {'jeden' : 1, 'dwa' : 2, 'trzy' : 3}
slownik['dwa']
→ 2
slownik['cztery']

KeyError Traceback (most recent call last)
<ipython-input-2-22c7b016c2c6> in <module>()
----> 1 slownik['cztery']

KeyError: 'cztery'
slownik['cztery'] = 4
slownik['cztery'] == 4
→ True
</source>

W notacji literalnej w nawiasach stoją, oddzielone przecinkami, pary klucz-wartość, a klucz od wartości oddziela dwukropek.
Nazwa ''słownik'' bierze się stąd, że jednym z możliwych zastosowań jest przekład kluczy (tu: słowa oznaczające liczby) na odpowiadające im wartości (tu: liczby). Widzimy też, że próba pobrania wartości odpowiadającej kluczowi, którego w słowniku nie ma, kończy się błędem. Z drugiej strony, w każdej chwili można do słownika dodać następną parę klucz-wartość; analogicznie, można wymienić wartość związaną z kluczem już istniejącym na inną.

Warto podkreślić jeszcze raz, że pary klucz-wartość w słowniku nie charakteryzują się w zasadzie określonym porządkiem. Niemniej w nowszych wersjach Pythona obowiązuje zasada, że pozycje słownika zachowują porządek, w jakim były tworzone — i np. w iteracji będą się pojawiać zgodnie z tym porządkiem.

Dalsze podstawowe operacje na słowniku to sprawdzenie występowania klucza, oraz iteracja:

<source lang=python>
'cztery' in slownik # operator `in' sprawdza przynależność do zbioru kluczy
→ True
'zero' in slownik
→ False
for klucz in slownik:
print(klucz, slownik[klucz])
→
jeden 1
dwa 2
trzy 3
cztery 4
</source>

Jak widać, w iteracji klucze słownika pojawiają się w porządku, w którym je dodawano. Takie zachowanie jest przepisane w definicji języka Python od wersji 3.7. Mając do czynienia z wersjami wcześniejszymi należy się liczyć z tym, że ten porządek nie będzie zachowany. Natomiast gwarantuje się, że każdy klucz pojawi się w iteracji dokładnie jeden raz.

W iteracjach (tzn. pętlach <tt>for</tt>) bardzo przydatne są kolekcje zwracane przez metody słowników: <tt>items</tt>, <tt>values</tt> i (rzadziej przydatna) <tt>keys</tt>. Zwracają one obiekty ,,listo-podobne"; jeżeli potrzebne są nam one w postaci dosłownych list, to wystarczy zastosować do nich funkcję <tt>list</tt>; jeżeli natomiast zamierzamy je wykorzystać w pętli <tt>for</tt>, to nie jest to potrzebne. Zawartość to odpowiednio:

*<tt>slownik.items()</tt>: pary (dwuelementowe krotki) postaci ''(klucz, wartość)''
*<tt>slownik.values()</tt>: same wartości występujące w słowniku
*<tt>slownik.keys()</tt>: same klucze występujące w słowniku.

Uwaga dotycząca porządku pozycji słownika stosuje się również do wyników zwracanych przez te metody.

Funkcją - konstruktorem słownika jest funkcja <tt>dict</tt>. Zamienia ona np. sekwencję par ''(klucz, wartość)'' w odpowiedni słownik. Jeżeli klucze w tej sekwencji się powtarzają, ,,wygrywa" ostatnie wystąpienie.

Wspomnieliśmy wcześniej, że nie każdy typ wartości może być kluczem słownika. Dokładniej - kluczami w słowniku mogą być tylko wartości typów niemodyfikowalnych, a więc nie listy ani same słowniki. Mogą nimi natomiast być napisy, liczby i krotki. ''Nota bene'': ponieważ liczby ułamkowe należy traktować jako przybliżone, używanie ich jako kluczy słownika na ogół nie jest dobrym pomysłem. Nie ma ograniczeń co do mieszania różnych typów kluczy (ani wartości) w jednym słowniku.

==Zbiory==

Zbiory w Pythonie mają sens taki, jak zbiory w matematyce (teorii mnogości). Mówiąc po prostu, zbiór jest kolekcją nieuporządkowaną i nie dopuszczającą powtórzeń: dany element albo do zbioru należy, albo nie; nie może należeć ''dwukrotnie'' (ani więcej razy). Standardowe zbiory są obiektami modyfikowalnymi.

Zbiór literalny zapisuje się za pomocą nawiasów klamrowych — łatwo odróżnić, że nie chodzi o słownik, gdyż zapis dla zbiorów nie zawiera dwukropków.

<blockquote>
Wiąże się z tym jednak jeden problem: czy <tt>{}</tt> oznacza zbiór pusty, czy pusty słownik? Dość arbitralnie przyjęto, że jednak pusty słownik (notację dla zbiorów wprowadzono później niż dla słowników).</blockquote>

Przykłady:

<source lang=python>
zbior = {'a', 'b', 'c'}
'a' in zbior
→ True
6 in zbior
→ False
zbior.add('d')
→ zbior == {'a', 'b', 'c', 'd'}
zbior.remove('a')
→ zbior == {'b', 'c', 'd'}
innyzb = {1, 2, 'b'}
zbior | innyzb # suma zbiorów
→ {'a', 1, 2, 'c', 'd', 'b'}
zbior & innyzb # iloczyn (część wspólna) zbiorów
→ {'b'}
zbior - innyzb # różnica zbiorów
→ {'a', 'c', 'd'}
zbior ^ innyzb == (zbior | innyzb) - (zbior & innyzb) # definicja różnicy symetrycznej zbiorów
→ True
innyzb <= zbior # pierwszy jest podzbiorem drugiego?
→ False
{'b', 'c'} <= zbior
→ True
{'b', 'c'} < zbior # podzbiór właściwy?
→ True
# znaki nierówności mogą być skierowane odwrotnie, z odp. zamianą argumentów
</source>

Elementy zbiorów podlegają analogicznemu ograniczeniu co do typów danych, co klucze słownika: nie mogą być to obiekty modyfikowalne.

Konstruktorem zbioru jest funkcja <tt>set</tt>: można jej podać jako argument dowolną kolekcję, a ona zwróci zbiór jej elementów (z dokładnością do ograniczeń co do typów danych tych elementów). Na przykład, typowy chwyt na usunięcie powtórzeń elementów: aby uzyskać uporządkowaną listę znaków, z jaki składa się napis <tt>s</tt>:

<source lang=python>
znaki = sorted(set(napis))
</source>

Podobnie jak lista ma swój odpowiednik niemodyfikowalny (krotkę), tak niemodyfikowalnym odpowiednikiem zbioru jest ''zbiór zamrożony'' (''frozenset''). Można taki wyprodukować za pomocą funkcji <tt>frozenset</tt>, analogu funkcji <tt>set</tt>. Zbiory zamrożone dopuszczają wszystkie te same operacje, co zwykłe zbiory - za wyjątkiem operacji zmieniających skład (jak <tt>add</tt> i <tt>remove</tt>).

==Napisy (jeszcze raz)==

O napisach już nieco było wcześniej, ale dla kompletności przypomnijmy.

*Napis to niemodyfikowalna sekwencja
*Jej elementami są znaki - napisy o długości 1
*Operatorem <tt>in</tt> można badać nie tylko, czy dany znak występuje w napisie, ale również czy jeden napis jest fragmentem drugiego:
<source lang=python>
s = 'abc XYZ'
'abc' in s
→ True
</source>
*Napisy mają szereg użytecznych metod; ale ''żadna z tych metod nie zmienia napisu, którego dotyczy'' - może jedynie tworzyć (i zwracać) nowy napis, utworzony na podstawie istniejącego. Przykłady:
<source lang=python>
s.lower()
→ 'abc xyz'
s.upper()
→ 'ABC XYZ'
s.replace(' ', ';')
→ 'abc;XYZ'
s.find('XY') # znajduje pozycję, na jakiej występuje podany fragment w napisie s
→ 4
s.find('q') # szukamy fragmentu, którego w s nie ma..
→ -1
</source>
*Metod tych jest więcej, poznamy je w przykładach
*Funkcją - konstruktorem napisu jest <tt>str</tt>; np. liczbę - zamienia w napis będący jej zapisem (najbardziej ,,standardowym"), i podobnie z innymi typami danych - zwraca najbardziej ,,standardową" ich reprezentację za pomocą napisu
*Szczególnie ważną i przydatną operacją napisową jest metoda <tt>format</tt>, o niej zaraz.

===Formatowanie===

Idea formatowania jest następująca: mamy pewien napis, który służy jako szablon do tworzenia napisów, w ten sposób, że określone miejsca w szablonie wypełniane są wartościami (a dokładniej - ich przedstawieniami napisowymi), które zazwyczaj nie są z góry znane i są wyliczane dopiero w wyniku działania programu. Najczęściej chodzi po prostu o przedstawienie uzyskanych wyników w postaci komunikatów lub zapisów w plikach, o określonej przez programistę postaci.

Gdy korzystamy z metody <tt>format</tt>, napis pełniący rolę szablonu (literalny lub przywołany poprzez nazwę) stoi przed kropką, tzn. wywołujemy metodę <tt>format</tt> tegoż napisu - szablonu, natomiast argumentami tego wywołania są wartości, które mają być wstawione w przeznaczone na to pozycje w szablonie.

Język opisu szablonów jest stosunkowo złożony i kryje w sobie szereg możliwości, na razie wprowadzimy najprostsze przypadki.

<source lang=python>
# Najprostsze formatowanie: wartości wstawiane są kolejno w miejsca zaznaczone poprzez {}
'x = {}, y = {}'.format(1.2, 9)
→ 'x = 1.2, y = 9'
# Numerowanie pozycji (ten sam numerek może występować więcej niż raz w szablonie
'x1 = {1}, x0 = {0}'.format(3, 15)
→ 'x1 = 15, x0 = 3'
# Obcięcie przedstawienia liczby ułamkowej do określonej liczby cyfr po kropce
'{0:.4f}'.format(3.141592653589793)
→ '3.1416'
# Bardziej szczegółowa kontrola formatowania
'{:4s}{:4s}{:*>4s}'.format('a', 'b', 'c')
→ 'a b ***c'
</source>
W tym ostatnim przykładzie, liczby 4 specyfikują ''minimalną'' szerokość pól przeznaczonych na wypełnienie podanymi wartościami, natomiast <tt>*></tt> oznacza, że gwiazdka ma być ,,wypełniaczem" pustego miejsca, jeżeli takie pozostanie w zadanej wielkości pola po wstawieniu wartości, a znak <tt>></tt> oznacza wyrównanie (wewnątrz pola) do strony prawej. Więcej szczegółów - w [https://docs.python.org/3/library/string.html#formatstrings dokumentacji].

Począwszy od wersji 3.6 języka Python wprowadzono uproszczoną składnię formatowania napisów. Poprzedzając w zapisie napisu literalnego otwierający cudzysłów (lub apostrof) literą <tt>f</tt> (lub <tt>F</tt>), możemy w tym napisie skorzystać z sekwencji w parach nawiasów klamrowych, gdzie wewnątrz nawiasów umieszczamy (zamiast jak wyżej — numeru pozycji w liście argumentów wywołania <tt>format()</tt>) po prostu zapis wyrażenia w Pythonie, którego aktualna wartość znajdzie się w tym miejscu w wyniku ewaluacji, plus ewentualnie dwukropek a po nim dyrektywy formatowania, jak wyżej. Przykłady:

<source lang=python>
x, y = 1.2, 9
f'x = {x}, y = {y}'
→ x = 1.2, y = 9
f'wynik działania arytmetycznego: {2 * x + y}'
→ wynik działania arytmetycznego: 11.4
</source>
Jeżeli chcemy, aby w wyniku wystąpiły dosłowne nawiasy klamrowe, a nie zostały one zinterpretowane jako pole do wypełnienia wartością wyrażenia, to musimy je podwoić (<tt>f'{{'</t> → { itd.)

=Ćwiczenia=

1. Ile wynosi najmniejsza liczba <tt>N</tt>, dla której <tt>S_N = 1 + 2**3 + 3**3 + ... + N**3</tt>
jest liczbą której zapis dziesiętny ma więcej niż M cyfr? Napisać funkcję <tt>znajdzN(M)</tt>, która wyznacza i zwraca tę liczbę.

''CDN''

----

[[PPy3/Funkcje|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/Moduły|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 16:06, 5 lip 2016 (CEST)

PPy3/Funkcje

2022-07-29T13:05:47Z

RobertJB: /* Definiowanie funkcji */

=Funkcje=

Gdy raz wymyślimy jakiś sprytny algorytm, to nie ma co go za każdym razem odkrywać na nowo. Żeby było łatwiej pisać raz, a korzystać wielokrotnie - wymyślono funkcje.

==Definiowanie funkcji==

<source lang=python>
def funkcja(x, y):
BLOK INSTRUKCJI
</source>

*Definicja funkcji to instrukcja złożona, podobna w strukturze do tych, które już znamy - instrukcji warunkowej i pętli.
*Wykonanie definicji funkcji ''nie wiąże się z natychmiastowym wykonaniem zawartego w niej bloku''.
*W definicji funkcji (przykładowej) <tt>x</tt> i <tt>y</tt> to ''parametry formalne''; nie mają one w tym momencie określonych wartości, są miejscami do wypełnienia konkretnymi wartościami, gdy funkcję postanowimy użyć. Może ich być (niemal) dowolnie wiele, w tym — zero. W tym ostatnim przypadku piszemy pustą parę nawiasów.
*Wykonanie definicji funkcji polega na nadaniu znaczenia jej nazwie, która odtąd będzie oznaczała ciąg instrukcji stanowiących wewnętrzny blok.
*Użycie czyli ''wywołanie'' funkcji to wyrażenie postaci

<source lang=python>
funkcja(x, y)
</source>

gdzie <tt>x</tt> i <tt>y</tt> mają już konkretne wartości (w tym miejscu mogą stać również wyrażenia złożone), które będą użyte w instrukcjach stanowiących definicję.

*W definicji na ogół występuje (raz lub więcej razy) słowo (instrukcja) <tt>return</tt>. Oznacza ono, że w tym miejscu wykonanie funkcji się kończy - funkcja powraca. Wartość wyrażenia po słowie <tt>return</tt> stanowi wynik zwracany przez funkcję - czyli wartość wyrażenia, będącego wywołaniem funkcji.
*Jeśli <tt>return</tt> nie ma, albo nie ma po nim wartości zwracanej, albo wykonanie funkcji kończy się ,,wypadnięciem" przez koniec bloku, wartością zwracaną jest <tt>None</tt> — która w zasadzie do niczego się specjalnie nie nadaje, poza sprawdzeniem, czy mamy do czynienia z właśnie tą wartością.
*''funkcja'' w Pythonie (i większości języków programowania) to coś nieco podobnego do funkcji (odwzorowania) w matematyce, ale '''to nie jest to samo pojęcie''':
**w Pythonie wywołanie funkcji może mieć skutki uboczne;
**wynik funkcji, w tym skutki uboczne, może zależeć nie tylko od argumentów wywołania.
Skutkami ubocznymi wywołania nazywamy jakiekolwiek efekty tej instrukcji, które nie sprowadzają się do wartości zwracanej. A więc, zmianę wartości innych zmiennych, czy np. wysłanie jakichś danych siecią, lub wypisanie czegoś na ekran.
*Funkcja może być wartością zmiennej; inaczej mówiąc, funkcja może być znana pod dodatkowymi nazwami (aliasami), może być włożona do listy na którąś z jej pozycji itp.

<source lang=python>
ff = funkcja
...
wynik = ff(x)
</source>

*,,Oryginalna" nazwa funkcji, czyli występująca w jej definicji, jest jednak w pewnym sensie uprzywilejowana.
*Zmienne (nazwy) '''powołane do życia''' wewnątrz funkcji są lokalne; ich wartości ,,żyją" tylko póki wykonuje się funkcja.
*Zmienne lokalne powielające nazwy ,,zewnętrzne" względem funkcji przesłaniają te zewnętrzne. Chyba, że użyjemy deklaracji <tt>global</tt>:
<source lang=python>
x = 1
def podwojx(): # to nie zadziała:
x = x * 2
podwojx()
UnboundLocalError Traceback (most recent call last)
<ipython-input-3-6edd575e5cda> in <module>()
----> 1 podwojx()

<ipython-input-1-1da635f42ffa> in podwojx()
1 def podwojx():
----> 2 x *= 2
3

UnboundLocalError: local variable 'x' referenced before assignment
</source>

Jak widzimy, komunikat o błędzie pojawił się dopiero w wyniku wywołania błędnej funkcji.

<source lang=python>
x = 1
def podwojx(): # to zadziała - co nie znaczy, że jest mądre...
global x
x = x * 2
podwojx()
print x
→ 2
</source>

Należy unikać takich sztuczek, jak powyżej; jeśli już, to:

<source lang=python>
def podwoj(x):
return 2 * x
liczba = 1
print podwoj(liczba)
→ 2
</source>

''Wskazówka:'' każde użycie deklaracji <tt>global</tt> w programie powinno być dobrze uzasadnione. Jeżeli używamy jej więcej niż sporadycznie, to coś jest nie tak.

Funkcja może być

*jednoargumentowa (jak powyższa <tt>podwoj</tt>),
*dwuargumentowa (jak przykładowa),
*trzy-, cztero-, ... itd.
*o zmiennej liczbie argumentów, z wartościami domyślnymi dla brakujących:

<source lang=python>
def dodaj(x, y=1):
return x + y
dodaj(2, 3)
→ 5
dodaj(2)
→ 3
</source>

Parametry z wartościami domyślnymi muszą występować na końcu listy parametrów.

=Ćwiczenia=

1. Napisz funkcję <tt>pierwiastki(a, b, c)</tt>, która wypisuje na ekran (za pomocą wywołania <tt>print</tt>) pierwiastki równania kwadratowego o wspołczynnikach ''a'', ''b'' i ''c'': <tt>a * x**2 + b * x + c == 0</tt>. W przypadku, gdy pierwiastków nie ma, wypisuje komunikat ''Równanie nie ma pierwiastków.'' W przypadku, gdy ''a=0'', wypisuje komunikat ''Błędne dane: a==0'' i kończy działanie.

2. Napisz analogiczną funkcję, która zamiast bezpośrednio wypisywać rozwiązania, zwraca je jako wynik swojego działania. Wypisaniem ich na ekran zajmuje się odrębna instrukcja. W przypadku, gdy pierwiastków nie ma, zwraca wartość <tt>None</tt>. Nie sprawdzaj warunku ''a!=0'' - co się dzieje, gdy nie jest spełniony przez argumenty wywołania funkcji?

3. Napisz funkcję <tt>silnia(n)</tt>, która oblicza i zwraca wartość silni: <tt>n! := 1 * 2 * 3 * ... (n - 1) * n</tt>. Uwzględnij, że przyjmuje się że <tt>0! = 1</tt>, natomiast dla liczb ujemnych silnia nie jest określona - co można zasygnalizować zwracając jako wynik <tt>None</tt>. Użyj pętli <tt>for</tt> i funkcji <tt>range</tt>.

4. Funkcję silnia można zdefiniować w sposób rekurencyjny - za pomocą następujących warunków:
<blockquote>
<tt>n! == None</tt> dla <tt>n < 0</tt> 
<tt>0! == 1</tt> 
<tt>n! == n * (n - 1)!</tt>
</blockquote>
Napisz kod funkcji <tt>silnia(n)</tt> realizujący powyższą definicję. Porównaj działanie tego kodu z realizacją tej funkcji z poprzedniego przykładu dla dużych wartości <tt>n</tt>.

----

[[PPy3/SekwencjeIIteracja|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/Kolekcje|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 16:10, 30 cze 2016 (CEST)

PPy3/SekwencjeIIteracja

2022-07-29T12:58:23Z

RobertJB: /* Sekwencje i iteracja */

=Sekwencje i iteracja=

'''Sekwencje''' to typ danych charakteryzujący się tym, że składają się z ''elementów'' zgromadzonych w pewnej ''kolejności''. Elementem sekwencji może być cokolwiek (w tym - inna sekwencja), ale w najprostszym przypadku elementami tymi są liczby.

<blockquote>
Sekwencje to szczególny przypadek ''kolekcji'' - takich typów danych, które składają się z elementów, ale niekoniecznie są one uporządkowane. Innym przykładem kolekcji jest zbiór (''set'').
</blockquote>

Najczęściej używanym typem sekwencji jest ''lista'' (''list''). Listę można stworzyć (i zapamiętać) np. nadając jej pewien początkowy skład:

<source lang=python>
numerki = [0, 1, 2, 3, 5, 8]
</source>

To co stoi po prawej stronie znaku równości to literalny zapis listy - ciąg elementów, oddzielonych przecinkami, wewnątrz pary nawiasów kwadratowych. Oczywiście jako elementy mogą występować zarówno stałe literalne - jak w tym przykładzie, jak i nazwy (zmienne) — oczywiście takie, którym uprzednio nadano wartości.

Z listy - podobnie jak z każdej sekwencji - można pobrać element stojący w dowolnej pozycji, podając jej numer:

<source lang=python>
print(numerki[4])
→ 5
</source>

'''Uwaga:''' pozycje numerowane są kolejnymi liczbami naturalnymi, począwszy od zera - podobnie, jak w większości języków programowania.

Sięgnięcie po element nie występujący w liście, to znaczy podanie numeru pozycji poza zakresem rozmiaru danej listy, będzie błędem i domyślnie spowoduje przerwanie wykonywania programu.

Można też podmienić istniejący element na inny:

<source lang=python>
numerki[0] = -1
print(numerki)
→ [-1, 1, 2, 3, 5, 8]
</source>

a nawet przedłużyć ją o kolejny element:

<source lang=python>
numerki.append(13)
print(numerki)
→ [-1, 1, 2, 3, 5, 8, 13]
</source>

oraz usunąć element (skracając listę):

<source lang=python>
del numerki[0]
print numerki
→ [1, 2, 3, 5, 8, 13]
</source>

Łatwo też ustalić, jaka jest ,,długość" listy, czyli liczba jej elementów:

<source lang=python>
print(len(numerki))
→ 6
</source>

Jest jeszcze sporo innych ,,gotowych do użytku" operacji na listach. Ale najważniejsza cecha listy jest taka: '''można zmieniać jej skład, a nawet długość, a pozostaje ona tą samą listą'''. Nawet jeśli występuje w programie pod więcej niż jedną nazwą.

==Pętla <tt>for</tt>==

Naczelne zastosowanie listy (czy ogólniej -sekwencji), to iteracja - czyli wykonanie jakiejś operacji dla każdego elementu. I tak wygląda najprostszy rodzaj iteracji - Pętla <tt>for</tt>:

<source lang=python>
for x in numerki:
print(x)
</source>

Zamiast <tt>print(x)</tt> pętlę <tt>for</tt> może tworzyć dowolny blok instrukcji, zgodnie z zasadami jakie już poznaliśmy przy omawianiu instrukcji warunkowej. Cały blok tworzący wnętrze pętli będzie wykonany wielokrotnie, tyle razy, ile elementów ma lista, a za każdym razem pod nazwę stojącą bezpośrednio po słowie <tt>for</tt> podstawiony będzie kolejny element listy (przywołanej po słowie <tt>in</tt>) - kolejny, tzn. zgodnie z kolejnością, w jakiej umieszczone są one w liście.

Inny, znany nam już rodzaj sekwencji to napis (''string''), zwany czasami ''łańcuchem znakowym''. Napis składa się ze znaków, i jest w szczególności sekwencją, której elementami są znaki. Analogicznie jak w przypadku listy, można pobierać znaki stojące na poszczególnych pozycjach w napisie. '''Nie można''' natomiast podmieniać znaków w napisie, ani ich usuwać bądź dopisywać: w odróżnieniu od listy, napis raz utworzony jest ''niezmienny''. Można go zastąpić innym napisem, i ewentualnie opatrzyć ten nowy napis tą samą nazwą, ale nie da się go zmodyfikować. I nie jest to dzielenie włosa na czworo, własność ta ma namacalne konsekwencje:

<source lang=python>
napis1 = 'abc'
napis2 = napis1
napis1 = 'ABC'
print(napis1, napis2)
→ ABC abc
# dla porównania, listy:
lista1 = ['a', 'b', 'c']
lista2 = lista1
lista1[0] = 'A'
print(lista1, lista2)
→ ['A', 'b', 'c'] ['A', 'b', 'c']
</source>

<blockquote>
Powraca jeszcze raz pytanie: czym są poszczególne znaki? Tzn. jaki typ danych reprezentują? Otóż w Pythonie pojedyncze znaki też są po prostu napisami, tyle że o długości jeden. Poza długością nic ich szczególnie nie wyróżnia. Ta uwaga jest na użytek tych z Was, którzy znają jakiś inny język programowania, gdyż w wielu z nich znak jest oddzielnym, innym niż napis typem danych.
</blockquote>

Pętlę <tt>for</tt> można zatem zastosować do napisu - zamiast do listy, wówczas w kolejnych iteracjach będą uwzględniane kolejne znaki, a których składa się napis.

===Ogólna postać pętli <tt>for</tt>===

<source lang=python>
for element in sekwencja:
<blok instrukcji>
else:
<blok instrukcji>
</source>

*Pierwszy blok instrukcji będzie wykonany ''w zasadzie'' tyle razy, ile elementów ma sekwencja
*Za każdym razem nazwa ''element'' oznaczać będzie kolejny element sekwencji, zgodnie z ich porządkiem
*''sekwencja'' może być pusta; nie jest to błąd, ale wtedy pierwszy blok nie będzie wykonany ani razu
*Gdy elementy sekwencji się wyczerpią, wykonany zostanie blok po <tt>else</tt>
*Blok <tt>else</tt> (wraz z linijką go otwierającą) jest opcjonalny (niekonieczny)
*W pierwszym bloku mogą wystąpić specjalne polecenia: <tt>break</tt> i <tt>continue</tt>
**<tt>break</tt> znaczy: przerwij pętlę natychmiast, pomiń wszystkie pozostałe elementy sekwekcji, '''pomiń również ewentualny blok <tt>else</tt>'''
**<tt>continue</tt> oznacza: przerwij działania na aktualnym elemencie, i wróć do początku bloku biorąc kolejny element. Jeśli już zabrakło elementów, przejdź do bloku <tt>else</tt>, albo (gdy go nie ma) do polecenia następnego po pętli
*W miejscu gdzie stoi ''sekwencja'' może tak naprawdę stać dowolny obiekt ''iterowalny'' - np. kolekcja. Ale innych typów kolekcji jeszcze nie poznaliśmy...

<blockquote>
Blok <tt>else</tt> w pętli <tt>for</tt> jest stosunkowo rzadko widywany. Nawet wielu programistów dość biegłych w Pythonie nie wie (lub zapomniało) o istnieniu tej opcji.
</blockquote>

A co, jeśli chcielibyśmy za pomocą pętli <tt>for</tt> (lub inaczej) zmienić w jakiś sposób skład samej sekwencji? Na przykład:

<source lang=python>
for x in lista:
x = x + 1
</source>

'''TO NIE ZADZIAŁA''' - w tym sensie, że ''lista'' będzie dalej miała te same elementy co poprzednio, a nie - powiększone o 1. W istocie operacja taka nic nie osiąga - oprócz tego, że po jej zakończeniu nazwa ''x'' ma wartość ostatniego elementu listy, powiększonego o 1. To samo można dostać bez pisania pętli.

Jak więc osiągnąć zmianę - przeliczenie - wszystkich elementów sekwencji wg. jakiejś reguły (np. powiększ każdy z nich o 1)?

Pożytecznym sposobem tworzenia sekwencji jest funkcja <tt>range</tt>:

<source lang=python>
for x in range(3):
print(x)
→ 0
→ 1
→ 2
</source>

Argument (tu: 3) oznacza liczbę elementów w wyprodukowanej sekwencji. Domyślnie zaczyna się ona od zera, tak jak numeracja pozycji w sekwencjach - ale można użyć wywołania <tt>range(a, b)</tt> aby uzyskać elementy dowolnego ciągu arytmetycznego - o elemencie początkowym ''a'' i przyroście ''b''.

<blockquote>
Tu jest pewne oszustwo: wynikiem wywołania <tt>range</tt> nie jest tak naprawdę lista, ale pewnego innego rodzaju typ sekwencji, a więc mogący służyć za źródło elementów w iteracji. Na razie to jest jednak drobny szczegół. Jeżeli potrzebujemy dosłownej listy o takich elementach, wystarczy wykonać tzw. rzutowanie, czyli przyłożyć funkcję <tt>list</tt>: <tt>lista = list(range(3))</tt>
</blockquote>

Wracając do problemu przeliczenia wszystkich elementów listy:

<source lang=python>
lista = [3, 5, 8]
for k in range(3):
lista[k] += 1
print lista
→ [4, 6, 9]
</source>

I to działa. Nie jest to jednak optymalne rozwiązanie.

*Pisząc to co powyżej wiedzieliśmy, że mamy do czynienia z listą o długości 3. W ogólności musielibyśmy użyć funkcji <tt>len</tt>;
*Można to jednak zrobić bardziej elegancko:

<source lang=python>
for k, x in enumerate(lista):
lista[k] = x + 1
</source>

Funkcja <tt>enumerate</tt> produkuje sekwencję par: ''nr pozycji'', ''element'' - i jest bardzo przydatna w takich sytuacjach.

Z dokonywaniem wewnątrz pętli zmian na sekwencji, po której iterujemy, należy jednak uważać. To, co robimy w tym przykładzie jest akurat niegroźne, natomiast umieszczenie wewnątrz pętli operacji zmieniających '''długość''' sekwencji, po której iterujemy mogłoby dać nieoczekiwane wyniki. Spróbuj np.:

<source lang=python>
L = [0, 1, 2, 3, 4]
for i in range(5):
del L[i]
</source>

Co tu się stanie, i dlaczego?

==Więcej o listach==

Elementy listy (innych rodzajów sekwencji również) można numerować od końca, używając ujemnych wartości wskaźników pozycji:

<source lang=python>
numerki = [0, 1, 2, 3, 5, 8]
numerki[-1]
→ 8
numerki[-3]
→ 3
</source>

Z list (i innych sekwencji) można wyjmować nie tylko poszczególne elementy, ale również podsekwencje, zwane też wycinkami:

<source lang=python>
numerki = [0, 1, 2, 3, 5, 8]
nn = numerki[1:4]
→ [1, 2, 3]
nn = numerki[2:]
→ [2, 3, 5, 8]
nn = numerki[:3]
→ [0, 1, 2]
nn = numerki[1:4:2]
→ [1, 3]
nn = numerki[4:1:-1]
→ [5, 3, 2]
nn = numerki[:]
→ [0, 1, 2, 3, 5, 8]
</source>

Jak widać, pominięcie pozycji początkowej lub końcowej oznacza: ,,do oporu". Trzecia liczba charakteryzująca wycinek, o ile występuje - to ,,skok" wskaźnika. Przykładowo, <tt>a[::2]</tt> oznaczałoby listę zawierającą co drugi element listy <tt>a</tt>, natomiast <tt>a[::-1]</tt>: listę składającą się z tych samych elementów, co <tt>a</tt> - lecz w odwrotnej kolejności.

Wyrażenie <tt>numerki[:]</tt>, tzw. pełny wycinek, tworzy pełną ''kopię'' listy <tt>numerki</tt>; tzn. '''nie''' jest to ''ta sama'' lista, chociaż składa się z tych samych elementów. Jest to tzw. ''kopia płytka'' - oznacza to tyle, że jeżeli wśród elementów kopiowanej listy były obiekty złożone (np. inne listy), to elementami kopii będą '''te same''' listy, a nie - ich kopie.

Wycinek jest zawsze nową listą, również w ostatnim przypadku - gdy jej skład jest taki sam, jak oryginalnej. Wtedy stanowi kopię pierwotnej listy. Można jednak też podstawiać do wycinka:

<source lang=python>
numerki[4:5] = [4]
→ [0, 1, 2, 3, 4, 8]
numerki[5:5] = [5, 6, 7]
→ [0, 1, 2, 3, 4, 5, 6, 7, 8]
</source>

i jest to jeszcze jeden sposób, by zmienić zawartość listy - w tym być może jej długość - zachowując jej tożsamość.

Listy można do siebie dodawać:

<source lang=python>
l = ['a', 'b', 'c'] + ['y', 'z']
→ ['a', 'b', 'c', 'y', 'z']
</source>

w ten sposób powstaje nowa lista, która ze składników bierze elementy, ale poza tym nie ma z nimi nic wspólnego; późniejsze zmiany w listach-składnikach nie mają wpływu na sumę.

Listy można też zwielokrotnić; np. aby uzyskać listę siedmiu dwójek:

<source lang=python>
l = [2] * 7
→ [2, 2, 2, 2, 2, 2, 2]
</source>

ta sama co poprzednio uwaga stosuje się i tu.

Elementy listy można posumować:

<source lang=python>
x = sum(range(101))
→ 5050
</source>

(wprawdzie <tt>range(101)</tt> nie jest dosłownie listą, ale z ,,prawdziwą" listą można zrobić to samo).

Podobnie jak inne ''obiekty'', listy posiadają szereg ''metod'', za pomocą których można na nich wykonywać różne działania. Przykładowo:

<source lang=python>
numerki.append(9)
→ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numerki.extend([10, 11])
→ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
</source>

Zwróćcie uwagę na notację: kropka sygnalizuje ,,wyciągnięcie" metody z danego obiektu (tu: listy), w nawiasach wpisujemy dane dla tej metody (argumenty - tu pojedyncze, ale może być więcej).

==Więcej o napisach==

Napisy dopuszczają tylko część operacji dostępnych dla list, ze względu na własność niemodyfikowalności. Posiadają za to szereg swoistych metod. Trzeba pamiętać, że żadna z tych metod ''nie zmienia'' napisu, którego dotyczy - wynikiem może być jedynie '''nowy''' napis, stworzony na podstawie oryginalnego.

Niemniej napis ''również'' jest sekwencją, i może być np. zastosowany w pętli <tt>for</tt>. Ale sekwencją czego? Oczywiście znaków — z tym, że w Pythonie nie ma oddzielnego typu danych ,,znak". Znaki to po prostu napisy jednoelementowe.

Przykład: metoda <tt>upper</tt> (zamienia małe litery na wielkie):

<source lang=python>
'abcde'.upper()
→ 'ABCDE'
</source>

Napis zawsze można łatwo zamienić na listę znaków:

<source lang=python>
l = list('abcde')
→ ['a', 'b', 'c', 'd', 'e']
</source>

(choć rzadko zachodzi taka potrzeba).

Do operacji odwrotnej można użyć metody <tt>join</tt>:

<source lang=python>
''.join(l)
→ 'abcde'
', '.join(l)
→ 'a, b, c, d, e'
</source>

==Pętla <tt>while</tt>==

To jeszcze jeden sposób iteracji, tak naprawdę prostszy od pętli <tt>for</tt> — gdyż nie oparty na sekwencjach; zwykle mniej wygodny w użyciu, ale w niektórych przypadkach nieodzowny.

<source lang=python>
# postać najprostsza

while WARUNEK:
BLOK INSTRUKCJI

# ogólna postać:

while WARUNEK:
BLOK1
else:
BLOK2
</source>

Polega na powtarzaniu bloku instrukcji nieokreśloną liczbę razy; przed każdym kolejnym wykonaniem na nowo sprawdzany jest warunek, i jeśli okaże się fałszywy - powtarzanie się kończy.

Innym sposobem przerwania pętli <tt>while</tt> jest umieszczenie gdzieś w bloku instrukcji <tt>break</tt> - zwykle pod pewnym warunkiem (tzn. wewnątrz instrukcji warunkowej <tt>if</tt>). Wykonanie break polega na ,,wyskoczeniu" z pętli - i przejściu do dalszego ciągu programu, po bloku wewnętrznym pętli.

Oczywiście aby <tt>WARUNEK</tt> mógł okazać się za którymś razem fałszywy, i spowodować przerwanie pętli, musi on być zbudowany z wykorzystaniem zmiennych, których wartości ulegają zmianom wewnątrz pętli. Zdarza się jednak widzieć pętlę zaczynającą się od <tt>while True:</tt> - formalnie jest to pętla nieskończona, którą może zakończyć jedynie wywołanie instrukcji <tt>break</tt> występującej gdzieś w wewnętrznym bloku.

Wewnątrz bloku może wystąpić również instrukcja <tt>continue</tt> - działa ona analogicznie, jak w pętli <tt>for</tt>, a więc powoduje przerwanie wykonywania aktualnej iteracji i przeskok do początku pętli, czyli sprawdzenia warunku jej kontynuowania.

W ogólnej postaci, blok występujący po linijce <tt>else:</tt> jest wykonywany po zakończeniu pętli wskutek niespełnienia warunku początkowego, natomiast jest pomijany, jeśli przerwanie pętli było spowodowane instrukcją <tt>break</tt>.

Zasadniczo każdą pętlę <tt>for</tt> dałoby się przepisać jako równoważną pętlę <tt>while</tt> - przykładowo:

<source lang=python>
for x in lista:
działaj_na(x)

# równoważnie:

k = 0
while k < len(lista):
działaj_na(lista[k])
k += 1
</source>

nie należy jednak zazwyczaj tego robić, ponieważ (najczęściej) pętla <tt>for</tt> jest bardziej czytelna.

=Ćwiczenia=

1. Napisać program, który sumuje liczby naturalne od 1 do 100:

*z wykorzystaniem pętli <tt>for</tt>
*z wykorzystaniem pętli <tt>while</tt>

2. Wykorzystując pętlę <tt>while</tt> napisać program, który sprawdza czy zadana liczba naturalna jest liczbą pierwszą.

3. Napisać program, który sprawdza jaka jest najmniejsza liczba wyrazów szeregu harmonicznego, jaką należy posumować, aby wynik przekroczył daną liczbę dodatnią (,,próg").

4. Napisać program, który gra z użytkownikiem w zgadywanie liczby (,,sekretna" liczba do odgadnięcia jest wpisana w kod programu). Użytkownik jest proszony o próbę zgadnięcia, w odpowiedzi otrzymuje informację, czy sekretna liczba jest większa czy mniejsza od podanej przez niego; w przypadku trafnego zgadnięcia, program składa gratulacje i podaje, po ilu próbach udało się zgadnąć.

----

[[PPy3/InstrukcjaWarunkowa|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/Funkcje|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 12:22, 29 cze 2016 (CEST)

PPy3/SekwencjeIIteracja

2022-07-29T12:54:56Z

RobertJB: /* Sekwencje i iteracja */

=Sekwencje i iteracja=

'''Sekwencje''' to typ danych charakteryzujący się tym, że składają się z ''elementów'' zgromadzonych w pewnej ''kolejności''. Elementem sekwencji może być cokolwiek (w tym - inna sekwencja), ale w najprostszym przypadku elementami tymi są liczby.

<blockquote>
Sekwencje to szczególny przypadek ''kolekcji'' - takich typów danych, które składają się z elementów, ale niekoniecznie są one uporządkowane. Innym przykładem kolekcji jest zbiór (''set'').
</blockquote>

Najczęściej używanym typem sekwencji jest ''lista'' (''list''). Listę można stworzyć (i zapamiętać) np. nadając jej pewien początkowy skład:

<source lang=python>
numerki = [0, 1, 2, 3, 5, 8]
</source>

To co stoi po prawej stronie znaku równości to literalny zapis listy - ciąg elementów, oddzielonych przecinkami, wewnątrz pary nawiasów kwadratowych. Oczywiście jako elementy mogą występować zarówno stałe literalne - jak w tym przykładzie, jak i nazwy (zmienne) — oczywiście takie, którym uprzednio nadano wartości.

Z listy - podobnie jak z każdej sekwencji - można pobrać element stojący w dowolnej pozycji, podając jej numer:

<source lang=python>
print(numerki[4])
→ 5
</source>

'''Uwaga:''' pozycje numerowane są kolejnymi liczbami naturalnymi, począwszy od zera - podobnie, jak w większości języków programowania.

Można też podmienić istniejący element na inny:

<source lang=python>
numerki[0] = -1
print(numerki)
→ [-1, 1, 2, 3, 5, 8]
</source>

a nawet przedłużyć ją o kolejny element:

<source lang=python>
numerki.append(13)
print(numerki)
→ [-1, 1, 2, 3, 5, 8, 13]
</source>

oraz usunąć element (skracając listę):

<source lang=python>
del numerki[0]
print numerki
→ [1, 2, 3, 5, 8, 13]
</source>

Łatwo też ustalić, jaka jest ,,długość" listy, czyli liczba jej elementów:

<source lang=python>
print(len(numerki))
→ 6
</source>

Jest jeszcze sporo innych ,,gotowych do użytku" operacji na listach. Ale najważniejsza cecha listy jest taka: '''można zmieniać jej skład, a nawet długość, a pozostaje ona tą samą listą'''. Nawet jeśli występuje w programie pod więcej niż jedną nazwą.

==Pętla <tt>for</tt>==

Naczelne zastosowanie listy (czy ogólniej -sekwencji), to iteracja - czyli wykonanie jakiejś operacji dla każdego elementu. I tak wygląda najprostszy rodzaj iteracji - Pętla <tt>for</tt>:

<source lang=python>
for x in numerki:
print(x)
</source>

Zamiast <tt>print(x)</tt> pętlę <tt>for</tt> może tworzyć dowolny blok instrukcji, zgodnie z zasadami jakie już poznaliśmy przy omawianiu instrukcji warunkowej. Cały blok tworzący wnętrze pętli będzie wykonany wielokrotnie, tyle razy, ile elementów ma lista, a za każdym razem pod nazwę stojącą bezpośrednio po słowie <tt>for</tt> podstawiony będzie kolejny element listy (przywołanej po słowie <tt>in</tt>) - kolejny, tzn. zgodnie z kolejnością, w jakiej umieszczone są one w liście.

Inny, znany nam już rodzaj sekwencji to napis (''string''), zwany czasami ''łańcuchem znakowym''. Napis składa się ze znaków, i jest w szczególności sekwencją, której elementami są znaki. Analogicznie jak w przypadku listy, można pobierać znaki stojące na poszczególnych pozycjach w napisie. '''Nie można''' natomiast podmieniać znaków w napisie, ani ich usuwać bądź dopisywać: w odróżnieniu od listy, napis raz utworzony jest ''niezmienny''. Można go zastąpić innym napisem, i ewentualnie opatrzyć ten nowy napis tą samą nazwą, ale nie da się go zmodyfikować. I nie jest to dzielenie włosa na czworo, własność ta ma namacalne konsekwencje:

<source lang=python>
napis1 = 'abc'
napis2 = napis1
napis1 = 'ABC'
print(napis1, napis2)
→ ABC abc
# dla porównania, listy:
lista1 = ['a', 'b', 'c']
lista2 = lista1
lista1[0] = 'A'
print(lista1, lista2)
→ ['A', 'b', 'c'] ['A', 'b', 'c']
</source>

<blockquote>
Powraca jeszcze raz pytanie: czym są poszczególne znaki? Tzn. jaki typ danych reprezentują? Otóż w Pythonie pojedyncze znaki też są po prostu napisami, tyle że o długości jeden. Poza długością nic ich szczególnie nie wyróżnia. Ta uwaga jest na użytek tych z Was, którzy znają jakiś inny język programowania, gdyż w wielu z nich znak jest oddzielnym, innym niż napis typem danych.
</blockquote>

Pętlę <tt>for</tt> można zatem zastosować do napisu - zamiast do listy, wówczas w kolejnych iteracjach będą uwzględniane kolejne znaki, a których składa się napis.

===Ogólna postać pętli <tt>for</tt>===

<source lang=python>
for element in sekwencja:
<blok instrukcji>
else:
<blok instrukcji>
</source>

*Pierwszy blok instrukcji będzie wykonany ''w zasadzie'' tyle razy, ile elementów ma sekwencja
*Za każdym razem nazwa ''element'' oznaczać będzie kolejny element sekwencji, zgodnie z ich porządkiem
*''sekwencja'' może być pusta; nie jest to błąd, ale wtedy pierwszy blok nie będzie wykonany ani razu
*Gdy elementy sekwencji się wyczerpią, wykonany zostanie blok po <tt>else</tt>
*Blok <tt>else</tt> (wraz z linijką go otwierającą) jest opcjonalny (niekonieczny)
*W pierwszym bloku mogą wystąpić specjalne polecenia: <tt>break</tt> i <tt>continue</tt>
**<tt>break</tt> znaczy: przerwij pętlę natychmiast, pomiń wszystkie pozostałe elementy sekwekcji, '''pomiń również ewentualny blok <tt>else</tt>'''
**<tt>continue</tt> oznacza: przerwij działania na aktualnym elemencie, i wróć do początku bloku biorąc kolejny element. Jeśli już zabrakło elementów, przejdź do bloku <tt>else</tt>, albo (gdy go nie ma) do polecenia następnego po pętli
*W miejscu gdzie stoi ''sekwencja'' może tak naprawdę stać dowolny obiekt ''iterowalny'' - np. kolekcja. Ale innych typów kolekcji jeszcze nie poznaliśmy...

<blockquote>
Blok <tt>else</tt> w pętli <tt>for</tt> jest stosunkowo rzadko widywany. Nawet wielu programistów dość biegłych w Pythonie nie wie (lub zapomniało) o istnieniu tej opcji.
</blockquote>

A co, jeśli chcielibyśmy za pomocą pętli <tt>for</tt> (lub inaczej) zmienić w jakiś sposób skład samej sekwencji? Na przykład:

<source lang=python>
for x in lista:
x = x + 1
</source>

'''TO NIE ZADZIAŁA''' - w tym sensie, że ''lista'' będzie dalej miała te same elementy co poprzednio, a nie - powiększone o 1. W istocie operacja taka nic nie osiąga - oprócz tego, że po jej zakończeniu nazwa ''x'' ma wartość ostatniego elementu listy, powiększonego o 1. To samo można dostać bez pisania pętli.

Jak więc osiągnąć zmianę - przeliczenie - wszystkich elementów sekwencji wg. jakiejś reguły (np. powiększ każdy z nich o 1)?

Pożytecznym sposobem tworzenia sekwencji jest funkcja <tt>range</tt>:

<source lang=python>
for x in range(3):
print(x)
→ 0
→ 1
→ 2
</source>

Argument (tu: 3) oznacza liczbę elementów w wyprodukowanej sekwencji. Domyślnie zaczyna się ona od zera, tak jak numeracja pozycji w sekwencjach - ale można użyć wywołania <tt>range(a, b)</tt> aby uzyskać elementy dowolnego ciągu arytmetycznego - o elemencie początkowym ''a'' i przyroście ''b''.

<blockquote>
Tu jest pewne oszustwo: wynikiem wywołania <tt>range</tt> nie jest tak naprawdę lista, ale pewnego innego rodzaju typ sekwencji, a więc mogący służyć za źródło elementów w iteracji. Na razie to jest jednak drobny szczegół. Jeżeli potrzebujemy dosłownej listy o takich elementach, wystarczy wykonać tzw. rzutowanie, czyli przyłożyć funkcję <tt>list</tt>: <tt>lista = list(range(3))</tt>
</blockquote>

Wracając do problemu przeliczenia wszystkich elementów listy:

<source lang=python>
lista = [3, 5, 8]
for k in range(3):
lista[k] += 1
print lista
→ [4, 6, 9]
</source>

I to działa. Nie jest to jednak optymalne rozwiązanie.

*Pisząc to co powyżej wiedzieliśmy, że mamy do czynienia z listą o długości 3. W ogólności musielibyśmy użyć funkcji <tt>len</tt>;
*Można to jednak zrobić bardziej elegancko:

<source lang=python>
for k, x in enumerate(lista):
lista[k] = x + 1
</source>

Funkcja <tt>enumerate</tt> produkuje sekwencję par: ''nr pozycji'', ''element'' - i jest bardzo przydatna w takich sytuacjach.

Z dokonywaniem wewnątrz pętli zmian na sekwencji, po której iterujemy, należy jednak uważać. To, co robimy w tym przykładzie jest akurat niegroźne, natomiast umieszczenie wewnątrz pętli operacji zmieniających '''długość''' sekwencji, po której iterujemy mogłoby dać nieoczekiwane wyniki. Spróbuj np.:

<source lang=python>
L = [0, 1, 2, 3, 4]
for i in range(5):
del L[i]
</source>

Co tu się stanie, i dlaczego?

==Więcej o listach==

Elementy listy (innych rodzajów sekwencji również) można numerować od końca, używając ujemnych wartości wskaźników pozycji:

<source lang=python>
numerki = [0, 1, 2, 3, 5, 8]
numerki[-1]
→ 8
numerki[-3]
→ 3
</source>

Z list (i innych sekwencji) można wyjmować nie tylko poszczególne elementy, ale również podsekwencje, zwane też wycinkami:

<source lang=python>
numerki = [0, 1, 2, 3, 5, 8]
nn = numerki[1:4]
→ [1, 2, 3]
nn = numerki[2:]
→ [2, 3, 5, 8]
nn = numerki[:3]
→ [0, 1, 2]
nn = numerki[1:4:2]
→ [1, 3]
nn = numerki[4:1:-1]
→ [5, 3, 2]
nn = numerki[:]
→ [0, 1, 2, 3, 5, 8]
</source>

Jak widać, pominięcie pozycji początkowej lub końcowej oznacza: ,,do oporu". Trzecia liczba charakteryzująca wycinek, o ile występuje - to ,,skok" wskaźnika. Przykładowo, <tt>a[::2]</tt> oznaczałoby listę zawierającą co drugi element listy <tt>a</tt>, natomiast <tt>a[::-1]</tt>: listę składającą się z tych samych elementów, co <tt>a</tt> - lecz w odwrotnej kolejności.

Wyrażenie <tt>numerki[:]</tt>, tzw. pełny wycinek, tworzy pełną ''kopię'' listy <tt>numerki</tt>; tzn. '''nie''' jest to ''ta sama'' lista, chociaż składa się z tych samych elementów. Jest to tzw. ''kopia płytka'' - oznacza to tyle, że jeżeli wśród elementów kopiowanej listy były obiekty złożone (np. inne listy), to elementami kopii będą '''te same''' listy, a nie - ich kopie.

Wycinek jest zawsze nową listą, również w ostatnim przypadku - gdy jej skład jest taki sam, jak oryginalnej. Wtedy stanowi kopię pierwotnej listy. Można jednak też podstawiać do wycinka:

<source lang=python>
numerki[4:5] = [4]
→ [0, 1, 2, 3, 4, 8]
numerki[5:5] = [5, 6, 7]
→ [0, 1, 2, 3, 4, 5, 6, 7, 8]
</source>

i jest to jeszcze jeden sposób, by zmienić zawartość listy - w tym być może jej długość - zachowując jej tożsamość.

Listy można do siebie dodawać:

<source lang=python>
l = ['a', 'b', 'c'] + ['y', 'z']
→ ['a', 'b', 'c', 'y', 'z']
</source>

w ten sposób powstaje nowa lista, która ze składników bierze elementy, ale poza tym nie ma z nimi nic wspólnego; późniejsze zmiany w listach-składnikach nie mają wpływu na sumę.

Listy można też zwielokrotnić; np. aby uzyskać listę siedmiu dwójek:

<source lang=python>
l = [2] * 7
→ [2, 2, 2, 2, 2, 2, 2]
</source>

ta sama co poprzednio uwaga stosuje się i tu.

Elementy listy można posumować:

<source lang=python>
x = sum(range(101))
→ 5050
</source>

(wprawdzie <tt>range(101)</tt> nie jest dosłownie listą, ale z ,,prawdziwą" listą można zrobić to samo).

Podobnie jak inne ''obiekty'', listy posiadają szereg ''metod'', za pomocą których można na nich wykonywać różne działania. Przykładowo:

<source lang=python>
numerki.append(9)
→ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numerki.extend([10, 11])
→ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
</source>

Zwróćcie uwagę na notację: kropka sygnalizuje ,,wyciągnięcie" metody z danego obiektu (tu: listy), w nawiasach wpisujemy dane dla tej metody (argumenty - tu pojedyncze, ale może być więcej).

==Więcej o napisach==

Napisy dopuszczają tylko część operacji dostępnych dla list, ze względu na własność niemodyfikowalności. Posiadają za to szereg swoistych metod. Trzeba pamiętać, że żadna z tych metod ''nie zmienia'' napisu, którego dotyczy - wynikiem może być jedynie '''nowy''' napis, stworzony na podstawie oryginalnego.

Niemniej napis ''również'' jest sekwencją, i może być np. zastosowany w pętli <tt>for</tt>. Ale sekwencją czego? Oczywiście znaków — z tym, że w Pythonie nie ma oddzielnego typu danych ,,znak". Znaki to po prostu napisy jednoelementowe.

Przykład: metoda <tt>upper</tt> (zamienia małe litery na wielkie):

<source lang=python>
'abcde'.upper()
→ 'ABCDE'
</source>

Napis zawsze można łatwo zamienić na listę znaków:

<source lang=python>
l = list('abcde')
→ ['a', 'b', 'c', 'd', 'e']
</source>

(choć rzadko zachodzi taka potrzeba).

Do operacji odwrotnej można użyć metody <tt>join</tt>:

<source lang=python>
''.join(l)
→ 'abcde'
', '.join(l)
→ 'a, b, c, d, e'
</source>

==Pętla <tt>while</tt>==

To jeszcze jeden sposób iteracji, tak naprawdę prostszy od pętli <tt>for</tt> — gdyż nie oparty na sekwencjach; zwykle mniej wygodny w użyciu, ale w niektórych przypadkach nieodzowny.

<source lang=python>
# postać najprostsza

while WARUNEK:
BLOK INSTRUKCJI

# ogólna postać:

while WARUNEK:
BLOK1
else:
BLOK2
</source>

Polega na powtarzaniu bloku instrukcji nieokreśloną liczbę razy; przed każdym kolejnym wykonaniem na nowo sprawdzany jest warunek, i jeśli okaże się fałszywy - powtarzanie się kończy.

Innym sposobem przerwania pętli <tt>while</tt> jest umieszczenie gdzieś w bloku instrukcji <tt>break</tt> - zwykle pod pewnym warunkiem (tzn. wewnątrz instrukcji warunkowej <tt>if</tt>). Wykonanie break polega na ,,wyskoczeniu" z pętli - i przejściu do dalszego ciągu programu, po bloku wewnętrznym pętli.

Oczywiście aby <tt>WARUNEK</tt> mógł okazać się za którymś razem fałszywy, i spowodować przerwanie pętli, musi on być zbudowany z wykorzystaniem zmiennych, których wartości ulegają zmianom wewnątrz pętli. Zdarza się jednak widzieć pętlę zaczynającą się od <tt>while True:</tt> - formalnie jest to pętla nieskończona, którą może zakończyć jedynie wywołanie instrukcji <tt>break</tt> występującej gdzieś w wewnętrznym bloku.

Wewnątrz bloku może wystąpić również instrukcja <tt>continue</tt> - działa ona analogicznie, jak w pętli <tt>for</tt>, a więc powoduje przerwanie wykonywania aktualnej iteracji i przeskok do początku pętli, czyli sprawdzenia warunku jej kontynuowania.

W ogólnej postaci, blok występujący po linijce <tt>else:</tt> jest wykonywany po zakończeniu pętli wskutek niespełnienia warunku początkowego, natomiast jest pomijany, jeśli przerwanie pętli było spowodowane instrukcją <tt>break</tt>.

Zasadniczo każdą pętlę <tt>for</tt> dałoby się przepisać jako równoważną pętlę <tt>while</tt> - przykładowo:

<source lang=python>
for x in lista:
działaj_na(x)

# równoważnie:

k = 0
while k < len(lista):
działaj_na(lista[k])
k += 1
</source>

nie należy jednak zazwyczaj tego robić, ponieważ (najczęściej) pętla <tt>for</tt> jest bardziej czytelna.

=Ćwiczenia=

1. Napisać program, który sumuje liczby naturalne od 1 do 100:

*z wykorzystaniem pętli <tt>for</tt>
*z wykorzystaniem pętli <tt>while</tt>

2. Wykorzystując pętlę <tt>while</tt> napisać program, który sprawdza czy zadana liczba naturalna jest liczbą pierwszą.

3. Napisać program, który sprawdza jaka jest najmniejsza liczba wyrazów szeregu harmonicznego, jaką należy posumować, aby wynik przekroczył daną liczbę dodatnią (,,próg").

4. Napisać program, który gra z użytkownikiem w zgadywanie liczby (,,sekretna" liczba do odgadnięcia jest wpisana w kod programu). Użytkownik jest proszony o próbę zgadnięcia, w odpowiedzi otrzymuje informację, czy sekretna liczba jest większa czy mniejsza od podanej przez niego; w przypadku trafnego zgadnięcia, program składa gratulacje i podaje, po ilu próbach udało się zgadnąć.

----

[[PPy3/InstrukcjaWarunkowa|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/Funkcje|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 12:22, 29 cze 2016 (CEST)

PPy3/InstrukcjaWarunkowa

2022-07-29T12:24:41Z

RobertJB: /* Ćwiczenia */

=Instrukcja warunkowa=

Zasadniczo każdy program w Pythonie składa się z ciągu instrukcji, które są wykonywane w kolejności, w jakiej zostały zapisane. W programowaniu potrzebna jest jednak możliwość podejmowania decyzji o przyjęciu różnych kursów postępowania, w zależności od danych z jakimi mamy do czynienia. Umożliwiają to instrukcje złożone, a szczególnie - instrukcja warunkowa.

Instrukcja warunkowa to pierwszy przykład instrukcji złożonej. W najprostszej postaci składa się ona z ciągu (jednej lub więcej) instrukcji ujętych w blok, który jako całość będzie wykonany lub nie, w zależności od tego, czy spełniony jest pewien warunek - co zależy zazwyczaj od aktualnych wartości pewnych zmiennych. Warunek ten zapisuje się w postaci wyrażenia logicznego.

<blockquote>
Wśród instrukcji tworzących blok warunkowy mogą oczywiście się pojawić również instrukcje złożone, nie tylko instrukcje proste. Na przykład, kolejne instrukcje warunkowe.
</blockquote>

==Przykład minimalny:==

<source lang=python>
x1, x2 = None, None
if delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print(x1, x2)
</source>

Linijka z wywołaniem <tt>print</tt> nie jest już częścią instrukcji warunkowej, tylko kolejną instrukcją.

'''Do zapamiętania''':
*wiersz otwierający instrukcję złożoną (czyli tu: zaczynająca się od <tt>if</tt>) zawsze kończy się dwukropkiem
*instrukcje tworzące blok w instrukcji złożonej są pisane z wcięciem, które musi być jednolite
*koniec bloku rozpoznaje się po powrocie do uprzedniego poziomu wcięcia
*blok instrukcji pod <tt>if ...</tt> nie może być pusty. Instrukcja <tt>if</tt> z pustym blokiem warunkowym jest nie tylko nieprzydatna, ale jest również błędem składniowym.

==Przykład bardziej złożony:==

<source lang=python>
if a == 0:
print('Równanie nie jest kwadratowe.')
elif delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print('Są dwa pierwiastki: x1 =', x1, 'x2 =', x2)
elif delta == 0:
x = -b / 2 / a
print('Jest tylko jeden pierwiastek: x =', x)
else: # delta < 0:
print('Nie ma pierwiastków rzeczywistych.')
</source>

Jak to działa?

*Jeżeli spełniony jest warunek <tt>a == 0</tt>, wykonany zostanie blok poniżej <tt>if ...</tt>, a reszta instrukcji zostanie pominięta;
*Jeżeli warunek ten jest nieprawdziwy (i tylko wtedy), to sprawdzane są kolejno warunki umieszczone w wierszach zaczynających się od <tt>elif</tt>. Jeśli któryś z nich okaże się prawdziwy, to blok poniżej tej linijki zostanie wykonany, a cała reszta - pominięta;
*Jeżeli żaden z warunków - tych po <tt>if</tt>, i tych po wszystkich <tt>elif</tt> - nie okazał się prawdziwy, wykonany zostanie blok związany z <tt>else</tt>.
*Bloków <tt>elif</tt> może być w instrukcji dowolnie wiele (w tym - wcale), <tt>if</tt> jest obowiązkowy (inaczej nie byłoby instrukcji warunkowej) i tylko jeden, <tt>else</tt> może wystąpić wyłącznie na końcu - jeden raz, lub wcale.
*Komentarz po <tt>else:</tt> jest podpowiedzią dla czytającego, że skoro już zbadano warunki <tt>delta == 0</tt> oraz <tt>delta > 0</tt>, a wykonanie dotarło do tej linijki, to <tt>delta < 0</tt> jest jedyną pozostałą możliwością (o ile możemy założyć, że <tt>delta</tt> jest na pewno liczbą!). Jest on przeznaczony wyłącznie dla ludzkich oczu - interpreter go zignoruje, jak każdy komentarz.

<blockquote>
Mam nadzieję, że czytający już zauważył, że <tt>and not a == 0</tt> w trzeciej linijce jest niepotrzebne. Dlaczego?
</blockquote>

==Wyrażenie warunkowe==

Innym sposobem uzależnienia wyniku działania od jakiegoś warunku jest tzw. ''wyrażenie warunkowe''. Jest ono szczególnie wygodne w prostych przypadkach, i pozwala zapisać pewne działania w bardziej zwięzły sposób.

Przykład: chcemy, aby z nazwą <tt>wbx</tt> wiązała się wartość bezwzględna (moduł) aktualnej wartości (liczby) <tt>x</tt>. Za pomocą instrukcji warunkowej można to zrealizować tak:

<source lang=python>
if x < 0:
wbx = -x
else:
wbx = x
</source>

Ten sam wynik można osiągnąć za pomocą wyrażenia warunkowego:

<source lang=python>
wbx = -x if x < 0 else x
</source>

W wyrażeniu warunkowym nie ma opcji uwzględnienie dodatkowych możliwości za pomocą <tt>elif</tt>.

=Ćwiczenia=

W programach ćwiczebnych nieraz przyda nam się funkcja <tt>input()</tt>. Działa ona w sposób następujący: argumentem wywołania powinien być jakiś napis (np. w postaci stałej napisowej): <tt>input('podaj jakąś liczbę całkowitą: ')</tt>. Gdy w programie przyjdzie kolej na wykonanie takiego wywołania, program wypisze ten napis do terminalu i będzie oczekiwał na reakcję użytkownika, czyli wpisanie czegoś z klawiatury (i zakończenie naciśnięciem klawisza ''Enter''). Gdy to nastąpi, wynikiem wywołania funkcji <tt>input</tt> w programie będzie treść wpisana prze użytkownika (bez końcowego znaku nowej linii).

''Uwaga:'' wartość zwracana przez <tt>input()</tt> zawsze jest napisem, a nie liczbą - choćby się składał z samych cyfr.

1. Napisz program, którego uruchomienie ma następujący skutek:
*program wita użytkownika (komunikatem w terminalu),
*prosi o wprowadzenie liczby całkowitej,
*sprawdza, czy liczba ta jest podzielna przez 7, i informuje o wyniku tego sprawdzenia

2. Napisz program, którego uruchomienie ma następujący skutek:
* program prosi użytkownika o podanie swojego (lub czyjegoś) wieku w latach
* jeśli wiek jest ujemny lub przekracza 120, odpowiada ,,Nieprawidłowy wiek"
* jeśli wiek wynosi 0, odpowiada ,,niemowlę"
* jeśli wiek jest poniżej 18, odpowiada ,,dziecko"
* jeśli wiek jest pomiędzy 18 a 120 (włącznie), odpowiada ,,dorosły"
* jeśli wiek przekracza 120, odpowiada ,,ludzie tyle nie żyją"

''CDN''

----

[[PPy3/StałeIZmienne|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/SekwencjeIIteracja|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 15:42, 28 cze 2016 (CEST)

PPy3/InstrukcjaWarunkowa

2022-07-29T12:19:36Z

RobertJB: /* Przykład minimalny: */

=Instrukcja warunkowa=

Zasadniczo każdy program w Pythonie składa się z ciągu instrukcji, które są wykonywane w kolejności, w jakiej zostały zapisane. W programowaniu potrzebna jest jednak możliwość podejmowania decyzji o przyjęciu różnych kursów postępowania, w zależności od danych z jakimi mamy do czynienia. Umożliwiają to instrukcje złożone, a szczególnie - instrukcja warunkowa.

Instrukcja warunkowa to pierwszy przykład instrukcji złożonej. W najprostszej postaci składa się ona z ciągu (jednej lub więcej) instrukcji ujętych w blok, który jako całość będzie wykonany lub nie, w zależności od tego, czy spełniony jest pewien warunek - co zależy zazwyczaj od aktualnych wartości pewnych zmiennych. Warunek ten zapisuje się w postaci wyrażenia logicznego.

<blockquote>
Wśród instrukcji tworzących blok warunkowy mogą oczywiście się pojawić również instrukcje złożone, nie tylko instrukcje proste. Na przykład, kolejne instrukcje warunkowe.
</blockquote>

==Przykład minimalny:==

<source lang=python>
x1, x2 = None, None
if delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print(x1, x2)
</source>

Linijka z wywołaniem <tt>print</tt> nie jest już częścią instrukcji warunkowej, tylko kolejną instrukcją.

'''Do zapamiętania''':
*wiersz otwierający instrukcję złożoną (czyli tu: zaczynająca się od <tt>if</tt>) zawsze kończy się dwukropkiem
*instrukcje tworzące blok w instrukcji złożonej są pisane z wcięciem, które musi być jednolite
*koniec bloku rozpoznaje się po powrocie do uprzedniego poziomu wcięcia
*blok instrukcji pod <tt>if ...</tt> nie może być pusty. Instrukcja <tt>if</tt> z pustym blokiem warunkowym jest nie tylko nieprzydatna, ale jest również błędem składniowym.

==Przykład bardziej złożony:==

<source lang=python>
if a == 0:
print('Równanie nie jest kwadratowe.')
elif delta > 0 and not a == 0:
x1 = (-b + delta) / 2 / a
x2 = (-b - delta) / 2 / a
print('Są dwa pierwiastki: x1 =', x1, 'x2 =', x2)
elif delta == 0:
x = -b / 2 / a
print('Jest tylko jeden pierwiastek: x =', x)
else: # delta < 0:
print('Nie ma pierwiastków rzeczywistych.')
</source>

Jak to działa?

*Jeżeli spełniony jest warunek <tt>a == 0</tt>, wykonany zostanie blok poniżej <tt>if ...</tt>, a reszta instrukcji zostanie pominięta;
*Jeżeli warunek ten jest nieprawdziwy (i tylko wtedy), to sprawdzane są kolejno warunki umieszczone w wierszach zaczynających się od <tt>elif</tt>. Jeśli któryś z nich okaże się prawdziwy, to blok poniżej tej linijki zostanie wykonany, a cała reszta - pominięta;
*Jeżeli żaden z warunków - tych po <tt>if</tt>, i tych po wszystkich <tt>elif</tt> - nie okazał się prawdziwy, wykonany zostanie blok związany z <tt>else</tt>.
*Bloków <tt>elif</tt> może być w instrukcji dowolnie wiele (w tym - wcale), <tt>if</tt> jest obowiązkowy (inaczej nie byłoby instrukcji warunkowej) i tylko jeden, <tt>else</tt> może wystąpić wyłącznie na końcu - jeden raz, lub wcale.
*Komentarz po <tt>else:</tt> jest podpowiedzią dla czytającego, że skoro już zbadano warunki <tt>delta == 0</tt> oraz <tt>delta > 0</tt>, a wykonanie dotarło do tej linijki, to <tt>delta < 0</tt> jest jedyną pozostałą możliwością (o ile możemy założyć, że <tt>delta</tt> jest na pewno liczbą!). Jest on przeznaczony wyłącznie dla ludzkich oczu - interpreter go zignoruje, jak każdy komentarz.

<blockquote>
Mam nadzieję, że czytający już zauważył, że <tt>and not a == 0</tt> w trzeciej linijce jest niepotrzebne. Dlaczego?
</blockquote>

==Wyrażenie warunkowe==

Innym sposobem uzależnienia wyniku działania od jakiegoś warunku jest tzw. ''wyrażenie warunkowe''. Jest ono szczególnie wygodne w prostych przypadkach, i pozwala zapisać pewne działania w bardziej zwięzły sposób.

Przykład: chcemy, aby z nazwą <tt>wbx</tt> wiązała się wartość bezwzględna (moduł) aktualnej wartości (liczby) <tt>x</tt>. Za pomocą instrukcji warunkowej można to zrealizować tak:

<source lang=python>
if x < 0:
wbx = -x
else:
wbx = x
</source>

Ten sam wynik można osiągnąć za pomocą wyrażenia warunkowego:

<source lang=python>
wbx = -x if x < 0 else x
</source>

W wyrażeniu warunkowym nie ma opcji uwzględnienie dodatkowych możliwości za pomocą <tt>elif</tt>.

=Ćwiczenia=

W programach ćwiczebnych nieraz przyda nam się funkcja <tt>input()</tt>. Działa ona w sposób następujący: argumentem wywołania powinien być jakiś napis (np. w postaci stałej napisowej): <tt>input('podaj jakąś liczbę całkowitą: ')</tt>. Gdy w programie przyjdzie kolej na wykonanie takiego wywołania, program wypisze ten napis do terminalu i będzie oczekiwał na reakcję użytkownika, czyli wpisanie czegoś z klawiatury (i zakończenie naciśnięciem klawisza ''Enter''). Gdy to nastąpi, wynikiem wywołania funkcji <tt>input</tt> w programie będzie treść wpisana prze użytkownika (bez końcowego znaku nowej linii).

''Uwaga:'' wartość zwracana przez <tt>input()</tt> zawsze jest napisem, a nie liczbą - choćby się składał z samych cyfr.

1. Napisz program, którego uruchomienie ma następujący skutek:
*program wita użytkownika (komunikatem w terminalu),
*prosi o wprowadzenie liczby całkowitej,
*sprawdza, czy liczba ta jest podzielna przez 7, i informuje o wyniku tego sprawdzenia

2. Napisz program, którego uruchomienie ma następujący skutek:
* program prosi użytkownika o podanie swojego (lub czyjegoś) wieku w latach
* jeśli wiek jest ujemny lub przekracza 120, odpowiada ,,Nieprawidłowy wiek"
* jeśli wiek wynosi 0, odpowiada ,,niemowlę"
* jeśli wiek jest poniżej 18, odpowiada ,,dziecko"
* jeśli wiek jest pomiędzy 18 a 120 (włącznie), odpowiada ,,dorosły"

''CDN''

----

[[PPy3/StałeIZmienne|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/SekwencjeIIteracja|dalej]]

[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 15:42, 28 cze 2016 (CEST)

PPy3/StałeIZmienne

2022-07-29T12:16:56Z

RobertJB: /* Inne wyrażenia */

=Stałe i zmienne=

==Stałe dosłowne (literalne)==

Stałe dosłowne to takie, których wartości wprost wpisano do pliku z kodem (lub w linii poleceń interpretera). Mogą to być liczby (paru rodzajów) lub napisy, ale również różne złożone rodzaje (typy) danych, z którymi zapoznamy się nieco później.

'''Zapamiętajmy''' od razu: ''liczba'' dla komputera to zupełnie co innego, niż ''napis'' składający się z cyfr. Na napisie nie wykonamy operacji arytmetycznych - a na liczbie, operacji właściwych dla napisów (takich jak np. wyjęcie z niego znaku stojącego na określonej pozycji). Istnieją jednak operacje przekształcające każdy z tych typów danych w drugi.

===Liczby===

Dobrze jest pamiętać, że nieco odmiennie traktowane są liczby całkowite, a inaczej - liczby ułamkowe, zwykle zwane ''zmiennoprzecinkowymi'' (po angielsku ''floating point'', jako że Amerykanie piszą kropkę dziesiętną a nie - jak my - przecinek, przez co i w Pythonie używa się w tym celu kropki).

*Liczby całkowite w zapisie dziesiętnym: <tt>1024</tt>, <tt>0</tt>, <tt>-666</tt>, ...
*Liczby ułamkowe: <tt>1.0</tt>, <tt>.99</tt>, <tt>98.6</tt>, <tt>-37.43</tt>, ...
*Liczby ułamkowe w zapisie wykładniczym: <tt>1.024e3</tt>, <tt>96.9E-12</tt>, ...

Notacja <tt>e3</tt>, <tt>E-12</tt> itp. (wielka i mała litera <tt>e</tt> są tu równoważne) oznacza pomnożenie poprzedzającej liczby przez odpowiednio 103, 10-12, ... i służy ułatwieniu zapisu liczb bardzo dużych lub bardzo małych. Nie można tam wtrącać dodatkowych odstępów, podobnie jak pomiędzy cyframi.

Jeśli część całkowita (lub ułamkowa) liczby zmiennoprzecinkowej wynosi zero, to można to zero pominąć. Oczywiście nie można pominąć obu, zapisując liczbę zero! (można napisać: <tt>0.</tt> albo <tt>.0</tt>, ale nie samotną kropkę).

Podstawowa różnica pomiędzy sposobem traktowania liczb całkowitych i zmiennoprzecinkowych polega na tym, że:

*liczby całkowite mogą być dowolnie duże, a rachunki całkowitoliczbowe wykonywane są dokładnie,
*liczby ułamkowe oraz wyniki rachunków na liczbach ułamkowych należy zawsze traktować jako przybliżone (oczywiście dla szczególnych wartości zdarza się, że są one dokładne); zakres wielkości liczb ułamkowych jest ograniczony.

<blockquote>
Python zna też liczby ''zespolone'' oraz operacje na nich, ale tego zdaje się nie było w szkole...
</blockquote>

Liczby całkowite można pisać również w podstawach innych niż 10:

*dwójkowe: <tt>0b101 == 5</tt>
*ósemkowe: <tt>0o123 == 83</tt>
*szesnastkowe: <tt>0x1f == 31</tt>

(podwojony znak równości oznacza: lewa strona jest równa prawej; litery b, o, x mogą być zarówno małe jak i wielkie).

W zapisie szesnastkowym, wymagającym 16 różnych cyfr, w roli "brakujących" cyfr oznaczających liczby od 10 do 15 przyjmuje się początkowe litery alfabetu (a-f), można równoważnie używać liter małych lub wielkich.

===Napisy===

Napis (ang. ''string'') to po prostu ciąg znaków.

<blockquote>
OK, nic nie jest tak proste, jak się wydaje. Pytanie: co to jest znak? Odpowiedzi dostarcza standard ''Unicode'', w skład którego chodzi m. in. katalog wszystkich znaków, używanych przez systemy pisma wszystkich w zasadzie języków świata (języków żywych, i co ważniejszych spośród martwych). Nie będziemy się w tej chwili zastanawiać nad tym, jak dokładnie znaki te są reprezentowane w komputerze. Warto jednak pamiętać, że napisy nie muszą ograniczać się do znaków znanych z zapisu języków europejskich.
</blockquote>

Literalne stałe napisowe, czyli napisy "na twardo" wpisane do kodu, mogą być podane w paru różnych postaciach:

<source lang=python>
napis1 = 'jedna z postaci napisu'
napis2 = "nieco inna postać napisu"
napis3 = '''tak też może wyglądać napis,
i w tej postaci może zawierać przejścia do nowego wiersza
(w poprzednich nie może)'''
napis4 = """zamiast apostrofów, mogą być cudzysłowy - wychodzi na to samo,
również w postaci takiej, jak napis1 i napis2 są one równoważne"""
napis5 = "korzyść z tego pojawia się np. gdy w treści napisu potrzebujemy umieścić znak taki jak ' "
napis6 = 'w treści napisów można użyć kilku specjalnych sekwencji:\nTo powoduje przejście do nowego wiersza..'
napis7 = 'jeśli dwa napisy (lub więcej) postawimy ' 'jeden obok drugiego ' 'to zostaną połączone w jeden'
napis8 = 'lecz uwaga: pomiędzy sklejone napisy nie zostanie wstawiona żadna spacja ani w ogóle nic.'
</source>

'''Sekwencje specjalne w napisach'''

{| class="wikitable"
|-
|<tt>\\</tt>||dosłowny znak <tt>\</tt>
|-
|<tt>\'</tt>||apostrof: <tt>'</tt>
|-
|<tt>\"</tt>||cudzysłów: <tt>"</tt>
|-
|<tt>\a</tt>||kod BEL
|-
|<tt>\b</tt>||kod BS ('backspace')
|-
|<tt>\f</tt>||kod FF ('formfeed')
|-
|<tt>\n</tt>||kod LF ('linefeed')
|-
|<tt>\r</tt>||kod CR ('carriage return')
|-
|<tt>\t</tt>||kod HT ('horizontal tab')
|-
|<tt>\v</tt>||kod VT ('vertical tab')
|-
|<tt>\nnn</tt>||znak o kodzie 'nnn' w zapisie ósemkowym
|-
|<tt>\xnn</tt>||znak o kodzie 'nn' w zapisie szesnastkowym
|-
|<tt>\N{nazwa}</tt>||znak o danej nazwie symbolicznej w tabeli Unicode
|-
|<tt>\unnnn</tt>||znak o pozycji '0xnnnn' w 16-bitowej tabeli Unicode
|-
|<tt>\Unnnnnnnn</tt>||znak o pozycji '0xnnnnnnnn' w 32-bitowej tabeli Unicode
|}

To co określam tutaj nazwą ''kod'' to są szczególne ,,znaki", które nie posiadają reprezentacji graficznej, ale mogą wystąpić w strumieniu tekstowym pełniąc jakiegoś rodzaju rolę sterującą (p. poniżej). Czasami stosuje się określenie ''znaki niedrukowalne''. Jest ich więcej, niż występuje w powyższej tabeli — pozostałym nie nadano specjalnego zapisu i dostępne są np. przez notację <tt>\nnn</tt> albo <tt>\xnn</tt>, ale niezwykle rzadko bywają potrzebne.

* Wypisanie kodu BEL na terminal najczęściej skutkuje sygnałem akustycznym (''BIP!'') lub wizualnym (błysk), zależy to od ustawień emulatora terminala
* Kod BS cofa kursor o jedną pozycję, umożliwiając nadpisanie ostatniego wypisanego znaku
* Kod FF stosowano w tekście przeznaczonym do wydrukowania na drukarce wierszowej, powodował przejście do następnej strony. Obecnie ze względu na wymarcie drukarek wierszowych w zasadzie nie ma zastosowania
* Kod LF to przejście do nowej linii, inaczej - znacznik końca linii w strumieniu tekstowym
* Kod CR czyli powrót karetki cofa kursor do początku aktualnej linii
* Kod HT to ten, który zwykle nazywa się po prostu kodem tabulacji. Jego interpretacja zależy od ustawień terminala lub innego programu renderującego tekst, zwykle oznacza przeskok do pozycji będącej kolejną całkowitą wielokrotnością 4 lub 8 w bieżącej linii
* Kod VT z założenia działa analogicznie jak HT, ale w kierunku pionowym. Obecnie rzadko stosowany
* W zapisie <tt>\nnn</tt> może wystąpić jedna, dwie lub trzy cyfry ósemkowe ''n''
* W zapisie <tt>\xnn</tt> należy użyć dokładnie dwóch cyfr szesnatkowych ''n''
* W zapisie <tt>\unnnn</tt> należy użyć dokładnie czterech cyfr szesnastkowych ''n''
* W zapisie <tt>\Unnnnnnnn</tt> należy użyć dokładnie ośmiu cyfr szesnastkowych ''n''

Jeżeli chcemy zapisać napis obfitujący w znaki <tt>\</tt>, możemy użyć notacji takiej:

<source lang="python">
napis1 = r'oto\napis\z\bakslaszami'
napis2 = R'tu\znak"\"nie\będzie\nigdy\oznaczał\początku\specjalnej\sekwencji'
</source>

Wielkość użytej na początku litery <tt>R</tt> nie ma znaczenia.

==Zmienne, czyli nazwy==

Programy oczywiście nie operują jedynie na stałych. Potrzebny jest w nich sposób odnoszenia się do wartości, które nie są znane z góry (w chwili pisania programu) - albo dlatego, że zostaną dostarczone dopiero przy uruchomieniu lub w trakcie pracy programu, jako dane wejściowe (później zobaczymy, na jakie sposoby można tego dokonać), albo dlatego, że będą wynikiem obliczeń lub przekształceń danych wykonywanych przez program.

Do tego w Pythonie służą ''zmienne'' - można je uważać za nazwy, z jakimi wiążemy pewne wartości (liczby, napisy, itd.), poprzez ''instrukcję podstawienia''. Do zapisu instrukcji podstawienia służy znak równości (<tt>=</tt>), po jego lewej stronie stawiamy nazwę (zmiennej), po drugiej - ''wyrażenie'', np. literalną stałą, ale również może być to wyrażenie zbudowane ze stałych, operatorów (np. arytmetycznych), nazw zmiennych (reprezentujących w wyrażeniu związane z nimi aktualnie wartości), i szereg innych elementów które dopiero poznamy.

'''Do zapamiętania''': pojedynczy znak równości <tt>=</tt> w Pythonie (i wielu innych językach programowania) nie tworzy ''równania'', czyli stwierdzenia, że lewa strona jest równa prawej; tylko ''podstawienie'', a więc operację powodującą, że z nazwą stojącą po stronie lewej zostaje związana obliczona wartość wyrażenie stojącego po prawej. Zauważmy, że jest to operacja niesymetryczna (stron nie można bezkarne zamienić miejscami):

<source lang=python>
i = 0 # pierwsze użycie nazwy, w tym przypadku 'i', tworzy zmienną i wiąże z nią wartość
i = i + 2 # to jest legalne, i oznacza, że wartość związana z 'i' rośnie o 2
i + 2 = i # to jest błędne, po lewej stronie nie może stać wyrażenie złożone
</source>

Pojawienie się w wyrażeniu stojącym po prawej stronie podstawienia tej samej nazwy, która stoi po lewej stronie, nie tworzy jakiejkolwiek niejednoznaczności: zasadą jest, że ''wpierw'' obliczana jest wartość wyrażenia z prawej strony, z wykorzystaniem aktualnych wartości zmiennych, a ''potem'' następuje związanie nazwy zmiennej stojącej po lewej z wynikiem.

Zauważmy, że błędem byłoby użycie nazwy po raz pierwszy ''bez'' uprzedniego nadania jej wartości, np. w wyrażeniu arytmetycznym.

===Reguły tworzenia nazw===

Aktualnie reguły określające, co jest poprawną nazwą w Pythonie, dopuszczają użycie całkiem szerokiego podzbioru znaków Unicode i są dość trudne do opisania w zrozumiały sposób. Pomijając jednak taką możliwość, że ktoś zechce użyć w nazwie zmiennej znaków pisma Kanji lub perskiego, można w dużym uproszczeniu powiedzieć tak:

*nazwy można budować z liter (wielkich i małych), cyfr, i znaku podkreślenia (<tt>_</tt>)
*z zastrzeżeniem, że pierwszym znakiem nazwy nie może być cyfra
*litery wielkie i małe są rozróżniane, tak więc nazwy różniące się jedynie wielkością liter ''są różne''
*długość nazwy nie podlega ograniczeniu
*zabronione jest użycie jako nazwy któregokolwiek z tzw. słów zastrzeżonych, które mają specjalne znaczenie w składni języka Python.[https://docs.python.org/3/reference/lexical_analysis.html#keywords Tutaj można znaleźć ich wykaz].

W szczególności, nazwy (zmiennych i innych obiektów) mogą jak najbardziej zawierać litery właściwe dla języka polskiego (oraz dla innych języków). Z rozmaitych względów nie jest to jednak szczególnie rekomendowane, lepiej (przynajmniej na razie) ograniczyć się do liter podstawowego alfabetu łacińskiego.

Oprócz twardych reguł zawartych w definicji języka, w tworzeniu nazw programiści trzymają się na ogół pewnych konwencji - które nie są w żaden sposób egzekwowane przez interpreter, ale ułatwiają czytanie kodu — zwłaszcza, gdy się nim dzielimy z innymi:

*w nazwach zmiennych używamy małych liter (a nie wielkich)
*wielkie litery rezerwujemy dla nazw oznaczających wartości stałe, które nie mają prawa się zmienić w trakcie pracy programu
*staramy się, by nazwy coś znaczyły i ułatwiały zrozumienie kodu programu
*nie unikamy nazw składających się z dwóch lub nawet kilku słów; ponieważ spacja jako składnik nazwy nie jest dozwolona, zastępujemy ją znakiem podkreślenia
*unikamy jednak nazw przesadnie długich, a nazwy zmiennych, które są potrzebne jedynie "chwilowo" mogą wręcz być jednoliterowe
*nazwy zaczynające się od podkreślenia (<tt>_</tt>) mają pewne specjalne znaczenia i nie tworzymy takich nazw, chyba że całkiem świadomie.

=Wyrażenia=

==Arytmetyczne==

Wyrażenia arytmetyczne tworzymy z udziałem znanych już operatorów arytmetycznych <tt>+, -, /, *, **, //, %, ...</tt>, ale również wywołań funkcji zwracających wartości liczbowe (więcej o tym dalej), z wykorzystaniem literalnych liczb i nazw oznaczających zmienne, których aktualne wartości powinny być liczbami. Możemy również używać nawiasów (wyłącznie okrągłych!) do grupowania podwyrażeń, aby wymusić określoną kolejność operacji. Każdy na ogół pamięta, że dzielenie i mnożenie mają pierwszeństwo przed dodawaniem i odejmowaniem; potęgowanie ma jeszcze wyższy priorytet. Gdy mamy do czynienia z operatorami o równym priorytecie, to operacje wykonywane są zgodnie z kolejnością czytania, od lewej do prawej. Jeżeli mamy wątpliwości, to użycie nawiasów nie będzie błędem. Przykłady:

<source lang=python>
a + b * c == a + (b * c)
a / b / c == (a / b) / c
a * b ** c == a * (b ** c)
a ** b ** c == a ** (b ** c)
a ** - b == a ** (-b)
a ** b / c == (a ** b) / c
</source>

Zachowanie operatora potęgowania jest tu nieco szczególne, i zgadza się z umową przyjętą w matematyce.

Operatory arytmetyczne znajdują również czasem zastosowanie do obiektów nie będących liczbami, mają wtedy oczywiście nieco inne znaczenie. Np. suma dwóch napisów jest ich sklejeniem (mówi się też: ''konkatenacją'').

W przypadku, gdy będziemy mieszać w jednym wyrażeniu liczby całkowite i zmiennoprzecinkowe, to wynik będzie liczbą zmiennoprzecinkową. Wyjątkiem jest dzielenie: <tt>a / b</tt> zawsze da w wyniku liczbę zmiennoprzecinkową, natomiast <tt>a // b</tt> - całkowitą, jeśli oba argumenty są całkowite; w przeciwnym razie, zmiennoprzecinkową (ale o zerowej części ułamkowej).

===Rozszerzone operatory przypisania===

Z dwuargumentowymi operatorami arytmetycznymi związane są tzw. ''rozszerzone operatory przypisania'', stanowiące drobne udogodnienie pozwalające w sposób bardziej zwięzły zapisać dość często występujące operacje - takie, jak powiększenie aktualnej wartości <tt>x</tt> o 1 i zapamiętanie tej nowej, powiększonej wartości pod nazwą <tt>x</tt>:

<source lang=python>
# poniższe instrukcje są parami równoważne
x = x + a
x += a
#
x = x * a
x *= a
#
x = x - a
x -= a
#
x = x / a
x /= a
#
x **= a
x = x**a
</source>

Wersja np. z potęgowaniem może jest niezbyt często przydatna, ale wprowadzono ją choćby po to, by było konsekwentnie.

==Logiczne==

Wyrażenia logiczne mogą mieć jedną z dwu wartości: Prawda (<tt>True</tt>) lub Fałsz (<tt>False</tt>). Literalne wartości <tt>True</tt> i <tt>False</tt> są też przykładami wyrażeń logicznych, choć dość mało przydatnymi. Prawdziwe lub fałszywe mogą być np. porównania dwóch wartości, tworzone za pomocą operatorów <tt>></tt>, <tt><</tt>, <tt>>=</tt>, <tt><=</tt>, <tt>==</tt>, <tt>!=</tt> (to ostatnie, to sposób w jaki w Pythonie pisze się znak nierówności). Jak już wspomniano, podwojony znak równości jest operatorem porównania (w odróżnieniu od pojedynczego - przypisania). Porównywać można przede wszystkim liczby (a więc - dowolne wyrażenia o wartościach liczbowych), ale również np. napisy - wówczas większy oznacza tyle, co dalszy w porządku leksykograficznym. Porównania mają priorytet niższy, niż operatory arytmetyczne.

<blockquote>
Przy bliższym poznaniu okazuje się, że wartości <tt>True</tt> i <tt>False</tt> są tak naprawdę w pewnym sensie liczbami: odpowiednio 1 i 0. Dozwolone jest więc np. stosowanie do nich operacji arytmetycznych.
</blockquote>

Z elementarnych wyrażeń logicznych (porównań) można tworzyć złożone wyrażenia logiczne za pomocą operatorów (spójników) logicznych, pisanych <tt>and</tt>, <tt>or</tt> i <tt>not</tt>. Mają one następujące właśności:

<source lang=python>
(a and b) == (b and a)
(False and False) == False
(False and True) == False
(True and True) == True
(a or b) == (b or a)
(False or False) == False
(False or True) == True
(True or True) == True
(not True) == False
(not False) == True
</source>

Spójniki logiczne mają priorytet jeszcze niższy, niż porównania - stąd nawiasy w powyższym. Wśród nich najwyższy priorytet ma <tt>not</tt>, następnie <tt>and</tt>, na końcu <tt>or</tt>.

Wyrażenia logiczne mają tę szczególną własność, że wartość wyrażenia można często określić obliczając jedynie część jego elementów. Np. <tt>a and b</tt>, jeżeli wartością <tt>a</tt> jest <tt>False</tt>, jest na pewno <tt>False</tt> - niezależnie od wartości <tt>b</tt>. W takich przypadkach Python przerywa obliczanie (od lewej do prawej, z uwzględnieniem nawiasów) gdy tylko wartość jest określona. Fakt ten czasami może mieć znaczenie - jeżeli np. obliczenie któregoś z członów wyrażenia logicznego jest szczególnie czasochłonne, lub ma tzw. skutki uboczne.

Wyrażenia logiczne znajdują zastosowanie przede wszystkim w instrukcji warunkowej - pozwalają określić warunki, pod jakimi pewne operacje będą wykonane, lub nie - o tym dalej.

Warto wiedzieć, że w Pythonie '''każde wyrażenie może służyć jako wyrażenie logiczne'''. Inaczej mówiąc, każda wartość (napis, liczba, lista, itd.) może być wykorzystana w charakterze wartości logicznej. Obowiązują tu proste reguły:

* liczba <tt>0</tt> jest fałszywa (równoważna <tt>False</tt>); obojętne, czy całkowita czy zmiennoprzecinkowa;
* każda liczba różna od zera jest prawdziwa (równoważna <tt>True</tt>);
* napis pusty (o długości 0) jest fałszywy, każdy inny napis jest prawdziwy (również np. zawierający wyłącznie spacje);
* ogólniej — dowolnego typu kolekcja (lista, słownik, zbiór, ...) jest prawdziwa, o ile jest niepusta; każda kolekcja pusta (0-elementowa) jest fałszywa;
* wartość pusta czyli <tt>None</tt> jest, jak nietrudno zgadnąć, fałszywa.

W przypadku ogólniejszych typów danych (obiektów klas złożonych) sytuacja może już nie być taka prosta, ponieważ twórca klasy ma moc określenia reguły decydującej o prawdziwości / nieprawdziwości obiektów danej klasy. Ten temat jest na razie poza zakresem naszego kursu.

Jeżeli chcemy wymusić, aby dana wartość stała się dosłownie wartością logiczną, tzn. jedną z (<tt>True</tt>, <tt>False</tt>) w sposób zgodny z powyższymi regułami, można to osiągnąć przykładając funkcję <tt>bool</tt>: a więc <tt>bool(wyrażenie)</tt>. Rzadko jednak bywa to potrzebne.

Reguła „skrótowej" ewaluacji wyrażeń logicznych, w połączeniu z regułami prawdziwości innych typów danych, pozwala na dość popularne idiomy, jak np.:

<source lang=python>
# jeśli `wynik' jest niepustą listą to wypisze jej zawartość
# jeśli natomiast pustą, pojawi się komunikat
print(wynik or "wynik jest pusty!")
</source>

które pozwalają uniknąć używania instrukcji złożonych w wielu prostych przypadkach. Działa to dzięki temu, że spójniki <tt>and</tt> i <tt>or</tt> nie wymuszają aby wynik był wartością logiczną:

* jeżeli <tt>a</tt> jest prawdziwe, to <tt>a or b == a</tt>, i <tt>a and b == b</tt> dla każdego <tt>b</tt>;
* jeżeli <tt>a</tt> jest fałszywe, to <tt>a and b == a</tt>, i <tt>a or b == b</tt> dla każdego <tt>b</tt>.

Inaczej w przypadku operatora <tt>not</tt>: wynikiem jego działania jest zawsze jedna z wartości logicznych, podobnie jak w przypadku funkcji <tt>bool()</tt> — tyle, że przeciwna.

==Napisowe==

Wartością wyrażenia może być również napis. Na przykład, <tt>a + b</tt>, jeżeli <tt>a</tt> i <tt>b</tt> są napisami, jest napisem utworzonym przez ich sklejenie (zauważmy, że w odróżnieniu od dodawania liczb nie jest to operacja przemienna).

<blockquote>
Wcześniej wspomniano, że dwa napisy literalne postawione obok siebie zostaną automatycznie sklejone w jeden: np. <tt>'abc' "123"</tt> jest równoważne <tt>'abc123'</tt>. Nie stosuje się to jednak np. do zmiennych o wartościach napisowych: napisanie dwóch nazw obok siebie bez operatora pomiędzy nimi jest błędem składniowym. Jest tak, ponieważ wspomniane sklejenie napisów literalnych ma miejsce na etapie ''kompilacji'' kodu - tzn. wtedy, gdy interpreter analizuje zapis programu i przekłada go na instrukcje, jakie zostaną wykonane w etapie uruchomienia - a wartości stojące za nazwami zmiennych nie są na tym etapie jednoznacznie określone.
</blockquote>

Bogatszy repertuar operacji tworzących wyrażenia o wartościach będących napisami poznamy dalej.

==Inne wyrażenia==

Oprócz liczb, napisów i wartości logicznych, Python posiada szereg dalszych, złożonych typów danych, które również mogą być wartościami wyrażeń. Wspomniano już przelotnie o kolekcjach (listy, słowniki, zbiory, ...) — służą one jako ,,pojemniki" do gromadzenia obiektów w zasadzie dowolnych typów, i zostaną omówione w dalszym ciągu. Istnieje też specjalny typ ''obiektu pustego'', mający dokładnie jednego reprezentanta: wartość specjalną <tt>None</tt>.

Każdy typ obiektu w Pythonie może być wartością odpowiednio zbudowanego wyrażenia. Gdy poznamy kolejne typy danych, wprowadzimy również operacje tworzące takie wyrażenia.

=Ćwiczenia=

1. Które z następujących są poprawnymi nazwami według reguł Pythona:
nazwa1
9sił
dluga-nazwa
wykonaj_rachunki
_
to&owo
if

2. Wykazać, że poniższe równości są równoważnościami -- tzn. że zachodzą dla dowolnej kombinacji wartości <tt>a</tt> i <tt>b</tt>:

not (a or b) == not a and not b
not (a and b) == not a or not b
a or not a == True

''Wskazówka:'' stworzyć tabelki wartości wyrażeń po lewej i prawej stronie operatora porównania <tt>==</tt> dla wszystkich możliwych kombinacji wartości <tt>a</tt> i <tt>b</tt>.

3. Które z poniższych równości są tożsamościami, w wyniku działania reguł pierwszeństwa operatorów?

a / b / c == a / (b / c)
a ** b / c == (a ** b) / c
-a ** b == (-a) ** b

''CDN...''

----

[[PPy3/PierwszeKroki|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/InstrukcjaWarunkowa|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:22, 21 cze 2016 (CEST)

PPy3/StałeIZmienne

2022-07-29T12:11:13Z

RobertJB: /* Logiczne */

=Stałe i zmienne=

==Stałe dosłowne (literalne)==

Stałe dosłowne to takie, których wartości wprost wpisano do pliku z kodem (lub w linii poleceń interpretera). Mogą to być liczby (paru rodzajów) lub napisy, ale również różne złożone rodzaje (typy) danych, z którymi zapoznamy się nieco później.

'''Zapamiętajmy''' od razu: ''liczba'' dla komputera to zupełnie co innego, niż ''napis'' składający się z cyfr. Na napisie nie wykonamy operacji arytmetycznych - a na liczbie, operacji właściwych dla napisów (takich jak np. wyjęcie z niego znaku stojącego na określonej pozycji). Istnieją jednak operacje przekształcające każdy z tych typów danych w drugi.

===Liczby===

Dobrze jest pamiętać, że nieco odmiennie traktowane są liczby całkowite, a inaczej - liczby ułamkowe, zwykle zwane ''zmiennoprzecinkowymi'' (po angielsku ''floating point'', jako że Amerykanie piszą kropkę dziesiętną a nie - jak my - przecinek, przez co i w Pythonie używa się w tym celu kropki).

*Liczby całkowite w zapisie dziesiętnym: <tt>1024</tt>, <tt>0</tt>, <tt>-666</tt>, ...
*Liczby ułamkowe: <tt>1.0</tt>, <tt>.99</tt>, <tt>98.6</tt>, <tt>-37.43</tt>, ...
*Liczby ułamkowe w zapisie wykładniczym: <tt>1.024e3</tt>, <tt>96.9E-12</tt>, ...

Notacja <tt>e3</tt>, <tt>E-12</tt> itp. (wielka i mała litera <tt>e</tt> są tu równoważne) oznacza pomnożenie poprzedzającej liczby przez odpowiednio 103, 10-12, ... i służy ułatwieniu zapisu liczb bardzo dużych lub bardzo małych. Nie można tam wtrącać dodatkowych odstępów, podobnie jak pomiędzy cyframi.

Jeśli część całkowita (lub ułamkowa) liczby zmiennoprzecinkowej wynosi zero, to można to zero pominąć. Oczywiście nie można pominąć obu, zapisując liczbę zero! (można napisać: <tt>0.</tt> albo <tt>.0</tt>, ale nie samotną kropkę).

Podstawowa różnica pomiędzy sposobem traktowania liczb całkowitych i zmiennoprzecinkowych polega na tym, że:

*liczby całkowite mogą być dowolnie duże, a rachunki całkowitoliczbowe wykonywane są dokładnie,
*liczby ułamkowe oraz wyniki rachunków na liczbach ułamkowych należy zawsze traktować jako przybliżone (oczywiście dla szczególnych wartości zdarza się, że są one dokładne); zakres wielkości liczb ułamkowych jest ograniczony.

<blockquote>
Python zna też liczby ''zespolone'' oraz operacje na nich, ale tego zdaje się nie było w szkole...
</blockquote>

Liczby całkowite można pisać również w podstawach innych niż 10:

*dwójkowe: <tt>0b101 == 5</tt>
*ósemkowe: <tt>0o123 == 83</tt>
*szesnastkowe: <tt>0x1f == 31</tt>

(podwojony znak równości oznacza: lewa strona jest równa prawej; litery b, o, x mogą być zarówno małe jak i wielkie).

W zapisie szesnastkowym, wymagającym 16 różnych cyfr, w roli "brakujących" cyfr oznaczających liczby od 10 do 15 przyjmuje się początkowe litery alfabetu (a-f), można równoważnie używać liter małych lub wielkich.

===Napisy===

Napis (ang. ''string'') to po prostu ciąg znaków.

<blockquote>
OK, nic nie jest tak proste, jak się wydaje. Pytanie: co to jest znak? Odpowiedzi dostarcza standard ''Unicode'', w skład którego chodzi m. in. katalog wszystkich znaków, używanych przez systemy pisma wszystkich w zasadzie języków świata (języków żywych, i co ważniejszych spośród martwych). Nie będziemy się w tej chwili zastanawiać nad tym, jak dokładnie znaki te są reprezentowane w komputerze. Warto jednak pamiętać, że napisy nie muszą ograniczać się do znaków znanych z zapisu języków europejskich.
</blockquote>

Literalne stałe napisowe, czyli napisy "na twardo" wpisane do kodu, mogą być podane w paru różnych postaciach:

<source lang=python>
napis1 = 'jedna z postaci napisu'
napis2 = "nieco inna postać napisu"
napis3 = '''tak też może wyglądać napis,
i w tej postaci może zawierać przejścia do nowego wiersza
(w poprzednich nie może)'''
napis4 = """zamiast apostrofów, mogą być cudzysłowy - wychodzi na to samo,
również w postaci takiej, jak napis1 i napis2 są one równoważne"""
napis5 = "korzyść z tego pojawia się np. gdy w treści napisu potrzebujemy umieścić znak taki jak ' "
napis6 = 'w treści napisów można użyć kilku specjalnych sekwencji:\nTo powoduje przejście do nowego wiersza..'
napis7 = 'jeśli dwa napisy (lub więcej) postawimy ' 'jeden obok drugiego ' 'to zostaną połączone w jeden'
napis8 = 'lecz uwaga: pomiędzy sklejone napisy nie zostanie wstawiona żadna spacja ani w ogóle nic.'
</source>

'''Sekwencje specjalne w napisach'''

{| class="wikitable"
|-
|<tt>\\</tt>||dosłowny znak <tt>\</tt>
|-
|<tt>\'</tt>||apostrof: <tt>'</tt>
|-
|<tt>\"</tt>||cudzysłów: <tt>"</tt>
|-
|<tt>\a</tt>||kod BEL
|-
|<tt>\b</tt>||kod BS ('backspace')
|-
|<tt>\f</tt>||kod FF ('formfeed')
|-
|<tt>\n</tt>||kod LF ('linefeed')
|-
|<tt>\r</tt>||kod CR ('carriage return')
|-
|<tt>\t</tt>||kod HT ('horizontal tab')
|-
|<tt>\v</tt>||kod VT ('vertical tab')
|-
|<tt>\nnn</tt>||znak o kodzie 'nnn' w zapisie ósemkowym
|-
|<tt>\xnn</tt>||znak o kodzie 'nn' w zapisie szesnastkowym
|-
|<tt>\N{nazwa}</tt>||znak o danej nazwie symbolicznej w tabeli Unicode
|-
|<tt>\unnnn</tt>||znak o pozycji '0xnnnn' w 16-bitowej tabeli Unicode
|-
|<tt>\Unnnnnnnn</tt>||znak o pozycji '0xnnnnnnnn' w 32-bitowej tabeli Unicode
|}

To co określam tutaj nazwą ''kod'' to są szczególne ,,znaki", które nie posiadają reprezentacji graficznej, ale mogą wystąpić w strumieniu tekstowym pełniąc jakiegoś rodzaju rolę sterującą (p. poniżej). Czasami stosuje się określenie ''znaki niedrukowalne''. Jest ich więcej, niż występuje w powyższej tabeli — pozostałym nie nadano specjalnego zapisu i dostępne są np. przez notację <tt>\nnn</tt> albo <tt>\xnn</tt>, ale niezwykle rzadko bywają potrzebne.

* Wypisanie kodu BEL na terminal najczęściej skutkuje sygnałem akustycznym (''BIP!'') lub wizualnym (błysk), zależy to od ustawień emulatora terminala
* Kod BS cofa kursor o jedną pozycję, umożliwiając nadpisanie ostatniego wypisanego znaku
* Kod FF stosowano w tekście przeznaczonym do wydrukowania na drukarce wierszowej, powodował przejście do następnej strony. Obecnie ze względu na wymarcie drukarek wierszowych w zasadzie nie ma zastosowania
* Kod LF to przejście do nowej linii, inaczej - znacznik końca linii w strumieniu tekstowym
* Kod CR czyli powrót karetki cofa kursor do początku aktualnej linii
* Kod HT to ten, który zwykle nazywa się po prostu kodem tabulacji. Jego interpretacja zależy od ustawień terminala lub innego programu renderującego tekst, zwykle oznacza przeskok do pozycji będącej kolejną całkowitą wielokrotnością 4 lub 8 w bieżącej linii
* Kod VT z założenia działa analogicznie jak HT, ale w kierunku pionowym. Obecnie rzadko stosowany
* W zapisie <tt>\nnn</tt> może wystąpić jedna, dwie lub trzy cyfry ósemkowe ''n''
* W zapisie <tt>\xnn</tt> należy użyć dokładnie dwóch cyfr szesnatkowych ''n''
* W zapisie <tt>\unnnn</tt> należy użyć dokładnie czterech cyfr szesnastkowych ''n''
* W zapisie <tt>\Unnnnnnnn</tt> należy użyć dokładnie ośmiu cyfr szesnastkowych ''n''

Jeżeli chcemy zapisać napis obfitujący w znaki <tt>\</tt>, możemy użyć notacji takiej:

<source lang="python">
napis1 = r'oto\napis\z\bakslaszami'
napis2 = R'tu\znak"\"nie\będzie\nigdy\oznaczał\początku\specjalnej\sekwencji'
</source>

Wielkość użytej na początku litery <tt>R</tt> nie ma znaczenia.

==Zmienne, czyli nazwy==

Programy oczywiście nie operują jedynie na stałych. Potrzebny jest w nich sposób odnoszenia się do wartości, które nie są znane z góry (w chwili pisania programu) - albo dlatego, że zostaną dostarczone dopiero przy uruchomieniu lub w trakcie pracy programu, jako dane wejściowe (później zobaczymy, na jakie sposoby można tego dokonać), albo dlatego, że będą wynikiem obliczeń lub przekształceń danych wykonywanych przez program.

Do tego w Pythonie służą ''zmienne'' - można je uważać za nazwy, z jakimi wiążemy pewne wartości (liczby, napisy, itd.), poprzez ''instrukcję podstawienia''. Do zapisu instrukcji podstawienia służy znak równości (<tt>=</tt>), po jego lewej stronie stawiamy nazwę (zmiennej), po drugiej - ''wyrażenie'', np. literalną stałą, ale również może być to wyrażenie zbudowane ze stałych, operatorów (np. arytmetycznych), nazw zmiennych (reprezentujących w wyrażeniu związane z nimi aktualnie wartości), i szereg innych elementów które dopiero poznamy.

'''Do zapamiętania''': pojedynczy znak równości <tt>=</tt> w Pythonie (i wielu innych językach programowania) nie tworzy ''równania'', czyli stwierdzenia, że lewa strona jest równa prawej; tylko ''podstawienie'', a więc operację powodującą, że z nazwą stojącą po stronie lewej zostaje związana obliczona wartość wyrażenie stojącego po prawej. Zauważmy, że jest to operacja niesymetryczna (stron nie można bezkarne zamienić miejscami):

<source lang=python>
i = 0 # pierwsze użycie nazwy, w tym przypadku 'i', tworzy zmienną i wiąże z nią wartość
i = i + 2 # to jest legalne, i oznacza, że wartość związana z 'i' rośnie o 2
i + 2 = i # to jest błędne, po lewej stronie nie może stać wyrażenie złożone
</source>

Pojawienie się w wyrażeniu stojącym po prawej stronie podstawienia tej samej nazwy, która stoi po lewej stronie, nie tworzy jakiejkolwiek niejednoznaczności: zasadą jest, że ''wpierw'' obliczana jest wartość wyrażenia z prawej strony, z wykorzystaniem aktualnych wartości zmiennych, a ''potem'' następuje związanie nazwy zmiennej stojącej po lewej z wynikiem.

Zauważmy, że błędem byłoby użycie nazwy po raz pierwszy ''bez'' uprzedniego nadania jej wartości, np. w wyrażeniu arytmetycznym.

===Reguły tworzenia nazw===

Aktualnie reguły określające, co jest poprawną nazwą w Pythonie, dopuszczają użycie całkiem szerokiego podzbioru znaków Unicode i są dość trudne do opisania w zrozumiały sposób. Pomijając jednak taką możliwość, że ktoś zechce użyć w nazwie zmiennej znaków pisma Kanji lub perskiego, można w dużym uproszczeniu powiedzieć tak:

*nazwy można budować z liter (wielkich i małych), cyfr, i znaku podkreślenia (<tt>_</tt>)
*z zastrzeżeniem, że pierwszym znakiem nazwy nie może być cyfra
*litery wielkie i małe są rozróżniane, tak więc nazwy różniące się jedynie wielkością liter ''są różne''
*długość nazwy nie podlega ograniczeniu
*zabronione jest użycie jako nazwy któregokolwiek z tzw. słów zastrzeżonych, które mają specjalne znaczenie w składni języka Python.[https://docs.python.org/3/reference/lexical_analysis.html#keywords Tutaj można znaleźć ich wykaz].

W szczególności, nazwy (zmiennych i innych obiektów) mogą jak najbardziej zawierać litery właściwe dla języka polskiego (oraz dla innych języków). Z rozmaitych względów nie jest to jednak szczególnie rekomendowane, lepiej (przynajmniej na razie) ograniczyć się do liter podstawowego alfabetu łacińskiego.

Oprócz twardych reguł zawartych w definicji języka, w tworzeniu nazw programiści trzymają się na ogół pewnych konwencji - które nie są w żaden sposób egzekwowane przez interpreter, ale ułatwiają czytanie kodu — zwłaszcza, gdy się nim dzielimy z innymi:

*w nazwach zmiennych używamy małych liter (a nie wielkich)
*wielkie litery rezerwujemy dla nazw oznaczających wartości stałe, które nie mają prawa się zmienić w trakcie pracy programu
*staramy się, by nazwy coś znaczyły i ułatwiały zrozumienie kodu programu
*nie unikamy nazw składających się z dwóch lub nawet kilku słów; ponieważ spacja jako składnik nazwy nie jest dozwolona, zastępujemy ją znakiem podkreślenia
*unikamy jednak nazw przesadnie długich, a nazwy zmiennych, które są potrzebne jedynie "chwilowo" mogą wręcz być jednoliterowe
*nazwy zaczynające się od podkreślenia (<tt>_</tt>) mają pewne specjalne znaczenia i nie tworzymy takich nazw, chyba że całkiem świadomie.

=Wyrażenia=

==Arytmetyczne==

Wyrażenia arytmetyczne tworzymy z udziałem znanych już operatorów arytmetycznych <tt>+, -, /, *, **, //, %, ...</tt>, ale również wywołań funkcji zwracających wartości liczbowe (więcej o tym dalej), z wykorzystaniem literalnych liczb i nazw oznaczających zmienne, których aktualne wartości powinny być liczbami. Możemy również używać nawiasów (wyłącznie okrągłych!) do grupowania podwyrażeń, aby wymusić określoną kolejność operacji. Każdy na ogół pamięta, że dzielenie i mnożenie mają pierwszeństwo przed dodawaniem i odejmowaniem; potęgowanie ma jeszcze wyższy priorytet. Gdy mamy do czynienia z operatorami o równym priorytecie, to operacje wykonywane są zgodnie z kolejnością czytania, od lewej do prawej. Jeżeli mamy wątpliwości, to użycie nawiasów nie będzie błędem. Przykłady:

<source lang=python>
a + b * c == a + (b * c)
a / b / c == (a / b) / c
a * b ** c == a * (b ** c)
a ** b ** c == a ** (b ** c)
a ** - b == a ** (-b)
a ** b / c == (a ** b) / c
</source>

Zachowanie operatora potęgowania jest tu nieco szczególne, i zgadza się z umową przyjętą w matematyce.

Operatory arytmetyczne znajdują również czasem zastosowanie do obiektów nie będących liczbami, mają wtedy oczywiście nieco inne znaczenie. Np. suma dwóch napisów jest ich sklejeniem (mówi się też: ''konkatenacją'').

W przypadku, gdy będziemy mieszać w jednym wyrażeniu liczby całkowite i zmiennoprzecinkowe, to wynik będzie liczbą zmiennoprzecinkową. Wyjątkiem jest dzielenie: <tt>a / b</tt> zawsze da w wyniku liczbę zmiennoprzecinkową, natomiast <tt>a // b</tt> - całkowitą, jeśli oba argumenty są całkowite; w przeciwnym razie, zmiennoprzecinkową (ale o zerowej części ułamkowej).

===Rozszerzone operatory przypisania===

Z dwuargumentowymi operatorami arytmetycznymi związane są tzw. ''rozszerzone operatory przypisania'', stanowiące drobne udogodnienie pozwalające w sposób bardziej zwięzły zapisać dość często występujące operacje - takie, jak powiększenie aktualnej wartości <tt>x</tt> o 1 i zapamiętanie tej nowej, powiększonej wartości pod nazwą <tt>x</tt>:

<source lang=python>
# poniższe instrukcje są parami równoważne
x = x + a
x += a
#
x = x * a
x *= a
#
x = x - a
x -= a
#
x = x / a
x /= a
#
x **= a
x = x**a
</source>

Wersja np. z potęgowaniem może jest niezbyt często przydatna, ale wprowadzono ją choćby po to, by było konsekwentnie.

==Logiczne==

Wyrażenia logiczne mogą mieć jedną z dwu wartości: Prawda (<tt>True</tt>) lub Fałsz (<tt>False</tt>). Literalne wartości <tt>True</tt> i <tt>False</tt> są też przykładami wyrażeń logicznych, choć dość mało przydatnymi. Prawdziwe lub fałszywe mogą być np. porównania dwóch wartości, tworzone za pomocą operatorów <tt>></tt>, <tt><</tt>, <tt>>=</tt>, <tt><=</tt>, <tt>==</tt>, <tt>!=</tt> (to ostatnie, to sposób w jaki w Pythonie pisze się znak nierówności). Jak już wspomniano, podwojony znak równości jest operatorem porównania (w odróżnieniu od pojedynczego - przypisania). Porównywać można przede wszystkim liczby (a więc - dowolne wyrażenia o wartościach liczbowych), ale również np. napisy - wówczas większy oznacza tyle, co dalszy w porządku leksykograficznym. Porównania mają priorytet niższy, niż operatory arytmetyczne.

<blockquote>
Przy bliższym poznaniu okazuje się, że wartości <tt>True</tt> i <tt>False</tt> są tak naprawdę w pewnym sensie liczbami: odpowiednio 1 i 0. Dozwolone jest więc np. stosowanie do nich operacji arytmetycznych.
</blockquote>

Z elementarnych wyrażeń logicznych (porównań) można tworzyć złożone wyrażenia logiczne za pomocą operatorów (spójników) logicznych, pisanych <tt>and</tt>, <tt>or</tt> i <tt>not</tt>. Mają one następujące właśności:

<source lang=python>
(a and b) == (b and a)
(False and False) == False
(False and True) == False
(True and True) == True
(a or b) == (b or a)
(False or False) == False
(False or True) == True
(True or True) == True
(not True) == False
(not False) == True
</source>

Spójniki logiczne mają priorytet jeszcze niższy, niż porównania - stąd nawiasy w powyższym. Wśród nich najwyższy priorytet ma <tt>not</tt>, następnie <tt>and</tt>, na końcu <tt>or</tt>.

Wyrażenia logiczne mają tę szczególną własność, że wartość wyrażenia można często określić obliczając jedynie część jego elementów. Np. <tt>a and b</tt>, jeżeli wartością <tt>a</tt> jest <tt>False</tt>, jest na pewno <tt>False</tt> - niezależnie od wartości <tt>b</tt>. W takich przypadkach Python przerywa obliczanie (od lewej do prawej, z uwzględnieniem nawiasów) gdy tylko wartość jest określona. Fakt ten czasami może mieć znaczenie - jeżeli np. obliczenie któregoś z członów wyrażenia logicznego jest szczególnie czasochłonne, lub ma tzw. skutki uboczne.

Wyrażenia logiczne znajdują zastosowanie przede wszystkim w instrukcji warunkowej - pozwalają określić warunki, pod jakimi pewne operacje będą wykonane, lub nie - o tym dalej.

Warto wiedzieć, że w Pythonie '''każde wyrażenie może służyć jako wyrażenie logiczne'''. Inaczej mówiąc, każda wartość (napis, liczba, lista, itd.) może być wykorzystana w charakterze wartości logicznej. Obowiązują tu proste reguły:

* liczba <tt>0</tt> jest fałszywa (równoważna <tt>False</tt>); obojętne, czy całkowita czy zmiennoprzecinkowa;
* każda liczba różna od zera jest prawdziwa (równoważna <tt>True</tt>);
* napis pusty (o długości 0) jest fałszywy, każdy inny napis jest prawdziwy (również np. zawierający wyłącznie spacje);
* ogólniej — dowolnego typu kolekcja (lista, słownik, zbiór, ...) jest prawdziwa, o ile jest niepusta; każda kolekcja pusta (0-elementowa) jest fałszywa;
* wartość pusta czyli <tt>None</tt> jest, jak nietrudno zgadnąć, fałszywa.

W przypadku ogólniejszych typów danych (obiektów klas złożonych) sytuacja może już nie być taka prosta, ponieważ twórca klasy ma moc określenia reguły decydującej o prawdziwości / nieprawdziwości obiektów danej klasy. Ten temat jest na razie poza zakresem naszego kursu.

Jeżeli chcemy wymusić, aby dana wartość stała się dosłownie wartością logiczną, tzn. jedną z (<tt>True</tt>, <tt>False</tt>) w sposób zgodny z powyższymi regułami, można to osiągnąć przykładając funkcję <tt>bool</tt>: a więc <tt>bool(wyrażenie)</tt>. Rzadko jednak bywa to potrzebne.

Reguła „skrótowej" ewaluacji wyrażeń logicznych, w połączeniu z regułami prawdziwości innych typów danych, pozwala na dość popularne idiomy, jak np.:

<source lang=python>
# jeśli `wynik' jest niepustą listą to wypisze jej zawartość
# jeśli natomiast pustą, pojawi się komunikat
print(wynik or "wynik jest pusty!")
</source>

które pozwalają uniknąć używania instrukcji złożonych w wielu prostych przypadkach. Działa to dzięki temu, że spójniki <tt>and</tt> i <tt>or</tt> nie wymuszają aby wynik był wartością logiczną:

* jeżeli <tt>a</tt> jest prawdziwe, to <tt>a or b == a</tt>, i <tt>a and b == b</tt> dla każdego <tt>b</tt>;
* jeżeli <tt>a</tt> jest fałszywe, to <tt>a and b == a</tt>, i <tt>a or b == b</tt> dla każdego <tt>b</tt>.

Inaczej w przypadku operatora <tt>not</tt>: wynikiem jego działania jest zawsze jedna z wartości logicznych, podobnie jak w przypadku funkcji <tt>bool()</tt> — tyle, że przeciwna.

==Napisowe==

Wartością wyrażenia może być również napis. Na przykład, <tt>a + b</tt>, jeżeli <tt>a</tt> i <tt>b</tt> są napisami, jest napisem utworzonym przez ich sklejenie (zauważmy, że w odróżnieniu od dodawania liczb nie jest to operacja przemienna).

<blockquote>
Wcześniej wspomniano, że dwa napisy literalne postawione obok siebie zostaną automatycznie sklejone w jeden: np. <tt>'abc' "123"</tt> jest równoważne <tt>'abc123'</tt>. Nie stosuje się to jednak np. do zmiennych o wartościach napisowych: napisanie dwóch nazw obok siebie bez operatora pomiędzy nimi jest błędem składniowym. Jest tak, ponieważ wspomniane sklejenie napisów literalnych ma miejsce na etapie ''kompilacji'' kodu - tzn. wtedy, gdy interpreter analizuje zapis programu i przekłada go na instrukcje, jakie zostaną wykonane w etapie uruchomienia - a wartości stojące za nazwami zmiennych nie są na tym etapie jednoznacznie określone.
</blockquote>

Bogatszy repertuar operacji tworzących wyrażenia o wartościach będących napisami poznamy dalej.

==Inne wyrażenia==

Oprócz liczb, napisów i wartości logicznych, Python posiada szereg dalszych, złożonych typów danych, które również mogą być wartościami wyrażeń. Każdy typ obiektu w Pythonie może być wartością odpowiednio zbudowanego wyrażenia. Gdy poznamy kolejne typy danych, wprowadzimy również operacje tworzące takie wyrażenia.

=Ćwiczenia=

1. Które z następujących są poprawnymi nazwami według reguł Pythona:
nazwa1
9sił
dluga-nazwa
wykonaj_rachunki
_
to&owo
if

2. Wykazać, że poniższe równości są równoważnościami -- tzn. że zachodzą dla dowolnej kombinacji wartości <tt>a</tt> i <tt>b</tt>:

not (a or b) == not a and not b
not (a and b) == not a or not b
a or not a == True

''Wskazówka:'' stworzyć tabelki wartości wyrażeń po lewej i prawej stronie operatora porównania <tt>==</tt> dla wszystkich możliwych kombinacji wartości <tt>a</tt> i <tt>b</tt>.

3. Które z poniższych równości są tożsamościami, w wyniku działania reguł pierwszeństwa operatorów?

a / b / c == a / (b / c)
a ** b / c == (a ** b) / c
-a ** b == (-a) ** b

''CDN...''

----

[[PPy3/PierwszeKroki|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/InstrukcjaWarunkowa|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:22, 21 cze 2016 (CEST)

PPy3/StałeIZmienne

2022-07-29T11:32:53Z

RobertJB: /* Stałe dosłowne (literalne) */

=Stałe i zmienne=

==Stałe dosłowne (literalne)==

Stałe dosłowne to takie, których wartości wprost wpisano do pliku z kodem (lub w linii poleceń interpretera). Mogą to być liczby (paru rodzajów) lub napisy, ale również różne złożone rodzaje (typy) danych, z którymi zapoznamy się nieco później.

'''Zapamiętajmy''' od razu: ''liczba'' dla komputera to zupełnie co innego, niż ''napis'' składający się z cyfr. Na napisie nie wykonamy operacji arytmetycznych - a na liczbie, operacji właściwych dla napisów (takich jak np. wyjęcie z niego znaku stojącego na określonej pozycji). Istnieją jednak operacje przekształcające każdy z tych typów danych w drugi.

===Liczby===

Dobrze jest pamiętać, że nieco odmiennie traktowane są liczby całkowite, a inaczej - liczby ułamkowe, zwykle zwane ''zmiennoprzecinkowymi'' (po angielsku ''floating point'', jako że Amerykanie piszą kropkę dziesiętną a nie - jak my - przecinek, przez co i w Pythonie używa się w tym celu kropki).

*Liczby całkowite w zapisie dziesiętnym: <tt>1024</tt>, <tt>0</tt>, <tt>-666</tt>, ...
*Liczby ułamkowe: <tt>1.0</tt>, <tt>.99</tt>, <tt>98.6</tt>, <tt>-37.43</tt>, ...
*Liczby ułamkowe w zapisie wykładniczym: <tt>1.024e3</tt>, <tt>96.9E-12</tt>, ...

Notacja <tt>e3</tt>, <tt>E-12</tt> itp. (wielka i mała litera <tt>e</tt> są tu równoważne) oznacza pomnożenie poprzedzającej liczby przez odpowiednio 103, 10-12, ... i służy ułatwieniu zapisu liczb bardzo dużych lub bardzo małych. Nie można tam wtrącać dodatkowych odstępów, podobnie jak pomiędzy cyframi.

Jeśli część całkowita (lub ułamkowa) liczby zmiennoprzecinkowej wynosi zero, to można to zero pominąć. Oczywiście nie można pominąć obu, zapisując liczbę zero! (można napisać: <tt>0.</tt> albo <tt>.0</tt>, ale nie samotną kropkę).

Podstawowa różnica pomiędzy sposobem traktowania liczb całkowitych i zmiennoprzecinkowych polega na tym, że:

*liczby całkowite mogą być dowolnie duże, a rachunki całkowitoliczbowe wykonywane są dokładnie,
*liczby ułamkowe oraz wyniki rachunków na liczbach ułamkowych należy zawsze traktować jako przybliżone (oczywiście dla szczególnych wartości zdarza się, że są one dokładne); zakres wielkości liczb ułamkowych jest ograniczony.

<blockquote>
Python zna też liczby ''zespolone'' oraz operacje na nich, ale tego zdaje się nie było w szkole...
</blockquote>

Liczby całkowite można pisać również w podstawach innych niż 10:

*dwójkowe: <tt>0b101 == 5</tt>
*ósemkowe: <tt>0o123 == 83</tt>
*szesnastkowe: <tt>0x1f == 31</tt>

(podwojony znak równości oznacza: lewa strona jest równa prawej; litery b, o, x mogą być zarówno małe jak i wielkie).

W zapisie szesnastkowym, wymagającym 16 różnych cyfr, w roli "brakujących" cyfr oznaczających liczby od 10 do 15 przyjmuje się początkowe litery alfabetu (a-f), można równoważnie używać liter małych lub wielkich.

===Napisy===

Napis (ang. ''string'') to po prostu ciąg znaków.

<blockquote>
OK, nic nie jest tak proste, jak się wydaje. Pytanie: co to jest znak? Odpowiedzi dostarcza standard ''Unicode'', w skład którego chodzi m. in. katalog wszystkich znaków, używanych przez systemy pisma wszystkich w zasadzie języków świata (języków żywych, i co ważniejszych spośród martwych). Nie będziemy się w tej chwili zastanawiać nad tym, jak dokładnie znaki te są reprezentowane w komputerze. Warto jednak pamiętać, że napisy nie muszą ograniczać się do znaków znanych z zapisu języków europejskich.
</blockquote>

Literalne stałe napisowe, czyli napisy "na twardo" wpisane do kodu, mogą być podane w paru różnych postaciach:

<source lang=python>
napis1 = 'jedna z postaci napisu'
napis2 = "nieco inna postać napisu"
napis3 = '''tak też może wyglądać napis,
i w tej postaci może zawierać przejścia do nowego wiersza
(w poprzednich nie może)'''
napis4 = """zamiast apostrofów, mogą być cudzysłowy - wychodzi na to samo,
również w postaci takiej, jak napis1 i napis2 są one równoważne"""
napis5 = "korzyść z tego pojawia się np. gdy w treści napisu potrzebujemy umieścić znak taki jak ' "
napis6 = 'w treści napisów można użyć kilku specjalnych sekwencji:\nTo powoduje przejście do nowego wiersza..'
napis7 = 'jeśli dwa napisy (lub więcej) postawimy ' 'jeden obok drugiego ' 'to zostaną połączone w jeden'
napis8 = 'lecz uwaga: pomiędzy sklejone napisy nie zostanie wstawiona żadna spacja ani w ogóle nic.'
</source>

'''Sekwencje specjalne w napisach'''

{| class="wikitable"
|-
|<tt>\\</tt>||dosłowny znak <tt>\</tt>
|-
|<tt>\'</tt>||apostrof: <tt>'</tt>
|-
|<tt>\"</tt>||cudzysłów: <tt>"</tt>
|-
|<tt>\a</tt>||kod BEL
|-
|<tt>\b</tt>||kod BS ('backspace')
|-
|<tt>\f</tt>||kod FF ('formfeed')
|-
|<tt>\n</tt>||kod LF ('linefeed')
|-
|<tt>\r</tt>||kod CR ('carriage return')
|-
|<tt>\t</tt>||kod HT ('horizontal tab')
|-
|<tt>\v</tt>||kod VT ('vertical tab')
|-
|<tt>\nnn</tt>||znak o kodzie 'nnn' w zapisie ósemkowym
|-
|<tt>\xnn</tt>||znak o kodzie 'nn' w zapisie szesnastkowym
|-
|<tt>\N{nazwa}</tt>||znak o danej nazwie symbolicznej w tabeli Unicode
|-
|<tt>\unnnn</tt>||znak o pozycji '0xnnnn' w 16-bitowej tabeli Unicode
|-
|<tt>\Unnnnnnnn</tt>||znak o pozycji '0xnnnnnnnn' w 32-bitowej tabeli Unicode
|}

To co określam tutaj nazwą ''kod'' to są szczególne ,,znaki", które nie posiadają reprezentacji graficznej, ale mogą wystąpić w strumieniu tekstowym pełniąc jakiegoś rodzaju rolę sterującą (p. poniżej). Czasami stosuje się określenie ''znaki niedrukowalne''. Jest ich więcej, niż występuje w powyższej tabeli — pozostałym nie nadano specjalnego zapisu i dostępne są np. przez notację <tt>\nnn</tt> albo <tt>\xnn</tt>, ale niezwykle rzadko bywają potrzebne.

* Wypisanie kodu BEL na terminal najczęściej skutkuje sygnałem akustycznym (''BIP!'') lub wizualnym (błysk), zależy to od ustawień emulatora terminala
* Kod BS cofa kursor o jedną pozycję, umożliwiając nadpisanie ostatniego wypisanego znaku
* Kod FF stosowano w tekście przeznaczonym do wydrukowania na drukarce wierszowej, powodował przejście do następnej strony. Obecnie ze względu na wymarcie drukarek wierszowych w zasadzie nie ma zastosowania
* Kod LF to przejście do nowej linii, inaczej - znacznik końca linii w strumieniu tekstowym
* Kod CR czyli powrót karetki cofa kursor do początku aktualnej linii
* Kod HT to ten, który zwykle nazywa się po prostu kodem tabulacji. Jego interpretacja zależy od ustawień terminala lub innego programu renderującego tekst, zwykle oznacza przeskok do pozycji będącej kolejną całkowitą wielokrotnością 4 lub 8 w bieżącej linii
* Kod VT z założenia działa analogicznie jak HT, ale w kierunku pionowym. Obecnie rzadko stosowany
* W zapisie <tt>\nnn</tt> może wystąpić jedna, dwie lub trzy cyfry ósemkowe ''n''
* W zapisie <tt>\xnn</tt> należy użyć dokładnie dwóch cyfr szesnatkowych ''n''
* W zapisie <tt>\unnnn</tt> należy użyć dokładnie czterech cyfr szesnastkowych ''n''
* W zapisie <tt>\Unnnnnnnn</tt> należy użyć dokładnie ośmiu cyfr szesnastkowych ''n''

Jeżeli chcemy zapisać napis obfitujący w znaki <tt>\</tt>, możemy użyć notacji takiej:

<source lang="python">
napis1 = r'oto\napis\z\bakslaszami'
napis2 = R'tu\znak"\"nie\będzie\nigdy\oznaczał\początku\specjalnej\sekwencji'
</source>

Wielkość użytej na początku litery <tt>R</tt> nie ma znaczenia.

==Zmienne, czyli nazwy==

Programy oczywiście nie operują jedynie na stałych. Potrzebny jest w nich sposób odnoszenia się do wartości, które nie są znane z góry (w chwili pisania programu) - albo dlatego, że zostaną dostarczone dopiero przy uruchomieniu lub w trakcie pracy programu, jako dane wejściowe (później zobaczymy, na jakie sposoby można tego dokonać), albo dlatego, że będą wynikiem obliczeń lub przekształceń danych wykonywanych przez program.

Do tego w Pythonie służą ''zmienne'' - można je uważać za nazwy, z jakimi wiążemy pewne wartości (liczby, napisy, itd.), poprzez ''instrukcję podstawienia''. Do zapisu instrukcji podstawienia służy znak równości (<tt>=</tt>), po jego lewej stronie stawiamy nazwę (zmiennej), po drugiej - ''wyrażenie'', np. literalną stałą, ale również może być to wyrażenie zbudowane ze stałych, operatorów (np. arytmetycznych), nazw zmiennych (reprezentujących w wyrażeniu związane z nimi aktualnie wartości), i szereg innych elementów które dopiero poznamy.

'''Do zapamiętania''': pojedynczy znak równości <tt>=</tt> w Pythonie (i wielu innych językach programowania) nie tworzy ''równania'', czyli stwierdzenia, że lewa strona jest równa prawej; tylko ''podstawienie'', a więc operację powodującą, że z nazwą stojącą po stronie lewej zostaje związana obliczona wartość wyrażenie stojącego po prawej. Zauważmy, że jest to operacja niesymetryczna (stron nie można bezkarne zamienić miejscami):

<source lang=python>
i = 0 # pierwsze użycie nazwy, w tym przypadku 'i', tworzy zmienną i wiąże z nią wartość
i = i + 2 # to jest legalne, i oznacza, że wartość związana z 'i' rośnie o 2
i + 2 = i # to jest błędne, po lewej stronie nie może stać wyrażenie złożone
</source>

Pojawienie się w wyrażeniu stojącym po prawej stronie podstawienia tej samej nazwy, która stoi po lewej stronie, nie tworzy jakiejkolwiek niejednoznaczności: zasadą jest, że ''wpierw'' obliczana jest wartość wyrażenia z prawej strony, z wykorzystaniem aktualnych wartości zmiennych, a ''potem'' następuje związanie nazwy zmiennej stojącej po lewej z wynikiem.

Zauważmy, że błędem byłoby użycie nazwy po raz pierwszy ''bez'' uprzedniego nadania jej wartości, np. w wyrażeniu arytmetycznym.

===Reguły tworzenia nazw===

Aktualnie reguły określające, co jest poprawną nazwą w Pythonie, dopuszczają użycie całkiem szerokiego podzbioru znaków Unicode i są dość trudne do opisania w zrozumiały sposób. Pomijając jednak taką możliwość, że ktoś zechce użyć w nazwie zmiennej znaków pisma Kanji lub perskiego, można w dużym uproszczeniu powiedzieć tak:

*nazwy można budować z liter (wielkich i małych), cyfr, i znaku podkreślenia (<tt>_</tt>)
*z zastrzeżeniem, że pierwszym znakiem nazwy nie może być cyfra
*litery wielkie i małe są rozróżniane, tak więc nazwy różniące się jedynie wielkością liter ''są różne''
*długość nazwy nie podlega ograniczeniu
*zabronione jest użycie jako nazwy któregokolwiek z tzw. słów zastrzeżonych, które mają specjalne znaczenie w składni języka Python.[https://docs.python.org/3/reference/lexical_analysis.html#keywords Tutaj można znaleźć ich wykaz].

W szczególności, nazwy (zmiennych i innych obiektów) mogą jak najbardziej zawierać litery właściwe dla języka polskiego (oraz dla innych języków). Z rozmaitych względów nie jest to jednak szczególnie rekomendowane, lepiej (przynajmniej na razie) ograniczyć się do liter podstawowego alfabetu łacińskiego.

Oprócz twardych reguł zawartych w definicji języka, w tworzeniu nazw programiści trzymają się na ogół pewnych konwencji - które nie są w żaden sposób egzekwowane przez interpreter, ale ułatwiają czytanie kodu — zwłaszcza, gdy się nim dzielimy z innymi:

*w nazwach zmiennych używamy małych liter (a nie wielkich)
*wielkie litery rezerwujemy dla nazw oznaczających wartości stałe, które nie mają prawa się zmienić w trakcie pracy programu
*staramy się, by nazwy coś znaczyły i ułatwiały zrozumienie kodu programu
*nie unikamy nazw składających się z dwóch lub nawet kilku słów; ponieważ spacja jako składnik nazwy nie jest dozwolona, zastępujemy ją znakiem podkreślenia
*unikamy jednak nazw przesadnie długich, a nazwy zmiennych, które są potrzebne jedynie "chwilowo" mogą wręcz być jednoliterowe
*nazwy zaczynające się od podkreślenia (<tt>_</tt>) mają pewne specjalne znaczenia i nie tworzymy takich nazw, chyba że całkiem świadomie.

=Wyrażenia=

==Arytmetyczne==

Wyrażenia arytmetyczne tworzymy z udziałem znanych już operatorów arytmetycznych <tt>+, -, /, *, **, //, %, ...</tt>, ale również wywołań funkcji zwracających wartości liczbowe (więcej o tym dalej), z wykorzystaniem literalnych liczb i nazw oznaczających zmienne, których aktualne wartości powinny być liczbami. Możemy również używać nawiasów (wyłącznie okrągłych!) do grupowania podwyrażeń, aby wymusić określoną kolejność operacji. Każdy na ogół pamięta, że dzielenie i mnożenie mają pierwszeństwo przed dodawaniem i odejmowaniem; potęgowanie ma jeszcze wyższy priorytet. Gdy mamy do czynienia z operatorami o równym priorytecie, to operacje wykonywane są zgodnie z kolejnością czytania, od lewej do prawej. Jeżeli mamy wątpliwości, to użycie nawiasów nie będzie błędem. Przykłady:

<source lang=python>
a + b * c == a + (b * c)
a / b / c == (a / b) / c
a * b ** c == a * (b ** c)
a ** b ** c == a ** (b ** c)
a ** - b == a ** (-b)
a ** b / c == (a ** b) / c
</source>

Zachowanie operatora potęgowania jest tu nieco szczególne, i zgadza się z umową przyjętą w matematyce.

Operatory arytmetyczne znajdują również czasem zastosowanie do obiektów nie będących liczbami, mają wtedy oczywiście nieco inne znaczenie. Np. suma dwóch napisów jest ich sklejeniem (mówi się też: ''konkatenacją'').

W przypadku, gdy będziemy mieszać w jednym wyrażeniu liczby całkowite i zmiennoprzecinkowe, to wynik będzie liczbą zmiennoprzecinkową. Wyjątkiem jest dzielenie: <tt>a / b</tt> zawsze da w wyniku liczbę zmiennoprzecinkową, natomiast <tt>a // b</tt> - całkowitą, jeśli oba argumenty są całkowite; w przeciwnym razie, zmiennoprzecinkową (ale o zerowej części ułamkowej).

===Rozszerzone operatory przypisania===

Z dwuargumentowymi operatorami arytmetycznymi związane są tzw. ''rozszerzone operatory przypisania'', stanowiące drobne udogodnienie pozwalające w sposób bardziej zwięzły zapisać dość często występujące operacje - takie, jak powiększenie aktualnej wartości <tt>x</tt> o 1 i zapamiętanie tej nowej, powiększonej wartości pod nazwą <tt>x</tt>:

<source lang=python>
# poniższe instrukcje są parami równoważne
x = x + a
x += a
#
x = x * a
x *= a
#
x = x - a
x -= a
#
x = x / a
x /= a
#
x **= a
x = x**a
</source>

Wersja np. z potęgowaniem może jest niezbyt często przydatna, ale wprowadzono ją choćby po to, by było konsekwentnie.

==Logiczne==

Wyrażenia logiczne mogą mieć jedną z dwu wartości: Prawda (<tt>True</tt>) lub Fałsz (<tt>False</tt>). Literalne wartości <tt>True</tt> i <tt>False</tt> są też przykładami wyrażeń logicznych, choć dość mało przydatnymi. Prawdziwe lub fałszywe mogą być np. porównania dwóch wartości, tworzone za pomocą operatorów <tt>></tt>, <tt><</tt>, <tt>>=</tt>, <tt><=</tt>, <tt>==</tt>, <tt>!=</tt> (to ostatnie, to sposób w jaki w Pythonie pisze się znak nierówności). Jak już wspomniano, podwojony znak równości jest operatorem porównania (w odróżnieniu od pojedynczego - przypisania). Porównywać można przede wszystkim liczby (a więc - dowolne wyrażenia o wartościach liczbowych), ale również np. napisy - wówczas większy oznacza tyle, co dalszy w porządku leksykograficznym. Porównania mają priorytet niższy, niż operatory arytmetyczne.

<blockquote>
Przy bliższym poznaniu okazuje się, że wartości <tt>True</tt> i <tt>False</tt> są tak naprawdę w pewnym sensie liczbami: odpowiednio 1 i 0. Dozwolone jest więc np. stosowanie do nich operacji arytmetycznych.
</blockquote>

Z elementarnych wyrażeń logicznych (porównań) można tworzyć złożone wyrażenia logiczne za pomocą operatorów (spójników) logicznych, pisanych <tt>and</tt>, <tt>or</tt> i <tt>not</tt>. Mają one następujące właśności:

<source lang=python>
(a and b) == (b and a)
(False and False) == False
(False and True) == False
(True and True) == True
(a or b) == (b or a)
(False or False) == False
(False or True) == True
(True or True) == True
(not True) == False
(not False) == True
</source>

Spójniki logiczne mają priorytet jeszcze niższy, niż porównania - stąd nawiasy w powyższym. Wśród nich najwyższy priorytet ma <tt>not</tt>, następnie <tt>and</tt>, na końcu <tt>or</tt>.

Wyrażenia logiczne mają tę szczególną własność, że wartość wyrażenia można często określić obliczając jedynie część jego elementów. Np. <tt>a and b</tt>, jeżeli wartością <tt>a</tt> jest <tt>False</tt>, jest na pewno <tt>False</tt> - niezależnie od wartości <tt>b</tt>. W takich przypadkach Python przerywa obliczanie (od prawej do lewej, z uwzględnieniem nawiasów) gdy tylko wartość jest określona. Fakt ten czasami może mieć znaczenie - jeżeli np. obliczenie któregoś z członów wyrażenia logicznego jest szczególnie czasochłonne, lub ma tzw. skutki uboczne.

Wyrażenia logiczne znajdują zastosowanie przede wszystkim w instrukcji warunkowej - pozwalają określić warunki, pod jakimi pewne operacje będą wykonane, lub nie - o tym dalej.

Warto wiedzieć, że w Pythonie '''każde wyrażenie może służyć jako wyrażenie logiczne'''. Inaczej mówiąc, każda wartość (napis, liczba, lista, itd.) może być wykorzystana w charakterze wartości logicznej. Obowiązują tu proste reguły:

* liczba <tt>0</tt> jest fałszywa (równoważna <tt>False</tt>); obojętne, czy całkowita czy zmiennoprzecinkowa;
* każda liczba różna od zera jest prawdziwa (równoważna <tt>True</tt>);
* napis pusty (o długości 0) jest fałszywy, każdy inny napis jest prawdziwy (również np. zawierający wyłącznie spacje);
* ogólniej — dowolnego typu kolekcja (lista, słownik, zbiór, ...) jest prawdziwa, o ile jest niepusta; każda kolekcja pusta (0-elementowa) jest fałszywa;
* wartość pusta czyli <tt>None</tt> jest, jak nietrudno zgadnąć, fałszywa.

W przypadku ogólniejszych typów danych (obiektów klas złożonych) sytuacja może już nie być taka prosta, ponieważ twórca klasy ma moc określenia reguły decydującej o prawdziwości / nieprawdziwości obiektów danej klasy. Ten temat jest na razie poza zakresem naszego kursu.

Jeżeli chcemy wymusić, aby dana wartość stała się dosłownie wartością logiczną, tzn. jedną z (<tt>True</tt>, <tt>False</tt>) w sposób zgodny z powyższymi regułami, można to osiągnąć przykładając funkcję <tt>bool</tt>: a więc <tt>bool(wyrażenie)</tt>. Rzadko jednak bywa to potrzebne.

Reguła „skrótowej" ewaluacji wyrażeń logicznych, w połączeniu z regułami prawdziwości innych typów danych, pozwala na dość popularne idiomy, jak np.:

<source lang=python>
# jeśli `wynik' jest niepustą listą to wypisze jej zawartość
# jeśli natomiast pustą, pojawi się komunikat
print(wynik or "wynik jest pusty!")
</source>

które pozwalają uniknąć używania instrukcji złożonych w wielu prostych przypadkach. Działa to dzięki temu, że spójniki <tt>and</tt> i <tt>or</tt> nie wymuszają aby wynik był wartością logiczną:

* jeżeli <tt>a</tt> jest prawdziwe, to <tt>a or b == a</tt>, i <tt>a and b == b</tt> dla każdego <tt>b</tt>;
* jeżeli <tt>a</tt> jest fałszywe, to <tt>a and b == a</tt>, i <tt>a or b == b</tt> dla każdego <tt>b</tt>.

Inaczej w przypadku operatora <tt>not</tt>: wynikiem jego działania jest zawsze jedna z wartości logicznych, podobnie jak w przypadku funkcji <tt>bool()</tt> — tyle, że przeciwna.

==Napisowe==

Wartością wyrażenia może być również napis. Na przykład, <tt>a + b</tt>, jeżeli <tt>a</tt> i <tt>b</tt> są napisami, jest napisem utworzonym przez ich sklejenie (zauważmy, że w odróżnieniu od dodawania liczb nie jest to operacja przemienna).

<blockquote>
Wcześniej wspomniano, że dwa napisy literalne postawione obok siebie zostaną automatycznie sklejone w jeden: np. <tt>'abc' "123"</tt> jest równoważne <tt>'abc123'</tt>. Nie stosuje się to jednak np. do zmiennych o wartościach napisowych: napisanie dwóch nazw obok siebie bez operatora pomiędzy nimi jest błędem składniowym. Jest tak, ponieważ wspomniane sklejenie napisów literalnych ma miejsce na etapie ''kompilacji'' kodu - tzn. wtedy, gdy interpreter analizuje zapis programu i przekłada go na instrukcje, jakie zostaną wykonane w etapie uruchomienia - a wartości stojące za nazwami zmiennych nie są na tym etapie jednoznacznie określone.
</blockquote>

Bogatszy repertuar operacji tworzących wyrażenia o wartościach będących napisami poznamy dalej.

==Inne wyrażenia==

Oprócz liczb, napisów i wartości logicznych, Python posiada szereg dalszych, złożonych typów danych, które również mogą być wartościami wyrażeń. Każdy typ obiektu w Pythonie może być wartością odpowiednio zbudowanego wyrażenia. Gdy poznamy kolejne typy danych, wprowadzimy również operacje tworzące takie wyrażenia.

=Ćwiczenia=

1. Które z następujących są poprawnymi nazwami według reguł Pythona:
nazwa1
9sił
dluga-nazwa
wykonaj_rachunki
_
to&owo
if

2. Wykazać, że poniższe równości są równoważnościami -- tzn. że zachodzą dla dowolnej kombinacji wartości <tt>a</tt> i <tt>b</tt>:

not (a or b) == not a and not b
not (a and b) == not a or not b
a or not a == True

''Wskazówka:'' stworzyć tabelki wartości wyrażeń po lewej i prawej stronie operatora porównania <tt>==</tt> dla wszystkich możliwych kombinacji wartości <tt>a</tt> i <tt>b</tt>.

3. Które z poniższych równości są tożsamościami, w wyniku działania reguł pierwszeństwa operatorów?

a / b / c == a / (b / c)
a ** b / c == (a ** b) / c
-a ** b == (-a) ** b

''CDN...''

----

[[PPy3/PierwszeKroki|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/InstrukcjaWarunkowa|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:22, 21 cze 2016 (CEST)

PPy3/PierwszeKroki

2022-07-29T11:18:43Z

RobertJB: /* Podstawowe cegiełki */

= Pierwsze kroki =

==Podstawowe cegiełki==

*Program w Pythonie to tekst, stanowiący ciąg instrukcji; są one wykonywane przez ''interpreter'' (zasadniczo) kolejno jedna po drugiej.
*''Prosta'' instrukcja to (zasadniczo) jedna linijka, kończy się wraz z przejściem do kolejnej linii.
*Instrukcja złożona, to linijka otwierająca '''zawsze zakończona dwukropkiem''', a po niej - '''blok wcięty''', tj. ciąg instrukcji (prostych i/lub złożonych) pisanych z dodatkowym ''wcięciem'' w stosunku do linijki otwierającej; mogą to być dodatkowe (np. dwie lub cztery) spacje, lub kod tabulacji, na początku każdej linijki. Koniec instrukcji złożonej następuje wraz z powrotem do poprzedniego ''poziomu wcięcia''.
*W tekście programu można umieszczać komentarze; komentarz zaczyna się od znaku <tt>#</tt>, a kończy się wraz z końcem bieżącej linii. Komentarze nie są częścią programu, tzn. są ignorowane przy jego wykonaniu.

<blockquote>
*Wyjątki od podanych reguł, istnienie których sygnalizuje słowo ''zasadniczo'', będą przedstawione później.
*Należy się raz zdecydować, jak dokładnie będziemy tworzyć poziomy wcięcia, i konsekwentnie się tego trzymać. Najlepiej po dwie lub cztery spacje (wg. upodobań), i ustawić w opcjach edytora kodu, żeby wciśnięcie klawisza ''Tab'' skutkowało odpowiednią liczbą spacji. Mieszanie w tekście kodu spacji i tabulacji zawsze prowadzi do kłopotów.
</blockquote>

Przykłady instrukcji prostych:

<source lang=python>
x = 1 + 2
y = 2 * x
x = x + 1
print(x, y)
</source>

Przykłady instrukcji złożonych:

<source lang=python>
if x > 0:
print(x)

def dodaj1(x):
return x + 1
</source>

Ważnym elementem są komentarze:

<source lang=python>
# a teraz, powiększę x o 1
x = x + 1
</source>

*Instrukcje budowane są z wyrażeń, a wyrażenia - z nazw, stałych i operatorów.
*'''Nazwa''' może składać się z liter, cyfr i znaku podkreślenia (_). Nie może zaczynać się od cyfry. Litery małe i wielkie są rozróżniane.
*Przykładem stałych są liczby - całkowite i ułamki dziesiętne. Zamiast przecinkiem, część ułamkową oddziela się kropką.
*Inny rodzaj stałych to napisy. Można je budować na kilka sposobów:

<source lang=python>
'to jest napis'
"to jest drugi napis"
'''a to jest...
jeszcze jeden napis'''
</source>

*Ostatni przypadek to wyjątek od zasady że koniec linii kończy instrukcję. Napis podany w pierwszych dwóch postaciach nie może zawierać przejścia do nowej linii.
*Nazwy są po to, aby oznaczać nimi wartości. Wartościami mogą być np. liczby i napisy:

<source lang=python>
pi = 3.14159
komunikat = 'Uwaga!!!'
</source>

'''UWAGA:''' znak równości to nie porównanie, a ''operator przypisania''. Powoduje on, że nazwa po jego lewej stronie będzie odtąd oznaczać wartość zapisaną po prawej. W szczególności, po lewej stronie znaku równości nie może występować np. stała liczba.

*Więcej o stałych i nazwach na następnej stronie, na razie tyle nam wystarczy.
*Inne operatory, to w szczególności arytmetyka:

<source lang=python>
+ - * / // % **
</source>

'*' to mnożenie, '//' to dzielenie całkowitoliczbowe, '%' to reszta z dzielenia (liczb całkowitych), '**' to potęgowanie.

*Napisy też można "dodawać":

<source lang=python>
imie = 'Jacek'
powitanie = 'witaj ' + imie
print(powitanie)
</source>

Czemu właściwie operację ,,sklejania" napisów oznaczono plusem? W matematyce zazwyczaj plus stosuje się na oznaczenie operacji przemiennych, tzn. takich, których wynik nie zależy od kolejności składników — a sklejanie napisów ewidentnie taką operacją nie jest. Ale cóż, tak się przyjęło.

==Używanie linii poleceń interpretera==

''Interpreter'' to aplikacja, która potrafi czytać tekst kodu w języku Python i wykonać zapisane w nim polecenia. Może on być używany jako samodzielne polecenie, wywoływane w oknie terminala, lub zintegrowany z środowiskiem programistycznym w rodzaju ''Spyder''.

Zanim zaczniemy pisać "poważne" programy, nauczymy się korzystać z ''trybu interaktywnego'' interpretera, który pozwala na wpisywanie po jednym poleceniu i natychmiastowe uzyskanie wyniku jego wykonania. Można go używać do podręcznych rachunków - zamiast kalkulatora -- i do eksperymentowania z kodem w Pythonie. Do pracy interaktywnej warto używać "wzbogaconej" wersji interpretera, wywoływanej poleceniem

<source lang=bash>
$ ipython3
</source>

w najprostszych zastosowaniach niewiele się on różni od "zwykłego" interpretera, wywoływanego przez <tt>python3</tt>, ale posiada pewne dodatkowe możliwości, które niedługo się nam przydadzą.

<blockquote>
'''UWAGA:''' polecenie <tt>ipython</tt> (bez 3) wywoła starszą wersję Pythona. I odpowiednio - <tt>python</tt> wywołuje starszą wersję "zwykłego" interpretera, a <tt>python3</tt> - wersję aktualną.
</blockquote>

===Wykonywanie rachunków===

<source lang=python>
$ ipython3
Python 3.5.1+ (default, Mar 30 2016, 22:46:26)
Type "copyright", "credits" or "license" for more information.

IPython 2.4.1 -- An enhanced Interactive Python.
? -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help -> Python's own help system.
object? -> Details about 'object', use 'object??' for extra details.

In [1]: 7 * (3 + 5)
Out[1]: 56

In [2]: 2.81 / (1.25 - .33)
Out[2]: 3.054347826086957

In [3]: 2**128
Out[3]: 340282366920938463463374607431768211456

In [4]: 1/9
Out[4]: 0.1111111111111111

In [5]: 11//9, 11%9
Out[5]: (1, 2)
</source>

Zapis wyrażeń arytmetycznych raczej nie zaskakuje. Drobne uwagi:

*spacje w zapisie wyrażenia, pomiędzy liczbami a operatorami (lub ich brak), nie mają znaczenia
*reguły pierwszeństwa operatorów (najpierw potęgowanie, potem mnożenie i dzielenie, potem odejmowanie i dodawanie,...) są w zasadzie takie, jak należy się spodziewać; kolejność operacji możemy narzucić nawiasami - ale tylko okrągłymi, które można wielokrotnie zagnieżdżać
*pisząc ułamek dziesiętny (liczbę z kropką), można pominąć część całkowitą lub ułamkową, o ile ma ona być zero (nie można jednak pominąć obu);
*liczby całkowite mogą być dowolnie duże (w ramach fizycznych ograniczeń komputera)
*operacje na ułamkach należy zawsze traktować jako przybliżone - komputer może ogarnąć tylko skończoną liczbę cyfr
*zwykłe dzielenie da zawsze wynik ułamkowy; istnieje jednak operator <tt>//</tt> dzielenia całkowitego
*gdy chcemy zakończyć "rozmowę" z interpreterem, piszemy <tt>exit()</tt>; jeżeli pracujemy w Linuxie, zadziała również dwukrotne <tt>Ctrl-D</tt> (tzn. trzymając naciśnięty klawisz <tt>Ctrl</tt> stukamy dwukrotnie w klawisz <tt>D</tt>)

==Jak uzyskać pomoc==

W programie IPython mamy w każdej chwili dostęp do pomocy na temat poleceń, funkcji itd. Pythona:

<source lang=python>
In [8]: print?
Type: builtin_function_or_method
String form: <built-in function print>
Namespace: Python builtin
Docstring:
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
</source>

W tym przykładzie uzyskaliśmy szczegółowy opis zastosowania funkcji wbudowanej <tt>print</tt>. Wprawdzie po angielsku, ale mam nadzieję, że nie jest to przeszkoda nie do przeskoczenia. Już niedługo będziemy dokładnie rozumieli to, co jest tu napisane.

<blockquote>
Jeżeli tekst pomocy jest dłuższy, to będzie wyświetlany w trybie pozwalającym m. in. na jego przewijanie z użyciem klawiszy strzałek czy <tt>PgUp</tt>, <tt>PgDn</tt>. Aby wyjść z tego trybu i powrócić do interpretera, wystarczy nacisnąć <tt>q</tt>.
</blockquote>

==Najprostszy program==

Za pomocą ulubionego edytora tekstowego stwórzmy plik o nazwie <tt>hello.py</tt> i następującej treści:

<source lang=python>
#! /usr/bin/python3

print('Witaj świecie!')

</source>

Zgodnie z tradycją, będzie to program wykonujący jedno banalne zadanie: wypisanie komunikatu o ustalonej treści. Zgodnie z zasadą, że programowanie w Pythonie ma być maksymalnie proste - jedynym niezbędnym elementem tego programu jest linijka wywołująca funkcję <tt>print</tt>. W tym przykładzie, uzupełniłem treść programu o pierwszą linijkę, zaczynającą się od znaku kratki (<tt>#</tt>) - istotne jest, aby była to dokładnie pierwsza linijka w pliku, i by zaczynała się od pierwszej pozycji w wierszu. Czyli, aby <tt>#!</tt> były dokładnie dwoma pierwszymi znakami w treści pliku. Z punktu widzenia Pythona, linijka ta jest komentarzem, i przy uruchamianiu pliku jest ignorowana. Pozwala ona jednak, by plik ten był automatycznie rozpoznawany przez system operacyjny (Linux) jako zawierający program w języku Python. Jaki z tego pożytek, dowiemy się za chwilę.

Aby ten program uruchomić, jest parę sposobów. Najprościej:

<source lang=bash>
$ python3 hello.py
</source>

powyższe polecenie wpisujemy w terminalu, w trybie powłoki systemowej (''nie w programie IPython!''). Tutaj musieliśmy jawnie wywołać interpreter Pythona i wskazać mu plik <tt>hello.py</tt> jako zawierający kod do uruchomienia.

Zamiast tego, możemy nadać plikowi <tt>hello.py</tt> atrybut pliku wykonywalnego, czyli programu, i uruchomić go bezpośrednio:

<source lang=bash>
$ chmod +x hello.py
$ ./hello.py
</source>

*Polecenie z pierwszej linijki wystarczy wykonać raz dla danego pliku
*Zamiast z linii poleceń, można w okienku ''Właściwości'' pliku znaleźć odpowiednie pole do kliknięcia
*Postać drugiej linijki tłumaczy się tym, że nasz program <tt>hello.py</tt> nie jest zainstalowany w systemie i nie zostanie odnaleziony przez przeszukanie standardowych lokalizacji programów na dysku. Należy wyraźnie wskazać, że chodzi o plik znajdujący się w bieżącym folderze - i to tu robimy.
*Plik z kodem w Pythonie nie musi mieć nazwy kończącej się na <tt>.py</tt> - jest to jednak wygodne, bo np. edytory tekstu traktują to jako sugestię co do zawartości pliku, i mogą dostosować do tego swoje działanie (np. <tt>gedit</tt>)

==Ćwiczenia==

===Rachunki w linii poleceń===

#Ile wynosi reszta z dzielenia 2999 przez 7?
#Która z tych liczb mniej się różni od pierwiastka kwadratowego z 2: 721/510 czy 722/510?
#Oblicz pierwiastek kwadratowy z 2, a następnie - podnieś go do kwadratu; ile wynosi względny błąd wyniku?

''CDN''

----

[[PPy3/Wprowadzenie|poprzednia]] | [["Programowanie z Pythonem3"|Strona główna]] | [[PPy3/StałeIZmienne|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 13:53, 15 cze 2016 (CEST)

"Programowanie z Pythonem3"

2022-07-27T13:12:22Z

RobertJB: /* Semestr zimowy 2021/2022 */

[[Grafika:Python-logo.png]]

[[Category:Informatyka]]
== Semestr zimowy 2022/2023 ==

'''''W trakcie opracowania'''''

===Uwagi ogólne===

W pracowniach OKWF zainstalowane są zarówno stara wersja Pythona (2.7), jak i aktualna (3.x). Aktualnie polecenie <tt>python</tt> uruchamia wersję 2.7; w celu uruchomienia wersji 3 należy pisać <tt>python3</tt>. Analogicznie, istnieją wywołania <tt>ipython3</tt> oraz <tt>spyder3</tt>.

Zasady zaliczenia ćwiczeń w roku 2022/2023:

* maksymalnie można zdobyć 40 punktów
* w semestrze będą dwa kolokwia, w połowie i pod koniec; na każdym można zdobyć po 15 punktów
* w sesji będzie kolokwium dodatkowe, dla chętnych; wynik z niego (maks. 15 punktów) zastępuje gorszy z wyników kolokwiów z semestru, o ile jest on od niego lepszy
* maksymalnie 10 punktów przydziela prowadzący na podstawie zadań domowych i aktywności na ćwiczeniach
* zaliczenie ćwiczeń na pozytywną ocenę wymaga co najmniej 50% punktów (20 p.)
* ocena rośnie o pół stopnia z osiągnięciem progu każdych kolejnych 10%, tj. 4 punktów.

Obecność na ćwiczeniach jest obowiązkowa. Dopuszczalne są '''dwie''' nieobecności nieusprawiedliwione w semestrze. '''Za każdą kolejną nieobecność nieusprawiedliwioną powyżej dwóch odejmujemy od wyniku 5 punktów.'''

Ocena końcowa z przedmiotu składa się z oceny z ćwiczeń, oraz z oceny z egzaminu testowego kończącego wykład, w proporcji 3:2 - z tym, że '''obie te oceny cząstkowe muszą być pozytywne''' aby ocena z całości była pozytywna.

===Spis treści===

#[[PPy3/Wprowadzenie|Wprowadzenie]]
#[[PPy3/PierwszeKroki|Pierwsze kroki]]
#[[PPy3/StałeIZmienne|Stałe i zmienne]]
#[[PPy3/InstrukcjaWarunkowa|Instrukcja warunkowa]]
#[[PPy3/SekwencjeIIteracja|Sekwencje i iteracja]]
#[[PPy3/Funkcje|Funkcje]]
#[[PPy3/Kolekcje|Kolekcje]]
#[[PPy3/Moduły|Moduły i biblioteki]]
#[[PPy3/WejścieWyjście|Obsługa wejścia i wyjścia]]
#[[PPy3/NumPy|NumPy]] - rachunki numeryczne na tablicach liczb
#[[PPy3/Matplotlib|Matplotlib]] - wizualizacja danych
#[[PPy3/TematyDodatkowe|Tematy dodatkowe]] - uzupełnienie
#[[PPy3/DobrePraktyki|Zasady dobrej praktyki]]

===O skrypcie===

Opracowane na nowo przez [[Użytkownik:RobertJB|RobertJB]], częściowo z wykorzystaniem [["Programowanie z Pythonem"|poprzedniej wersji]].

PPy3/Wprowadzenie

2021-10-05T18:42:57Z

RobertJB: /* Instalacja */ WSL

==Wprowadzenie==

Aby komputer wykonał za nas jakąś pracę, musimy mu przekazać dość precyzyjne instrukcje, mówiące co ma zrobić. Taki zestaw instrukcji nazywa się ''programem'', a proces tworzenia programów - to ''programowanie''. Stworzenie programu wymaga wykonania dwóch zasadniczych zadań:

#wymyślenia algorytmu
#zapisania tegoż algorytmu w sposób możliwy do zinterpretowania przez komputer - a więc w jakimś języku programowania.

Podczas opracowywania algorytmu musimy zastanowić się, jak dojdziemy do poszukiwanego rozwiązania. W jaki sposób z posiadanych danych wejściowych uzyskać możemy oczekiwany wynik? Jakie operacje po drodze muszę wykonać? Ile razy? Co po drodze muszę wiedzieć, a co dodatkowo sprawdzić? Jeśli wiemy już, jakie niezbędne etapy obliczeń musimy wykonać możemy przejść do fazy drugiej, czyli pisania właściwego programu.

Programy piszemy używając specjalnych języków stworzonych do komunikacji z komputerami. Zawierają one pewien zestaw słów — poleceń, które komputer może wykonać. Wybór konkretnego języka może zależeć od rozwiązywanego problemu, ale w wielu wypadkach jest sprawą drugorzędną. Ponieważ, tak jak w przypadku języków obcych, aby porozumieć się z cudzoziemcem musimy nauczyć się obcego języka, tak i tu musimy nauczyć się wybranego języka (języków) programowania.

Dlaczego uczymy się programować akurat w języku Python?

*Jest jednym z najłatwiejszych do opanowania języków programowania, i najbardziej czytelnych dla człowieka.
*Jest narzędziem dojrzałym, rozwijanym od wielu lat i dobrze sprawdzonym.
*Zawiera jako standardowe wyposażenie wiele gotowych rozwiązań, które można wykorzystać jako elementy własnych programów.
*Jest coraz szerzej wykorzystywany do zadań naukowych.
*Jest dostępny bezpłatnie i bez uciążliwych ograniczeń licencyjnych na wiele różnych platform - systemów operacyjnych.

Na początku nauczymy się podstaw języka, aby móc zacząć pisać i uruchamiać pierwsze, na razie proste programy. Następnie przećwiczymy rozwiązywanie rozmaitych zagadnień, wymyślając do tego odpowiednie algorytmy i zapisując je w postaci programów w Pythonie.

<blockquote>
Pracując z komputerem tak jak sekretarz czy księgowy, nie potrzeba w zasadzie nic wiedzieć o programowaniu i wewnętrznym działaniu komputera. Tak jak kurs nauki jazdy nie uczy, jak projektować konstrukcje samochodów, ani nawet jak je naprawiać. Założeniem studiów na fizyce jest jednak przygotowanie absolwenta, który będzie umiał sobie radzić z nowymi zadaniami i rozwiązywać problemy, a nie jedynie wykonywać pewne procedury. Elementarna umiejętność programowania jest jednym z narzędzi do tego celu.
</blockquote>

===Instalacja===

W systemach z rodziny '''Linux''' Python należy do wyposażenie standardowego. Niewykluczone, że dla celów drugiej części kursu będzie potrzeba doinstalowania opcjonalnych składników środowiska Python, m. in. narzędzi do obliczeń numerycznych i wizualizacji danych (tj. wykresów, itp.). Oczywiście na pracowniach dydaktycznych zostało to już za nas wykonane.

Dla systemów z rodziny '''Windows''' możemy np. skorzystać z [https://docs.microsoft.com/en-us/windows/python/beginners dystrybucji] dostępnej ze "sklepu" Microsoft, lub z [https://www.python.org/downloads/windows/ pakietów] dostępnych z oficjalnych stron projektu Python. Dla bardziej zaawansowanych użytkowników, którzy jednak nie chcą opuszczać środowiska Windows, ciekawym rozwiązaniem może być [https://docs.microsoft.com/en-us/windows/wsl/install WSL] — emulacja środowiska Linux wewnątrz Windows.

W systemie '''MacOS''' Python dostępny jest domyślnie, preinstalowana wersja może być jednak niepełna i/lub przestarzała. Pakiety instalacyjne Pythona dostępne są np. [https://www.python.org/downloads/macos/ tu].

===Ogólnie o pracy z komputerem===

Tu jest właściwy moment, aby zapoznać się (o ile jest to komuś obce) z kilkoma podstawowymi faktami dotyczącymi
,,zaawansowanej" pracy z komputerem, a nie dotyczącymi samego Pythona — w tym:

*logiczna organizacja danych na dysku; foldery (katalogi), podfoldery
*prawa dostępu do plików i folderów
*pliki tekstowe i jak je edytować
*co to jest terminal i powłoka systemowa (''shell'')
*co to jest katalog bieżący; podstawowe operacje na plikach w linii poleceń (''ls'', ''pwd'', ''cd'', ''cp'', ''mv'', ''rm'', ...)
*jak uruchomić program w linii poleceń; ścieżka wyszukiwania

----
[["Programowanie_z_Pythonem3"|Strona główna]] | [[PPy3/PierwszeKroki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 13:16, 29 wrz 2017 (CEST)

PPy3/Wprowadzenie

2021-10-05T18:39:43Z

RobertJB: /* Instalacja */ wywaliłem nieaktualne linki. Początkującym lepiej jednak nie polecać Anacondy.

==Wprowadzenie==

Aby komputer wykonał za nas jakąś pracę, musimy mu przekazać dość precyzyjne instrukcje, mówiące co ma zrobić. Taki zestaw instrukcji nazywa się ''programem'', a proces tworzenia programów - to ''programowanie''. Stworzenie programu wymaga wykonania dwóch zasadniczych zadań:

#wymyślenia algorytmu
#zapisania tegoż algorytmu w sposób możliwy do zinterpretowania przez komputer - a więc w jakimś języku programowania.

Podczas opracowywania algorytmu musimy zastanowić się, jak dojdziemy do poszukiwanego rozwiązania. W jaki sposób z posiadanych danych wejściowych uzyskać możemy oczekiwany wynik? Jakie operacje po drodze muszę wykonać? Ile razy? Co po drodze muszę wiedzieć, a co dodatkowo sprawdzić? Jeśli wiemy już, jakie niezbędne etapy obliczeń musimy wykonać możemy przejść do fazy drugiej, czyli pisania właściwego programu.

Programy piszemy używając specjalnych języków stworzonych do komunikacji z komputerami. Zawierają one pewien zestaw słów — poleceń, które komputer może wykonać. Wybór konkretnego języka może zależeć od rozwiązywanego problemu, ale w wielu wypadkach jest sprawą drugorzędną. Ponieważ, tak jak w przypadku języków obcych, aby porozumieć się z cudzoziemcem musimy nauczyć się obcego języka, tak i tu musimy nauczyć się wybranego języka (języków) programowania.

Dlaczego uczymy się programować akurat w języku Python?

*Jest jednym z najłatwiejszych do opanowania języków programowania, i najbardziej czytelnych dla człowieka.
*Jest narzędziem dojrzałym, rozwijanym od wielu lat i dobrze sprawdzonym.
*Zawiera jako standardowe wyposażenie wiele gotowych rozwiązań, które można wykorzystać jako elementy własnych programów.
*Jest coraz szerzej wykorzystywany do zadań naukowych.
*Jest dostępny bezpłatnie i bez uciążliwych ograniczeń licencyjnych na wiele różnych platform - systemów operacyjnych.

Na początku nauczymy się podstaw języka, aby móc zacząć pisać i uruchamiać pierwsze, na razie proste programy. Następnie przećwiczymy rozwiązywanie rozmaitych zagadnień, wymyślając do tego odpowiednie algorytmy i zapisując je w postaci programów w Pythonie.

<blockquote>
Pracując z komputerem tak jak sekretarz czy księgowy, nie potrzeba w zasadzie nic wiedzieć o programowaniu i wewnętrznym działaniu komputera. Tak jak kurs nauki jazdy nie uczy, jak projektować konstrukcje samochodów, ani nawet jak je naprawiać. Założeniem studiów na fizyce jest jednak przygotowanie absolwenta, który będzie umiał sobie radzić z nowymi zadaniami i rozwiązywać problemy, a nie jedynie wykonywać pewne procedury. Elementarna umiejętność programowania jest jednym z narzędzi do tego celu.
</blockquote>

===Instalacja===

W systemach z rodziny '''Linux''' Python należy do wyposażenie standardowego. Niewykluczone, że dla celów drugiej części kursu będzie potrzeba doinstalowania opcjonalnych składników środowiska Python, m. in. narzędzi do obliczeń numerycznych i wizualizacji danych (tj. wykresów, itp.). Oczywiście na pracowniach dydaktycznych zostało to już za nas wykonane.

Dla systemów z rodziny '''Windows''' możemy np. skorzystać z [https://docs.microsoft.com/en-us/windows/python/beginners dystrybucji] dostępnej ze "sklepu" Microsoft, lub z [https://www.python.org/downloads/windows/ pakietów] dostępnych z oficjalnych stron projektu Python.

W systemie '''MacOS''' Python dostępny jest domyślnie, preinstalowana wersja może być jednak niepełna i/lub przestarzała. Pakiety instalacyjne Pythona dostępne są np. [https://www.python.org/downloads/macos/ tu].

===Ogólnie o pracy z komputerem===

Tu jest właściwy moment, aby zapoznać się (o ile jest to komuś obce) z kilkoma podstawowymi faktami dotyczącymi
,,zaawansowanej" pracy z komputerem, a nie dotyczącymi samego Pythona — w tym:

*logiczna organizacja danych na dysku; foldery (katalogi), podfoldery
*prawa dostępu do plików i folderów
*pliki tekstowe i jak je edytować
*co to jest terminal i powłoka systemowa (''shell'')
*co to jest katalog bieżący; podstawowe operacje na plikach w linii poleceń (''ls'', ''pwd'', ''cd'', ''cp'', ''mv'', ''rm'', ...)
*jak uruchomić program w linii poleceń; ścieżka wyszukiwania

----
[["Programowanie_z_Pythonem3"|Strona główna]] | [[PPy3/PierwszeKroki|dalej]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 13:16, 29 wrz 2017 (CEST)

"Programowanie z Pythonem3"

2021-10-04T13:52:01Z

RobertJB: /* Uwagi ogólne */

[[Grafika:Python-logo.png]]

[[Category:Informatyka]]
== Semestr zimowy 2021/2022 ==

'''''W trakcie opracowania'''''

===Uwagi ogólne===

W pracowniach OKWF zainstalowane są zarówno stara wersja Pythona (2.7), jak i aktualna (3.x). Aktualnie polecenie <tt>python</tt> uruchamia wersję 2.7; w celu uruchomienia wersji 3 należy pisać <tt>python3</tt>. Analogicznie, istnieją wywołania <tt>ipython3</tt> oraz <tt>spyder3</tt>.

Zasady zaliczenia ćwiczeń w roku 2021/2022:

* maksymalnie można zdobyć 40 punktów
* w semestrze będą dwa kolokwia, w połowie i pod koniec; na każdym można zdobyć po 15 punktów
* w sesji będzie kolokwium dodatkowe, dla chętnych; wynik z niego (maks. 15 punktów) zastępuje gorszy z wyników kolokwiów z semestru, o ile jest on od niego lepszy
* maksymalnie 10 punktów przydziela prowadzący na podstawie zadań domowych i aktywności na ćwiczeniach
* zaliczenie ćwiczeń na pozytywną ocenę wymaga co najmniej 50% punktów (20 p.)
* ocena rośnie o pół stopnia z osiągnięciem progu każdych kolejnych 10%, tj. 4 punktów.

Obecność na ćwiczeniach jest obowiązkowa. Dopuszczalne są '''dwie''' nieobecności nieusprawiedliwione w semestrze. '''Za każdą kolejną nieobecność nieusprawiedliwioną powyżej dwóch odejmujemy od wyniku 5 punktów.'''

Ocena końcowa z przedmiotu składa się z oceny z ćwiczeń, oraz z oceny z egzaminu testowego kończącego wykład, w proporcji 3:2 - z tym, że '''obie te oceny cząstkowe muszą być pozytywne''' aby ocena z całości była pozytywna.

===Spis treści===

#[[PPy3/Wprowadzenie|Wprowadzenie]]
#[[PPy3/PierwszeKroki|Pierwsze kroki]]
#[[PPy3/StałeIZmienne|Stałe i zmienne]]
#[[PPy3/InstrukcjaWarunkowa|Instrukcja warunkowa]]
#[[PPy3/SekwencjeIIteracja|Sekwencje i iteracja]]
#[[PPy3/Funkcje|Funkcje]]
#[[PPy3/Kolekcje|Kolekcje]]
#[[PPy3/Moduły|Moduły i biblioteki]]
#[[PPy3/WejścieWyjście|Obsługa wejścia i wyjścia]]
#[[PPy3/NumPy|NumPy]] - rachunki numeryczne na tablicach liczb
#[[PPy3/Matplotlib|Matplotlib]] - wizualizacja danych
#[[PPy3/TematyDodatkowe|Tematy dodatkowe]] - uzupełnienie
#[[PPy3/DobrePraktyki|Zasady dobrej praktyki]]

===O skrypcie===

Opracowane na nowo przez [[Użytkownik:RobertJB|RobertJB]], częściowo z wykorzystaniem [["Programowanie z Pythonem"|poprzedniej wersji]].

Strona główna

2021-09-14T10:13:51Z

RobertJB: /* Informatyka: */

=Materiały dydaktycznie dla studentów kierunku [http://fizykaxxi.fuw.edu.pl/zastosowania-fizyki-w-biologii-i-medycynie/ Zastosowania Fizyki w Biologii i Medycynie]=

==Informatyka:==
[[Plik:Pętla_while.svg|175px|right]]
* Technologia Informacyjna:
** Wykład [["Technologia informacyjna"]]
** Wykład [[Slajdy z wykładów dla optyki okularowej z roku 2015|"Technologie cyfrowe"]] (dla specjalności Optyka Okularowa)
** Ćwiczenia [["Programowanie z Pythonem"]] (dla studentów Wydziału Fizyki) '''STARE'''
** Ćwiczenia [["Programowanie z Pythonem3"]] (dla studentów Wydziału Fizyki) '''od 2020/21'''
** Ćwiczenia [[dla studentów Wydziału Biologii|"Technologia informacyjna"]] (dla studentów Wydziału Biologii)
* Programowanie dla Neuroinformatyków:
** Ćwiczenia [["Programowanie dla Neuroinformatyków"]]
* Programowanie dla Fizyków Medycznych:
** Ćwiczenia [["Programowanie dla Fizyków Medycznych"]]
* Bazy danych:
** Wykład [[TI:WTBD|"Wstęp do technologii baz danych"]]
** Ćwiczenia [[TI:WTBD|"Wstęp do technologii baz danych"]]
* [[TI/Pracownia wykorzystania zasobów internetowych|Pracownia wykorzystania zasobów internetowych]]

==Matematyka:==
* Wykład [[Matematyka I - FMiN lecture|Matematyka I]] (dla specjalności Fizyka Medyczna i Neuroinformatyka)
** Ćwiczenia [[Matematyka I - FMiN exercises|Matematyka I]] (dla specjalności Fizyka Medyczna i Neuroinformatyka)
** Ćwiczenia [[Matematyka I - OO exercises|Matematyka I]] (dla specjalności Optyka Okularowa)
[[Plik:main_math.png|175px|right]]
* Wykład [[Matematyka II - FMiN lecture|Matematyka II]] (dla specjalności Fizyka Medyczna i Neuroinformatyka)
** Ćwiczenia [[Matematyka II - FMiN exercises|Matematyka II]] (dla specjalności Fizyka Medyczna i Neuroinformatyka)

==Fizyka:==
* Fizyka I:
** Wykład [[Fizyka I - FMiN lecture|Fizyka I]] - Mechanika (dla specjalności Fizyka Medyczna i Neuroinformatyka)
** Wykład [[Fizyka I - OO lecture|Fizyka I]] - Mechanika (dla specjalności Optyka Okularowa)
** Ćwiczenia [[Fizyka I - FMiN exercises|Fizyka I]] - Mechanika (dla specjalności Fizyka Medyczna i Neuroinformatyka)
* Fizyka II: [[Plik:main_phys.png|220px|right]]
** Wykład [[Fizyka II - OO lecture|Fizyka II]] - Elektrostatyka (dla specjalności Optyka Okularowa)
** Wykład [[Fizyka II - NI lecture|Fizyka II]] - Elektrostatyka (dla specjalności Fizyka Medyczna i Neuroinformatyka)
** Ćwiczenia [[Fizyka II - FMiN exercises|Fizyka II]] - Elektrostatyka (dla specjalności Fizyka Medyczna i Neuroinformatyka)
** Ćwiczenia [[Fizyka II - OO exercises|Fizyka II]] - Elektrostatyka (dla specjalności Optyka Okularowa)
* Fizyka III:
** Wykład [[Fizyka III - FMiN lecture|Fizyka III]] - Drgania i Fale (dla specjalności Fizyka Medyczna i Neuroinformatyka)
** Ćwiczenia [[Fizyka III - FMiN exercises|Fizyka III]] - Drgania i Fale (dla specjalności Fizyka Medyczna i Neuroinformatyka)
* Elektrodynamika:
** Ćwiczenia [[Ćwiczenia z elektrodynamiki dla neuroinformatyków|Elektrodynamika]] (dla specjalności Neuroinformatyka)
* Ćwiczenia [[Fizyka Promieniowania Jądrowego]]
* Ćwiczenia [[Fizyka atomów oraz cząstek i makrocząstek biologicznych]]

==Chemia:==
* Wykład [[Podstawy chemii z elementami biochemii]]
* Wykład [[Chemia ogólna - lecture|Chemia ogólna]]
* Pracownia [[Chemia ogólna - workshop|Chemia ogólna]]
* Wykład [[Chemia organiczna]]

==Biologia:==
[[Plik:main_biol.jpg|220px|right]]
* Wykład [[Biologia komórki]]
* Wykład [[Histologia]]
* Pracownia [[Biologia molekularna]]

==Biofizyka molekularna:==
* Wykład [[Metody Biofizyki Molekularnej - lecture|Metody Biofizyki Molekularnej]]
** Ćwiczenia [[Metody Biofizyki Molekularnej - exercises|Metody Biofizyki Molekularnej]]
*[[Pracownia podstaw biofizyki]] (dla specjalności Biofizyka molekularna)
* Pracownia [[Podstawy Biofizyki]]
* Pracownia [[Pracownia Biofizyki dla Zaawansowanych]]
*[[Pracownia biofizyki dla zaawansowanych]] (dla specjalności Biofizyka Molekularna)

== Przedmioty specjalizacyjne: ==
* Wykład [[Obrazowanie Medyczne]]

* Wykład [[Ochrona radiologiczna]]
* Wykład [[Ochrona radilogiczna 2]]

* Wykład [[Elektroencefalografia]]
* Wykład [[Wnioskowanie Statystyczne - lecture|Wnioskowanie Statystyczne]] [[Plik:main_eeg2.png|125px|right]]
** Ćwiczenia [[Wnioskowanie Statystyczne - exercises|Wnioskowanie Statystyczne]]
* Wykład [[Analiza sygnałów - lecture|Analiza sygnałów]] [[Plik:Logo_pelne_KNI.png|220px|right|link=https://pl-pl.facebook.com/KNNeuroinformatyki/]]
** Ćwiczenia [[Analiza sygnałów - exercises|Analiza sygnałów]]
* [[Uczenie maszynowe i sztuczne sieci neuronowe]]

* Warsztaty [[Metody diagnostyczne]]
* Warsztaty [[Warsztaty_z_Metod_Terapeutycznych|z Metod Terapeutycznych]] (dla specjalności Fizyka Medyczna)
* Warsztaty [[Modelowanie molekularne 2]]

== Pracownie specjalistyczne: ==
[[Plik:main_eeg1.jpg|220px|right]]
*[[INFORMACJE O OPROGRAMOWANIU DO PRACOWNI EEG i SYGNAŁÓW BIOELEKTRYCZNYCH]]
*[[Pracownia Sygnałów Bioelektrycznych]] (dla specjalności Neuroinformatyka)
*[[Pracownia EEG|Pracownia EEG]] (dla specjalności Neuroinformatyka)
*[[Laboratorium EEG|Laboratorium EEG]] (dla specjalności Neuroinformatyka)
*[[Nowe technologie w fizyce biomedycznej]] (dla specjalności Fizyka Medyczna i Neuroinformatyka)
*[[USG|Warsztaty z metod obrazowania ultradźwiękowego]]

== Inne: ==
[[Plik:Bookstack.svg|130px|right]]

* Pracownia [["Wykorzystanie zasobów internetowych"]]
* Proseminarium [[Proseminarium licencjackie|licencjackie]]

==Strony dodatkowe==
* [[Podręcznik użytkownika systemu do badań dostępnego w laboratorium EEG Wydziału Fizyki Uniwersytetu Warszawskiego]]: http://laboratorium-eeg.braintech.pl/ w tym:
** dokumentacja SVAROG: http://laboratorium-eeg.braintech.pl/svarog/index.html
** dokumentacja PSYCHOPY: http://laboratorium-eeg.braintech.pl/psychopy/index.html
** dokumentacja techniczna BCI framework: http://laboratorium-eeg.braintech.pl/openbci/
** dokumentacja i tutorial biblioteki ReadManager (Python, Matlab): http://moduly-analizy-danych.braintech.pl/

* [[Instalacja i konfiguracja Kinect, Wiimote i Eyetrackera]]
* Strona [http://www.fuw.edu.pl/biblioteki.html Biblioteki Wydziału Fizyki]
* Podręcznik dotyczący stosowania Jupyter notebook do prowadzenia zajęć dydaktycznych: https://jupyter4edu.github.io/jupyter-edu-book/notebooks-in-teaching-and-learning.html

* Podręcznik [https://wuw.pl/data/include/cms/Neurocybernetyka_teoretyczna_Tadeusiewicz_Ryszard_red_nauk_2009.pdf Neurocybernetyka Teoretyczna]

"Programowanie z Pythonem3"

2021-09-14T10:13:27Z

RobertJB: /* Uwagi ogólne */

[[Grafika:Python-logo.png]]

[[Category:Informatyka]]
== Semestr zimowy 2021/2022 ==

'''''W trakcie opracowania'''''

===Uwagi ogólne===

W pracowniach OKWF zainstalowane są zarówno stara wersja Pythona (2.7), jak i aktualna (3.x). Aktualnie polecenie <tt>python</tt> uruchamia wersję 2.7; w celu uruchomienia wersji 3 należy pisać <tt>python3</tt>. Analogicznie, istnieją wywołania <tt>ipython3</tt> oraz <tt>spyder3</tt>.

Zasady zaliczenia ćwiczeń w roku 2021/2022:

* maksymalnie można zdobyć 40 punktów
* w semestrze będą dwa kolokwia, w połowie i pod koniec; na każdym można zdobyć po 15 punktów
* w sesji będzie kolokwium dodatkowe, dla chętnych; wynik z niego (maks. 15 punktów) zastępuje gorszy z wyników kolokwiów z semestru, o ile jest on niego lepszy
* maksymalnie 10 punktów przydziela prowadzący na podstawie zadań domowych i aktywności na ćwiczeniach
* zaliczenie ćwiczeń na pozytywną ocenę wymaga co najmniej 50% punktów (20 p.)
* ocena rośnie o pół stopnia z osiągnięciem progu każdych kolejnych 10%, tj. 4 punktów.

Obecność na ćwiczeniach jest obowiązkowa. Dopuszczalne są '''dwie''' nieobecności nieusprawiedliwione w semestrze. '''Za każdą kolejną nieobecność nieusprawiedliwioną powyżej dwóch odejmujemy od wyniku 5 punktów.'''

Ocena końcowa z przedmiotu składa się z oceny z ćwiczeń, oraz z oceny z egzaminu testowego kończącego wykład, w proporcji 3:2 - z tym, że '''obie te oceny cząstkowe muszą być pozytywne''' aby ocena z całości była pozytywna.

===Spis treści===

#[[PPy3/Wprowadzenie|Wprowadzenie]]
#[[PPy3/PierwszeKroki|Pierwsze kroki]]
#[[PPy3/StałeIZmienne|Stałe i zmienne]]
#[[PPy3/InstrukcjaWarunkowa|Instrukcja warunkowa]]
#[[PPy3/SekwencjeIIteracja|Sekwencje i iteracja]]
#[[PPy3/Funkcje|Funkcje]]
#[[PPy3/Kolekcje|Kolekcje]]
#[[PPy3/Moduły|Moduły i biblioteki]]
#[[PPy3/WejścieWyjście|Obsługa wejścia i wyjścia]]
#[[PPy3/NumPy|NumPy]] - rachunki numeryczne na tablicach liczb
#[[PPy3/Matplotlib|Matplotlib]] - wizualizacja danych
#[[PPy3/TematyDodatkowe|Tematy dodatkowe]] - uzupełnienie
#[[PPy3/DobrePraktyki|Zasady dobrej praktyki]]

===O skrypcie===

Opracowane na nowo przez [[Użytkownik:RobertJB|RobertJB]], częściowo z wykorzystaniem [["Programowanie z Pythonem"|poprzedniej wersji]].

"Programowanie z Pythonem3"

2021-09-14T10:13:03Z

RobertJB: /* Semestr zimowy 2020/2021 */

[[Grafika:Python-logo.png]]

[[Category:Informatyka]]
== Semestr zimowy 2021/2022 ==

'''''W trakcie opracowania'''''

===Uwagi ogólne===

W pracowniach OKWF zainstalowane są zarówno stara wersja Pythona (2.7), jak i aktualna (3.x). Aktualnie polecenie <tt>python</tt> uruchamia wersję 2.7; w celu uruchomienia wersji 3 należy pisać <tt>python3</tt>. Analogicznie, istnieją wywołania <tt>ipython3</tt> oraz <tt>spyder3</tt>.

Zasady zaliczenia ćwiczeń w roku 2020/2021:

* maksymalnie można zdobyć 40 punktów
* w semestrze będą dwa kolokwia, w połowie i pod koniec; na każdym można zdobyć po 15 punktów
* w sesji będzie kolokwium dodatkowe, dla chętnych; wynik z niego (maks. 15 punktów) zastępuje gorszy z wyników kolokwiów z semestru, o ile jest on niego lepszy
* maksymalnie 10 punktów przydziela prowadzący na podstawie zadań domowych i aktywności na ćwiczeniach
* zaliczenie ćwiczeń na pozytywną ocenę wymaga co najmniej 50% punktów (20 p.)
* ocena rośnie o pół stopnia z osiągnięciem progu każdych kolejnych 10%, tj. 4 punktów.

Obecność na ćwiczeniach jest obowiązkowa. Dopuszczalne są '''dwie''' nieobecności nieusprawiedliwione w semestrze. '''Za każdą kolejną nieobecność nieusprawiedliwioną powyżej dwóch odejmujemy od wyniku 5 punktów.'''

Ocena końcowa z przedmiotu składa się z oceny z ćwiczeń, oraz z oceny z egzaminu testowego kończącego wykład, w proporcji 3:2 - z tym, że '''obie te oceny cząstkowe muszą być pozytywne''' aby ocena z całości była pozytywna.

===Spis treści===

#[[PPy3/Wprowadzenie|Wprowadzenie]]
#[[PPy3/PierwszeKroki|Pierwsze kroki]]
#[[PPy3/StałeIZmienne|Stałe i zmienne]]
#[[PPy3/InstrukcjaWarunkowa|Instrukcja warunkowa]]
#[[PPy3/SekwencjeIIteracja|Sekwencje i iteracja]]
#[[PPy3/Funkcje|Funkcje]]
#[[PPy3/Kolekcje|Kolekcje]]
#[[PPy3/Moduły|Moduły i biblioteki]]
#[[PPy3/WejścieWyjście|Obsługa wejścia i wyjścia]]
#[[PPy3/NumPy|NumPy]] - rachunki numeryczne na tablicach liczb
#[[PPy3/Matplotlib|Matplotlib]] - wizualizacja danych
#[[PPy3/TematyDodatkowe|Tematy dodatkowe]] - uzupełnienie
#[[PPy3/DobrePraktyki|Zasady dobrej praktyki]]

===O skrypcie===

Opracowane na nowo przez [[Użytkownik:RobertJB|RobertJB]], częściowo z wykorzystaniem [["Programowanie z Pythonem"|poprzedniej wersji]].

"Programowanie z Pythonem3"

2021-05-13T09:58:27Z

RobertJB: python logo

[[Grafika:Python-logo.png]]

[[Category:Informatyka]]
== Semestr zimowy 2020/2021 ==

'''''W trakcie opracowania'''''

===Uwagi ogólne===

W pracowniach OKWF zainstalowane są zarówno stara wersja Pythona (2.7), jak i aktualna (3.x). Aktualnie polecenie <tt>python</tt> uruchamia wersję 2.7; w celu uruchomienia wersji 3 należy pisać <tt>python3</tt>. Analogicznie, istnieją wywołania <tt>ipython3</tt> oraz <tt>spyder3</tt>.

Zasady zaliczenia ćwiczeń w roku 2020/2021:

* maksymalnie można zdobyć 40 punktów
* w semestrze będą dwa kolokwia, w połowie i pod koniec; na każdym można zdobyć po 15 punktów
* w sesji będzie kolokwium dodatkowe, dla chętnych; wynik z niego (maks. 15 punktów) zastępuje gorszy z wyników kolokwiów z semestru, o ile jest on niego lepszy
* maksymalnie 10 punktów przydziela prowadzący na podstawie zadań domowych i aktywności na ćwiczeniach
* zaliczenie ćwiczeń na pozytywną ocenę wymaga co najmniej 50% punktów (20 p.)
* ocena rośnie o pół stopnia z osiągnięciem progu każdych kolejnych 10%, tj. 4 punktów.

Obecność na ćwiczeniach jest obowiązkowa. Dopuszczalne są '''dwie''' nieobecności nieusprawiedliwione w semestrze. '''Za każdą kolejną nieobecność nieusprawiedliwioną powyżej dwóch odejmujemy od wyniku 5 punktów.'''

Ocena końcowa z przedmiotu składa się z oceny z ćwiczeń, oraz z oceny z egzaminu testowego kończącego wykład, w proporcji 3:2 - z tym, że '''obie te oceny cząstkowe muszą być pozytywne''' aby ocena z całości była pozytywna.

===Spis treści===

#[[PPy3/Wprowadzenie|Wprowadzenie]]
#[[PPy3/PierwszeKroki|Pierwsze kroki]]
#[[PPy3/StałeIZmienne|Stałe i zmienne]]
#[[PPy3/InstrukcjaWarunkowa|Instrukcja warunkowa]]
#[[PPy3/SekwencjeIIteracja|Sekwencje i iteracja]]
#[[PPy3/Funkcje|Funkcje]]
#[[PPy3/Kolekcje|Kolekcje]]
#[[PPy3/Moduły|Moduły i biblioteki]]
#[[PPy3/WejścieWyjście|Obsługa wejścia i wyjścia]]
#[[PPy3/NumPy|NumPy]] - rachunki numeryczne na tablicach liczb
#[[PPy3/Matplotlib|Matplotlib]] - wizualizacja danych
#[[PPy3/TematyDodatkowe|Tematy dodatkowe]] - uzupełnienie
#[[PPy3/DobrePraktyki|Zasady dobrej praktyki]]

===O skrypcie===

Opracowane na nowo przez [[Użytkownik:RobertJB|RobertJB]], częściowo z wykorzystaniem [["Programowanie z Pythonem"|poprzedniej wersji]].

Plik:Python-logo.png

2021-05-13T09:55:07Z

RobertJB: Python Logo

== Opis ==
Python Logo

PPy3/Matplotlib

2021-01-08T09:45:01Z

RobertJB: /* Przykład bardziej zaawansowany */

= Matplotlib - wizualizacja danych =

== Wprowadzenie do pakietu Matplotlib na przykładach ==

Pakiet Matplotlib bazuje na pakiecie numerycznym Numpy i korzysta z obiektów w nim zawartych. Pokażemy, jak z jego pomocą rysować różnorodne wykresy prezentujące graficznie przetwarzane dane i wyniki obliczeń. Zamiast wyliczać zawartość pakietu pokażemy ich użyteczność na przykładach. Zaczniemy od prostych i będziemy po drodze omawiać zastosowane w nich konstrukcje.

== Wykresy funkcji ==

===''y'' = ''f''(''x'')===

Prześledźmy działanie poniższego programu:

<source lang = python>
import matplotlib.pyplot as plt
x = [1,2,3]
y = [4,6,5]
plt.plot(x,y)
plt.show()
</source>

; Rezultat
[[Grafika:Wykres1.gif]]

; Jak to działa?

Aby skorzystać z pakietu graficznego Matplotlib importujemy go do naszego programu poleceniem <tt>import</tt>.

<blockquote>
Pod-pakiet pyplot jest jednym z paru nieco różnych ''interfejsów'' do Matplotlib - tj. sposobów wykorzystania
jego funkcjonalności. Inny, też często wykorzystywany, nazywa się <tt>pylab</tt> i można go importować wprost
(<tt>import pylab</tt>). Pyplot zapewnie nieco większą elastyczność, chociaż dla najprostszych przykładów -
takich, jakie tu omówimy - nie ma istotnej różnicy.
</blockquote>

Wytwarzamy dwie listy <tt>x</tt> i <tt>y</tt> zawierające ciągi liczb 1, 2, 3 oraz 4, 6, 5.

Funkcja <tt>plot</tt> rysuje wykres i umieszcza na nim punkty o współrzędnych zawartych w listach przekazanych jej jako argumenty. Pierwszy argument zawiera współrzędne ''x''-owe kolejnych punktów, a drugi argument współrzędne ''y''-owe kolejnych punktów wykresu. Ponieważ listy mają po trzy elementy, tak więc wykres zawierać będzie trzy punkty o współrzędnych (1, 4), (2, 6) oraz (3, 5). Domyślnie punkty na wykresie łączone są ze sobą niebieską linią ciągłą. To
oczywiście można zmienić - dodając opcjonalne parametry do wywołania <tt>plot</tt> można uzyskać linię o innym kolorze,
linię przerywaną, z kropek, albo w ogóle brak linii - a za to np. duże kropki (trójkąty, gwiazdki, ...) w miejscach
odpowiadających punktom danych.

Po wywołaniu funkcji <tt>plot</tt> wykres nie pokazuje się jeszcze na ekranie. Aby go pokazać, używamy funkcji <tt>show</tt>. Wykres pojawia się na ekranie w osobnym oknie, a Python czeka z wykonywaniem kolejnych instrukcji do momentu zamknięcia okna z wykresem.

W okienku wykresu mamy kilka guzików (po lewej stronie na dole). Służą one do manipulowania wyglądem rysunku. Guzikiem z krzyżykiem możemy zmniejszać/zwiększać skalę na osiach (wciskając prawy guzik myszy i przesuwając kursor po obrazku) oraz przesuwać cały wykres (wciskając lewy guzik myszy i przesuwając kursor po obrazku). Guzik z okienkiem i strzałkami pozwala także zmieniać rozmiar i położenie osi wykresu wewnątrz okna wybierając właściwe wartości. Guzik z domkiem przywraca wyjściowe ustawienia rysunku. Guzik z obrazkiem dyskietki (czy ktoś jeszcze wie, co to takiego?) pozwala
zachować wykres (jego aktualny stan, czyli z uwzględnieniem dokonanych interaktywnie modyfikacji) jako plik graficzny
jednego z kilku formatów.

=== Rysujemy wykres funkcji sinus ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0.0, 2.0, 0.01)
y = np.sin(2.0*np.pi*x)
plt.plot(x,y)
plt.show()
</source>

; Rezultat
[[Grafika:Wykres2.gif]]

; Jak to działa?

Oprócz funkcji z Matplotlib będziemu tu odwoływać się również wprost do elementów z pakietu NumPy.

Funkcja <tt>arange</tt> jest podobna do standardowej funkcji <tt>range</tt> wytwarzającej określone sekwencje liczb w postaci listy. Funkcja <tt>arange</tt> zamiast listy wytwarza tablicę zawierającą ciąg liczb zmiennoprzecinkowych zaczynający się od pierwszego podanego argumentu funkcji <tt>arange</tt> (u nas <tt>0.0</tt>), a kończący się przed drugim argumentem (tradycyjnie, ciąg wynikowy nie zawiera wartości podanej jako drugi argument, u nas <tt>2.0</tt>). Różnica między elementami wytworzonego ciągu domyślnie wynosi 1, ale jeśli podamy funkcji <tt>arange</tt> trzeci argument, to definiuje on nową różnicę ciągu, u nas wynosi on <tt>0.01</tt>.

Tak więc zmienna <tt>x</tt> jest tablicą-wektorem zawierającą ciąg liczb od 0 do 1,99 co 0,01 (czyli 0, 0,01, 0,02, ..., 1,98, 1,99).

Funkcja <tt>sin</tt> służy do obliczania wartości funkcji sinus dla argumentu podanego w radianach. A co u nas jest argumentem tej funkcji? Wyrażenie będące argumentem zawiera mnożenie liczby <tt>2.0</tt> przez <tt>pi</tt> (pochodzące z pakietu NumPy), a następnie mnożenie wyniku przez tablicę <tt>x</tt>. Zmienna <tt>pi</tt> zawiera przybliżoną wartość matematycznej stałej π ≈ 3,1415926... Mnożenie liczby i tablicy, jak wiemy z poprzedniego punktu, daje w wyniku tablicę. Oznacza to, że argumentem funkcji <tt>sin</tt> jest nie liczba, ale tablica! Taka możliwość jest przewidziana przez twórców pakietu Numpy; wynikiem wywołania funkcji jest wtedy również tablica. Jest ona tej samej długości co tablica będąca argumentem wywołania funkcji.

Tak więc zmienna <tt>y</tt> zawiera ciąg wartości funkcji sinus policzonych dla wartości zawartych w zmiennej <tt>x</tt> pomnożonych każda przez 2π (czyli sin(2π·0), sin(2π·0,01), sin(2π·0,02), ..., sin(2π·1,98), sin(2π·1,99)).

Funkcja <tt>plot(x,y)</tt> narysuje zestaw punktów o współrzędnych (0, sin(2π·0)), (0,01, sin(2π·0,01)), (0,02, sin(2π·0,02)), ..., (1,98, sin(2π·1,98)), (1,99, sin(2π·1,99)) połączonych niebieską linią.

=== Ulepszamy wykres ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0, 2.0, 0.01)
y = np.sin(2.0*p.pi*x)
plt.plot(x,y,'r:',linewidth=6)

plt.xlabel('Czas')
plt.ylabel('Pozycja')
plt.title('Nasz pierwszy wykres')
plt.grid(True)
plt.show()
</source>

; Rezultat
[[Grafika:Wykres3.gif]]

; Jak to działa?

W porównaniu z poprzednim przykładem pojawiło się na wykresie kilka drobnych zmian i &bdquo;ozdobników”.

W funkcji <tt>plot</tt> pojawiły się dwa nowe parametry:
# <tt>'r:'</tt> — ten parametr steruje wyglądem rysowanej linii wykresu. Pierwsza litera tego napisu określa kolor linii (na przykład <tt>r</tt>: czerwony, <tt>b</tt>: niebieski, <tt>g</tt>: zielony, <tt>y</tt>: żółty, <tt>k</tt>: czarny). Drugi znak napisu określa wygląd samej linii (np. <tt>-</tt>: ciągła, <tt>:</tt>: kropkowana, <tt>o</tt>: okrągłe punkty bez linii, <tt>+</tt>: krzyżyki bez linii, itd.).
# <tt>linewidth=6</tt> — ten parametr zmienia grubość rysowanej linii.

Dodaliśmy też wywołania funkcji <tt>xlabel</tt> i <tt>ylabel</tt>. Ich argumentami są napisy, które pojawią się jako opisy osi, odpowiednio poziomej i pionowej.
Wywołanie funkcji <tt>title</tt> wypisuje przekazany jej napis jako tytuł całego wykresu.

Funkcja <tt>grid</tt> dorysowuje siatkę prostokątną na wykresie w wybranych punktach opisujących wartości na osiach wykresu. Punkty, w których wybierane są wartości opisane na osiach (ang. ''tick'') są wybierane automatycznie (oczywiście jeśli chcemy, możemy zmieniać ich położenie i opisy odpowiednią funkcją, powiemy o tym później).

=== Kilka wykresów we wspólnych osiach - Pierwsza wersja ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0, 2.0, 0.01)
y1 = np.sin(2.0*p.pi*x)
y2 = np.cos(2.0*p.pi*x)
plt.plot(x,y1,'r:',x,y2,'g')
plt.legend(('dane y1','dane y2'))
plt.xlabel('Czas')
plt.ylabel('Pozycja')
plt.title('Wykres ')
plt.grid(True)
plt.show()
</source>
'''Rezultat:''' 
[[Grafika:Wykres_2_linie.svg‎]]

;Jak to działa?

W jednym układzie współrzędnych możemy narysować wiele wykresów. Robimy to podając w jednym poleceniu <tt>plot</tt> kolejno zestawy parametrów opisujące poszczególne linie: współrzędne x, współrzędne y, sposób wykreślania linii. Aby łatwo identyfikować linie można dodać legendę poleceniem <tt>legend()</tt>. Sposób kontrolowania wyglądu i położenia legendy: <tt>help(plt.legend)</tt> (oczywiście po zaimportowaniu modułu: <tt>import matplotlib.pyplot as plt</tt> ).

=== Kilka wykresów we wspólnych osiach - Druga wersja ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0, 2.0, 0.01)
y1 = np.sin(2.0*p.pi*x)
y2 = np.cos(2.0*p.pi*x)
y = y1*y2
l1, = plt.plot(x,y,'b')
l2,l3 = plt.plot(x,y1,'r:',x,y2,'g')
plt.legend((l2,l3,l1),('dane y1','dane y2','y1*y2'))
plt.xlabel('Czas')
plt.ylabel('Pozycja')
plt.title('Wykres ')
plt.grid(True)
plt.show()

</source>
'''Rezultat:''' 
[[Grafika:Wykres_3_linie.svg‎]]

;Jak to działa?

Wykresy możemy dodawać do współrzędnych kolejnymi poleceniami <tt>plot</tt>.
Funkcja <tt>plot</tt> zwraca listę linii. Notacja <tt>l1, = plt.plot(x,y,'b')</tt> wydobywa z listy pierwszą linię (Gdyby po <tt>l1</tt> nie było przecinka to <tt>l1</tt> byłoby listą zawierającą jeden obiekt klasy linia ).

Dzięki nazwaniu poszczególnych obiektów linii możemy kontrolować ich kolejność (i obecność) na legendzie.

==Histogram (diagram liczebności)==

<source lang=python>
import matplotlib.pyplot as plt

zliczenia = [0, 1, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 7]
plt.hist(zliczenia)
plt.show()
</source>

'''Rezultat:''' 
[[Grafika:Hist1.gif]]

;Jak to działa ?

Do zmiennej <tt>zliczenia</tt> przypisujemy sekwencję z ręcznie podanymi wartościami.
Zakres zmienności badanych zliczeń (odkładany na osi ''X'') zostanie podzielony na przedziały (ang. ''bin'') o jednakowej &bdquo;szerokości”; domyślnie będzie ich 10. Funkcja <tt>hist()</tt> zlicza wystąpienia wartości w binach i rysuje histogram. Funkcja ta zwraca krotkę (array ze zliczeniami, array z binami, lista zawierająca prostokąty, które histogram rysuje, tzw. obiekty Patch).

Porządek wartości, których histogram zostanie stworzony nie ma znaczenia. Mogą one oczywiście być umieszczone również w tablicy NumPy.

===Przykład bardziej zaawansowany===

Wyjaśnienie działania znajduje się w komentarzach do programu:
<source lang = python>
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

mi, sigma = 100, 15
x = mi + sigma * np.random.randn(10000)
# numpy.random.randn zwraca array z liczbami pseudolosowymi
# pochodzącymi z rozkładu normalnego o średniej 0 i wariancji 1
# przemnożenie przez odchylenie standandardowe sigma i dodanie śreniej mi
# transformuje rozkład do rozkładu normalnego o średniej mi i wariancji sigma**2

n, bins, patches = plt.hist(x, 50, density=True,
facecolor='green', edgecolor='black', alpha=0.75)
# Tu w jawny sposób odbieramy zwracane przez plt.hist obiekty
# Zmieniamy też:
# - ilość binów na 50
# - normujemy histogram do jedności
# - ustalamy kolor prostokątów na zielony
# - ustawiamy (nie)przezroczystość prostokątów na 0.75

bincenters = 0.5*(bins[1:]+bins[:-1])
# wytwarzamy array z centrami binów korzystając z granic binów
# zwróconych przez plt.hist w macierzy bins

y = norm.pdf( bincenters, mi, sigma)
# obliczamy wartości w normalnym rozkładzie gęstości prawdopodobieństwa
# o średniej mi i wariancji sigma**2 dla wartości bincenters

l = plt.plot(bincenters, y, 'r--', linewidth=1)
# do histogramu dorysowujemy linię

plt.show()
</source>

'''Rezultat:''' 
[[Grafika:Hist2.gif]]

==Krzywa parametryczna==

Rysowanie krzywej danej w postaci parametrycznej niewiele się różni od rysowania wykresu funkcji. Żeby było zabawniej, wykonam jeszcze przy okazji rachunek Monte Carlo oraz jego wizualizację.

Krzywa, jaką tutaj narysujemy to tzw. [https://pl.wikipedia.org/wiki/Lemniskata_Gerona lemniskata Gerona]. Zostanie dodatkowo opisana okręgiem jednostkowym; następnie, wylosuję dużą liczbę punktów o równomiernym rozkładzie leżących w kwadracie opisanym na tym okręgu. Robię tak, ponieważ łatwo mi jest wylosować tablicę wielu liczb z zakresu (0, 1) — jest do tego gotowa funkcja <tt>numpy.random.random</tt>, następnie przeskalować i przesunąć je do odcinka (-1, 1). Wreszcie, traktując je jako pary współrzędnych <tt>(x, y)</tt>, pozostawiam tylko te, które znalazły się we wnętrzu koła jednostkowego (odrzucając pozostałe), i dzielę na te, które znalazły się w obszarze wewnątrz lemniskaty, i te, które znalazły się na zewnątrz.

Intuicyjnie jest dość jasne, że — o ile losowaliśmy punkty rzeczywiście w sposób równomierny — stosunek liczby „trafień" w obszar ograniczony lemniskatą do liczby wszystkich „trafień" w obszar koła będzie w przybliżeniu równy stosunkowi pól powierzchni tych obszarów. I na tym tu poprzestaniemy; to, jak dokładne to może być przybliżenie, czyli jakiej wielkości błędu możemy oczekiwać, to już problem na inne zajęcia...

<source lang=python>
import numpy as np
import matplotlib.pyplot as plt

Φ = np.arange(0, 2*np.pi, 2*np.pi/600)
X = np.cos(Φ)
Y = np.sin(2*Φ) / 2 # = np.sin(Φ) * np.cos(Φ)
plt.axes(aspect='equal') # to mi gwarantuje, że okrąg nie wyjdzie „spłaszczony"
plt.plot(X, Y, 'b')
YO = np.sin(Φ)
plt.plot(X, YO, 'k')
# biorę całą kupę losowych punktów z przedziału (-1, 1)
P = np.random.random((100000, 2)) * 2 - 1 # milion par (x, y)
# wyrzucam te, które są poza kołem x**2 + y**2 < 1
P = P[(P**2).sum(axis=1) < 1]
# dzielę na te co wewnątrz lemniskaty, i te co na zewnątrz
I_in = np.abs(P[:,1]) < np.abs(P[:,0]) * np.sqrt(1 - P[:,0]**2)
P_in = P[I_in]
P_out = P[~I_in]
# maluję wewnętrzne na niebiesko
plt.plot(P_in[:,0], P_in[:,1], 'b,')
# a zewnętrzne na czerwono
plt.plot(P_out[:,0], P_out[:,1], 'r,')
# powierzchnia to z grubsza stosunek l. punktów wewnętrznych do wszystkich
S = P_in.size / P.size
plt.title('Pole pow. wnętrza lemniskaty to ok. {:.3f} pola pow. koła'.format(S))
plt.show()
</source>

Przy okazji, jak widać w kodzie Pythona (wersja 3) można bezproblemowo używać liter z innych alfabetów, nie tylko łacińskiego. Niestety nie wszystkie systemy operacyjne zapewniają bezproblemową obsługę pełnego zestawu liter wszelkich języków, dlatego na ogół wykorzystywanie liter z egzotycznych systemów pisma nie jest szczególnie zalecane.

W wyniku uruchomienia tego programu powinno pojawić się okno z obrazkiem podobnym do poniższego:

[[File:Lemniskata.png]]

==Wizualizacja zawartości tablicy dwuwymiarowej==

<source lang=python>
import numpy as np
import matplotlib.pyplot as plt

A = np.arange(20)
X, Y = np.meshgrid(A, A)
Z = X + Y
plt.imshow(Z, cmap='hot', interpolation='none')
plt.colorbar()
plt.show()
</source>

'''Wynik:'''

[[Grafika:Imshow1.png]]

Jak można się domyślić, parametr <tt>cmap</tt> wywołania funkcji <tt>imshow</tt> odpowiada za odwzorowanie pomiędzy wartościami elementów tablicy a barwami - jest wiele predefiniowanych takich odwzorowań (''colormaps''), opisanych w dokumentacji. Za pomocą wartości <tt>'none'</tt> parametru <tt>interpolation</tt> wyłączyliśmy ,,wygładzanie" obrazu, inne możliwe wartości umożliwiają wybór różnych algorytmów wygładzania. Wywołanie <tt>colorbar</tt> dostarcza paska wizualizującego odpowiedniość pomiędzy wartościami liczbowy i barwami.

==Plik graficzny jako źródło danych==

<source lang=python>
import numpy as np
import matplotlib.pyplot as plt

img = plt.imread('reading-girl.jpg')
plt.imshow()
plt.show()
</source>

'''Wynik:'''

[[Grafika:Imshow-girl-1.jpg]]

Wynikiem wywołania <tt>imread</tt> jest tablica o kształcie ''(wysokość, szerokość, 3)'' zawierająca dla każdego piksela obrazu wartości jego składowych RGB, tj. natężeń barw: czerwonej, zielonej, i niebieskiej - jako liczby w zakresie od 0 do 255 włącznie. Oczywiście na tej tablicy możemy wykonywać najróżniejsze operacje, analizując treść obrazu czy przekształcając go. Przykładowo:

<source lang=python>
img1 = img[:400, -400:] # przycinam obraz do kształtu 400x400 pikseli
img2 = img1.sum(axis=2)
img3 = img2 / img2.max()
plt.imgshow(img3, cmap='bone')
plt.show()
</source>

'''Wynik:'''

[[Grafika:reading-girl-bone.jpg]]

<source lang=python>
plt.hist(img3.flatten(), bins=100)
plt.show()
</source>

'''Wynik:'''

[[Grafika:reading-girl-hist.png]]

Wykonaliśmy w ten sposób histogram opisujący rozkład natężenia pikseli obrazka.

==Wiele wykresów w jednym oknie==

==Ćwiczenia==

1. Spróbuj znaleźć sposób przekształcenia obrazka takiego, jak poniższy portret autora skryptu:

[[Grafika:rjb_small.jpg]]

do postaci przypominającej

[[Grafika:rjb_bw.png]]

2. (''Nieco złożone'') Napisz program symulujący „bilard na kółku". Dokładniej: wewnątrz koła jednostkowego na płaszczyźnie porusza się cząstka (punkt), zachowując stałą prędkość — dopóki nie napotka brzegu, czyli okręgu; wówczas odbija się zgodnie z zasadą, że kąt padania równa się kątowi odbicia; chodzi o kąt pomiędzy wektorem prędkości a promieniem okręgu jednostkowego w miejscu, gdzie tor ruchu przecina się z okręgiem, po odbiciu jest on taki sam co do wartości ale ''po drugiej stronie'' promienia. Program rysuje okręg jednostkowy oraz tor ruchu cząstki wewnątrz tego okręgu, w zależności od początkowego położenia, kierunku początkowej prędkości (wartość prędkości jest nieistotna, ponieważ jest stała), i czasu obserwacji.

Wynikiem programu są wykresy podobne do poniższego:

[[Grafika:bilard_na_kole.png]]

czarną kropką oznaczono położenie początkowe, a na zielono — końcowe.

----

[[PPy3/NumPy|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/TematyDodatkowe]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:05, 10 kwi 2017 (CEST)

PPy3/Matplotlib

2021-01-08T09:44:15Z

RobertJB: /* Przykład bardziej zaawansowany */

= Matplotlib - wizualizacja danych =

== Wprowadzenie do pakietu Matplotlib na przykładach ==

Pakiet Matplotlib bazuje na pakiecie numerycznym Numpy i korzysta z obiektów w nim zawartych. Pokażemy, jak z jego pomocą rysować różnorodne wykresy prezentujące graficznie przetwarzane dane i wyniki obliczeń. Zamiast wyliczać zawartość pakietu pokażemy ich użyteczność na przykładach. Zaczniemy od prostych i będziemy po drodze omawiać zastosowane w nich konstrukcje.

== Wykresy funkcji ==

===''y'' = ''f''(''x'')===

Prześledźmy działanie poniższego programu:

<source lang = python>
import matplotlib.pyplot as plt
x = [1,2,3]
y = [4,6,5]
plt.plot(x,y)
plt.show()
</source>

; Rezultat
[[Grafika:Wykres1.gif]]

; Jak to działa?

Aby skorzystać z pakietu graficznego Matplotlib importujemy go do naszego programu poleceniem <tt>import</tt>.

<blockquote>
Pod-pakiet pyplot jest jednym z paru nieco różnych ''interfejsów'' do Matplotlib - tj. sposobów wykorzystania
jego funkcjonalności. Inny, też często wykorzystywany, nazywa się <tt>pylab</tt> i można go importować wprost
(<tt>import pylab</tt>). Pyplot zapewnie nieco większą elastyczność, chociaż dla najprostszych przykładów -
takich, jakie tu omówimy - nie ma istotnej różnicy.
</blockquote>

Wytwarzamy dwie listy <tt>x</tt> i <tt>y</tt> zawierające ciągi liczb 1, 2, 3 oraz 4, 6, 5.

Funkcja <tt>plot</tt> rysuje wykres i umieszcza na nim punkty o współrzędnych zawartych w listach przekazanych jej jako argumenty. Pierwszy argument zawiera współrzędne ''x''-owe kolejnych punktów, a drugi argument współrzędne ''y''-owe kolejnych punktów wykresu. Ponieważ listy mają po trzy elementy, tak więc wykres zawierać będzie trzy punkty o współrzędnych (1, 4), (2, 6) oraz (3, 5). Domyślnie punkty na wykresie łączone są ze sobą niebieską linią ciągłą. To
oczywiście można zmienić - dodając opcjonalne parametry do wywołania <tt>plot</tt> można uzyskać linię o innym kolorze,
linię przerywaną, z kropek, albo w ogóle brak linii - a za to np. duże kropki (trójkąty, gwiazdki, ...) w miejscach
odpowiadających punktom danych.

Po wywołaniu funkcji <tt>plot</tt> wykres nie pokazuje się jeszcze na ekranie. Aby go pokazać, używamy funkcji <tt>show</tt>. Wykres pojawia się na ekranie w osobnym oknie, a Python czeka z wykonywaniem kolejnych instrukcji do momentu zamknięcia okna z wykresem.

W okienku wykresu mamy kilka guzików (po lewej stronie na dole). Służą one do manipulowania wyglądem rysunku. Guzikiem z krzyżykiem możemy zmniejszać/zwiększać skalę na osiach (wciskając prawy guzik myszy i przesuwając kursor po obrazku) oraz przesuwać cały wykres (wciskając lewy guzik myszy i przesuwając kursor po obrazku). Guzik z okienkiem i strzałkami pozwala także zmieniać rozmiar i położenie osi wykresu wewnątrz okna wybierając właściwe wartości. Guzik z domkiem przywraca wyjściowe ustawienia rysunku. Guzik z obrazkiem dyskietki (czy ktoś jeszcze wie, co to takiego?) pozwala
zachować wykres (jego aktualny stan, czyli z uwzględnieniem dokonanych interaktywnie modyfikacji) jako plik graficzny
jednego z kilku formatów.

=== Rysujemy wykres funkcji sinus ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0.0, 2.0, 0.01)
y = np.sin(2.0*np.pi*x)
plt.plot(x,y)
plt.show()
</source>

; Rezultat
[[Grafika:Wykres2.gif]]

; Jak to działa?

Oprócz funkcji z Matplotlib będziemu tu odwoływać się również wprost do elementów z pakietu NumPy.

Funkcja <tt>arange</tt> jest podobna do standardowej funkcji <tt>range</tt> wytwarzającej określone sekwencje liczb w postaci listy. Funkcja <tt>arange</tt> zamiast listy wytwarza tablicę zawierającą ciąg liczb zmiennoprzecinkowych zaczynający się od pierwszego podanego argumentu funkcji <tt>arange</tt> (u nas <tt>0.0</tt>), a kończący się przed drugim argumentem (tradycyjnie, ciąg wynikowy nie zawiera wartości podanej jako drugi argument, u nas <tt>2.0</tt>). Różnica między elementami wytworzonego ciągu domyślnie wynosi 1, ale jeśli podamy funkcji <tt>arange</tt> trzeci argument, to definiuje on nową różnicę ciągu, u nas wynosi on <tt>0.01</tt>.

Tak więc zmienna <tt>x</tt> jest tablicą-wektorem zawierającą ciąg liczb od 0 do 1,99 co 0,01 (czyli 0, 0,01, 0,02, ..., 1,98, 1,99).

Funkcja <tt>sin</tt> służy do obliczania wartości funkcji sinus dla argumentu podanego w radianach. A co u nas jest argumentem tej funkcji? Wyrażenie będące argumentem zawiera mnożenie liczby <tt>2.0</tt> przez <tt>pi</tt> (pochodzące z pakietu NumPy), a następnie mnożenie wyniku przez tablicę <tt>x</tt>. Zmienna <tt>pi</tt> zawiera przybliżoną wartość matematycznej stałej π ≈ 3,1415926... Mnożenie liczby i tablicy, jak wiemy z poprzedniego punktu, daje w wyniku tablicę. Oznacza to, że argumentem funkcji <tt>sin</tt> jest nie liczba, ale tablica! Taka możliwość jest przewidziana przez twórców pakietu Numpy; wynikiem wywołania funkcji jest wtedy również tablica. Jest ona tej samej długości co tablica będąca argumentem wywołania funkcji.

Tak więc zmienna <tt>y</tt> zawiera ciąg wartości funkcji sinus policzonych dla wartości zawartych w zmiennej <tt>x</tt> pomnożonych każda przez 2π (czyli sin(2π·0), sin(2π·0,01), sin(2π·0,02), ..., sin(2π·1,98), sin(2π·1,99)).

Funkcja <tt>plot(x,y)</tt> narysuje zestaw punktów o współrzędnych (0, sin(2π·0)), (0,01, sin(2π·0,01)), (0,02, sin(2π·0,02)), ..., (1,98, sin(2π·1,98)), (1,99, sin(2π·1,99)) połączonych niebieską linią.

=== Ulepszamy wykres ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0, 2.0, 0.01)
y = np.sin(2.0*p.pi*x)
plt.plot(x,y,'r:',linewidth=6)

plt.xlabel('Czas')
plt.ylabel('Pozycja')
plt.title('Nasz pierwszy wykres')
plt.grid(True)
plt.show()
</source>

; Rezultat
[[Grafika:Wykres3.gif]]

; Jak to działa?

W porównaniu z poprzednim przykładem pojawiło się na wykresie kilka drobnych zmian i &bdquo;ozdobników”.

W funkcji <tt>plot</tt> pojawiły się dwa nowe parametry:
# <tt>'r:'</tt> — ten parametr steruje wyglądem rysowanej linii wykresu. Pierwsza litera tego napisu określa kolor linii (na przykład <tt>r</tt>: czerwony, <tt>b</tt>: niebieski, <tt>g</tt>: zielony, <tt>y</tt>: żółty, <tt>k</tt>: czarny). Drugi znak napisu określa wygląd samej linii (np. <tt>-</tt>: ciągła, <tt>:</tt>: kropkowana, <tt>o</tt>: okrągłe punkty bez linii, <tt>+</tt>: krzyżyki bez linii, itd.).
# <tt>linewidth=6</tt> — ten parametr zmienia grubość rysowanej linii.

Dodaliśmy też wywołania funkcji <tt>xlabel</tt> i <tt>ylabel</tt>. Ich argumentami są napisy, które pojawią się jako opisy osi, odpowiednio poziomej i pionowej.
Wywołanie funkcji <tt>title</tt> wypisuje przekazany jej napis jako tytuł całego wykresu.

Funkcja <tt>grid</tt> dorysowuje siatkę prostokątną na wykresie w wybranych punktach opisujących wartości na osiach wykresu. Punkty, w których wybierane są wartości opisane na osiach (ang. ''tick'') są wybierane automatycznie (oczywiście jeśli chcemy, możemy zmieniać ich położenie i opisy odpowiednią funkcją, powiemy o tym później).

=== Kilka wykresów we wspólnych osiach - Pierwsza wersja ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0, 2.0, 0.01)
y1 = np.sin(2.0*p.pi*x)
y2 = np.cos(2.0*p.pi*x)
plt.plot(x,y1,'r:',x,y2,'g')
plt.legend(('dane y1','dane y2'))
plt.xlabel('Czas')
plt.ylabel('Pozycja')
plt.title('Wykres ')
plt.grid(True)
plt.show()
</source>
'''Rezultat:''' 
[[Grafika:Wykres_2_linie.svg‎]]

;Jak to działa?

W jednym układzie współrzędnych możemy narysować wiele wykresów. Robimy to podając w jednym poleceniu <tt>plot</tt> kolejno zestawy parametrów opisujące poszczególne linie: współrzędne x, współrzędne y, sposób wykreślania linii. Aby łatwo identyfikować linie można dodać legendę poleceniem <tt>legend()</tt>. Sposób kontrolowania wyglądu i położenia legendy: <tt>help(plt.legend)</tt> (oczywiście po zaimportowaniu modułu: <tt>import matplotlib.pyplot as plt</tt> ).

=== Kilka wykresów we wspólnych osiach - Druga wersja ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0, 2.0, 0.01)
y1 = np.sin(2.0*p.pi*x)
y2 = np.cos(2.0*p.pi*x)
y = y1*y2
l1, = plt.plot(x,y,'b')
l2,l3 = plt.plot(x,y1,'r:',x,y2,'g')
plt.legend((l2,l3,l1),('dane y1','dane y2','y1*y2'))
plt.xlabel('Czas')
plt.ylabel('Pozycja')
plt.title('Wykres ')
plt.grid(True)
plt.show()

</source>
'''Rezultat:''' 
[[Grafika:Wykres_3_linie.svg‎]]

;Jak to działa?

Wykresy możemy dodawać do współrzędnych kolejnymi poleceniami <tt>plot</tt>.
Funkcja <tt>plot</tt> zwraca listę linii. Notacja <tt>l1, = plt.plot(x,y,'b')</tt> wydobywa z listy pierwszą linię (Gdyby po <tt>l1</tt> nie było przecinka to <tt>l1</tt> byłoby listą zawierającą jeden obiekt klasy linia ).

Dzięki nazwaniu poszczególnych obiektów linii możemy kontrolować ich kolejność (i obecność) na legendzie.

==Histogram (diagram liczebności)==

<source lang=python>
import matplotlib.pyplot as plt

zliczenia = [0, 1, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 7]
plt.hist(zliczenia)
plt.show()
</source>

'''Rezultat:''' 
[[Grafika:Hist1.gif]]

;Jak to działa ?

Do zmiennej <tt>zliczenia</tt> przypisujemy sekwencję z ręcznie podanymi wartościami.
Zakres zmienności badanych zliczeń (odkładany na osi ''X'') zostanie podzielony na przedziały (ang. ''bin'') o jednakowej &bdquo;szerokości”; domyślnie będzie ich 10. Funkcja <tt>hist()</tt> zlicza wystąpienia wartości w binach i rysuje histogram. Funkcja ta zwraca krotkę (array ze zliczeniami, array z binami, lista zawierająca prostokąty, które histogram rysuje, tzw. obiekty Patch).

Porządek wartości, których histogram zostanie stworzony nie ma znaczenia. Mogą one oczywiście być umieszczone również w tablicy NumPy.

===Przykład bardziej zaawansowany===

Wyjaśnienie działania znajduje się w komentarzach do programu:
<source lang = python>
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

mi, sigma = 100, 15
x = mi + sigma * np.random.randn(10000)
# numpy.random.randn zwraca array z liczbami pseudolosowymi
# pochodzącymi z rozkładu normalnego o średniej 0 i wariancji 1
# przemnożenie przez odchylenie standandardowe sigma i dodanie śreniej mi
# transformuje rozkład do rozkładu normalnego o średniej mi i wariancji sigma**2

n, bins, patches = plt.hist(x, 50, normed=True,
facecolor='green', edgecolor='black', alpha=0.75)
# Tu w jawny sposób odbieramy zwracane przez plt.hist obiekty
# Zmieniamy też:
# - ilość binów na 50
# - normujemy histogram do jedności
# - ustalamy kolor prostokątów na zielony
# - ustawiamy (nie)przezroczystość prostokątów na 0.75

bincenters = 0.5*(bins[1:]+bins[:-1])
# wytwarzamy array z centrami binów korzystając z granic binów
# zwróconych przez plt.hist w macierzy bins

y = norm.pdf( bincenters, mi, sigma)
# obliczamy wartości w normalnym rozkładzie gęstości prawdopodobieństwa
# o średniej mi i wariancji sigma**2 dla wartości bincenters

l = plt.plot(bincenters, y, 'r--', linewidth=1)
# do histogramu dorysowujemy linię

plt.show()
</source>

'''Rezultat:''' 
[[Grafika:Hist2.gif]]

==Krzywa parametryczna==

Rysowanie krzywej danej w postaci parametrycznej niewiele się różni od rysowania wykresu funkcji. Żeby było zabawniej, wykonam jeszcze przy okazji rachunek Monte Carlo oraz jego wizualizację.

Krzywa, jaką tutaj narysujemy to tzw. [https://pl.wikipedia.org/wiki/Lemniskata_Gerona lemniskata Gerona]. Zostanie dodatkowo opisana okręgiem jednostkowym; następnie, wylosuję dużą liczbę punktów o równomiernym rozkładzie leżących w kwadracie opisanym na tym okręgu. Robię tak, ponieważ łatwo mi jest wylosować tablicę wielu liczb z zakresu (0, 1) — jest do tego gotowa funkcja <tt>numpy.random.random</tt>, następnie przeskalować i przesunąć je do odcinka (-1, 1). Wreszcie, traktując je jako pary współrzędnych <tt>(x, y)</tt>, pozostawiam tylko te, które znalazły się we wnętrzu koła jednostkowego (odrzucając pozostałe), i dzielę na te, które znalazły się w obszarze wewnątrz lemniskaty, i te, które znalazły się na zewnątrz.

Intuicyjnie jest dość jasne, że — o ile losowaliśmy punkty rzeczywiście w sposób równomierny — stosunek liczby „trafień" w obszar ograniczony lemniskatą do liczby wszystkich „trafień" w obszar koła będzie w przybliżeniu równy stosunkowi pól powierzchni tych obszarów. I na tym tu poprzestaniemy; to, jak dokładne to może być przybliżenie, czyli jakiej wielkości błędu możemy oczekiwać, to już problem na inne zajęcia...

<source lang=python>
import numpy as np
import matplotlib.pyplot as plt

Φ = np.arange(0, 2*np.pi, 2*np.pi/600)
X = np.cos(Φ)
Y = np.sin(2*Φ) / 2 # = np.sin(Φ) * np.cos(Φ)
plt.axes(aspect='equal') # to mi gwarantuje, że okrąg nie wyjdzie „spłaszczony"
plt.plot(X, Y, 'b')
YO = np.sin(Φ)
plt.plot(X, YO, 'k')
# biorę całą kupę losowych punktów z przedziału (-1, 1)
P = np.random.random((100000, 2)) * 2 - 1 # milion par (x, y)
# wyrzucam te, które są poza kołem x**2 + y**2 < 1
P = P[(P**2).sum(axis=1) < 1]
# dzielę na te co wewnątrz lemniskaty, i te co na zewnątrz
I_in = np.abs(P[:,1]) < np.abs(P[:,0]) * np.sqrt(1 - P[:,0]**2)
P_in = P[I_in]
P_out = P[~I_in]
# maluję wewnętrzne na niebiesko
plt.plot(P_in[:,0], P_in[:,1], 'b,')
# a zewnętrzne na czerwono
plt.plot(P_out[:,0], P_out[:,1], 'r,')
# powierzchnia to z grubsza stosunek l. punktów wewnętrznych do wszystkich
S = P_in.size / P.size
plt.title('Pole pow. wnętrza lemniskaty to ok. {:.3f} pola pow. koła'.format(S))
plt.show()
</source>

Przy okazji, jak widać w kodzie Pythona (wersja 3) można bezproblemowo używać liter z innych alfabetów, nie tylko łacińskiego. Niestety nie wszystkie systemy operacyjne zapewniają bezproblemową obsługę pełnego zestawu liter wszelkich języków, dlatego na ogół wykorzystywanie liter z egzotycznych systemów pisma nie jest szczególnie zalecane.

W wyniku uruchomienia tego programu powinno pojawić się okno z obrazkiem podobnym do poniższego:

[[File:Lemniskata.png]]

==Wizualizacja zawartości tablicy dwuwymiarowej==

<source lang=python>
import numpy as np
import matplotlib.pyplot as plt

A = np.arange(20)
X, Y = np.meshgrid(A, A)
Z = X + Y
plt.imshow(Z, cmap='hot', interpolation='none')
plt.colorbar()
plt.show()
</source>

'''Wynik:'''

[[Grafika:Imshow1.png]]

Jak można się domyślić, parametr <tt>cmap</tt> wywołania funkcji <tt>imshow</tt> odpowiada za odwzorowanie pomiędzy wartościami elementów tablicy a barwami - jest wiele predefiniowanych takich odwzorowań (''colormaps''), opisanych w dokumentacji. Za pomocą wartości <tt>'none'</tt> parametru <tt>interpolation</tt> wyłączyliśmy ,,wygładzanie" obrazu, inne możliwe wartości umożliwiają wybór różnych algorytmów wygładzania. Wywołanie <tt>colorbar</tt> dostarcza paska wizualizującego odpowiedniość pomiędzy wartościami liczbowy i barwami.

==Plik graficzny jako źródło danych==

<source lang=python>
import numpy as np
import matplotlib.pyplot as plt

img = plt.imread('reading-girl.jpg')
plt.imshow()
plt.show()
</source>

'''Wynik:'''

[[Grafika:Imshow-girl-1.jpg]]

Wynikiem wywołania <tt>imread</tt> jest tablica o kształcie ''(wysokość, szerokość, 3)'' zawierająca dla każdego piksela obrazu wartości jego składowych RGB, tj. natężeń barw: czerwonej, zielonej, i niebieskiej - jako liczby w zakresie od 0 do 255 włącznie. Oczywiście na tej tablicy możemy wykonywać najróżniejsze operacje, analizując treść obrazu czy przekształcając go. Przykładowo:

<source lang=python>
img1 = img[:400, -400:] # przycinam obraz do kształtu 400x400 pikseli
img2 = img1.sum(axis=2)
img3 = img2 / img2.max()
plt.imgshow(img3, cmap='bone')
plt.show()
</source>

'''Wynik:'''

[[Grafika:reading-girl-bone.jpg]]

<source lang=python>
plt.hist(img3.flatten(), bins=100)
plt.show()
</source>

'''Wynik:'''

[[Grafika:reading-girl-hist.png]]

Wykonaliśmy w ten sposób histogram opisujący rozkład natężenia pikseli obrazka.

==Wiele wykresów w jednym oknie==

==Ćwiczenia==

1. Spróbuj znaleźć sposób przekształcenia obrazka takiego, jak poniższy portret autora skryptu:

[[Grafika:rjb_small.jpg]]

do postaci przypominającej

[[Grafika:rjb_bw.png]]

2. (''Nieco złożone'') Napisz program symulujący „bilard na kółku". Dokładniej: wewnątrz koła jednostkowego na płaszczyźnie porusza się cząstka (punkt), zachowując stałą prędkość — dopóki nie napotka brzegu, czyli okręgu; wówczas odbija się zgodnie z zasadą, że kąt padania równa się kątowi odbicia; chodzi o kąt pomiędzy wektorem prędkości a promieniem okręgu jednostkowego w miejscu, gdzie tor ruchu przecina się z okręgiem, po odbiciu jest on taki sam co do wartości ale ''po drugiej stronie'' promienia. Program rysuje okręg jednostkowy oraz tor ruchu cząstki wewnątrz tego okręgu, w zależności od początkowego położenia, kierunku początkowej prędkości (wartość prędkości jest nieistotna, ponieważ jest stała), i czasu obserwacji.

Wynikiem programu są wykresy podobne do poniższego:

[[Grafika:bilard_na_kole.png]]

czarną kropką oznaczono położenie początkowe, a na zielono — końcowe.

----

[[PPy3/NumPy|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/TematyDodatkowe]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:05, 10 kwi 2017 (CEST)

PPy3/Matplotlib

2021-01-08T09:40:05Z

RobertJB: /* Przykład bardziej zaawansowany */

= Matplotlib - wizualizacja danych =

== Wprowadzenie do pakietu Matplotlib na przykładach ==

Pakiet Matplotlib bazuje na pakiecie numerycznym Numpy i korzysta z obiektów w nim zawartych. Pokażemy, jak z jego pomocą rysować różnorodne wykresy prezentujące graficznie przetwarzane dane i wyniki obliczeń. Zamiast wyliczać zawartość pakietu pokażemy ich użyteczność na przykładach. Zaczniemy od prostych i będziemy po drodze omawiać zastosowane w nich konstrukcje.

== Wykresy funkcji ==

===''y'' = ''f''(''x'')===

Prześledźmy działanie poniższego programu:

<source lang = python>
import matplotlib.pyplot as plt
x = [1,2,3]
y = [4,6,5]
plt.plot(x,y)
plt.show()
</source>

; Rezultat
[[Grafika:Wykres1.gif]]

; Jak to działa?

Aby skorzystać z pakietu graficznego Matplotlib importujemy go do naszego programu poleceniem <tt>import</tt>.

<blockquote>
Pod-pakiet pyplot jest jednym z paru nieco różnych ''interfejsów'' do Matplotlib - tj. sposobów wykorzystania
jego funkcjonalności. Inny, też często wykorzystywany, nazywa się <tt>pylab</tt> i można go importować wprost
(<tt>import pylab</tt>). Pyplot zapewnie nieco większą elastyczność, chociaż dla najprostszych przykładów -
takich, jakie tu omówimy - nie ma istotnej różnicy.
</blockquote>

Wytwarzamy dwie listy <tt>x</tt> i <tt>y</tt> zawierające ciągi liczb 1, 2, 3 oraz 4, 6, 5.

Funkcja <tt>plot</tt> rysuje wykres i umieszcza na nim punkty o współrzędnych zawartych w listach przekazanych jej jako argumenty. Pierwszy argument zawiera współrzędne ''x''-owe kolejnych punktów, a drugi argument współrzędne ''y''-owe kolejnych punktów wykresu. Ponieważ listy mają po trzy elementy, tak więc wykres zawierać będzie trzy punkty o współrzędnych (1, 4), (2, 6) oraz (3, 5). Domyślnie punkty na wykresie łączone są ze sobą niebieską linią ciągłą. To
oczywiście można zmienić - dodając opcjonalne parametry do wywołania <tt>plot</tt> można uzyskać linię o innym kolorze,
linię przerywaną, z kropek, albo w ogóle brak linii - a za to np. duże kropki (trójkąty, gwiazdki, ...) w miejscach
odpowiadających punktom danych.

Po wywołaniu funkcji <tt>plot</tt> wykres nie pokazuje się jeszcze na ekranie. Aby go pokazać, używamy funkcji <tt>show</tt>. Wykres pojawia się na ekranie w osobnym oknie, a Python czeka z wykonywaniem kolejnych instrukcji do momentu zamknięcia okna z wykresem.

W okienku wykresu mamy kilka guzików (po lewej stronie na dole). Służą one do manipulowania wyglądem rysunku. Guzikiem z krzyżykiem możemy zmniejszać/zwiększać skalę na osiach (wciskając prawy guzik myszy i przesuwając kursor po obrazku) oraz przesuwać cały wykres (wciskając lewy guzik myszy i przesuwając kursor po obrazku). Guzik z okienkiem i strzałkami pozwala także zmieniać rozmiar i położenie osi wykresu wewnątrz okna wybierając właściwe wartości. Guzik z domkiem przywraca wyjściowe ustawienia rysunku. Guzik z obrazkiem dyskietki (czy ktoś jeszcze wie, co to takiego?) pozwala
zachować wykres (jego aktualny stan, czyli z uwzględnieniem dokonanych interaktywnie modyfikacji) jako plik graficzny
jednego z kilku formatów.

=== Rysujemy wykres funkcji sinus ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0.0, 2.0, 0.01)
y = np.sin(2.0*np.pi*x)
plt.plot(x,y)
plt.show()
</source>

; Rezultat
[[Grafika:Wykres2.gif]]

; Jak to działa?

Oprócz funkcji z Matplotlib będziemu tu odwoływać się również wprost do elementów z pakietu NumPy.

Funkcja <tt>arange</tt> jest podobna do standardowej funkcji <tt>range</tt> wytwarzającej określone sekwencje liczb w postaci listy. Funkcja <tt>arange</tt> zamiast listy wytwarza tablicę zawierającą ciąg liczb zmiennoprzecinkowych zaczynający się od pierwszego podanego argumentu funkcji <tt>arange</tt> (u nas <tt>0.0</tt>), a kończący się przed drugim argumentem (tradycyjnie, ciąg wynikowy nie zawiera wartości podanej jako drugi argument, u nas <tt>2.0</tt>). Różnica między elementami wytworzonego ciągu domyślnie wynosi 1, ale jeśli podamy funkcji <tt>arange</tt> trzeci argument, to definiuje on nową różnicę ciągu, u nas wynosi on <tt>0.01</tt>.

Tak więc zmienna <tt>x</tt> jest tablicą-wektorem zawierającą ciąg liczb od 0 do 1,99 co 0,01 (czyli 0, 0,01, 0,02, ..., 1,98, 1,99).

Funkcja <tt>sin</tt> służy do obliczania wartości funkcji sinus dla argumentu podanego w radianach. A co u nas jest argumentem tej funkcji? Wyrażenie będące argumentem zawiera mnożenie liczby <tt>2.0</tt> przez <tt>pi</tt> (pochodzące z pakietu NumPy), a następnie mnożenie wyniku przez tablicę <tt>x</tt>. Zmienna <tt>pi</tt> zawiera przybliżoną wartość matematycznej stałej π ≈ 3,1415926... Mnożenie liczby i tablicy, jak wiemy z poprzedniego punktu, daje w wyniku tablicę. Oznacza to, że argumentem funkcji <tt>sin</tt> jest nie liczba, ale tablica! Taka możliwość jest przewidziana przez twórców pakietu Numpy; wynikiem wywołania funkcji jest wtedy również tablica. Jest ona tej samej długości co tablica będąca argumentem wywołania funkcji.

Tak więc zmienna <tt>y</tt> zawiera ciąg wartości funkcji sinus policzonych dla wartości zawartych w zmiennej <tt>x</tt> pomnożonych każda przez 2π (czyli sin(2π·0), sin(2π·0,01), sin(2π·0,02), ..., sin(2π·1,98), sin(2π·1,99)).

Funkcja <tt>plot(x,y)</tt> narysuje zestaw punktów o współrzędnych (0, sin(2π·0)), (0,01, sin(2π·0,01)), (0,02, sin(2π·0,02)), ..., (1,98, sin(2π·1,98)), (1,99, sin(2π·1,99)) połączonych niebieską linią.

=== Ulepszamy wykres ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0, 2.0, 0.01)
y = np.sin(2.0*p.pi*x)
plt.plot(x,y,'r:',linewidth=6)

plt.xlabel('Czas')
plt.ylabel('Pozycja')
plt.title('Nasz pierwszy wykres')
plt.grid(True)
plt.show()
</source>

; Rezultat
[[Grafika:Wykres3.gif]]

; Jak to działa?

W porównaniu z poprzednim przykładem pojawiło się na wykresie kilka drobnych zmian i &bdquo;ozdobników”.

W funkcji <tt>plot</tt> pojawiły się dwa nowe parametry:
# <tt>'r:'</tt> — ten parametr steruje wyglądem rysowanej linii wykresu. Pierwsza litera tego napisu określa kolor linii (na przykład <tt>r</tt>: czerwony, <tt>b</tt>: niebieski, <tt>g</tt>: zielony, <tt>y</tt>: żółty, <tt>k</tt>: czarny). Drugi znak napisu określa wygląd samej linii (np. <tt>-</tt>: ciągła, <tt>:</tt>: kropkowana, <tt>o</tt>: okrągłe punkty bez linii, <tt>+</tt>: krzyżyki bez linii, itd.).
# <tt>linewidth=6</tt> — ten parametr zmienia grubość rysowanej linii.

Dodaliśmy też wywołania funkcji <tt>xlabel</tt> i <tt>ylabel</tt>. Ich argumentami są napisy, które pojawią się jako opisy osi, odpowiednio poziomej i pionowej.
Wywołanie funkcji <tt>title</tt> wypisuje przekazany jej napis jako tytuł całego wykresu.

Funkcja <tt>grid</tt> dorysowuje siatkę prostokątną na wykresie w wybranych punktach opisujących wartości na osiach wykresu. Punkty, w których wybierane są wartości opisane na osiach (ang. ''tick'') są wybierane automatycznie (oczywiście jeśli chcemy, możemy zmieniać ich położenie i opisy odpowiednią funkcją, powiemy o tym później).

=== Kilka wykresów we wspólnych osiach - Pierwsza wersja ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0, 2.0, 0.01)
y1 = np.sin(2.0*p.pi*x)
y2 = np.cos(2.0*p.pi*x)
plt.plot(x,y1,'r:',x,y2,'g')
plt.legend(('dane y1','dane y2'))
plt.xlabel('Czas')
plt.ylabel('Pozycja')
plt.title('Wykres ')
plt.grid(True)
plt.show()
</source>
'''Rezultat:''' 
[[Grafika:Wykres_2_linie.svg‎]]

;Jak to działa?

W jednym układzie współrzędnych możemy narysować wiele wykresów. Robimy to podając w jednym poleceniu <tt>plot</tt> kolejno zestawy parametrów opisujące poszczególne linie: współrzędne x, współrzędne y, sposób wykreślania linii. Aby łatwo identyfikować linie można dodać legendę poleceniem <tt>legend()</tt>. Sposób kontrolowania wyglądu i położenia legendy: <tt>help(plt.legend)</tt> (oczywiście po zaimportowaniu modułu: <tt>import matplotlib.pyplot as plt</tt> ).

=== Kilka wykresów we wspólnych osiach - Druga wersja ===

<source lang = python>
import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0, 2.0, 0.01)
y1 = np.sin(2.0*p.pi*x)
y2 = np.cos(2.0*p.pi*x)
y = y1*y2
l1, = plt.plot(x,y,'b')
l2,l3 = plt.plot(x,y1,'r:',x,y2,'g')
plt.legend((l2,l3,l1),('dane y1','dane y2','y1*y2'))
plt.xlabel('Czas')
plt.ylabel('Pozycja')
plt.title('Wykres ')
plt.grid(True)
plt.show()

</source>
'''Rezultat:''' 
[[Grafika:Wykres_3_linie.svg‎]]

;Jak to działa?

Wykresy możemy dodawać do współrzędnych kolejnymi poleceniami <tt>plot</tt>.
Funkcja <tt>plot</tt> zwraca listę linii. Notacja <tt>l1, = plt.plot(x,y,'b')</tt> wydobywa z listy pierwszą linię (Gdyby po <tt>l1</tt> nie było przecinka to <tt>l1</tt> byłoby listą zawierającą jeden obiekt klasy linia ).

Dzięki nazwaniu poszczególnych obiektów linii możemy kontrolować ich kolejność (i obecność) na legendzie.

==Histogram (diagram liczebności)==

<source lang=python>
import matplotlib.pyplot as plt

zliczenia = [0, 1, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 7]
plt.hist(zliczenia)
plt.show()
</source>

'''Rezultat:''' 
[[Grafika:Hist1.gif]]

;Jak to działa ?

Do zmiennej <tt>zliczenia</tt> przypisujemy sekwencję z ręcznie podanymi wartościami.
Zakres zmienności badanych zliczeń (odkładany na osi ''X'') zostanie podzielony na przedziały (ang. ''bin'') o jednakowej &bdquo;szerokości”; domyślnie będzie ich 10. Funkcja <tt>hist()</tt> zlicza wystąpienia wartości w binach i rysuje histogram. Funkcja ta zwraca krotkę (array ze zliczeniami, array z binami, lista zawierająca prostokąty, które histogram rysuje, tzw. obiekty Patch).

Porządek wartości, których histogram zostanie stworzony nie ma znaczenia. Mogą one oczywiście być umieszczone również w tablicy NumPy.

===Przykład bardziej zaawansowany===

Wyjaśnienie działania znajduje się w komentarzach do programu:
<source lang = python>
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

mi, sigma = 100, 15
x = mi + sigma * np.random.randn(10000)
# numpy.random.randn zwraca array z liczbami pseudolosowymi
# pochodzącymi z rozkładu normalnego o średniej 0 i wariancji 1
# przemnożenie przez odchylenie standandardowe sigma i dodanie śreniej mi
# transformuje rozkład do rozkładu normalnego o średniej mi i wariancji sigma**2

n, bins, patches = plt.hist(x, 50, normed=True, facecolor='green', alpha=0.75)
# Tu w jawny sposób odbieramy zwracane przez plt.hist obiekty
# Zmieniamy też:
# - ilość binów na 50
# - normujemy histogram do jedności
# - ustalamy kolor prostokątów na zielony
# - ustawiamy (nie)przezroczystość prostokątów na 0.75

bincenters = 0.5*(bins[1:]+bins[:-1])
# wytwarzamy array z centrami binów korzystając z granic binów
# zwróconych przez plt.hist w macierzy bins

y = norm.pdf( bincenters, mi, sigma)
# obliczamy wartości w normalnym rozkładzie gęstości prawdopodobieństwa
# o średniej mi i wariancji sigma**2 dla wartości bincenters

l = plt.plot(bincenters, y, 'r--', linewidth=1)
# do histogramu dorysowujemy linię

plt.show()
</source>

'''Rezultat:''' 
[[Grafika:Hist2.gif]]

==Krzywa parametryczna==

Rysowanie krzywej danej w postaci parametrycznej niewiele się różni od rysowania wykresu funkcji. Żeby było zabawniej, wykonam jeszcze przy okazji rachunek Monte Carlo oraz jego wizualizację.

Krzywa, jaką tutaj narysujemy to tzw. [https://pl.wikipedia.org/wiki/Lemniskata_Gerona lemniskata Gerona]. Zostanie dodatkowo opisana okręgiem jednostkowym; następnie, wylosuję dużą liczbę punktów o równomiernym rozkładzie leżących w kwadracie opisanym na tym okręgu. Robię tak, ponieważ łatwo mi jest wylosować tablicę wielu liczb z zakresu (0, 1) — jest do tego gotowa funkcja <tt>numpy.random.random</tt>, następnie przeskalować i przesunąć je do odcinka (-1, 1). Wreszcie, traktując je jako pary współrzędnych <tt>(x, y)</tt>, pozostawiam tylko te, które znalazły się we wnętrzu koła jednostkowego (odrzucając pozostałe), i dzielę na te, które znalazły się w obszarze wewnątrz lemniskaty, i te, które znalazły się na zewnątrz.

Intuicyjnie jest dość jasne, że — o ile losowaliśmy punkty rzeczywiście w sposób równomierny — stosunek liczby „trafień" w obszar ograniczony lemniskatą do liczby wszystkich „trafień" w obszar koła będzie w przybliżeniu równy stosunkowi pól powierzchni tych obszarów. I na tym tu poprzestaniemy; to, jak dokładne to może być przybliżenie, czyli jakiej wielkości błędu możemy oczekiwać, to już problem na inne zajęcia...

<source lang=python>
import numpy as np
import matplotlib.pyplot as plt

Φ = np.arange(0, 2*np.pi, 2*np.pi/600)
X = np.cos(Φ)
Y = np.sin(2*Φ) / 2 # = np.sin(Φ) * np.cos(Φ)
plt.axes(aspect='equal') # to mi gwarantuje, że okrąg nie wyjdzie „spłaszczony"
plt.plot(X, Y, 'b')
YO = np.sin(Φ)
plt.plot(X, YO, 'k')
# biorę całą kupę losowych punktów z przedziału (-1, 1)
P = np.random.random((100000, 2)) * 2 - 1 # milion par (x, y)
# wyrzucam te, które są poza kołem x**2 + y**2 < 1
P = P[(P**2).sum(axis=1) < 1]
# dzielę na te co wewnątrz lemniskaty, i te co na zewnątrz
I_in = np.abs(P[:,1]) < np.abs(P[:,0]) * np.sqrt(1 - P[:,0]**2)
P_in = P[I_in]
P_out = P[~I_in]
# maluję wewnętrzne na niebiesko
plt.plot(P_in[:,0], P_in[:,1], 'b,')
# a zewnętrzne na czerwono
plt.plot(P_out[:,0], P_out[:,1], 'r,')
# powierzchnia to z grubsza stosunek l. punktów wewnętrznych do wszystkich
S = P_in.size / P.size
plt.title('Pole pow. wnętrza lemniskaty to ok. {:.3f} pola pow. koła'.format(S))
plt.show()
</source>

Przy okazji, jak widać w kodzie Pythona (wersja 3) można bezproblemowo używać liter z innych alfabetów, nie tylko łacińskiego. Niestety nie wszystkie systemy operacyjne zapewniają bezproblemową obsługę pełnego zestawu liter wszelkich języków, dlatego na ogół wykorzystywanie liter z egzotycznych systemów pisma nie jest szczególnie zalecane.

W wyniku uruchomienia tego programu powinno pojawić się okno z obrazkiem podobnym do poniższego:

[[File:Lemniskata.png]]

==Wizualizacja zawartości tablicy dwuwymiarowej==

<source lang=python>
import numpy as np
import matplotlib.pyplot as plt

A = np.arange(20)
X, Y = np.meshgrid(A, A)
Z = X + Y
plt.imshow(Z, cmap='hot', interpolation='none')
plt.colorbar()
plt.show()
</source>

'''Wynik:'''

[[Grafika:Imshow1.png]]

Jak można się domyślić, parametr <tt>cmap</tt> wywołania funkcji <tt>imshow</tt> odpowiada za odwzorowanie pomiędzy wartościami elementów tablicy a barwami - jest wiele predefiniowanych takich odwzorowań (''colormaps''), opisanych w dokumentacji. Za pomocą wartości <tt>'none'</tt> parametru <tt>interpolation</tt> wyłączyliśmy ,,wygładzanie" obrazu, inne możliwe wartości umożliwiają wybór różnych algorytmów wygładzania. Wywołanie <tt>colorbar</tt> dostarcza paska wizualizującego odpowiedniość pomiędzy wartościami liczbowy i barwami.

==Plik graficzny jako źródło danych==

<source lang=python>
import numpy as np
import matplotlib.pyplot as plt

img = plt.imread('reading-girl.jpg')
plt.imshow()
plt.show()
</source>

'''Wynik:'''

[[Grafika:Imshow-girl-1.jpg]]

Wynikiem wywołania <tt>imread</tt> jest tablica o kształcie ''(wysokość, szerokość, 3)'' zawierająca dla każdego piksela obrazu wartości jego składowych RGB, tj. natężeń barw: czerwonej, zielonej, i niebieskiej - jako liczby w zakresie od 0 do 255 włącznie. Oczywiście na tej tablicy możemy wykonywać najróżniejsze operacje, analizując treść obrazu czy przekształcając go. Przykładowo:

<source lang=python>
img1 = img[:400, -400:] # przycinam obraz do kształtu 400x400 pikseli
img2 = img1.sum(axis=2)
img3 = img2 / img2.max()
plt.imgshow(img3, cmap='bone')
plt.show()
</source>

'''Wynik:'''

[[Grafika:reading-girl-bone.jpg]]

<source lang=python>
plt.hist(img3.flatten(), bins=100)
plt.show()
</source>

'''Wynik:'''

[[Grafika:reading-girl-hist.png]]

Wykonaliśmy w ten sposób histogram opisujący rozkład natężenia pikseli obrazka.

==Wiele wykresów w jednym oknie==

==Ćwiczenia==

1. Spróbuj znaleźć sposób przekształcenia obrazka takiego, jak poniższy portret autora skryptu:

[[Grafika:rjb_small.jpg]]

do postaci przypominającej

[[Grafika:rjb_bw.png]]

2. (''Nieco złożone'') Napisz program symulujący „bilard na kółku". Dokładniej: wewnątrz koła jednostkowego na płaszczyźnie porusza się cząstka (punkt), zachowując stałą prędkość — dopóki nie napotka brzegu, czyli okręgu; wówczas odbija się zgodnie z zasadą, że kąt padania równa się kątowi odbicia; chodzi o kąt pomiędzy wektorem prędkości a promieniem okręgu jednostkowego w miejscu, gdzie tor ruchu przecina się z okręgiem, po odbiciu jest on taki sam co do wartości ale ''po drugiej stronie'' promienia. Program rysuje okręg jednostkowy oraz tor ruchu cząstki wewnątrz tego okręgu, w zależności od początkowego położenia, kierunku początkowej prędkości (wartość prędkości jest nieistotna, ponieważ jest stała), i czasu obserwacji.

Wynikiem programu są wykresy podobne do poniższego:

[[Grafika:bilard_na_kole.png]]

czarną kropką oznaczono położenie początkowe, a na zielono — końcowe.

----

[[PPy3/NumPy|poprzednie]] | [["Programowanie z Pythonem3"|strona główna]] | [[PPy3/TematyDodatkowe]]

--[[Użytkownik:RobertJB|RobertJB]] ([[Dyskusja użytkownika:RobertJB|dyskusja]]) 14:05, 10 kwi 2017 (CEST)