Класове в нов стил

• Въведени в Python 2.2 за да добавят нови възможности в езика, без да чупят стар код
• Наследяват object или клас, който наследява object - list, dict, tuple, str и т.н.
• Другите класове се наричат "класически"
• Променят малко множественото наследяване.
• Дават ви нов начин за конструкция - __new__.
• Можете да ограничавате полетата им със __slots__.

Класове в нов стил — __slots__

class Something(object):
    __slots__ = ['spam', 'eggs']

>>> smth = Something()
>>> smth.spam = 1
>>> smth.eggs = 2
>>> smth.foo = 3

Traceback (most recent call last):
  File "<stdin>", line 5, in <module>
AttributeError: 'Something' object has no attribute 'foo'

Класове в нов стил — __new__

Обикновенно се налага, когато наследявате immutable стандартни класове

  class SpamTuple(tuple):
      def __new__(cls, number = 1):
          result = ("Spam",) * number
          return tuple.__new__(cls, result)

      def countSpam(self):
          return len(self)

  spams = SpamTuple(3)
  print spams             # ('Spam', 'Spam', 'Spam')
  print spams.countSpam() # 3

Множествено наследяване (1)

При класове от стар стил, атрибутите се търсят в родителите по дълбочина

class A:
    def spam(self): print "A's spam"
class B(A): pass
class C(A):
    def spam(self): print "C's spam"
class D(B, C): pass

d = D()
d.spam() # A's spam

Множествено наследяване (2)

При класове от нов стил, атрибутите се търсят в родителите по широчина

class A(object):
    def spam(self): print "A's spam"
class B(A): pass
class C(A):
    def spam(self): print "C's spam"
class D(B, C): pass

d = D()
d.spam() # C's spam

Атрибути

• getattr(обект, име_на_атрубит) връща обект.атрибут, където атрибут.
• setattr(обект, име_на_атрибут, стойност) присвоява стойност на обект.атрибут.
• delattr(обект, име_на_атрибут) работи като del обект.атрибут.

class Spam: pass

>>> spam = Spam()
>>> spam.eggs = "Eggs"
>>> getattr(spam, 'eggs')
Eggs
>>> setattr(spam, 'bacon', 'Spam, eggs and bacon')
>>> spam.bacon
Spam, eggs and bacon
>>> delattr(spam, 'bacon')

Сравняване на обекти (2)

Можете да предефинирате равенството за обекти от даден клас с метода__eq__

class Vector(object):
    def __init__(self, x, y, z): self._coords = map(float, [x, y, z])
    def __eq__(self, other):
        return all([a == b for a, b in zip(self._coords, other._coords)])

По подразбиране, __eq__ е имплементирана с is

class Food(object): pass
spam = Food()
eggs = Food()
moreSpam = spam
print spam == moreSpam, spam is moreSpam # True True
print spam == eggs, spam is eggs # False False

Сравняване на обекти (3)

class Vector(object):
    def __init__(self, x, y, z): self._coords = map(float, [x, y, z])
    def __eq__(self, other):
        return all([a == b for a, b in zip(self._coords, other._coords)])

>>> a, b = Vector(1.0, 1.0, 1.0), Vector(1.0, 1.0, 1.0)
>>> print a == b
True
>>> print a != b
True
>>> print "WTF?!"

• __eq__ не предефинира !=
• За целта трябва да дефинирате метода __ne__

Сравняване на обекти (5)

Можете да предефинирате всичките шест оператора __cmp__(self, other). Този метод трябва да сравнява self и other и да връща:

• Отрицателно число, ако self < other.
• Нула, ако self == other.
• Положително число, ако self > other.

class Vector(object):
    ...
    def __cmp__(self, other):
        if self.length() < other.length(): return -1
        elif self.length() == other.length(): return 0
        else: return 1

str и repr (1)

• В Python от всеки обект могат да се получат две важни неща - текстов низ (str) и "репрезентация" (repr)
• Текстовото представяне се използва при str(обект) или при "%s" % обект
• Репрезентацията представлява текст, който ако се изпълни като Python код ще създаде обекта на който е извикан - т.е. eval(repr(обект)) == обект
• Репрезентация се извежда с repr(обект).

>>> print "Spam\nand\neggs"
Spam
and
eggs
>>> print repr("Spam\nand\neggs")
'Spam\nand\neggs'

Аритметични оператори (2)

• Всеки оператор има вариантен метод за прилагане на операцията "на място" - например +=, /= и т.н.
• Метода има същото име, но със i след двете подчертавки - __add__ става __iadd__
• Хубаво е когато дефинирате такива методи, те да променят self и да връщат self

a, b, c = MagicNumber(3), MagicNumber(5), MagicNumber(7)

a = a + b # MagicNumber.__add__(a, b)
a += c    # MagicNumber.__iadd__(a, c)

Обекти, които могат да бъдат извиквани като функции

Можете да предефинирате оператора две скоби ().

class Stamp(object):
    def __init__(self, name): self.name = name
    def __call__(self, something):
        print "%s was stamped by %s" % (something, self.name)

>>> stamp = Stamp("The goverment")
>>> stamp("That thing there")
That thing there was stamped by The goverment

Още атрибути (2)

__getattr__(self, name) се извиква само, ако обекта няма атрибут с име name.

class Spam(object):
    def __getattr__(self, name):
        print "Getting attribute: " + name
        return None

spam = Spam()
spam.eggs = "Eggs"
print spam.eggs
print spam.foo


Eggs
Getting attribute: foo
None