﻿while <test>:                                # Test pętli
   <instrukcje1>                             # Ciało pętli
else:                                        # Opcjonalne else
   <instrukcje2>                             # Wykonane, jeśli pętli nie zakończyło break
   
   
>>> while True:
...    print 'Wpisz Ctrl+C, by mnie zatrzymać!'


>>> x = 'mielonka'
>>> while x:                                 # Póki x nie jest puste
...    print x,
...    x = x[1:]                             # Odcięcie pierwszego znaku z x
...
mielonka ielonka elonka lonka onka nka ka a


>>> a=0; b=10
>>> while a < b:                             # Jeden sposób kodowania pętli licznika
...    print a,
...    a += 1                                # Lub a = a + 1
...
0 1 2 3 4 5 6 7 8 9


while True:
   ...ciało pętli...
   if exitTest( ): break

   
while <test1>:
   <instrukcje1>
   if <test2>: break                         # Wyjście z pętli, pominięcie reszty
   if <test3>: continue                      # Przejście do góry pętli, do testu1
else:
   <instrukcje2>                             # Wykonywane, jeśli nie trafiliśmy na break   
   

while 1: pass                                # Użyj Ctrl+C, by mnie zatrzymać!


def func1( ):
   pass                                      # Wstawić tu później prawdziwy kod!

def func2( ):
   pass
   

x = 10
while x:
   x = x-1                                   # Lub x -= 1
   if x % 2 != 0: continue                   # Nieparzyste? Pomijamy!
   print x,


x = 10
while x:
   x = x-1
   if x % 2 == 0:                            # Parzyste? Wyświetlamy!
      print x,


>>> while 1:
...    name = raw_input('Podaj imię:')
...    if name == 'stop': break
...    age = raw_input('Podaj wiek: ')
...    print 'Witaj,', name, '=>', int(age) ** 2
...
Podaj imię:Amadeusz
Podaj wiek: 40
Witaj, Amadeusz => 1600
Podaj imię:Maurycy
Podaj wiek: 30
Witaj, Maurycy => 900
Podaj imię:stop


x = y / 2                                    # Dla jakiegoś y > 1
while x > 1:
   if y % x == 0:                            # Reszta
      print y, 'ma czynnik', x
      break                                  # Pominięcie reszty
   x = x-1
else:                                        # Normalne wyjście
   print y, 'jest liczbą pierwszą'


found = False
while x and not found:
   if match(x[0]):                           # Wartość na początku?
      print 'Ni'
      found = True
   else:
      x = x[1:]                              # Odcięcie początku i powtórzenie
if not found:
   print 'Nie znaleziono'


while x:                                     # Wyjście, gdy x jest puste
   if match(x[0]):
      print 'Ni'
      break                                  # Wyjście, ominięcie else
   x = x[1:]
else:
   print 'Nie znaleziono'                    # Tylko wtedy, gdy wyczerpano x


while ((x = next( )) != NULL) {...przetwarzanie x...}


while True:
   x = next( )
   if not x: break
   ...przetwarzanie x...


x = 1
while x:
   x = next( )
   if x:
      ...przetwarzanie x...


x = next( )
while x:
   ...przetwarzanie x...
   x = next( )


for <cel> in <obiekt>:                       # Przypisanie elementów obiektu do celu
   <instrukcje>                              # Powtarzane ciało pętli: użycie celu
else:
   <instrukcje>                              # Jeśli nie trafiliśmy na break


for <cel> in <obiekt>:                       # Przypisanie elementów obiektu do celu
   <instrukcje>
   if <test>: break                          # Wyjście z pętli, pominięcie else
   if <test>: continue                       # Przejście na górę pętli
else:
   <instrukcje>                              # Jeśli nie trafiliśmy na break


>>> for x in ["mielonka", "jajka", "szynka"]:
...    print x,
...
mielonka jajka szynka


>>> sum = 0
>>> for x in [1, 2, 3, 4]:
...    sum = sum + x
...
>>> sum
10
>>> prod = 1
>>> for item in [1, 2, 3, 4]: prod *= item
...
>>> prod
24


>>> S = "drwal"
>>> T = ("i", "jestem", "git")
>>> for x in S: print x,                     # Iteracja po łańcuchu znaków
...
d r w a l
>>> for x in T: print x,                     # Iteracja po krotce
...
i jestem git


>>> T = [(1, 2), (3, 4), (5, 6)]
>>> for (a, b) in T:                         # Przypisanie krotek
...    print a, b
...
1 2
3 4
5 6


>>> items = ["aaa", 111, (4, 5), 2.01]       # Zbiór obiektów
>>> tests = [(4, 5), 3.14]                   # Szukane klucze
>>>
>>> for key in tests:                        # Dla wszystkich kluczy
...    for item in items:                    # Dla wszystkich elementów
...       if item == key:                    # Sprawdzenie
...          print key, "znaleziono"
...          break
...    else:
...       print key, "nie znaleziono!"
...
(4, 5) znaleziono
3.14 nie znaleziono!


>>> for key in tests:                        # Dla wszystkich kluczy
...    if key in items:                      # Niech Python sam sprawdza
...       print key, "znaleziono"
...    else:
...       print key, "nie znaleziono!"
...
(4, 5) znaleziono
3.14 nie znaleziono!


>>> seq1 = "mielonka"
>>> seq2 = "biedronka"
>>>
>>> res = []                                 # Na początek pusta lista
>>> for x in seq1:                           # Przeszukanie pierwszej sekwencji
...    if x in seq2:                         # Powtarzający się element?
...       res.append(x)                      # Dodanie na końcu listy wyników
...
>>> res
['i', 'e', 'o', 'n', 'k', 'a']


>>> for x in [1, 2, 3, 4]: print x ** 2,
...
1 4 9 16
>>> for x in (1, 2, 3, 4): print x ** 3,
...
1 8 27 64
>>> for x in 'mielonka': print x * 2,
...
mm ii ee ll oo nn kk aa


# Ramka "Znaczenie skanerów plików"

file = open('test.txt', 'r')
print file.read( )


file = open('test.txt')
while True:
   char = file.read(1)                       # Wczytanie znak po znaku
   if not char: break
   print char,

for char in open('test.txt').read( ):
   print char


file = open('test.txt')
while True:
   line = file.readline( )                   # Wczytanie wiersz po wierszu
   if not line: break
   print line,

file = open('test.txt', 'rb')
while True:
   chunk = file.read(10)                     # Wczytanie bajtowych fragmentów
   if not chunk: break
   print chunk,

   
for line in open('test.txt').readlines( ):
   print line

for line in open('test.txt').xreadlines( ):
   print line

for line in open('test.txt'):
   print line
   
   
>>> f = open('script1.py')
>>> f.readline( )
'import sys\n'
>>> f.readline( )
'print sys.path\n'
>>> f.readline( )
'x = 2\n'
>>> f.readline( )
'print 2 ** 33\n'
>>> f.readline( )
''
   

>>> f = open('script1.py')
>>> f.next( )
'import sys\n'
>>> f.next( )
'print sys.path\n'
>>> f.next( )
'x = 2\n'
>>> f.next( )
'print 2 ** 33\n'
>>> f.next( )
Traceback (most recent call last):
   File "<pyshell#330>", line 1, in <module>
      f.next( )
StopIteration


>>> for line in open('script1.py'):          # Użycie iteratorów plików
...    print line.upper( ),
...
IMPORT SYS
PRINT SYS.PATH
X = 2
PRINT 2 ** 33


>>> for line in open('script1.py').readlines( ):
...    print line.upper( ),
...
IMPORT SYS
PRINT SYS.PATH
X = 2
PRINT 2 ** 33


>>> f = open('script1.py')
>>> while True:
...    line = f.readline( )
...    if not line: break
...    print line.upper( ),
...
...te same dane wyjściowe...


>>> L = [1, 2, 3]
>>> I = iter(L)                              # Uzyskanie obiektu iteratora
>>> I.next( )                                # Wywołanie next w celu przejścia do kolejnego elementu
1
>>> I.next( )
2
>>> I.next( )
3
>>> I.next( )
Traceback (most recent call last):
   File "<pyshell#343>", line 1, in <module>
      I.next( )
StopIteration


>>> D = {'a':1, 'b':2, 'c':3}
>>> for key in D.keys( ):
...    print key, D[key]
...
a 1
c 3
b 2


>>> for key in D:
...    print key, D[key]
...
a 1
c 3
b 2


>>> for line in open('script1.py'):          # Użycie iteratorów plików
...    print line.upper( ),
...
IMPORT SYS
PRINT SYS.PATH
X = 2
PRINT 2 ** 33


>>> uppers = [line.upper( ) for line in open('script1.py')]
>>> uppers
['IMPORT SYS\n', 'PRINT SYS.PATH\n', 'X = 2\n', 'PRINT 2 ** 33\n']

>>> map(str.upper, open('script1.py'))
['IMPORT SYS\n', 'PRINT SYS.PATH\n', 'X = 2\n', 'PRINT 2 ** 33\n']

>>> 'y = 2\n' in open('script1.py')
False

>>> 'x = 2\n' in open('script1.py')
True

>>> sorted(open('script1.py'))
['import sys\n', 'print 2 ** 33\n', 'print sys.path\n', 'x = 2\n']


>>> sorted([3, 2, 4, 1, 5, 0])               # Więcej kontekstów iteracji
[0, 1, 2, 3, 4, 5]

>>> sum([3, 2, 4, 1, 5, 0])
15

>>> any(['mielonka', '', 'ni'])
True

>>> all(['mielonka', '', 'ni'])
False


>>> list(open('script1.py'))
['import sys\n', 'print sys.path\n', 'x = 2\n', 'print 2 ** 33\n']

>>> tuple(open('script1.py'))
('import sys\n', 'print sys.path\n', 'x = 2\n', 'print 2 ** 33\n')

>>> '&&'.join(open('script1.py'))
'import sys\n&&print sys.path\n&&x = 2\n&&print 2 ** 33\n'

>>> a, b, c, d = open('script1.py')
>>> a, d
('import sys\n', 'print 2 ** 33\n')


>>> range(5), range(2, 5), range(0, 10, 2)
([0, 1, 2, 3, 4], [2, 3, 4], [0, 2, 4, 6, 8])


>>> range(-5, 5)
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

>>> range(5, -5, -1)
[5, 4, 3, 2, 1, 0, -1, -2, -3, -4]


>>> for i in range(3):
...    print i, 'Python'
...
0 Python
1 Python
2 Python


>>> X = 'mielonka'
>>> for item in X: print item,               # Prosta iteracja
...
m i e l o n k a


>>> i = 0
>>> while i < len(X):                        # Iteracja z pętlą while
...    print X[i],; i += 1
...
m i e l o n k a


>>> X
'mielonka'
>>> len(X)                                   # Długość łańcucha znaków
8
>>> range(len(X))                            # Wszystkie poprawne wartości przesunięcia dla X
[0, 1, 2, 3, 4, 5, 6, 7]
>>>
>>> for i in range(len(X)): print X[i],      # Ręczne indeksowanie
...
m i e l o n k a


>>> for item in X: print item,               # Prosta iteracja
...


>>> S = 'abcdefghijk'
>>> range(0, len(S), 2)
[0, 2, 4, 6, 8, 10]

>>> for i in range(0, len(S), 2): print S[i],
...
a c e g i k


>>> for x in S[::2]: print x
...


>>> L = [1, 2, 3, 4, 5]

>>> for x in L:
...    x += 1
...
>>> L
[1, 2, 3, 4, 5]
>>> x
6


>>> L = [1, 2, 3, 4, 5]

>>> for i in range(len(L)):                  # Dodanie 1 do każdego elementu listy L
...    L[i] += 1                             # Lub L[i] = L[i] + 1
...
>>> L
[2, 3, 4, 5, 6]


>>> i = 0
>>> while i < len(L):
...    L[i] += 1
...    i += 1
...
>>> L
[3, 4, 5, 6, 7]


>>> L1 = [1,2,3,4]
>>> L2 = [5,6,7,8]


>>> zip(L1,L2)
[(1, 5), (2, 6), (3, 7), (4, 8)]


>>> for (x, y) in zip(L1, L2):
...    print x, y, '--', x+y
...
1 5 -- 6
2 6 -- 8
3 7 -- 10
4 8 -- 12


>>> T1, T2, T3 = (1,2,3), (4,5,6), (7,8,9)
>>> T3
(7, 8, 9)
>>> zip(T1,T2,T3)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]


>>> S1 = 'abc'
>>> S2 = 'xyz123'
>>>
>>> zip(S1, S2)
[('a', 'x'), ('b', 'y'), ('c', 'z')]


>>> map(None, S1, S2)
[('a', 'x'), ('b', 'y'), ('c', 'z'), (None, '1'), (None, '2'), (None,'3')]


>>> D1 = {'mielonka':1, 'jajka':3, 'tost':5}
>>> D1
{'tost': 5, 'jajka': 3, 'mielonka': 1}

>>> D1 = {}
>>> D1['mielonka'] = 1
>>> D1['jajka'] = 3
>>> D1['tost'] = 5


>>> keys = ['mielonka', 'jajka', 'tost']
>>> vals = [1, 3, 5]


>>> zip(keys, vals)
[('mielonka', 1), ('jajka', 3), ('tost', 5)]

>>> D2 = {}
>>> for (k, v) in zip(keys, vals): D2[k] = v
...
>>> D2
{'tost': 5, 'jajka': 3, 'mielonka': 1}


>>> keys = ['mielonka', 'jajka', 'tost']
>>> vals = [1, 3, 5]

>>> D3 = dict(zip(keys, vals))
>>> D3
{'tost': 5, 'jajka': 3, 'mielonka': 1}


>>> S = 'mielonka'
>>> offset = 0
>>> for item in S:
...    print item, 'występuje na pozycji przesunięcia', offset
...    offset += 1
...
m występuje na pozycji przesunięcia 0
i występuje na pozycji przesunięcia 1
e występuje na pozycji przesunięcia 2
l występuje na pozycji przesunięcia 3
o występuje na pozycji przesunięcia 4
n występuje na pozycji przesunięcia 5
k występuje na pozycji przesunięcia 6
a występuje na pozycji przesunięcia 7


>>> S = 'mielonka'
>>> for (offset, item) in enumerate(S):
...    print item, 'występuje na pozycji przesunięcia', offset
...
m występuje na pozycji przesunięcia 0
i występuje na pozycji przesunięcia 1
e występuje na pozycji przesunięcia 2
l występuje na pozycji przesunięcia 3
o występuje na pozycji przesunięcia 4
n występuje na pozycji przesunięcia 5
k występuje na pozycji przesunięcia 6
a występuje na pozycji przesunięcia 7


>>> E = enumerate(S)
>>> E.next( )
(0, 'm')
>>> E.next( )
(1, 'i')


>>> [c * i for (i, c) in enumerate(S)]
['', 'i', 'ee', 'lll', 'oooo', 'nnnnn', 'kkkkkk', 'aaaaaaa']


>>> L = [1, 2, 3, 4, 5]
>>> for i in range(len(L)):
...    L[i] += 10
...
>>> L
[11, 12, 13, 14, 15]


>>> L = [x + 10 for x in L]
>>> L
[21, 22, 23, 24, 25]


>>> res = []
>>> for x in L:
...    res.append(x + 10)
...
>>> res
[21, 22, 23, 24, 25]


>>> f = open('script1.py')
>>> lines = f.readlines( )
>>> lines
['import sys\n', 'print sys.path\n', 'x = 2\n', 'print 2 ** 33\n']


>>> lines = [line.rstrip( ) for line in lines]
>>> lines
['import sys', 'print sys.path', 'x = 2', 'print 2 ** 33']


>>> lines = [line.rstrip( ) for line in open('script1.py')]
>>> lines
['import sys', 'print sys.path', 'x = 2', 'print 2 ** 33']


>>> lines = [line.rstrip( ) for line in open('script1.py') if line[0] == 'p']
>>> lines
['print sys.path', 'print 2 ** 33']


>>> res = []
>>> for line in open('script1.py'):
...    if line[0] == 'p':
...       res.append(line.rstrip( ))
...
>>> res
['print sys.path', 'print 2 ** 33']


>>> [x + y for x in 'abc' for y in 'lmn']
['al', 'am', 'an', 'bl', 'bm', 'bn', 'cl', 'cm', 'cn']


>>> res = []
>>> for x in 'abc':
...    for y in 'lmn':
...       res.append(x + y)
...
>>> res
['al', 'am', 'an', 'bl', 'bm', 'bn', 'cl', 'cm', 'cn']