U programiranju, često se javlja potreba da se neki delovi koda izvrše više puta. U tim situacijama, koriste se petlje.

Petlja while

Za petlju tipa while, u Pajtonu se koristi ključna reč while. Kod ovog tipa petlje, telo petlje se izvršava dok god je uslov koji smo zadali zadovoljen.

U sledećem primeru, uslov će biti da je vrednost promenljive i manja od 10, a u telu petlje ćemo prikazivati trenutnu vrednost promenljive i i uvećavati je za 1.


In [1]:
# Initialize the counter
i = 1

# Loop while printing out and incrementing the values of the counter
while i <= 10:
    print(i)
    # Increment the counter inside the loop
    i = i + 1


1
2
3
4
5
6
7
8
9
10

U sledećem primeru, broj ponavljanja zavisiće od broja koji korisnik unese s tastature, a prvi i poslednji prolazak kroz petlju razlikovaće se od ostalih.


In [2]:
# Obtain the required number of passes from the user
num_passes = int(input("How many rows would you like printed?\n"))

# Initialize the counter
i = 1

# Loop and print the required number of rows
while i <= num_passes:
    if (1 == i):
        print("Here is the first row.")
    elif (num_passes == i):
        print("Here is the last (%dth) row." % i)
    else:
        print("Here is another row.")
    
    # Increment the counter inside the loop
    i += 1 # "i += x" is equivalent to "i = i + x"


How many rows would you like printed?
7
Here is the first row.
Here is another row.
Here is another row.
Here is another row.
Here is another row.
Here is another row.
Here is the last (7th) row.

Realizovaćemo istu funkcionalnost iz prethodnog primera na drugačiji način, tako što ćemo štampanje prvog i poslednjeg reda izmestiti iz petlje. Prvi red ćemo štampati pre petlje, a poslednji posle petlje.


In [3]:
# Obtain the required number of passes from the user
num_passes = int(input("How many rows would you like printed?\n"))

# Print the first row BEFORE entering the loop
print("Here is the first row.")

# Initialize the counter to 2, because the first row has already been printed
i = 2

# Print the "middle rows" - all rows except the first and the last one
while (i <= num_passes - 1):
    print("Here is another row.")
    i += 1

# Print the last row AFTER finishing the loop
print("Here is the last (%dth) row." % i)


How many rows would you like printed?
9
Here is the first row.
Here is another row.
Here is another row.
Here is another row.
Here is another row.
Here is another row.
Here is another row.
Here is another row.
Here is the last (9th) row.

Petlja for

Još jedan tip petlje u Pajtonu je petlja for, koja se realizuje korišćenjem ključnih reči for i in. Sledi primer u kojem se na ekranu štampaju prirodni brojevi od 1 do 10, kao u prvom primeru petlje while.

Osim ključnih reči for i in, još nešto što koristimo kod petlji tipa for jeste tip podataka koji se naziva listom (eng. list). Lista se obeležava otvorenom uglastom zagradom, listom njenih elemenata razdvojenih zapetama i zatvorenom uglastom zagradom, tim redosledom. Listom zadajemo vrednosti kroz koje petlja prolazi u svojim ponavljanjima - u svakom ponavljanju Pajton će uzimati naredni unos iz liste. Ovakav način rada petlje for razlikuje se od tradicionalnih programskih jezika, i više liči na ono što se naziva for each ili foreach u mnogim programskim jezicima koji su u vreme nastajanja Pajtona bili popularni.


In [4]:
for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    print(i)


1
2
3
4
5
6
7
8
9
10

Funkcija range

Kako ne bismo svaki put prilikom korišćenja petlje for eksplicitno navodili elemente liste, možemo koristiti funkciju range, koja služi za generisanje liste.

Ukoliko funkciji range prosledimo jedan argument, ona će generisati listu svih brojeva od 0 do datog broja, ne uključujući dati broj. Kada funkciji range prosledimo broj N kao argument, ona će generisati listu od ukupno N elemenata.


In [5]:
my_list = range(10) # starting from 0, 10 not included
for i in my_list:
    print(i)


0
1
2
3
4
5
6
7
8
9

Možemo joj proslediti i dva argumenta, koje će ona tumačiti kao početni i krajnji broj u intervalu zatvorenom s leve strane (prvi broj pripada intervalu, dok poslednji broj ne pripada intervalu).


In [6]:
for i in range(8, 13): # 8 included, 13 not included
    print(i)


8
9
10
11
12

Ukoliko funkciji range prosledimo tri argumenta, ona će prvi tumačiti kao početak, a drugi kao kraj intervala zatvorenog s leve strane. Treći argument je korak kojim će niz brojeva u ovom intervalu napredovati (aritmetički).


In [7]:
for i in range(10, 20, 2):
    print(i)


10
12
14
16
18

Neke operacije nad listama

Za pristupanje elementu liste koriste se uglaste zagrade. Između uglastih zagrada navodi se pozicija elementa kojem želimo da pristupimo - njegov indeks. U listi od N elemenata, prvom elementu liste odgovara indeks 0 (nula), a poslednjem - indeks N - 1.


In [21]:
# Prints the ith element of a list of integers
def print_ith_element(input_list, i):
    print("The %dth element of the list is %d" % (i, input_list[i]))

# Define a list
my_list = [10, 20, 30, 40, 50]

# Print out a few elements of the list
print_ith_element(my_list, 0)
print_ith_element(my_list, 2)
print_ith_element(my_list, 4)


The 0th element of the list is 10
The 2th element of the list is 30
The 4th element of the list is 50

Korišćenjem uglastih zagrada možemo promeniti sadržaj liste, odnosno vrednost nekog njenog elementa.


In [22]:
my_list = [100, 200, 300, 400, 500, 600, 700, 800]

my_list[3] = -1

print(my_list) # The print function can take a list as an argument and print out all of its elements


[100, 200, 300, -1, 500, 600, 700, 800]

U Pajtonu postoji mnogo funkcija za rad s listama, poput funkcije len koja računa dužinu liste.


In [23]:
list1 = [1, 2, 3]
list2 = range(10)

len1 = len(list1)
len2 = len(list2)

print("The length of the first list is %d and the length of the second list is %d" % (len1, len2))


The length of the first list is 3 and the length of the second list is 10

Petlje i stringovi

String se može shvatiti kao niz karaktera, pa možemo koristiti petlje sa stringovima na sličan način na koji ih koristimo s listama.

Indeksiranje


In [26]:
my_str = "My string"

print(my_str[0])
print(my_str[3])
print(my_str[8])


M
s
g

Dužina stringa


In [32]:
my_str = "My string"

print("String length is %d" % len(my_str))


String length is 9

Iteriranje petljom while


In [30]:
my_str = "My string"

# Initialize counter
cnt = 0

while cnt < len(my_str):
    print("Character number %d is %s" % (cnt, my_str[cnt]))
    cnt += 1


Character number 0 is M
Character number 1 is y
Character number 2 is  
Character number 3 is s
Character number 4 is t
Character number 5 is r
Character number 6 is i
Character number 7 is n
Character number 8 is g

Iteriranje petljom for


In [27]:
my_str = "My string"

for character in my_str:
    print(character)


M
y
 
s
t
r
i
n
g

Ugnježdene petlje

U telu petlje mogu se naći bilo koje instrukcije koje Pajton prepoznaje, pa se tako može naći i zaglavlje nove petlje. Ovo se naziva ugnježdenim petljama. Sledeći primer prikazaće sva polja na šahovskoj tabli. Polje na šahovskoj tabli određeno je kolonom i redom. Kolone se obeležavaju slovima od A do H, a redovi brojevima od 1 do 8.


In [37]:
columns = ["A", "B", "C", "D", "E", "F", "G", "H"]
rows = [1, 2, 3, 4, 5, 6, 7, 8]

for c in columns:
    for r in rows:
        # Print a column-row combination
        #
        # Set print function's optional argumnt end to an
        # empty string to avoid going to a new line after each print
        print("%s%s " % (c, r), end="")
    
    # After each printed rown, print a newline to make it look like a chess board
    print("\n")


A1 A2 A3 A4 A5 A6 A7 A8 

B1 B2 B3 B4 B5 B6 B7 B8 

C1 C2 C3 C4 C5 C6 C7 C8 

D1 D2 D3 D4 D5 D6 D7 D8 

E1 E2 E3 E4 E5 E6 E7 E8 

F1 F2 F3 F4 F5 F6 F7 F8 

G1 G2 G3 G4 G5 G6 G7 G8 

H1 H2 H3 H4 H5 H6 H7 H8 

Isto se može postići korišćenjem petlje while.


In [38]:
columns = ["A", "B", "C", "D", "E", "F", "G", "H"]
rows = [1, 2, 3, 4, 5, 6, 7, 8]

# The length of the lists
len_c = len(columns)
len_r = len(rows)

# Initialize the column counter
cnt_c = 0

while cnt_c < len_c:
    # Initialize the row counter
    # The row counter needs to be re-initialized to zero each time
    # we move to a new column. That's why we t inside the column loop
    cnt_r = 0
    
    while cnt_r < len_r:
        # Print a column-row combination
        #
        # Set print function's optional argumnt end to an
        # empty string to avoid going to a new line after each print
        print("%s%s " % (columns[cnt_c], rows[cnt_r]), end="")
        
        # Increment the row counter
        cnt_r += 1
        
    # Increment the columnt counter
    cnt_c += 1
        
    # After each printed rown, print a newline to make it look like a chess board
    print("\n")


A1 A2 A3 A4 A5 A6 A7 A8 

B1 B2 B3 B4 B5 B6 B7 B8 

C1 C2 C3 C4 C5 C6 C7 C8 

D1 D2 D3 D4 D5 D6 D7 D8 

E1 E2 E3 E4 E5 E6 E7 E8 

F1 F2 F3 F4 F5 F6 F7 F8 

G1 G2 G3 G4 G5 G6 G7 G8 

H1 H2 H3 H4 H5 H6 H7 H8