Języki skryptowe ­ Python

27  Download (0)

Pełen tekst

(1)

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: 4 jest liczbą całkowitą (ang. integer), 3.2 jest 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)

In [2]:

type(3.2)

In [3]:

type("Cześć") Out[1]:

int

Out[2]:

float

Out[3]:

str

(2)

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')

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')

Uwaga! Do wprowadzania części ułamkowej liczb zmiennoprzecinkowych używamy kropki:

In [6]:

1.0

In [7]:

type(_)

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[4]:

str

Out[5]:

4

Out[6]:

1.0

Out[7]:

float

Out[8]:

(1, 0)

(3)

In [9]:

type(_)

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)

In [12]:

type(n)

In [13]:

type(pi)

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"

Out[9]:

tuple

Out[11]:

str

Out[12]:

int

Out[13]:

float

(4)

type(n)

Używać możemy jedynie zmiennych "zdefiniowanych", tzn. takich, którym przypisana jest jakaś wartość:

In [20]:

b

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 Out[15]:

str

--- ---

NameError Traceback (most recent ca ll last)

<ipython-input-20-3b5d5c371295> in <module>() ----> 1b

NameError: name 'b' is not defined

(5)

In [24]:

temperatureInFahrenheit =32+ (9/5)*temperatureInCelsius

In [25]:

print(temperatureInFahrenheit)

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'

In [27]:

osiem_puzonów ='sekcja dęta'

In [28]:

total@=10000

In [29]:

class = 'Informatyka stosowana'

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 class należy do tzw. słów kluczowych, czyli zarezerwowanych słów, przy pomocy których definiowana jest składnia języka.

46.04

File "<ipython-input-26-7f22220e7abb>", line 1 76trombones = 'wielka parada'

^

SyntaxError: invalid syntax

File "<ipython-input-28-0c9d8b7bda7c>", line 1 total@ = 10000

^

SyntaxError: invalid syntax

File "<ipython-input-29-20ade69cb30e>", line 1 class = 'Informatyka stosowana'

^

SyntaxError: invalid syntax

(6)

importkeyword

keyword.iskeyword('class')

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[31]:

True

Out[32]:

['False', 'None', 'True', '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']

(7)

Instrukcje warunkowe

Wyrażenia logiczne

Wyrażenie logiczne to wyrażenie, które jest albo prawdą (True) albo fałszem (False). Sprawdzenie, czy dwie liczby są równe, to przykład takiego wyrażenia:

In [33]:

5==6

In [34]:

5==5

In [35]:

val =5 val ==5

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

W przypadku porównywania zmiennych będziemy mieli natomiast do czynienia z błędem semantycznym, który jest dużo trudniej znaleźć.

True i False to specjalne wartości typu logicznego:

In [33]:

type(True) Out[33]:

False

Out[34]:

True

Out[35]:

True

File "<ipython-input-36-bf9f671a8299>", line 1 5=4

^

SyntaxError: can't assign to literal

Out[33]:

bool

(8)

type(False)

Używany powyżej operator == to przykład operatora porównania. Innymi operatorami tego typu są:

In [37]:

3!=4# nie jest równy

In [38]:

3>2# większy

In [39]:

3<2# mniejszy

In [40]:

3>=2# większy równy

In [41]:

3<=2# mniejszy równy

Operatory logiczne

W Pythonie mamy do dyspozycji trzy operatory logiczne: and, or i not. Ich znaczenie jest podobne do znaczenia odpowiadających im słów w języku naturalnym:

wyrażenie x > 0 and x < 10 będzie miało wartość True, jeśli x jest większe od 0 i jednocześnie mniejsze od 10

n%2 == 0 or n%3 == 0 będzie miało wartośc True, jeśli n jest podzielne przed 2 lub przez 3 not neguje wartość wyrażenia logicznego, tzn. not (x>y) będzie prawdą, jeśli x>y jest fałszem Out[34]:

bool

Out[37]:

True

Out[38]:

True

Out[39]:

False

Out[40]:

True

Out[41]:

False

(9)

In [42]:

x =5

x >0and x <10

In [43]:

x =-5

x >0and x <10

In [44]:

n=13

n%2 == 0 or n%3 == 0

In [45]:

n=12

n%2 == 0 or n%3 == 0

In [46]:

x < n

In [47]:

not (x<n)

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 True:

Out[42]:

True

Out[43]:

False

Out[44]:

False

Out[45]:

True

Out[46]:

True

Out[47]:

False

(10)

17andTrue

In [49]:

-1andTrue

In [50]:

0andTrue

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ść True lub False

każda niezerowa liczba lub sekwencja o niezerowej długości oznaczają True zero, sekwencja o zerowej długości lub None oznaczają False

dwukropek po warunku jest ważny (otwiera blok instrukcji)

jeśli warunek ma wartość True, 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.") Out[48]:

True

Out[49]:

True

Out[50]:

0

Podaj liczbę: -1

<class 'int'>

Błąd! Liczba ujemna.

(11)

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

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")

File "<ipython-input-55-8e881e2ac4c1>", line 1

if x<0: # do zrobienia - przetwarzanie liczb ujemnych ^ SyntaxError: unexpected EOF while parsing

Podaj liczbę: 3

<class 'str'>

Liczba dodatnia

(12)

switch/case spotykana 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)

Ł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)

Ten sam efekt uzyskamy przy pomocy apostrofów:

Podaj liczbę: 2

Podaj drugą liczbę: 3 2 jest mniejsze od 3

Witaj świecie

(13)

In [64]:

s ='Witaj świecie' print(s)

Rozważmy następujący przykład:

In [65]:

print(" "Kto tam?" zapytał Wojtek")

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")

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 ')

In [68]:

print("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"

Witaj świecie

File "<ipython-input-65-9bb1add46e58>", line 1 print(" "Kto tam?" zapytał Wojtek")

^

SyntaxError: invalid syntax

"Kto tam?" zapytał Wojtek

"Kto tam?" zapytał Wojtek

He doesn't...

(14)

print(halo)

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"

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)

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")

Rozwiązania tego problemu są dwa. Możemy albo skorzystać ze znanego już znaku ucieczki:

In [75]:

print("C:\some\\name")

To dość długi łańcuch znaków, który rozciąga się na wiele linii

File "<ipython-input-71-4927b6c8dcf0>", line 1 halo = "To dość długi łańcuch znaków,\n ^ SyntaxError: EOL while scanning string literal

To dość długi łańcuch znaków, który rozciąga się na wiele linii

C:\some ame

C:\some\name

(15)

albo z tzw. surowych łańcuchów (zwróć uwagę na literę r poprzedzającą łańcuch znaków):

In [76]:

print(r"C:\some\name")

In [78]:

napis =input("Jakiś tekst: ") print(napis)

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)

Jeżeli łączymy ze sobą dwa literały łańcuchowe, możemy pominąć ten operator:

In [81]:

'Witaj'' świecie'

Automatyczne łączenie nie działa jednak w przypadku zmiennych:

In [83]:

imie ="Janusz"

nazwisko ="Szwabiński"

In [84]:

imie nazwisko C:\some\name

Jakiś tekst: he doesn't he doesn't

świta

Out[81]:

'Witaj świecie'

File "<ipython-input-84-c5695307cc4a>", line 1 imie nazwisko

^

SyntaxError: invalid syntax

(16)

imie+nazwisko

Mnożenie łańcucha przez skalar to nic innego jak powtarzanie tego łańcucha:

In [86]:

print(slowo*5)

Jednak działa to tylko dla liczb całkowitych:

In [87]:

print(slowo*5.0)

Działania na łańcuchach znaków możemy oczywiście ze sobą łączyć:

In [88]:

'<'+2*slowo +'>'

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) Out[85]:

'JanuszSzwabiński'

świtaświtaświtaświtaświta

--- ---

TypeError Traceback (most recent ca ll last)

<ipython-input-87-a14ebdf38ba7> in <module>() ----> 1print(slowo*5.0)

TypeError: can't multiply sequence by non-int of type 'float'

Out[88]:

'<świtaświta>'

(17)

In [91]:

print(text1)

In [92]:

text2 ="%s%d, %f, %s"% (s,x,y,z)

In [93]:

print(text2)

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)

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])

In [97]:

print(slowo[1])

In [98]:

print(slowo[5])

0

kilka liczb: 2, 1.34, 2.00+3.00i

Witaj świecie 2, 1.340000, (2+3j)

a

t

a

a

(18)

In [99]:

len(slowo)

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])

Dlatego użycie długości łańcucha jako indeksu spowoduje wyjście poza zakres:

In [101]:

print(slowo[n])

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)

In [103]:

slowo[:2] #dwie pierwsze litery

0 1 n − 1 n n

Out[99]:

6

a

--- ---

IndexError Traceback (most recent ca ll last)

<ipython-input-101-d348d9284622> in <module>() ----> 1print(slowo[n])

IndexError: string index out of range

Out[102]:

'tac'

Out[103]:

'ta'

(19)

In [104]:

slowo[2:] #wszystkie oprócz dwóch pierwszych

Przy wycinkach nie ma błędu z wyjściem poza zakres:

In [105]:

slowo[2:100]

Indeksy ujemne

Python dopuszcza ujemne indeksy we wszystkich sekwencyjnych typach danych. Przy tym, indeks  należy rozumieć jako  :

In [106]:

slowo[-1] #ostatnia litera

In [107]:

slowo[-2] #przedostatnia

In [108]:

slowo[-2:] #dwie ostatnie

In [109]:

slowo[0:-2] #wszystkie oprócz dwóch ostatnich

n − k −k

Out[104]:

'czka'

Out[105]:

'czka'

Out[106]:

'a'

Out[107]:

'k'

Out[108]:

'ka'

Out[109]:

'tacz'

(20)

slowo[-0] #jak w matematyce: -0=0

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)

In [112]:

slowo[0] ='k'

Nie jest to jednak wielkim ograniczeniem, ponieważ możliwa jest taka operacja:

In [113]:

slowo ='k'+ slowo[1:]

In [114]:

print(slowo)

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 Out[110]:

't'

taczka

--- ---

TypeError Traceback (most recent ca ll last)

<ipython-input-112-bdf5d26b7f3e> in <module>() ----> 1slowo[0]='k'

TypeError: 'str' object does not support item assignment

kaczka

(21)

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 upper był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)

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)

In [118]:

index = slowo.find('cz') print(index)

In [119]:

print(slowo.find('a'))

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))

Natomiast trzecim argumentem może być indeks, na którym należy skończyć wyszukiwanie:

KACZKA

kaczka

2

1

5

(22)

print(slowo.find('a',2,4))

Wynik   oznacza, że w podanym zakresie nie było żadnych trafień.

Operator in

Słowo kluczowe in jest operatorem logicznym, który dla dwóch argumentów sprawdza, czy pierwszy jest podciągiem drugiego.

In [122]:

print(slowo)

In [123]:

'kac'in slowo

In [124]:

't'in slowo

Porównywanie łańcuchów znaków

Operator == pozwoli nam sprawdzić, czy łańcuchy znaków są takie same:

In [125]:

print(slowo)

In [127]:

if slowo =='kaczka':

print("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.

−1

-1

kaczka

Out[123]:

True

Out[124]:

False

kaczka

Uwaga! Sezon polowań na kaczki już trwa

(23)

In [128]:

if slowo <'taczka':

print(slowo, 'taczka') else:

print('taczka', slowo)

In [129]:

slowo2 ='paczka' if slowo2 <'kaczka':

print(slowo2, 'kaczka') else:

print('kaczka', slowo2)

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'

In [131]:

'paczka'<'Taczka'

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() kaczka taczka

kaczka paczka

Out[130]:

True

Out[131]:

False

Out[132]:

True

(24)

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, for i while.

Pętla for

Instrukcja for w 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)

Ogólnie, składnia pętli for ma 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 inrange(5):

print(i)

In [9]:

for i inrange(2,5):

print(i,i**2) kaczka

paczka taczka

0 1 2 3 4

2 4 3 9 4 16

(25)

In [8]:

for i inrange(0,10,2):

print(i,i**3)

In [4]:

print(range(5))

In [5]:

type(range(5))

Chociaż rzeczywiście wywołujemy range jako funkcję, jest to raczej typ danych reprezentujący niezmienną sekwencję liczb. Wykorzystuje się go najczęście w petlach for do wykonania określonej liczby powtórzeń.

Pętla while

Pętla while sł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 0 0

2 8 4 64 6 216 8 512

range(0, 5)

Out[5]:

range

B a n a n a

(26)

Instrukcja break powoduje wyjście z najbliższej zagnieżdżonej pętli for lub while.

Rozważmy przykład:

In [136]:

fruit ='banana' index =0

while1: #w zasadzie pętla nieskończona print(fruit[index])

index = index +1

Aby uniknąć błędu, możemy przerwać pętlę w odpowiednim momencie:

In [137]:

fruit ='banana' index =0

while1: #w zasadzie pętla nieskończona print(fruit[index])

index = index +1

if index ==len(fruit):

break

Instrukcja continue powoduje przejście do następnego kroku iteracji:

b a n a n a

--- ---

IndexError Traceback (most recent ca ll last)

<ipython-input-136-536266ccf1b8> in <module>() 2 index =0

3while1: #w zasadzie pętla nieskończona ----> 4 print(fruit[index])

5 index = index +1

IndexError: string index out of range

b a n a n a

(27)

In [138]:

fruit ='Banana' for letter in fruit:

if letter =='a': continue print(letter)

B n n

Obraz

Updating...

Cytaty

Powiązane tematy :