__all__ = ["Error", "encode", "decode"]      # Eksportuje tylko te zmienne


from __future__ import nazwa_opcji


# Plik runme.py

def tester( ):
   print "Jest Gwiazdka w niebie..."

if __name__ == '__main__':                   # Tylko przy wykonywaniu
   tester( )                                 # A nie przy importowaniu

   
% python
>>> import runme
>>> runme.tester( )
Jest Gwiazdka w niebie...   


% python runme.py
Jest Gwiazdka w niebie...


# Plik min.py

# -*- coding: utf-8 -*-
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
def grtrthan(x, y): return x > y

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


# Plik min.py

# -*- coding: utf-8 -*-
print 'Jestem:', __name__

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
def grtrthan(x, y): return x > y

if __name__ == '__main__':
   print minmax(lessthan, 4, 2, 1, 5, 6, 3)     # Kod testu samosprawdzającego
   print minmax(grtrthan, 4, 2, 1, 5, 6, 3)


% python min.py
Jestem: __main__
1
6


>>> import min
Jestem: min
>>> min.minmax(min.lessthan, 'm', 'i', 'e', 'l', 'o', 'n', 'k', 'a')
'a'


>>> import sys
>>> sys.path
['', 'D:\\PP3ECD-Partial\\Examples', 'C:\\Python25', ...pozostałe usunięto...]

>>> sys.path.append('C:\\sourcedir')         # Rozszerzenie ścieżki wyszukiwania modułów
>>> import string                            # Wszystkie importy przeszukują nowy katalog


>>> sys.path = [r'd:\temp']                  # Zmiana ścieżki wyszukiwania modułów
>>> sys.path.append('c:\\lp3e\\examples')    # Tylko dla tego procesu
>>> sys.path
['d:\\temp', 'c:\\lp3e\\examples']

>>> import string
Traceback (most recent call last):
   File "<stdin>", line 1, in ?
ImportError: No module named string


import długanazwamodułu as nazwa


import długanazwamodułu
nazwa = długanazwamodułu
del długanazwamodułu                         # Nie zachowujemy oryginalnej nazwy


from moduł import długanazwa as nazwa


from .spam import name


from __future__ import absolute_import       # Wymagane aż do wersji 2.7?


import string                                # Zawsze znajduje wersję z biblioteki standardowej


from . import string                         # Przeszukuje najpierw ten pakiet


from .string import name1, name2             # Importuje zmienne z mypkg.string
from . import string                         # Importuje mypkg.string
from .. import string                        # Importuje string z katalogu nadrzędnego


mypkg\
      __init__.py
      main.py
      string.py


import string                                # Importuje moduł string z biblioteki standardowej


from mypkg import string                     # Importuje mypkg.string (bezwzględnie)


from . import string                         # Importuje mypkg.string (względnie)


from .string import name1, name2             # Importuje zmienne z modułu mypkg.string


from .. import spam                          # Importuje moduł równoległy do mypkg


from . import D                              # Importuje A.B.D
from .. import E                             # Importuje A.E
from ..F import G                            # Importuje A.F.G


M.name                                       # Kwalifikacja obiektu
M.__dict__['name']                           # Ręczne indeksowanie słownika przestrzeni nazw
sys.modules['M'].name                        # Ręczne indeksowanie tabeli załadowanych modułów
getattr(M, 'name')                           # Wywołanie wbudowanej funkcji pobierającej


# Plik mydir.py

# -*- coding: utf-8 -*-

# Moduł wymieniający przestrzeń nazw innych modułów

verbose = 1

def listing(module):
   if verbose:
      print "-"*30
      print "nazwa:", module.__name__, "plik:", module.__file__
      print "-"*30

   count = 0
   for attr in module.__dict__.keys( ):      # Przeszukanie przestrzeni nazw
      print "%02d) %s" % (count, attr),
      if attr[0:2] == "__":
         print "<zmienna wbudowana>"         # Pominięcie __file__ itd.
      else:
         print getattr(module, attr)         # To samo co .__dict__[attr]
      count = count+1
   
   if verbose:
      print "-"*30
      print module.__name__, "ma %d zmiennych" % count
      print "-"*30

if __name__ == "__main__":
   import mydir
   listing(mydir)                            # Kod samosprawdzający - lista samego siebie


C:\python> python mydir.py
------------------------------
name: mydir file: mydir.py
------------------------------
00) __file__ <zmienna wbudowana>
01) __name__ <zmienna wbudowana>
02) listing <function listing at 885450>
03) __doc__ <zmienna wbudowana>
04) __builtins__ <zmienna wbudowana>
05) verbose 1
------------------------------
mydir ma 6 zmiennych
------------------------------


func1( )                                     # Błąd: "func1" nie została jeszcze przypisana

def func1( ):
   print func2( )                            # OK: "func2" zostanie wyszukana później

func1( )                                     # Błąd: "func2" nie została jeszcze przypisana

def func2( ):
   return "Witam"

func1( )                                     # OK: "func1" i "func2" zostały już przypisane


>>> import "string"
   File "<stdin>", line 1
      import "string"
                    ^
SyntaxError: invalid syntax


x = "string"
import x


>>> modname = "string"
>>> exec "import " + modname                 # Wykonanie łańcucha kodu
>>> string                                   # Zaimportowany w tej przestrzeni nazw
<module 'string'>


>>> modname = "string"
>>> string = __import__(modname)
>>> string
<module 'string'>


# Plik nested1.py

X = 99
def printer( ): print X


# Plik nested2.py

# -*- coding: utf-8 -*-
from nested1 import X, printer               # Kopiuje zmienne
X = 88                                       # Modyfikuje tylko X lokalne!
printer( )                                   # X w nested1 nadal ma wartość 99


% python nested2.py
99


# Plik nested3.py

# -*- coding: utf-8 -*-
import nested1                               # Pobranie modułu jako całości
nested1.X = 88                               # OK: modyfikuje X z modułu nested1
nested1.printer( )


% python nested3.py
88


>>> from module1 import *                    # Źle: może po cichu nadpisać nasze zmienne
>>> from module2 import *                    # Gorzej: skąd mamy wiedzieć, co dostajemy?
>>> from module3 import *
>>> . . .

>>> func( )                                  # Hę???


from module import X                         # X może nie odzwierciedlać przeładowanych modułów!
. . .
reload(module)                               # Modyfikacja modułu, ale nie zaimportowanych zmiennych
X                                            # Nadal odnosi się do starego obiektu


import module                                # Pobranie modułu, nie zmiennych
. . .
reload(module)                               # Modyfikuje moduł w miejscu
module.X                                     # Bieżące X: odzwierciedla przeładowanie modułu


from module import function
function(1, 2, 3)


reload(module)


import module
reload(module)
function(1, 2, 3)


import module
reload(module)
from module import function
function(1, 2, 3)


# Plik A.py

# -*- coding: utf-8 -*-
import B                                      # Nie jest przeładowywany razem z A
import C                                      # Importuje załadowany już moduł


% python
>>> . . .
>>> reload(A)


# Plik reloadall.py

# -*- coding: utf-8 -*-
import types

def status(module):
   print 'przeładowanie', module.__name__

def transitive_reload(module, visited):
   if not visited.has_key(module):           # Przechwycenie cykli i powtarzających się modułów
      status(module)                         # Przeładowanie modułu
      reload(module)                         # Przejście do jego modułów podrzędnych
      visited[module] = None
      for attrobj in module.__dict__.values( ): # Dla wszystkich atrybutów
         if type(attrobj) == types.ModuleType:  # Rekurencja, jeśli to moduł
            transitive_reload(attrobj, visited)

def reload_all(*args):
   visited = { }
   for arg in args:
      if type(arg) == types.ModuleType:
         transitive_reload(arg, visited)

if __name__ == '__main__':
   import reloadall                          # Kod samosprawdzający: przeładowuje siebie
   reload_all(reloadall)                     # Powinien to przeładować


# Plik: recur1.py

# -*- coding: utf-8 -*-
X = 1
import recur2                                # Wykonuje recur2, jeśli obiekt modułu nie istnieje
Y = 2


# Plik: recur2.py

# -*- coding: utf-8 -*-
from recur1 import X                         # OK: "X" jest już przypisane
from recur1 import Y                         # Błąd: "Y" nie jest przypisane


>>> import recur1
Traceback (innermost last):
   File "<stdin>", line 1, in ?
   File "recur1.py", line 2, in ?
      import recur2
   File "recur2.py", line 2, in ?
      from recur1 import Y                   # Błąd: "Y" nie jest przypisane
   ImportError: cannot import name Y



