https://docs.python.org/3/tutorial/controlflow.html
Pętla for jest uniwersalnym iteratorem po sekwencjach lub innych obiektach iterowalnych. Jeżeli chcemy wykonać pętlę po ciągu liczb całkowitych, to pomocna jest funkcja range() (Py3) lub wersja z generatorem xrange() (Py2). Można stosować break (natychmiastowe wyjście z pętli) i continue (kontynuacja pętli) jak w języku C.
Niebezpiecznie jest modyfikować sekwencję (np. listę) po której biegnie pętla for. Należy raczej zrobić kopię listy do iteracji. Bezpieczną operacją jest wydłużenie listy przez L.append(item) lub L.extend(sequence).
# Składnia.
for item in sequence: # wiersz nagłówkowy
instrukcje # tu zwykle używamy item
if test1:
break # wyjście z pętli, opcjonalne
if test2:
continue # przejście na górę pętli, opcjonalne
instrukcje
else: # opcjonalne
instrukcje # jeżeli nie było break, działa nawet przy pustej sekwencji
word = "praca"
for char in word: # pętla po stringu
#print char, # przecinek daje wydruk w jednym wierszu (Py2)
print(char, end=" ") # wydruk w jednym wierszu (Py3)
print("") # na koniec przechodzimy do nowej linii
# Pętla po liczbach z funkcji range().
for i in range(6): # liczby od 0 do 5
print(i)
# Indeks pętli żyje poza nią.
print(i) # wynik to 5
# Pętla po liście składającej się z elementów różnych typów.
for item in [4, "s", [2, 3], 3.14159]:
print(item)
# Pętla po krotce różnych elementów.
for item in (6, "abc", 1.2):
print(item)
# Pętla po liście składającej się z krotek.
# Następuje pozycyjne przypisanie zmiennych.
for (a, b) in [(2, "i"), (3.14, "f"), ("a", "s")]:
print("{} {} {} {}".format("pierwszy", a, "drugi", b))
# Wydłużanie listy w trakcie działania pętli for.
# Zachować ostrożność!
# Można wpaść w pętlę nieskończoną.
L = list(range(5))
for i in L:
print(i)
if (i % 2) == 1: # jeżeli i jest nieparzyste
L.append(2 * i) # dodaję tylko parzyste
L.append(4 * i) # dodaję tylko parzyste
#L.extend((2 * i, 4 * i))
# Wynik: 0 1 2 3 4 2 4 6 12
# Bezpieczniejszy wariant z kopią listy.
for item in L[:]: # albo list(L)
process(item)
# Pętla for w konteście słowników.
D = {"a": 1, "b": 2, "c": 3}
for key in D: # pętla po kluczach
print("{} {}".format(key, D[key]))
for (key, value) in D.items():
print("{} {}".format(key, value))
# Pętla po sekwencji w kolejności odwrotnej.
for char in reversed("qwerty"): # 'reversed object'
print(char) # y, t, r, e, w, q
# Pętla po sekwencji posortowanej w locie.
for char in sorted("qwerty"): # ['e', 'q', 'r', 't', 'w', 'y']
print(char)
# Pętla po sekwencji bez duplikatów.
for char in set("abracadabra"): # 'a', 'c', 'd', 'b', 'r'
print(char)
fruits = ["apple", "pear", "plum"]
# Pętla for po liście stringów.
for fruit in fruits:
print("Bardzo lubię {}!".format(fruit))
# Pętla po liście stringów z wykorzystaniem indeksów.
# Tak można robić, gdy potrzebujemy wykorzystać numer elementu.
for i in range(len(fruits)):
print("{} {}".format(i, fruits[i]))
# Obecnie wygodniej jest zastosować funkcję enumerate().
# enumerate(iterable, start=0) - zwraca 'enumerate object' (iterator).
for (i, item) in enumerate(fruits):
print("{} {}".format(i, item))
list(enumerate(fruits, start=1)) # [(1, 'apple'), (2, 'pear'), (3, 'plum')]
[c*i for (i, c) in enumerate("abcd")] # ["", "b", "cc", "ddd"]
[2**i for i in range(5)] # [1, 2, 4, 8, 16]
# Wyszukiwanie wspólnych elementów dwóch sekwencji.
seq1 = "mielonka"
seq2 = "biedronka"
alist = []
for item in seq1:
if item in seq2: # mało wydajne
alist.append(item)
print(alist) # ["i","e","o","n","k","a"]
# Inny sposób polega na zastosowaniu zbiorów.
# Oczyszczanie linii z białych znaków po prawej stronie.
# lines to lista stringów.
lines = [line.rstrip() for line in lines]
lines = [line.rstrip() for line in open("words.txt")]
lines = [line.upper() for line in open("words.txt")]
lines = [line.replace("\t", ";") for line in open("words.txt")]
# Składnia Py2.
# zip(seq1 [, seq2 [...]]) zwraca listę krotek [(seq1[0], seq2[0] ...), (...)].
# Lista ma długość najkrótszej sekwencji.
# W Py3 zip() zwraca 'zip object' (iterator).
L = [1, 2, 3, 4]
M = [5, 6, 7, 8]
for (x, y) in zip(L, M):
print("{} {} {}".format(x, y, x+y))
for (x, y) in zip("abcdef", "qwerty"):
print("{} {} {}".format(x, y, x+y))
list(zip("ab", "1234")) # [('a', '1'), ('b', '2')]
# Składnia Py2. # map(function, sequence[, sequence, ...]) zwraca listę. # W Py3 map() zwraca 'map object' (iterator).
# Funkcję map można łatwo zastąpić listą składaną. L = [-2, -1, 0, 1, 2] list(map(abs, L)) # [2, 1, 0, 1, 2] [abs(x) for x in L] list(map(ord, "qwerty")) # [113, 119, 101, 114, 116, 121] [ord(x) for x in "qwerty"] L = [1, 2, 3, 4] M = [1, 1, 2, 2] list(map(pow, L, M)) # [1, 2, 9, 16] [pow(x, y) for (x, y) in zip(L, M)] words = ["jeden", "dwa", "trzy"] list(map(str.upper, words)) # ['JEDEN', 'DWA', 'TRZY'] [word.upper() for word in words]
keys = ["jeden", "dwa", "trzy"]
values = ["I", "II", "III"]
D = dict(zip(keys, values))
# To samo za pomocą pętli for.
D = {} # lub D = dict()
for (k, v) in zip(keys, values):
D[k] = v
D = dict(zip(range(6), "qwerty"))
Funkcje wbudowane: sorted(), sum(), min(), max(), any(), all(), list(), tuple(), set(), str.join(), zip().
Nowe obiekty iterowane w Pythonie 3: dict.keys(), dict.values(), dict.items(), range(), map(), zip(), filter().
# Zastosowanie funkcji all() i any().
L = [1, 2, 4, 5]
#L = [2, 4, 6]
# Sprawdzamy, czy wszystkie liczby są parzyste.
# Zastosowanie klauzuli else w pętli for.
for x in L:
if x % 2 != 0:
break
else:
print("wszystkie parzyste")
# Zastosowanie all().
if all(x % 2 == 0 for x in L):
print("wszystkie parzyste")
# Sprawdzamy, czy choć jedna liczba jest parzysta.
if any(x % 2 == 0 for x in L):
print("jest liczba parzysta na liście")