Języki skryptowe Python

Języki skryptowe Python Wykład 3 Zmienne, wyrażenia, instrukcje Janusz Szwabiński Plan wykładu: Wartości i ich typy Zmienne Instrukcje warunkowe Łańcuchy znaków Pętle Wartości i ich typy Wartości (liczby i litery) należą do podstawowych obiektów przetwarzanych przez programy komputerowe. Są one podzielone na różne typy: 4jest liczbą całkowitą (ang. integer), 3.2jest liczbą zmiennoprzecinkową (float), natomiast "Witaj ściecie"to napis lub łańcuch znaków (string). Napisy rozpoznajemy po cudzysłowach lub apostrofach, w które ujęte. Jeśli nie jesteśmy pewni, jakiego typu jest dana wartość, możemy sprawdzić ją przy pomocy polecenia type: In [1]: type(2) Out[1]: int In [2]: type(3.2) Out[2]: float In [3]: type("cześć") Out[3]: str

W powyższych przykładach wyniki działania polecenia typesą sformatowane przez notatnik IPythona. W konsoli zobaczymy raczej coś takiego: >>> type(2) <class 'int'> >>> Liczby ujęte w cudzysłowach lub apostrofach interpretowane są również jako łańcuchy znaków: In [4]: type('3.4') Out[4]: str Warto wiedzieć: jeśli ciąg znaków zawiera poprawne wyrażenie, możemy je wykonać przy pomocy funkcji eval: In [5]: eval('2+2') Out[5]: 4 Uwaga! Do wprowadzania części ułamkowej liczb zmiennoprzecinkowych używamy kropki: In [6]: 1.0 Out[6]: 1.0 In [7]: type(_) Out[7]: float Użycie przecinka nie jest błędem składniowym, ale wynik jest zupełnie inny, niż moglibyśmy się spodziewać. In [8]: 1,0 Out[8]: (1, 0)

In [9]: type(_) Out[9]: tuple Zmienne Operowanie na zmiennych to jedna z najważniejszych funkcjonalności, jakie oferują języki programowania. Zmienna to po prostu nazwa, która wskazuje na jakąś wartość. Zmienne tworzymy i nadajemy im wartości operatorem przypisania: In [10]: message = "To jest przykład łańcucha znaków" n = 17 pi = 3.14 Typ zmiennej to po prostu typ wartości, do której zmienna się odnosi: In [11]: type(message) Out[11]: str In [12]: type(n) Out[12]: int In [13]: type(pi) Out[13]: float Ponieważ Python jest językiem o typowaniu dynamicznym, typ zmiennej możemy zmienić w trakcie wykonywania programu: In [14]: n = "To była wcześniej zmienna typu int"

In [15]: type(n) Out[15]: str Używać możemy jedynie zmiennych "zdefiniowanych", tzn. takich, którym przypisana jest jakaś wartość: In [20]: b ------------------------------------------------------------------- -------- NameError Traceback (most recent ca ll last) <ipython-input-20-3b5d5c371295> in <module>() ----> 1 b NameError: name 'b' is not defined Diagram stanów Bardzo przydatnym narzędziem w projektowaniu i analizie programu jest tzw. diagram stanu (ang. state diagram). W przypadku zmiennych przedstawia on ich stan w każdej chwili czasu, np.: Nazwy zmiennych i słowa kluczowe Nazwy zmiennych w Pythonie mogą być dowolnie długie. Mogą zawierać litery (bez znaków diakrytycznych), cyfry oraz dowolną liczbę podkreślników, jednak nie mogą zaczynać się od cyfr. Wielu (dobrych) programistów wybiera opisowe nazwy zmiennych. Wówczas kod jest bardziej czytelny i łatwiej go analizować, ponieważ na podstawie nazwy można stwierdzić, do czego zmienna jest wykorzystywana: In [21]: t = 7.8 In [22]: temperatureincelsius = 7.8

In [24]: temperatureinfahrenheit = 32 + (9/5)*temperatureInCelsius In [25]: print(temperatureinfahrenheit) 46.04 Powyższy przykład to konwencja nazewnicza mixedcase. Możliwych jest kilka innych. Więcej na ten temat można przeczytać w artykule PEP 0008 Style Guide for Python Code (https://www.python.org/dev/peps/pep 0008/ (https://www.python.org/dev/peps/pep 0008/)). Jeżeli użyjemy niepoprawnej nazwy zmiennej, interpreter Pythona zwróci błąd składni: In [26]: 76trombones = 'wielka parada' File "<ipython-input-26-7f22220e7abb>", line 1 76trombones = 'wielka parada' ^ SyntaxError: invalid syntax In [27]: osiem_puzonów = 'sekcja dęta' In [28]: total@ = 10000 File "<ipython-input-28-0c9d8b7bda7c>", line 1 total@ = 10000 ^ SyntaxError: invalid syntax In [29]: class = 'Informatyka stosowana' File "<ipython-input-29-20ade69cb30e>", line 1 class = 'Informatyka stosowana' ^ SyntaxError: invalid syntax Pierwsze trzy błędy powinny być oczywiste: w pierwszym przykładzie nazwa zaczyna się od cyfry, w drugim pojawił się znak diakrytyczny, w trzecim niedozwolony znak @. W ostatnim przykładzie nazwa jest wprawdzie formalnie poprawna, ale classnależy do tzw. słów kluczowych, czyli zarezerwowanych słów, przy pomocy których definiowana jest składnia języka.

In [31]: import keyword keyword.iskeyword('class') Out[31]: Słów kluczowych jest obecnie ponad 30. Nie mogą być one używane jako nazwy zmiennych, a ich zapis musi być zgodny z podanym poniżej: In [32]: keyword.kwlist Out[32]: ['False', 'None', '', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

Instrukcje warunkowe Wyrażenia logiczne Wyrażenie logiczne to wyrażenie, które jest albo prawdą () albo fałszem (False). Sprawdzenie, czy dwie liczby są równe, to przykład takiego wyrażenia: In [33]: 5 == 6 Out[33]: False In [34]: 5 == 5 Out[34]: In [35]: val = 5 val == 5 Out[35]: Częstym błędem przy porównaniach jest użycie operatora przypisania =zamiast operatora porównania ==. W przypadku porównywania dwóch literałów będzie to łatwy do zlokalizowania błąd składni: In [36]: 5=4 File "<ipython-input-36-bf9f671a8299>", line 1 5=4 ^ SyntaxError: can't assign to literal W przypadku porównywania zmiennych będziemy mieli natomiast do czynienia z błędem semantycznym, który jest dużo trudniej znaleźć. i Falseto specjalne wartości typu logicznego: In [33]: type() Out[33]: bool

In [34]: type(false) Out[34]: bool Używany powyżej operator ==to przykład operatora porównania. Innymi operatorami tego typu są: In [37]: 3!= 4 # nie jest równy Out[37]: In [38]: 3 > 2 # większy Out[38]: In [39]: 3 < 2 # mniejszy Out[39]: False In [40]: 3 >= 2 # większy równy Out[40]: In [41]: 3 <= 2 # mniejszy równy Out[41]: False Operatory logiczne W Pythonie mamy do dyspozycji trzy operatory logiczne: and, ori not. Ich znaczenie jest podobne do znaczenia odpowiadających im słów w języku naturalnym: wyrażenie x > 0 and x < 10będzie miało wartość, jeśli x jest większe od 0 i jednocześnie mniejsze od 10 n%2 == 0 or n%3 == 0będzie miało wartośc, jeśli njest podzielne przed 2 lub przez 3 notneguje wartość wyrażenia logicznego, tzn. not (x>y)będzie prawdą, jeśli x>yjest fałszem

In [42]: x = 5 x > 0 and x < 10 Out[42]: In [43]: x = -5 x > 0 and x < 10 Out[43]: False In [44]: n=13 n%2 == 0 or n%3 == 0 Out[44]: False In [45]: n=12 n%2 == 0 or n%3 == 0 Out[45]: In [46]: x < n Out[46]: In [47]: not (x<n) Out[47]: False W zasadzie argumentami operatorów logicznych powinny być wyrażenia logiczne. Jednak Python pod tym względem nie jest bardzo rygorystyczny i każda liczba różna od zera jest traktowana jako :

In [48]: 17 and Out[48]: In [49]: -1 and Out[49]: In [50]: 0 and Out[50]: 0 Wyrażenia warunkowe Wyrażenie warunkowe to jedno z ważniejszych poleceń pozwalających kontrolować wywołanie programu. Dzięki niemu możemy spowodować, aby pewne partie programu wykonywały się tylko po spełnieniu pewnych warunków. Składnia podstawowego wyrażenia warunkowego jest następująca: if <warunek>: <instrukcje> Przy tym: warunek ma wartość lub False każda niezerowa liczba lub sekwencja o niezerowej długości oznaczają zero, sekwencja o zerowej długości lub Noneoznaczają False dwukropek po warunku jest ważny (otwiera blok instrukcji) jeśli warunek ma wartość, wykonywane są instrukcje wcięte w stosunku do słowa kluczowego if jeśli warunek ma wartość False, instrukcje są pomijane In [54]: x = eval(input("podaj liczbę: ")) print(type(x)) if x < 0: print("błąd! Liczba ujemna.") Podaj liczbę: -1 <class 'int'> Błąd! Liczba ujemna.

W bloku musi być co najmniej jedna instrukcja, natomiast nie ma żadnych ograniczeń na ich maksymalną. Czasami, zwłaszcza w początkowej fazie pisania programu, potrzeba jednak bloku instrukcji, który nie robi nic: In [55]: if x<0: # do zrobienia - przetwarzanie liczb ujemnych File "<ipython-input-55-8e881e2ac4c1>", line 1 if x<0: # do zrobienia - przetwarzanie liczb ujemnych ^ SyntaxError: unexpected EOF while parsing W takiej sytuacji używamy instrukcji pass. Nie robi ona nic, powoduje jednak, że blok ma poprawną składnię: In [56]: if x<0: pass # do zrobienia - przetwarzanie liczb ujemnych Można traktować tę instrukcję jako wypełniacz, który w trakcie rozbudowywania programu zastąpiony zostanie właściwym kodem. Wyrażenia warunkowe można uogólnić na więcej (opcjonalnych) warunków. Składnia ma wówczas postać: if <warunek1>: <instrukcje> elif <warunek2>: <instrukcje> else: <instrukcje> jeśli spełniony jest warunek1, wykonywane są instrukcje z bloku if jeśli spełniony jest warunek2, wykonywane są instrukcje z bloku elif jeżeli żaden z powyższych warunków nie jest spełniony, wykonywany jest blok else In [57]: x = input('podaj liczbę: ') print(type(x)) x = int(x) if x < 0: print("liczba ujemna") elif x == 0: print("bingo! Trafiłeś 0") else: print("liczba dodatnia") Podaj liczbę: 3 <class 'str'> Liczba dodatnia

Uwaga! Sekwencja if...elif...elif...elseoferuje podobną funkcjonalność jak instrukcja switch/casespotykana w innych językach programowania. Ponadto, wyrażenia warunkowe możemy zagnieżdżać w sobie: In [59]: x = eval(input('podaj liczbę: ')) y = eval(input('podaj drugą liczbę: ')) if x == y: print("liczby są równe!") else: if x<y: print(x, " jest mniejsze od ", y) else: print(x, " jest większe od ", y) Podaj liczbę: 2 Podaj drugą liczbę: 3 2 jest mniejsze od 3 Łańcuchy znaków (ang. strings) Łańcuch znaków to jeden z wbudowanych sekwencyjnych typów danych w Pythonie. Służy on do przechowywania ciągów znaków. Najważniejsze własności: do definiowania łańcuchów znaków służą cudzysłowy lub apostrofy łańcuchy znaków mogą rozciągać się na wiele linii nie ma oddzielnego typu dla pojedynczego znaku to po prostu łańcuch o długości 1 znaki w łańcuchu można indeksować inaczej niż w C/C++, raz utworzony łańcuch nie może być zmieniony łańcuchy można łączyć przy pomocy operatora + łańcuchy można powtarzać przy pomocy operatora * wsparcie dla unicode Definiowanie łańcuchów znaków In [60]: s = "Witaj świecie" In [63]: print(s) Witaj świecie Ten sam efekt uzyskamy przy pomocy apostrofów:

In [64]: s = 'Witaj świecie' print(s) Witaj świecie Rozważmy następujący przykład: In [65]: print(" "Kto tam?" zapytał Wojtek") File "<ipython-input-65-9bb1add46e58>", line 1 print(" "Kto tam?" zapytał Wojtek") ^ SyntaxError: invalid syntax Jak w wielu innych językach programowania, możemy do wewnętrznych cudzysłowów użyć znaków ucieczki, tzn. spowodować, aby interpreter traktował je dosłownie: In [66]: print(" \"Kto tam?\" zapytał Wojtek") "Kto tam?" zapytał Wojtek Jest to jednak mało wygodne (więcej znaków do wprowadzenia). Dlatego dwa rodzaje znaków definiujących łańcuchy znaków okazują się bardzo przydatne: In [67]: print(' "Kto tam?" zapytał Wojtek ') "Kto tam?" zapytał Wojtek In [68]: print("he doesn't...") He doesn't... Powyższe przykłady dotyczyły krótkich łańcuchów znaków. Python obsługuje również napisy dłuższe, rozciągające się na wiele linii. Mamy kilka sposobów na ich wprowadzenie. Po pierwsze, możemy sami wstawiać znak nowej linii, \n: In [69]: halo = "To dość długi łańcuch znaków,\n\ który rozciąga się na wiele\n\ linii"

In [70]: print(halo) To dość długi łańcuch znaków, który rozciąga się na wiele linii Znak kontynuacji linii w powyższym przykładzie jest również wymagany: In [71]: halo = "To dość długi łańcuch znaków,\n który rozciąga się na wiele\n linii" File "<ipython-input-71-4927b6c8dcf0>", line 1 halo = "To dość długi łańcuch znaków,\n ^ SyntaxError: EOL while scanning string literal Inna możliwość to skorzystanie z potrójnych apostrofów lub cudzysłowów: In [72]: halo = """To dość długi łańcuch znaków, który rozciąga się na wiele linii""" In [73]: print(halo) To dość długi łańcuch znaków, który rozciąga się na wiele linii Czasami może się zdarzyć, że interpreter Pythona znajdzie znak nowej linii tam, gdzie go tak naprawdę nie powinno być: In [74]: print("c:\some\name") C:\some ame Rozwiązania tego problemu są dwa. Możemy albo skorzystać ze znanego już znaku ucieczki: In [75]: print("c:\some\\name") C:\some\name

albo z tzw. surowych łańcuchów (zwróć uwagę na literę rpoprzedzającą łańcuch znaków): In [76]: print(r"c:\some\name") C:\some\name In [78]: napis = input("jakiś tekst: ") print(napis) Jakiś tekst: he doesn't he doesn't Operacje na łańcuchach Łańcuchy znaków możemy łączyć ze sobą przy pomocy operatora +: In [79]: slowo = 'świt' + 'a' In [80]: print(slowo) świta Jeżeli łączymy ze sobą dwa literały łańcuchowe, możemy pominąć ten operator: In [81]: 'Witaj' ' świecie' Out[81]: 'Witaj świecie' Automatyczne łączenie nie działa jednak w przypadku zmiennych: In [83]: imie = "Janusz" nazwisko = "Szwabiński" In [84]: imie nazwisko File "<ipython-input-84-c5695307cc4a>", line 1 imie nazwisko ^ SyntaxError: invalid syntax

In [85]: imie+nazwisko Out[85]: 'JanuszSzwabiński' Mnożenie łańcucha przez skalar to nic innego jak powtarzanie tego łańcucha: In [86]: print(slowo*5) świtaświtaświtaświtaświta Jednak działa to tylko dla liczb całkowitych: In [87]: print(slowo*5.0) ------------------------------------------------------------------- -------- TypeError Traceback (most recent ca ll last) <ipython-input-87-a14ebdf38ba7> in <module>() ----> 1 print(slowo*5.0) TypeError: can't multiply sequence by non-int of type 'float' Działania na łańcuchach znaków możemy oczywiście ze sobą łączyć: In [88]: '<' + 2*slowo + '>' Out[88]: '<świtaświta>' Formatowanie łańcuchów znaków In [89]: txt = "kilka liczb: " x = 2 y = 1.34 z = 2 + 3j In [90]: text1 = "%s %d, %.2f, %.2f+%.2fi" % (txt,x,y,z.real,z.imag)

In [91]: print(text1) kilka liczb: 2, 1.34, 2.00+3.00i In [92]: text2 = "%s %d, %f, %s" % (s,x,y,z) In [93]: print(text2) Witaj świecie 2, 1.340000, (2+3j) Indeksowanie łańcuchów znaków Łańcuch znaków to nic innego jak ciąg znaków, z których każdy ma określoną pozycję. Dostęp do poszczególnych znaków w ciągu uzyskamy przy pomocy nawiasów kwadratowych: In [94]: slowo = 'taczka' znak = slowo[1] Wyrażenie w nawiasie kwadratowym to indeks. Wskazuje on znak, do którego zażądaliśmy dostępu. Czyli zmienna znak wskazuje na literę w słowie o indeksie 1: In [95]: print(znak) a Okazuje się jednak, że nie jest to pierwsza litera tego słowa. W Pythonie, podobnie jak w C/C++ i wielu innych językach, indeksowanie sekwencyjnych typów danych zaczyna się od : In [96]: print(slowo[0]) t 0 In [97]: print(slowo[1]) a In [98]: print(slowo[5]) a

Długość łańcucha, czyli liczbę znaków w łańcuchu, odczytamy przy pomocy funkcji len: In [99]: len(slowo) Out[99]: 6 0 1 n 1 n n Ponieważ indeksowanie zaczyna się od a nie od, ostatni element łańcucha ma indeks, a nie ( to liczba znaków): In [100]: n = len(slowo) print(slowo[n-1]) a Dlatego użycie długości łańcucha jako indeksu spowoduje wyjście poza zakres: In [101]: print(slowo[n]) ------------------------------------------------------------------- -------- IndexError Traceback (most recent ca ll last) <ipython-input-101-d348d9284622> in <module>() ----> 1 print(slowo[n]) IndexError: string index out of range Python wspiera również tworzenie wycinków z łańcuchów znaków (ogólnie ze wszystkich typów sekwencyjnych): In [102]: slowo[0:3] #elementy od indeksu 0 (włącznie) do indeksu 3 (bez tego indeksu) Out[102]: 'tac' In [103]: slowo[:2] #dwie pierwsze litery Out[103]: 'ta'

In [104]: slowo[2:] #wszystkie oprócz dwóch pierwszych Out[104]: 'czka' Przy wycinkach nie ma błędu z wyjściem poza zakres: In [105]: slowo[2:100] Out[105]: 'czka' Indeksy ujemne Python dopuszcza ujemne indeksy we wszystkich sekwencyjnych typach danych. Przy tym, indeks należy rozumieć jako : n k k In [106]: slowo[-1] #ostatnia litera Out[106]: 'a' In [107]: slowo[-2] #przedostatnia Out[107]: 'k' In [108]: slowo[-2:] #dwie ostatnie Out[108]: 'ka' In [109]: slowo[0:-2] #wszystkie oprócz dwóch ostatnich Out[109]: 'tacz'

In [110]: slowo[-0] #jak w matematyce: -0=0 Out[110]: 't' Niezmienny typ danych Łańcuchy znaków w Pythonie to jeden z tzw. niezmiennych typów danych. Oznacza to tylko tyle, że raz utworzony, nie może zostać zmieniony: In [111]: print(slowo) taczka In [112]: slowo[0] = 'k' ------------------------------------------------------------------- -------- TypeError Traceback (most recent ca ll last) <ipython-input-112-bdf5d26b7f3e> in <module>() ----> 1 slowo[0] = 'k' TypeError: 'str' object does not support item assignment Nie jest to jednak wielkim ograniczeniem, ponieważ możliwa jest taka operacja: In [113]: slowo = 'k' + slowo[1:] In [114]: print(slowo) kaczka Ostatnie wyrażenie oznacza tyle, że z dwóch łańcuchów znaków stworzony został nowy napis, a następnie nadano mu nazwę slowo. Jeżeli w programie nie było więcej zmiennych wskazujących na stary napis, to niemożliwe jest uzyskanie dostępu do niego i zostanie on usunięty przez interpreter w celu zwolnienia zasobów. Dlatego efekt końcowy przypomina po prostu zmodyfikowanie łańcucha znaków znane z innych języków, mimo że od podszewki jest to zupełnie inna operacja. Łańcuchy znaków i ich metody

Metoda przypomina swoim działaniem funkcję pobiera argumenty i zwraca jakiś wynik, ma jednak inną niż funkcja składnię. Rozważmy metodę upper, która w podanym jako argument łańcuchu znaków zmienia wszystkie małe litery na duże i tworzy z nich nowy łańcuch. Gdyby upperbyła funkcją, jej wywołanie wygładałoby następująco: upper(slowo) Jako metoda wywoływane jest tak: In [115]: nowe_slowo = slowo.upper() In [116]: print(nowe_slowo) KACZKA Najpierw podajemy nazwę zmiennej (lub literał) na której chcemy wykonać metodę, po której następuje kropka, a po kropce nazwa metody. Puste nawiasy w powyższym przykładzie oznaczają, że metoda nie potrzebuje dodatkowych argumentów do wykonania. Przykładem metody, która wymaga argumentu, jet metoda find. Służy ona do wyszukiwania podanych znaków w łańcuchu: In [117]: print(slowo) kaczka In [118]: index = slowo.find('cz') print(index) 2 In [119]: print(slowo.find('a')) 1 Wywołując find, możemy podać jeszcze jeden argument indeks, od którego należy rozpocząć przeszukiwanie: In [120]: print(slowo.find('a',2)) 5 Natomiast trzecim argumentem może być indeks, na którym należy skończyć wyszukiwanie:

In [121]: print(slowo.find('a',2,4)) -1 Wynik 1 oznacza, że w podanym zakresie nie było żadnych trafień. Operator in Słowo kluczowe injest operatorem logicznym, który dla dwóch argumentów sprawdza, czy pierwszy jest podciągiem drugiego. In [122]: print(slowo) kaczka In [123]: 'kac' in slowo Out[123]: In [124]: 't' in slowo Out[124]: False Porównywanie łańcuchów znaków Operator ==pozwoli nam sprawdzić, czy łańcuchy znaków są takie same: In [125]: print(slowo) kaczka In [127]: if slowo == 'kaczka': print("uwaga! Sezon polowań na kaczki już trwa") Uwaga! Sezon polowań na kaczki już trwa Pozostałe operatory porównań również działają. Można je wykorzystać do ustalenia porządku alfabetycznego wyrazów.

In [128]: if slowo < 'taczka': print(slowo, 'taczka') else: print('taczka', slowo) kaczka taczka In [129]: slowo2 = 'paczka' if slowo2 < 'kaczka': print(slowo2, 'kaczka') else: print('kaczka', slowo2) kaczka paczka Jedyny problem z porównywaniem wyrazów związany jest z tym, że Python inaczej niż ludzie w życiu codziennym traktuje wielkie litery (wielkie litery przed małymi). In [130]: 'paczka' < 'taczka' Out[130]: In [131]: 'paczka' < 'Taczka' Out[131]: False Aby uniknąć błędu spowodowanego tą własnością, przed porównywaniem warto jest przekonwertować oba napisy do jakiegoś standardowego formatu, np. do małych liter: In [132]: 'paczka'.lower() < 'Taczka'.lower() Out[132]:

Pętle Obok instrukcji warunkowych pętle to jedne z ważniejszych konstrukcji programowania strukturalnego. Umożliwiają cykliczne wykonywanie ciągu instrukcji określoną liczbę razy lub do momentu zajścia pewnych warunków. W Pythonie mamy do dyspozycji dwie pętle, fori while. Pętla for Instrukcja forw Pythonie różni się od pętli o tej samej nazwie w C/C++, ponieważ iteracja nie odbywa się od liczby do liczby, a po elementach dowolnej sekwencji (łańcucha znaków, listy, krotki itp.) w takim porządku, w jakim są one umieszczone w sekwencji: In [133]: przedrostki = 'kpt' przyrostek = 'aczka' for przedrostek in przedrostki: print(przedrostek+przyrostek) kaczka paczka taczka Ogólnie, składnia pętli forma postać: for <zmienna> in <sekwencja>: <instrukcje> W dalszej części wykładu poznamy inne typy sekwencji, po elementach których można iterować. Natomiast tutaj wspomnimy tylko o jednej funkcji, dość często wykorzystywanej w pętlach, zwłaszcza przez początkujących programistów w Pythonie z doświadczeniami w innych językach programowania: In [1]: for i in range(5): print(i) 0 1 2 3 4 In [9]: for i in range(2,5): print(i,i**2) 2 4 3 9 4 16

In [8]: for i in range(0,10,2): print(i,i**3) 0 0 2 8 4 64 6 216 8 512 In [4]: print(range(5)) range(0, 5) In [5]: type(range(5)) Out[5]: range Chociaż rzeczywiście wywołujemy rangejako funkcję, jest to raczej typ danych reprezentujący niezmienną sekwencję liczb. Wykorzystuje się go najczęście w petlach fordo wykonania określonej liczby powtórzeń. Pętla while Pętla whilesłuży do cyklicznego wykonywania ciągu instrukcji do momentu, aż warunek przestanie być spełniony: while <warunek>: <instrukcje> In [134]: fruit = 'Banana' index = 0 while index < len(fruit): letter = fruit[index] print(letter) index = index + 1 B a n a n a

Instrukcje breaki continue Instrukcja breakpowoduje wyjście z najbliższej zagnieżdżonej pętli forlub while. Rozważmy przykład: In [136]: fruit = 'banana' index = 0 while 1: #w zasadzie pętla nieskończona print(fruit[index]) index = index + 1 b a n a n a ------------------------------------------------------------------- -------- IndexError Traceback (most recent ca ll last) <ipython-input-136-536266ccf1b8> in <module>() 2 index = 0 3 while 1: #w zasadzie pętla nieskończona ----> 4 print(fruit[index]) 5 index = index + 1 IndexError: string index out of range Aby uniknąć błędu, możemy przerwać pętlę w odpowiednim momencie: In [137]: fruit = 'banana' index = 0 while 1: #w zasadzie pętla nieskończona print(fruit[index]) index = index + 1 if index == len(fruit): break b a n a n a Instrukcja continuepowoduje przejście do następnego kroku iteracji:

In [138]: fruit = 'Banana' for letter in fruit: if letter == 'a': continue print(letter) B n n