X = 99

def func():
   X = 88

   
# Zakres globalny
X = 99                                       # X i func przypisane w module: globalne

def func(Y):                                 # Y i Z przypisane w funkcji: lokalne
   # Zakres lokalny
   Z = X + Y                                 # X jest globalne
   return Z

func(1)                                      # func w module: wynik = 100


>>> import __builtin__
>>> dir(__builtin__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning', 'EOFError', 'Ellipsis', ...pominięto wiele nazw... 'str', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']


>>> zip                                      # W normalny sposób
<built-in function zip>

>>> import __builtin__                       # W bardziej skomplikowany sposób
>>> __builtin__.zip
<built-in function zip>


def hider():
   open = 'mielonka'                         # Zmienna lokalna, ukrywa wbudowaną
   ...
   open('data.txt')                          # Polecenie to nie otworzy w tym zakresie pliku!


X = 88                                       # Zmienna globalna X

def func( ):
   X = 99                                    # Zmienna lokalna X: ukrywa globalną

func( )
print X                                      # Wyświetla 88: bez zmian


X = 88                                       # Zmienna globalna X

def func( ):
   global X
   X = 99                                    # Zmienna globalna X: poza def

func( )
print X                                      # Wyświetla 99


y, z = 1, 2                                  # Zmienne globalne modułu

def all_global( ):
   global x                                  # Deklaracja przypisanych zmiennych globalnych
   x = y + z                                 # Nie trzeba przypisywać y i z - działa reguła LEGB


X = 99

def func1( ):
   global X
   X = 88

def func2( ):
   global X
   X = 77


# Plik first.py
X = 99

# Plik second.py
import first
first.X = 88


# Plik first.py
X = 99

def setX(new):
   global X
   X = new

# Plik second.py
import first
first.setX(88)


# Plik thismod.py

var = 99                                     # Zmienna globalna == atrybut modułu

def local( ):
   var = 0                                   # Modyfikacja zmiennej lokalnej var

def glob1( ):
   global var                                # Deklaracja zmiennej globalnej (normalnej)
   var += 1                                  # Modyfikacja zmiennej globalnej var

def glob2( ):
   var = 0                                   # Modyfikacja zmiennej lokalnej var
   import thismod                            # Zaimportowanie myself
   thismod.var += 1                          # Modyfikacja zmiennej globalnej var

def glob3( ):
   var = 0                                   # Modyfikacja zmiennej lokalnej var
   import sys                                # Zaimportowanie tabeli systemowej
   glob = sys.modules['thismod']             # Obiekt modułu (można też użyć __name__)
   glob.var += 1                             # Modyfikacja zmiennej globalnej var

def test( ):
   print var
   local(); glob1(); glob2( ); glob3( )
   print var


>>> import thismod
>>> thismod.test( )
99
102
>>> thismod.var
102


def f1( ):
   x = 88
   def f2( ):
      print x
   f2( )

f1( )                                        # Wyświetla 88


def f1( ):
   x = 88
   def f2( ):
      print x
   return f2

action = f1( )                               # Utworzenie i zwrócenie funkcji
action( )                                    # Teraz wywołanie jej - wyświetla 88


>>> def maker(N):
...    def action(X):
...       return X ** N
...    return action
...


>>> f = maker(2)                             # Przekazanie 2 do N
>>> f
<function action at 0x014720B0>


>>> f(3)                                     # Przekazanie 3 do X, N pamięta 2
9
>>> f(4)                                     # 4 ** 2
16


>>> g = maker(3)
>>> g(3)                                     # 3 ** 3
27
>>> f(3)                                     # 3 ** 2
9


def f1( ):
   x = 88
   def f2(x=x):
      print x
   f2( )

f1( )                                        # Wyświetla 88


>>> def f1( ):
...    x = 88
...    f2(x)
...
>>> def f2(x):
...    print x
...
>>> f1( )
88


def func( ):
   x = 4
   action = (lambda n: x ** n)               # x pamiętane z zakresu zawierającego
   return action

x = func( )
print x(2)                                   # Wyświetla 16 (4 ** 2)


def func( ):
   x = 4
   action = (lambda n, x=x: x ** n)          # Ręczne przekazanie x
   
   
>>> def makeActions( ):
...    acts = []
...    for i in range(5):                    # Próbuje zapamiętać każde i
...       acts.append(lambda x: i ** x)      # Wszystkie pamiętają to samo ostatnie i!
...    return acts
...
>>> acts = makeActions( )
>>> acts[0]
<function <lambda> at 0x012B16B0>   
   
   
>>> acts[0](2)                               # Wszystkie to 4 ** 2, wartość ostatniego i
16
>>> acts[2](2)                               # Powinno być 2 ** 2
16
>>> acts[4](2)                               # Powinno być 4 ** 2
16


>>> def makeActions( ):
...    acts = []
...    for i in range(5):                    # Użycie domyślnych wartości argumentów
...       acts.append(lambda x, i=i: i ** x) # Pamiętanie bieżącej wartości zmiennej i
... return acts
...
>>> acts = makeActions( )
>>> acts[0](2) # 0 ** 2
0
>>> acts[2](2) # 2 ** 2
4
>>> acts[4](2) # 4 ** 2
16


>>> def f1( ):
...    x = 99
...    def f2( ):
...       def f3( ):
...          print x                         # Znalezione w zakresie lokalnym f1!
...       f3( )
...    f2( )
...
>>> f1( )
99


>>> def changer(a, b):                       # Funkcja
...    a = 2                                 # Zmiana wartości jedynie zmiennej lokalnej
...    b[0] = 'mielonka'                     # Zmiana współdzielonego obiektu w miejscu
...
>>> X = 1
>>> L = [1, 2]                               # Wywołujący
>>> changer(X, L)                            # Przekazanie obiektów niezmiennych i zmiennych
>>> X, L                                     # X bez zmian, L jest inne
(1, ['mielonka', 2])


>>> X = 1
>>> a = X                                    # Współdzielą jeden obiekt
>>> a = 2                                    # Przestawia tylko 'a', 'X' nadal jest równe 1
>>> print X
1


>>> L = [1, 2]
>>> b = L                                    # Współdzielą ten sam obiekt
>>> b[0] = 'mielonka'                        # Modyfikacja w miejscu: 'L' także widzi zmianę
>>> print L
['mielonka', 2]


L = [1, 2]
changer(X, L[:])                             # Przekazanie kopii, tak by 'L' się nie zmieniło


def changer(a, b):
   b = b[:]                                  # Kopia listy w celu uniknięcia wpływu na wywołującego
   a = 2
   b[0] = 'mielonka'                         # Modyfikacja tylko kopii listy


L = [1, 2]
changer(X, tuple(L))                         # Przekazanie krotki - zmiany będą błędami


>>> def multiple(x, y):
...    x = 2                                 # Modyfikacja jedynie zmiennych lokalnych
...    y = [3, 4]
...    return x, y                           # Zwrócenie nowych wartości w krotce
...
>>> X = 1
>>> L = [1, 2]
>>> X, L = multiple(X, L)                    # Przypisanie wyników do zmiennych wywołującego
>>> X, L
(2, [3, 4])


>>> def f(a, b, c): print a, b, c
...


>>> f(1, 2, 3)
1 2 3


>>> f(c=3, b=2, a=1)
1 2 3


>>> f(1, c=3, b=2)
1 2 3


func(name='Teofil', age=40, job='programista')


>>> def f(a, b=2, c=3): print a, b, c
...


>>> f(1)
1 2 3
>>> f(a=1)
1 2 3


>>> f(1, 4)
1 4 3
>>> f(1, 4, 5)
1 4 5


>>> def f(*args): print args
...


>>> f( )
()
>>> f(1)
(1,)
>>> f(1,2,3,4)
(1, 2, 3, 4)


>>> def f(**args): print args
...
>>> f( )
{ }
>>> f(a=1, b=2)
{'a': 1, 'b': 2}


>>> def f(a, *pargs, **kargs): print a, pargs, kargs
...
>>> f(1, 2, 3, x=1, y=2)
1 (2, 3) {'y': 2, 'x': 1}


>>> def func(a, b, c, d): print a, b, c, d
...
>>> args = (1, 2)
>>> args += (3, 4)
>>> func(*args)
1 2 3 4


>>> args = {'a': 1, 'b': 2, 'c': 3}
>>> args['d'] = 4
>>> func(**args)
1 2 3 4


>>> func(*(1, 2), **{'d': 4, 'c': 4})
1 2 4 4
>>> func(1, *(2, 3), **{'d': 4})
1 2 3 4
>>> func(1, c=3, *(2,), **{'d': 4})
1 2 3 4


def func(spam, eggs, toast=0, ham=0):        # Pierwsze dwa wymagane
print (spam, eggs, toast, ham)

func(1, 2)                                   # Wynik: (1, 2, 0, 0)
func(1, ham=1, eggs=0)                       # Wynik: (1, 0, 0, 1)
func(spam=1, eggs=0)                         # Wynik: (1, 0, 0, 0)
func(toast=1, eggs=2, spam=3)                # Wynik: (3, 2, 1, 0)
func(1, 2, 3, 4)                             # Wynik: (1, 2, 3, 4)


# Plik mins.py

def min1(*args):
   res = args[0]
   for arg in args[1:]:
      if arg < res:
         res = arg
   return res

def min2(first, *rest):
   for arg in rest:
      if arg < first:
         first = arg
   return first

def min3(*args):
   tmp = list(args)                          # Lub w Pythonie 2.4+: return sorted(args)[0]
   tmp.sort( )
   return tmp[0]

print min1(3,4,1,2)
print min2("bb", "aa")
print min3([2,2], [1,1], [3,3])


% python mins.py
1
aa
[1, 1]


def minmax(test, *args):
   res = args[0]
   for arg in args[1:]:
      if test(arg, res):
         res = arg
   return res

def lessthan(x, y): return x < y             # Zobacz również lambda
def grtrthan(x, y): return x > y

print minmax(lessthan, 4, 2, 1, 5, 6, 3)     # Kod testu
print minmax(grtrthan, 4, 2, 1, 5, 6, 3)

% python minmax.py
1
6


# Plik inter2.py

def intersect(*args):
   res = []
   for x in args[0]:                         # Przejrzenie pierwszej sekwencji
      for other in args[1:]:                 # Dla wszystkich pozostałych argumentów
         if x not in other: break            # Element w każdym z nich?
      else:                                  # Nie - wyjście z pętli
         res.append(x)                       # Tak - dodanie elementów na końcu
   return res

def union(*args):
   res = []
   for seq in args:                          # Dla wszystkich argumentów
     for x in seq:                           # Dla wszystkich węzłów
         if not x in res:
            res.append(x)                    # Dodanie nowych elementów do wyniku
   return res


% python
>>> from inter2 import intersect, union
>>> s1, s2, s3 = "Teodor", "Teofil", "Troll"

>>> intersect(s1, s2), union(s1, s2)         # Dwa argumenty
(['T', 'e', 'o', 'o'], ['T', 'e', 'o', 'd', 'r', 'f', 'i', 'l'])

>>> intersect([1,2,3], (1,4))                # Typy mieszane
[1]

>>> intersect(s1, s2, s3)                    # Trzy argumenty
['T', 'o', 'o']

>>> union(s1, s2, s3)
['T', 'e', 'o', 'd', 'r', 'f', 'i', 'l']


from Tkinter import *
widget = Button(text="Naciśnij mnie", command=someFunction)


>>> X = 'Mielonka'
>>> def func( ):
...    print X
...
>>> func( )


>>> X = 'Mielonka'
>>> def func( ):
...    X = 'NI!'
...
>>> func( )
>>> print X


>>> X = 'Mielonka'
>>> def func( ):
...    X = 'NI'
...    print X
...
>>> func( )
>>> print X


>>> X = 'Mielonka'
>>> def func( ):
...    global X
...    X = 'NI'
...
>>> func( )
>>> print X


>>> X = 'Mielonka'
>>> def func( ):
...    X = 'NI'
...    def nested( ):
...       print X
...    nested( )
...
>>> func( )
>>> X


>>> def func(a, b, c=3, d=4): print a, b, c, d
...
>>> func(1, *(5,6))