详解Python中类属性、 实例属性、 类方法、 静态方法、实例方法以及super()的使用和单例模式

一、Python类中各种名词定义

1、类属性：

类对象所拥有的属性，被该类的所有实例对象共有。类属性可以通过类对象或实例对象访问。

2、实例属性：

要求每个对象为其单独开辟一份内存空间来记录数据，而类属性为全类所共有，仅占一分内存，更加节省存储空间。

tips:

类属性只能通过类对象修改，不能通过实例例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。

私有属性和方法：

名称前有双下划线，子类无法访问父类的私有变量、方法（但可以通过_类名__名称的方式访问 ）；私有变量只有本类的内部能直接调用

保护属性和方法：

名称前有单下划线，父类的 protect 属性，子类可以继承，实例对象、类对象都能直接调用 protect 属性、方法

3、类方法：

需要用装饰器@classmethed来标识其为类方法，对于类方法，第一个参数必须是对象，一般以cls作为第一个参数。

使用场景:

当方法中需要使用类对象（如访问私有类属性等）时，定义为类方法。类方法一般和类属性配合使用。

4、静态方法:

需要通过装饰器@staticmethod来进行修饰，静态方法几不需要传递类对象也不需要传递实例对象(形参没有self/cls);静态方法也能够通过实例对象和类对象去访问。

使用场景：

方法中既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性，类方法，创建实例等）时，定义静态方法；取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗

5、实例方法：

定义实例方法与定义函数基本相同，只是Python要求实例方法的第一个形参必须为self，也就是实例对象本身，因此实例方法至少应该有一个self参数。

# In[1]
class Person():
    # 类属性
    age = 18

    def __init__(self):
        # 实例属性
        self.name = "张三"
        self.sex = "男"

    # 类方法
    @classmethod
    def exe_class(cls):
        print("永远{}岁".format(cls.age))

    #静态方法
    @staticmethod
    def exe_static():
        print("我是静态方法")
    # 实例方法
    def myinfo(self):
        print("我叫{}，我是{}，我今年{}岁".format(self.name,self.sex,self.age))

if __name__ == '__main__':
    my = Person()
    my.exe_class()
    # 永远18岁
    my.exe_static()
    # 我是静态方法
    my.myinfo()
    # 我叫张三，我是男，我今年18岁

二、Python中的super的作用

python中的super，名为超类，可以简单的理解为执行父类的__init__函数。由于在python中不论是一对一的继承，还是一子类继承多个父类，都会涉及到执行的先后顺序的问题。

1、单继承

class Person():
    def __init__(self):
        print('我是Peson的__init__构造方法')

class Teacher(Person):
    def __init__(self):
        super().__init__()
        print('我是Teacher的__init__构造方法')

tea = Teacher()
#我是Peson的__init__构造方法
#我是Teacher的__init__构造方法

2、多继承

class A():
    def __init__(self):
        self.n = 2
    def add(self, m):
        print("A开始执行")
        self.n += m
        print("A结束执行")

class B(A):
    def __init__(self):
        self.n = 3
    def add(self, m):
        print("B开始执行")
        super().add(m)
        self.n += 3
        print("B结束执行")

class C(A):
    def __init__(self):
        self.n = 4
    def add(self, m):
        print("C开始执行")
        super().add(m)
        self.n += 4
        print("C结束执行")

class D(B, C):
    def __init__(self):
        self.n = 5
    def add(self, m):
        print("D开始执行")
        super().add(m)
        self.n += 5
        print("D结束执行")

print(D.__mro__)
d = D()
d.add(6)
print(d.n)

结果

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
D开始执行
B开始执行
C开始执行
A开始执行
A结束执行
C结束执行
B结束执行
D结束执行
23

根据结果我们可以推出计算过程：

首先是D的实例化n=5使用A的方法add,计算n加m=6,n=11;
然后开始执行C的add方法，n+4,结果n=15;
然后执行B的add方法，n+3,结果n=18;
最后执行D的add方法，n+5,结果n=23。

三、Python的单例模式

class SingLeton():
    instance = None
    lock = threading.RLock()

    def __init__(self,name):
        self.name = name

    def __new__(cls, *args, **kwargs):
        if cls.instance:
            return cls.instance
        with cls.lock:
            if cls.instance:
                return cls.instance
            cls.instance = object.__new__(cls)
        return cls.instance