面向对象（中）

一、类的构造方法

init()构造方法

1）调用时间：在对象被实例化时被程序自动调用

2）作用：用于对象创建时初始化

3）书写格式：init前后分别是两个下划线

4）程序不显示定义init方法，则程序默认调用一个无参init方法

  1. class Dog:
  2.     def __init__(self):
  3.         print("我是构造方法，在创建对象时自动调用")
  4.     def eat(self):
  5.         print("正在吃骨头...")
  6.     def drink(self):
  7.         print("正在喝水....")
  8. wangcai = Dog()
  9. print("------------")
  10. wangcai.eat()
  11. wangcai.drink()

运行结果：

  1. 我是构造方法，在创建对象时自动调用
  2. ------------
  3. 正在吃骨头...
  4. 正在喝水....

5）对象创建过程

第七课：面向对象（中） - 图1

6）在init()构造方法中初始化对象属性

  1. class Dog:
  2. def __init__(self, gender, variety, name):
  3.     self.gender = gender
  4.     self.variety = variety
  5.     self.name = name
  6. # 获取对象属性，并打印出来
  7. def get_pro(self):
  8.     print("gender:{},variety:{},name:{}".format(self.gender, self.variety, self.name))
  10. wangcai = Dog("male","golden","wangcai")
  11. yuanbao = Dog("female","husky","yuanbao")
  12. wangcai.get_pro()
  13. yuanbao.get_pro()

运行结果：

  1. gender:male,variety:golden,name:wangcai
  2. gender:female,variety:husky,name:yuanbao

分别调用，互不干扰

注：self参数必须是第一个参数

对象创建过程：

第七课：面向对象（中） - 图2

第七课：面向对象（中） - 图3

二、类的访问权限

1、修改对象属性的方法

1）方法1：对象变量名.属性 = 新值

方法1存在的问题：

（1）可能修改的属性值不合法

（2）在类的外部可以随意修改类的内部属性

2）方法2：对象变量名.内部修改属性方法

  1. class Dog:
  2.     def __init__(self,gender,variety,name,age):
  3.         self.gender = gender
  4.         self.variety = variety
  5.         self.name = name
  6.         self.age = age
  7.     # 获取对象属性，并打印出来
  8.     def get_pro(self):
  9.         print("gender:{},variety:{},name:{},age:{}".format(self.gender, self.variety, self.name, self.age))
  11.     def set_pro(self, **kwargs):
  12.         if "gender" in kwargs:
  13.             self.gender = kwargs["gender"]
  14.         elif "age" in kwargs:
  15.             if kwargs["age"] < 0 or kwargs["age"] > 20:
  16.                 print("非法年龄")
  17.             else:
  18.                 self.age = kwargs["age"]
  19. wangcai = Dog("male","golden","wangcai",5)
  20. #修改对象属性，方法1直接修改
  21. wangcai.age = 100 #数值可能不合法，但仍可以修改
  22. wangcai.get_pro()
  23. #方法2：通过内部方法修改属性
  24. wangcai.set_pro(age=10)
  25. wangcai.get_pro()

运行结果：

  1. gender:male,variety:golden,name:wangcai,age:100
  2. gender:male,variety:golden,name:wangcai,age:10

2、私有属性

1）定义：__私有变量名

在变量名前加两个下划线：self.__private_attrs

2）只能在类内部使用，类外部不能访问，否则报错
例1：

  1. class Dog:
  2. def __init__(self,gender,variety,name,age):
  3.     self.gender = gender
  4.     self.variety = variety
  5.     self.name = name
  6.     self.__age = age
  7. # 获取对象属性，并打印出来
  8. def get_pro(self):
  9.     print("gender:{},variety:{},name:{},age:{}".format(self.gender, self.variety, self.name, self.__age))
  11. def set_pro(self, **kwargs):
  12.     if "gender" in kwargs:
  13.         self.gender = kwargs["gender"]
  14.     elif "age" in kwargs:
  15.         if kwargs["age"] < 0 or kwargs["age"] > 20:
  16.             print("非法年龄")
  17.         else:
  18.             self.__age = kwargs["age"]
  20. wangcai = Dog("male","golden","wangcai",5)
  21. #方法1，无法修改私有属性值
  22. wangcai.age = 100
  23. wangcai.get_pro()
  24. #方法2，可以通过内部的方法修改私有属性值
  25. wangcai.set_pro(age=10)
  26. wangcai.get_pro()

运行结果：

  1. gender:male,variety:golden,name:wangcai,age:5
  2. gender:male,variety:golden,name:wangcai,age:10

例2：

  1. class Counter:
  2.     __privateCount = 0  # 私有变量
  3.     publicCount = 0    # 公有变量
  4.     def count(self):
  5.         self.__privateCount += 1
  6.         self.publicCount += 1
  7.         print(self.__privateCount)
  8. counter = Counter()
  9. counter.count()
  10. counter.count()
  11. print(counter.publicCount)
  12. print(counter.__privateCount) #会报错，类外部不能访问

3、私有方法

1）只能在类内部调用，在类的外部无法调用

2）定义私有方法：在方法名前添加两个下划线

3）类内部调用私有方法：self.__private_methods

  1. #私有方法的使用
  2. class Comrade:
  3.     #私有方法
  4.     def __send_message(self):
  5.         print("消息已经向上级汇报")
  7. def answer_secret(self,secret):
  8.         if secret == "芝麻开门":
  9.             print("接头成功!")    self.__send_message()#调用私有方法
  10.         else:
  11.             print("接头失败！")
  12. comrade = Comrade()
  13. comrade.answer_secret("芝麻开门")

运行结果：

  1. 接头成功!
  2. 消息已经向上级汇报

三、继承和多态

在程序中，继承描述的时类中类型与子类型之间的所属关系

1、单继承

1）子类继承一个父类，在定义子类时，小括号中写父类的类名

2）父类的非私有属性、方法会被子类继承

  1. class Animal:
  2.     def eat(self):
  3.         print("----吃----")
  4.     def drink(self):
  5.         print("----喝----")
  6.     def run(self):
  7.         print("----跑----")
  9. class Dog(Animal):
  10.     def hand(self):
  11.         print("------握手-----")
  13. wangcai = Dog()
  14. #调用从父类继承的方法
  15. wangcai.eat()
  16. wangcai.drink()
  17. wangcai.run()
  18. #调用自身的方法
  19. wangcai.hand()

运行结果：

  1. ----吃----
  2. ----喝----
  3. ----跑----
  4. ------握手-----

3）子类中方法的查找方式：先查找子类中对应的方法，如果找不到，再到父类中查找

4）子类可以继承父类的属性和方法，也可以继承父类的父类的非私有属性和方法，以次类推

  1. class Animal:
  2.     def eat(self):
  3.         print("----吃----")
  4.     def drink(self):
  5.         print("----喝----")
  6.     def run(self):
  7.         print("----跑----")
  9. class Dog(Animal):
  10.     def hand(self):
  11.         print("------握手-----")
  13. class GoldenDog(Dog):
  14.     def guid(self):
  15.         print("我能导航！")
  17. golden = GoldenDog()
  18. golden.guid()
  19. golden.hand()
  20. golden.run()

运行结果：

  1. 我能导航！
  2. ------握手-----
  3. ----跑----

5）在子类中调用父类的方法：ClassName.methodname(self)

  1. class Animal:
  2.     def run(self):
  3.         print("----跑----")
  5. class Dog(Animal):
  6.     def hand(self):
  7.         Animal.run(self)
  8.         print("------握手-----")
  10. wangcai = Dog()
  11. wangcai.hand()

运行结果：

  1. ----跑----
  2. ------握手-----

6）重写父类方法：

（1）子类对父类允许访问的方法的实现过程进行重新编写

（2）在子类中定义与父类同名的方法

（3）优点：子类可以根据需要，定义合适的方法实现逻辑

  1. class Animal:
  2.     def run(self):
  3.         print("----跑----")
  5. class Dog(Animal):
  6.     #父类方法重写
  7.     def run(self):
  8.         print("摇着尾巴跑")
  10. duoduo = Dog()
  11. duoduo.run()

运行结果：

  1. 摇着尾巴跑

7）如果在子类中没有定义init构造方法，则自动调用父类的init构造方法，如果在子类中定义了init构造方法，则不会调用父类的构造方法

  1. class Animal:
  2.     def __init__(self):
  3.         print("---animal构造方法----")
  4.     def run(self):
  5.         print("----跑----")
  6. class Dog(Animal):
  7.     def __init__(self):
  8.         print("dog构造方法")
  9.     def run(self):
  10.         print("摇着尾巴跑")
  12. duoduo = Dog()
  13. duoduo.run()

运行结果：

  1. dog构造方法
  2. 摇着尾巴跑

2、多继承

1）object类是所有类的基类，在定义类的时候不需要显示的在括号中表明继承自object类

2）多继承：一个子类可以继承多个父类

3）多继承定义方式：在类名后的括号中添加需要继承的多个类名

4）多继承中，如果多个类中有同名的方法，子类调用查找方法的顺序是按照小括号内继承父类的顺序从左到右顺序查找，第一个匹配方法名的父类方法将会被调用

  1. class AI:
  2.     def face_recongnition(self):
  3.         print("人脸识别")
  4.     def data_handle(self):
  5.         print("AI数据处理")
  6. class BigData:
  7.     def data_analysis(self):
  8.         print("数据分析")
  9.     def data_handle(self):
  10.         print("BigData数据处理")
  11. class Python(BigData,AI):
  12.     def operation(self):
  13.         print("自动化运维")
  14. class Python2(AI,BigData):
  15.     def operation(self):
  16.         print("自动化运维2")
  18. py = Python()
  19. py2 = Python2()
  20. py.face_recongnition()
  21. py.data_analysis()
  22. py.operation()
  23. py.data_handle()
  24. py2.data_handle()
  25. print(Python.__mro__)
  26. print(Python2.__mro__)

运行结果：

  1. 人脸识别
  2. 数据分析
  3. 自动化运维
  4. BigData数据处理
  5. AI数据处理
  6. (<class '__main__.Python'>, <class '__main__.BigData'>, <class '__main__.AI'>, <class 'object'>)
  7. (<class '__main__.Python2'>, <class '__main__.AI'>, <class '__main__.BigData'>, <class 'object'>)

注：在父类起方法名的时候尽量避免同名，避免制造麻烦

3、多态

一个抽象类有多个子类，不同的类表现出多种形态

  1. class Animal:
  2.     def eat(self):
  3.         print("Animal正在吃饭")
  4. class Dog(Animal):
  5.     def eat(self):
  6.         print("Dog正在吃饭")
  7. class Cat(Animal):
  8.     def eat(self):
  9.         print("Cat正在吃饭")
  10.     def show_eat(obj):
  11.         obj.eat()
  12. wangcai = Dog()
  13. show_eat(wangcai)
  14. tom = Cat()
  15. show_eat(tom)

运行结果：

  1. Dog正在吃饭
  2. Cat正在吃饭