>>> class FirstClass:                        # Zdefiniowanie obiektu klasy
...    def setdata(self, value):             # Zdefiniowanie metod klasy
...       self.data = value                  # self to instancja
...    def display(self):
...       print self.data                    # self.data: dla instancji
...


>>> x = FirstClass( )                        # Utworzenie dwóch instancji
>>> y = FirstClass( )                        # Każda jest nową przestrzenią nazw


>>> x.setdata("Król Artur")                  # Wywołanie metod: self to x
>>> y.setdata(3.14159)                       # Wykonuje FirstClass.setdata(y, 3.14159)


>>> x.display( )                             # self.data różni się w każdej instancji
Król Artur
>>> y.display( )
3.14159


>>> x.data = "Nowa wartość"                  # Pobiera lub ustawia atrybuty
>>> x.display( )                             # Również poza klasą
Nowa wartość


>>> x.anothername = "mielonka"               # Można tutaj również ustawiać nowe atrybuty


>>> class SecondClass(FirstClass):           # Dziedziczy metodę setdata
...    def display(self):                    # Modyfikuje metodę display
...       print 'Aktualna wartość = "%s"' % self.data
...


>>> z = SecondClass( )
>>> z.setdata(42)                            # Odnajduje metodę setdata w FirstClass
>>> z.display( )                             # Odnajduje przesłoniętą metodę w SecondClass
Aktualna wartość = "42"


>>> x.display( )                             # x nadal jest instancją FirstClass (stary komunikat)
Nowa wartość


from modulename import FirstClass            # Skopiowanie nazwy do mojego zakresu
class SecondClass(FirstClass):               # Bezpośrednie wykorzystanie nazwy klasy
   def display(self): ...


import modulename                            # Dostęp do całego modułu
class SecondClass(modulename.FirstClass):    # Składnia kwalifikująca tworzy referencję
   def display(self): ...


# Plik food.py

var = 1                                      # food.var
def func( ):                                 # food.func
   ...
class spam:                                  # food.spam
   ...
class ham:                                   # food.ham
   ...
class eggs:                                  # food.eggs
   ...


# Plik person.py

class person:
   ...


import person                                # Zaimportowanie modułu
x = person.person( )                         # Klasa wewnątrz modułu


from person import person                    # Pobranie klasy z modułu
x = person( )                                # Wykorzystanie nazwy klasy


>>> class ThirdClass(SecondClass):           # Dziedziczy po SecondClass
...    def __init__(self, value):            # Przy "ThirdClass(value)"
...       self.data = value
...    def __add__(self, other):             # Przy "self + other"
...       return ThirdClass(self.data + other)
...    def __mul__(self, other):
...       self.data = self.data * other      # Przy "self * other"
...
>>> a = ThirdClass("abc")                    # Wywołane nowe __init__
>>> a.display( )                             # Odziedziczona metoda
Aktualna wartość = "abc"

>>> b = a + 'xyz'                            # Nowe __add__: utworzenie nowej instancji
>>> b.display( )
Aktualna wartość = "abcxyz"

>>> a * 3                                    # Nowe __mul__: modyfikuje instancję w miejscu
>>> a.display( )
Aktualna wartość = "abcabcabc"


>>> class rec: pass                          # Pusty obiekt przestrzeni nazw


>>> rec.name = 'Edward'                      # Obiekty z atrybutami
>>> rec.age = 40


>>> print rec.name                           # Jak struktura z języka C lub rekord
Edward


>>> x = rec( )                               # Instancje dziedziczą nazwy klas
>>> y = rec( )


>>> x.name, y.name                           # Zmienna jest przechowywana tylko w klasie
('Edward', 'Edward')


>>> x.name = 'Amadeusz'                      # Przypisanie modyfikuje jedynie x
>>> rec.name, x.name, y.name
('Edward', 'Amadeusz', 'Edward')


>>> rec.__dict__.keys( )
['age', '__module__', '__doc__', 'name']

>>> x.__dict__.keys( )
['name']

>>> y.__dict__.keys( )
[]


>>> x.__class__
<class __main__.rec at 0x00BAFF60>


>>> def upperName(self):
...    return self.name.upper( )             # Nadal potrzebuje self


>>> rec.method = upperName

>>> x.method( )                              # Wykonanie metody w celu przetworzenia x
'AMADEUSZ'

>>> y.method( )                              # To samo, jednak przekazuje y do self
'EDWARD'

>>> rec.method(x)                            # Można wywołać przez instancję lub klasę
'AMADEUSZ'