Protected и private

• В Python няма protected и private променливи - всичко е достъпно отвън! Все пак има неписано правила
• Имена от типа _име се смятат за protected
• Имена от типа __име се смятат за private
• Интерпретаторът променя имената от типа __име до _клас__име. Това се нарича name mangling и ефектът му е подобен на private в други езици

class Spam:
    def __stuff(self): pass

>>> dir(Spam)
['_Spam__stuff', '__doc__', '__module__', ...]

super

class A:
    def spam(self, sth): print("A's spam and {0}".format(sth))

class B(A):
    def spam(self, sth):
        print("B's spam and {0}".format(sth))
        super().spam(sth)    # еквивалентно на super(B, self).method(eggs)
        print("B's spam and {0} (again)".format(sth))

>>> B().spam("eggs")
B's spam and eggs
A's spam and eggs
B's spam and eggs (again)

>>> super(B, B()).spam("eggs")
A's spam and eggs

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

Атрибутите се търсят в родителите по дълбочина (отляво надясно)

class A:
    def spam(self): print("A's spam")

class B(A): pass

class C:
    def spam(self): print("C's spam")

class D(B, C): pass

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

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

Всъщност в python използват "call-next-method"

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() # C's spam

super (2)

class A:
    def x(self):
        print('A')

class B(A):
    def x(self):
        super().x()
        print('B')

class C(A):
    def x(self):
        super().x()
        print('C')

class D(B,C):
    def x(self):
        super().x()
        print('D')

D().x()

Атрибути

• 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:
    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: pass

spam = Food()
eggs = Food()
more_spam = spam
print(spam == more_spam, spam is more_spam) # True True
print(spam == eggs, spam is eggs)           # False False

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

class Vector:
    def __init__(self, x, y, z): self._coords = list(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)
False

• __eq__ предефинира !=
• Може да дефинирате метода __ne__

str и repr (1)

• В Python от всеки обект могат да се получат две важни неща - текстов низ (str) и "репрезентация" (repr)
• Текстовото представяне се използва при str(обект)
• Репрезентацията представлява текст, който ако се изпълни като 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 OP= b и недефиниран __iOP__ се извиква a = a OP b

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

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

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

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

class Stamp:
    def __init__(self, name): self.name = name
    def __call__(self, something):
        print("{0} was stamped by {1}".format(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:
    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