前言时刻：学习了面向对象的基本概念，其实也没多少东西，主要是一些规范之类的

1、类

我们都知道 Python 是面向对象的一门语言，所以类是非常重要的一个概念，

  1. 每个定义的类都有一个空间，存储是定义在class中所有属性名称

  2. 每个实例化的对象都拥有自己的存储空间，通过对象名.__dict__，就可以获得这个对象的属性值。

  3. 对象的属性值有增删改查等方式，设有一个对象

    • 增：s.name="pyton"

    • 删除：del s.name

    • 查看：s.name或者s.__dict__['name']

  4. 不要将要计算的代码放到 __init__函数中执行。

2、类的基本概念

1）初始化类：

通过使用__init__函数，初始化对象的属性。

  1. # 1、初始化类
  3. class A:
  5.     def __init__(self, name, age):
  6.         self.name = name
  7.         self.age = age
  9.     def add(self):
  10.         self.age = self.age + 1
  11.         return self.age
  13. a = A("python", 16)
  14. a.add()   # 17

2）类的静态变量：

这个静态变量就有点佛系了，它不放在 __init__函数中初始化，而是和函数的位置一样，放在外面定义。可以通过类名访问或者对象名访问。

  1. class A:
  2.     job = "data"
  3.     def __init__(self, name, age):
  4.         self.name = name
  5.         self.age = age
  7.     def add(self):
  8.         self.age = self.age + 1
  9.         return self.age
  11. a = A("python", 16)
  13. a.job   # data  通过对象访问
  14. A.job   # data   通过类名访问

1）类的静态变量的用处：

  • 类被初始化后，其实例化的所有对象共享同一静态变量

2）静态变量的修改：

通过类.变量，修改变量值，如果是通过对象名.变量是修改对象的变量值。

  2. class A:
  3.     name = "Python"
  4.     def __init__(self):
  5.         self.name = "Java"
  6.         self.job = 'data'
  7.         print("初始化class A")
  8.     def func(self):
  9.         print('A func is called')
  12. # 1、调用类的静态变量
  13. a1 = A()
  14. print(a1.name)  # Java
  15. print(A.name)   # Python
  17. # 修改类的静态变量
  18. A.name = "C++"
  19. print(A.name)   # C++
  21. # 2、对象的属性添加变量
  22. a1.ability = "99"   # 99
  23. print(a1.ability)  # 99
  26. # 3、类添加静态变量
  27. A.is_active = True
  28. print(A.is_active)   # True

3、命名空间：

当创建一个类的时候，会初始化一个类空间，里面存放着各个类属性的地址，如果类中有私有

  • Python中一切皆是对象，对象的类型即使类，函数也是类对象
  • 当使用对象名.属性的时候，会优先调用对象的属性，如果没有的话就找类的静态变量。

1）类的组合使用：

类的组合使用有利于解决类之间的绑定问题，将两个类绑定在一起，方便之间的调用。举个例子：今天老板让你写一个功能，在一个课程类中可以调用讲课的老师的姓名、年龄？

你会怎么办，这里可以使用类的组合功能。

  1. class Teacher:
  3.     def __init__(self, *args):
  4.         self.name = args[0]
  6. class Course:
  7.     def __init__(self, *args):
  8.         self.teacher = args[0]
  9.         self.name = args[1]
  10.     def get_teacher_name(self):
  11.         return self.teacher.name
  13. teacher1 = Teacher('zi', 18)
  15. python_course = Course(teacher1, 'python')
  16. python_course.get_teacher_name()   # zi

4、封装

其实就是Python的开放封闭原则，开放：指的是可以对该类进行扩展功能，而封闭：是可以控制一些属性不被外部访问。

4.1 私有属性和方法：

具体的私有（private）用法是：

  • 双下划线+变量，是类的私有变量，只可以在本类中调用，且外部不能调用和修改。
  • 双下划线+方法，是类的私有方法，同样也是只可在本类中调用，外部不可调用。注意：其子类不可调用父类的私有变量和私有方法

而公共（public）方法是：不加双下划线默认就是公共方法。

  • 父子均可调用，
  • 并且类外也可调用

使用私有方法，可以防止有些敏感数据被外部修改（其实也可修改，下面有提），提高安全性，复用性。

例子：

  2. # 私有变量
  4. class Person:
  6.     def __init__(self, name, age, *args, **kwargs):
  7.         self.name = name
  8.         self.__age = age
  9.         pass
  11.     def __get_age(self):
  12.         return self.__age + 600
  14.     def get_msg2(self):
  15.         return self.name, self.__get_age()
  18. class Worker(Person):
  20.     def __intit__(self, name, age, *args, **kwargs):
  21.         self.w_age = age
  22.         Super(Worker, self).__init__(name, age)
  24.     def get_msg1(self):
  25.         return self.get_msg2

1、私有属性 类外不可访问：

  2. p = Person('jingdong', 18, 'python')
  3. # p.age   # AttributeError: 'Person' object has no attribute 'age'
  4. # p.get_age()   # AttributeError: 'Person' object has no attribute 'get_age'
  6. # 想访问就需要通过类的成员函数 间接访问
  7. p.get_msg2()   # ('jingdong', 618)

2、子类 也不可访问 父类的私有属性：

  2. w = Worker('jingdong', 18, 'python')
  3. # w.get_age()   # AttributeError: 'Worker' object has no attribute 'get_age'
  4. w.get_msg2()   # ('jingdong', 618)

3、类外也可访问和修改私有属性：

我们打印下 p 对象的属性，发现原设置的__age变量变成了_Person__age，

  1. p.__dict__   # {'name': 'jingdong', '_Person__age': 18}
  3. # 取类的私有变量
  4. p._Person__age   # 18
  6. # 修改类的私有变量
  7. p._Person__age = 17
  8. p._Person__age   # 17

4.2 property

这个方法挺好玩的的，它把一个函数看似变成了属性调用，比如self.func()变成了self.func，返回的结果一样。

使用 property 有啥优点呢？

  • 隐藏函数形式，
  • 缺点：不可以直接传参数，
  1. # property装饰器
  3. class Person:
  5.     def __init__(self, name, age, *args, **kwargs):
  6.         self.name = name
  7.         self.age = age
  9.     @property
  10.     def get_name(self):
  11.         return self.name
  13.     @get_name.setter
  14.     def get_name(self, te):
  15.         if isinstance(te, str):
  16.             self.name += te
  17.         else:
  18.             raise TpyeError(f"{te} must be str")
  20.     def get_age(self):
  21.         return self.age
  23. p = Person('jingdong', 618, 'python')
  24. print(p.get_name, p.get_age(), sep=' : ')   # jingdong : 618
  26. # 可以看出，本来是函数，却用调用属性的方式进行调用。

修改属性：

  1. p.get_name = '(666)'  
  2. print(p.get_name)    # jingdong(666)

5、继承

继承主要为了解决代码冗余问题，子类可以调用父类的全部功能。在 Python3 中，所有的类都是默认继承于新式类 object 。

继承的称为子类或者派生类，被继承的称为父类或者父类。

继承可分为：

  • 单继承
  • 多继承：按照 C3 算法找父类的函数

另外还有新式类（Python3中的类都是新式类）和经典类（Python2中的）之分。

5.1 初始化父类

类中使用__init__函数进行类的属性构造，类似于 C++ 中的构造函数。

  1. # 初始化父类
  3. class A:
  4.     def __init__(self, *args):
  5.         self.age = args[0]
  6.         self.name = 'java'
  7.         pass
  9.     def func(self):
  10.         print('A', self.name, sep=' : ')
  12. class B(A):
  13.     def __init__(self, *args):
  14. #         A.__init__(self, *args)    # 初始化父类 经典类的方法
  15.         # super(B, self).__init__(*args)
  16.         # super().__init__(*args)   # 新式类的初始化父类方法，和上一行等同。
  17.         self.name = args[1]
  19.     def func(self):
  20.         print('B', self.name, sep=' : ')
  22. B(17, 'python').func()  # B : python

5.3 调用同名函数/变量

  1. class A:
  2.     def __init__(self, *args):
  3.         self.age = args[0]
  4.         self.name = 'java'
  6.     def func(self):
  7.         print('A', self.name, sep=' : ')
  9. class B(A):
  10.     name = 'B name'
  11.     def __init__(self, *args):
  12.         super().__init__(*args)   # 初始化父类
  13.         self.name = args[1]
  15.     def func2(self):
  16.         print('B', self.name, sep=' : ')
  18. b_class = B(17, 'python')
  19. b_class.func()   # A : python
  20. b_class.name   # python
  21. # 寻找name属性顺序：python->java->B name
  • 调用属性时，找属性的顺序：优先该类中->父类中->该类中的静态变量
  • 调用函数时：优先该类中->父类中

5.3 多继承

新式类中多继承的查找顺序规则是：MRO（module resolution order），其定义了调用父类属性的顺序问题，有点类似广度优先，但还是不一样。而在经典类中则采用深度优先的规则，来查找父类的属性。

多继承有两种方式，一种是使用super方法，另外一种是使用类名.__init__，那是一种系统的方法，

  1. # 3、多继承
  3. class Animal:
  4.     def __init__(self, name, age, *args):
  5.         print("初始化 Animal 类")
  6.         self.age = age
  7.         self.name2 = name
  9.     def func1(self):
  10.         print('Animal called', self.name2, sep=' : ')
  12. class Single:
  13.     def __init__(self, name, age, feature, *args):
  14.         print("初始化 Single 类")
  15.         self.feature = feature
  17.     def func(self):
  18.         print("Single called", self.name, self.feature)
  21. class Dog(Single, Animal):
  22.     name = 'Dog static'
  23.     def __init__(self, name, age, feature, *args):
  24.         Animal.__init__(self, '狗仔', 18)   # 初始化Animal类
  25.         Single.__init__(self, name, age, feature)   # 初始化个体类
  26.         self.name = name
  28.     def func2(self):
  29.         print('Dog', self.name, sep=' : ')
  31. dog = Dog('旺财', 2, '柯基犬')
  32. print(Dog.__mro__)   # (<class '__main__.Dog'>, <class '__main__.Single'>, <class '__main__.Animal'>, <class 'object'>)
  33. dog.func1()
  34. dog.name2    # 狗仔
  36. """
  37. 初始化 Animal 类
  38. 初始化 Single 类
  39. (<class '__main__.Dog'>, <class '__main__.Single'>, <class '__main__.Animal'>, <class 'object'>)
  40. Animal called : 狗仔
  41. '狗仔'
  42. """

使用类名.__mro__打印出当前类的继承所有类的顺序。

2）使用super方法初始化父类：

这个需要重点掌握，因为很绕，

  1. # 3、多继承
  3. class Animal:
  4.     def __init__(self, name, age, *args):
  5.         print("初始化 Animal 类")
  6.         self.age = age
  7.         self.name2 = name
  9.     def func1(self):
  10.         print('Animal called', self.name2, sep=' : ')
  12. class Single:
  13.     def __init__(self, name, age, feature, *args):
  14.         print("初始化 Single 类")
  15.         self.feature = feature
  17.     def func(self):
  18.         print("Single called", self.name, self.feature)
  21. class Dog(Single, Animal):
  22.     name = 'Dog static'
  23.     def __init__(self, name, age, feature, *args):
  24.         super().__init__(name, age, feature)   # 初始化Single类
  25.         super(Single, self).__init__('狗仔', 18, feature)   # 初始化Animal类
  26.         self.name = name
  28.     def func2(self):
  29.         print('Dog', self.name, sep=' : ')
  31. dog = Dog('旺财', 2, '柯基犬')
  32. print(Dog.__mro__)
  33. dog.func1()
  34. dog.name2   # 狗仔
  36. """
  37. 初始化 Single 类
  38. 初始化 Animal 类
  39. (<class '__main__.Dog'>, <class '__main__.Single'>, <class '__main__.Animal'>, <class 'object'>)
  40. Animal called : 狗仔
  41. '狗仔'
  42. """

3）mor算法介绍：

6、多态

其实前面已经用到了多态的概念，就是在继承中。在c++中，多态指的是：通过传入不同的参数类型和数量实现不同的功能。在 Python 中也是类似的，子类继承于父类，在子类中写一个和父类的同名函数。调用函数的时候，就可有不同用法。

多态有啥优点：

  • 不破坏父类的结构，可添加自定义功能
  • 可定义同名函数，覆盖父类的函数功能
  2. class Person:
  4.     def __intit__(self):
  5.         pass
  6.     def func(self, name):
  7.         print(f"Person {name}")
  9.     def get_name(self):
  10.         print("func get_name")
  12. class Boy(Person):
  14.     def __init__(self):
  15.         super().__init__()
  16.         pass
  17.     def func(self, name):
  18.         print(f"Boy {name}")
  21. xm = Boy()
  23. # 多态
  24. xm.func('小明')   # Boy 小明
  26. # 继承
  27. xm.get_name()   # func get_name

6.1 多态的用处

多态可以用来做项目架构，事先定义一个父类，等到后面只需要定义一些子类，重写一些函数即可，高效而简洁。

  2. # 多态的用处
  4. import abc
  6. class Person(metaclass=abc.ABCMeta):
  8.     @abc.abstractmethod
  9.     def get_name(self):
  10.         pass
  12. class Boy(Person):
  14.     def get_name2(self):
  15.         print('Boy')
  17. xm = Boy()
  18. xm.get_name()
  19. # TypeError: Can't instantiate abstract class Boy with abstract methods get_name

如果子类不定义一个同名函数，直接就报错。

7、classmethod用法

从字面上的意思就是：类方法，官方的解释就是在不实例化对象的时候，可以通过类名或者对象调用被装饰的函数。用法很简单直接给函数添加一个装饰器：@classmethod，被装饰器的函数的第一个参数必须是cls。

  1. class A(object):
  2.     __age = 17   # 类静态变量
  3.     __age2 = 17
  5.     @classmethod
  6.     def get_age(cls, age):
  7.         cls.__age += age
  8.         return cls.__age
  10.     def get_age2(self, age):
  11.         self.__age += age
  12.         return self.__age
  15. # 直接就可通过类名访问类方法
  16. A.get_age(1)   # 18
  18. # 通过实例化的对象调用
  19. a = A()
  20. a.get_age2(1)   # 19

2）思考🤔：这个classmethod有啥用？

个人觉的最大的好处就是不用实例化类就可调用成员函数，并且默认给函数传进取了一个cls，其实就是 self，可以初始化一个对象并返回，可以看下面：

  1. class A(object):
  3.     def __init__(self, age):
  4.         self.age = age
  6.     @classmethod
  7.     def get_obj(cls, age):
  8.         return cls(age)
  11. # 直接就可通过
  12. a = A.get_obj(666)
  13. print(a)   # <__main__.A object at 0x7f8f1ab4b670>
  14. a.age   # 666

8、staticmethod方法

他是放在类中的一个普通函数，不带有self参数，想当时与专属于这个类的一个局部函数。

  1. # staticmethod方法
  3. class A(object):
  4.     @staticmethod
  5.     def get_age(age):
  6.         print("我就是一个普通的函数，只不过在类中")
  7.         return age
  10. # 1. 通过类名访问
  11. A.get_age(1)   # 1
  13. # 2. 通过对象名访问
  14. a = A()
  15. a.get_age(2)   # 2

总结

面向对象的东西很多很杂，还是那句话，多看多练多总结！

参考链接：

http://www.langzi.fun/Python面向对象编程.html

多继承：

https://blog.csdn.net/JackZhao/article/details/82840901

https://blog.csdn.net/RSstudent/article/details/108809921

https://www.cnblogs.com/wongbingming/p/10934356.html