Python3 面向对象

self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类

class Test:
    w = 10  # 类变量
    def __init__(self, k):
        Test.h = 50  # 类变量
        self.k = k  # 实例变量
    def prt(self):
        print(self)
        print(self.__class__)

# 内存：类{Test, w=10}  此时不存在类变量h
a = Test(1)  # 实例化类，存在类变量h
'''
print(dir(Test))
print(Test.__dict__)
print(dir(a))
print(a.__dict__)
'''
# 内存：类{Test w=10, h=50}, 实例a{Test类对象指针, k=1}
print("1", Test.w, id(Test.w), Test.h, id(Test.h))
print("2", a.w, id(a.w))  # 通过实例a访问类变量w
a.w = 100  # 类变量w并没有修改，而添加一个实例变量w
# 内存：类{Test w=10, h=50}，实例a{Test类对象指针, w=100, k=1}
print("3", a.w, id(a.w))  # 通过实例a访问实例变量w，屏蔽了同名类变量w
a.w = 200  # 修改实例变量，通过新的实例变量地址w'掩盖原实例w
# 实例a{Test类对象指针, w'=200, k=1}
print("4", a.w, id(a.w))
Test.h = 500  # 通过类名修改类变量，通过新的变量地址h'掩盖原h
# 类{Test, w=10, h=500}
print("5", Test.h, id(Test.h))

b = Test(2)  # 实例化类
# 类{Test, w=10, h=50}  实例b{Test类对象指针，k=2}
print("6", Test.h, id(Test.h))  # 注意h的地址
print("7", b.k, id(b.k))  # 不存在类变量Test.k
Test.t = 'Hello'  # 动态添加类变量
# 类{Test, w=10, h=50, t="Hello"}  实例b{Test类对象指针，k=2}
b.t = "Python"  # 添加实例变量t
'''
print(dir(Test))
print(Test.__dict__)
print(dir(b))
print(b.__dict__)
'''
print("8", Test.t, id(Test.t), b.t, id(b.t))
del Test.t  # 删除类变量
print("9", b.t, id(b.t))  # 修改，删除类变量t，不会影响同名实例变量t
a.prt()

类方法 & 静态方法 & 实例方法

• 采用@classmethod修饰的方法为类方法；
• 采用 @staticmethod修饰的方法为静态方法；
• 不用任何修改的方法为实例方法。

class Site:
    def __init__(self, name, url):
        self.name = name   # public 实例变量
        self.__url = url   # private 实例变量
    def who(self):
        print('name: ', self.name)
        print('url: ', self.__url)
    def __foo(self):  # 私有方法
        print('这是私有方法')
    def foo(self): # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('菜鸟教程', 'www.runoob.com') # 实例化类
x.who()        # 正常输出，访问类的属性和方法
x.foo()        # 正常输出
x.__foo()      # 报错，外部不能调用私有方法
print(x.__url)  # 报错，实例不能访问私有变量

super() 函数是用来调用父类的一个方法。在多继承中使用时，需要考虑 MRO（即Method Resolution Order）的问题。super() 函数获取的是 MRO 列表中的下一个类。

class A(object):
    def __init__(self):
        self.n = 10

    def minus(self, m):
        print('minus in class A start',
              '  self is {0} @A.minus.format(self)'.format(self))
        self.n -= m
        print('minus in class A end', "  self.n=", self.n)


class B(A):
    def __init__(self):
        self.n = 7

    def minus(self, m):
        print('minus in class B start',
              '  self is {0} @B.minus.format(self)'.format(self))
        super(B, self).minus(m)
        self.n -= 2
        print('minus in class B end', "  self.n=", self.n)


class C(A):
    def __init__(self):
        self.n = 12

    def minus(self, m):
        print('minus in class C start',
              '  self is {0} @C.minus.format(self)'.format(self))
        super(C, self).minus(m)
        self.n -= 5
        print('minus in class C end', "  self.n=", self.n)


class D(B, C):
    def __init__(self):
        self.n = 15  # 实例变量

    def minus(self, m):
        print('minus in class D start',
              '  self is {0} @D.minus.format(self)'.format(self))
        super(D, self).minus(m)
        self.n -= 2
        print('minus in class D end', "  self.n=", self.n)


print('The MRO of class D is :', D.__mro__)  # D.mro()
d = D()
d.minus(2)
print(d.n)

class Vector:
	def __init__(self, a, b):
		self.a = a
		self.b = b
	def __str__(self):
		return 'Vector(%d, %d)' % (self.a, self.b)
	def __add__(self, other):
		return Vector(self.a+other.a, self.b+other.b)

v1 = Vector(2, 10)
v2 = Vector(5, -2)
print(v1+v2)