面向对象介绍

  1. 面向过程：
  2.     核心是"过程"二字
  4.     过程的终极奥义就是将程序流程化
  5.     过程是"流水线"，用来分步骤解决问题的
  7. 面向对象：
  8.     核心是"对象"二字
  9.     对象的终极奥义就是将程序"整合"
  10.     对象是"容器"，用来盛放数据与功能的
  12.     类也是"容器"，该容器用来存放同类对象共有的数据与功能
  14. python这门语言到底提供了什么语法来允许我们将数据与功能很好地整合好一起呢？？？
  16. # 程序=数据+功能
  18. # 学生的容器=学生的数据+学生的功能
  19. # 课程的容器=课程的数据+课程的功能
  21. # 粉扑、眼影、各种颜料=》原材料=》数据
  22. # 眉笔、小刷子       =》工具 =》功能
  1. # 学生的功能
  2. def tell_stu_info(stu_obj):
  3.     print('学生信息：名字：%s 年龄：%s 性别：%s' %(
  4.         stu_obj['stu_name'],
  5.         stu_obj['stu_age'],
  6.         stu_obj['stu_gender']
  7.     ))
  9. def set_info(stu_obj,x,y,z):
  10.     stu_obj['stu_name']=x
  11.     stu_obj['stu_age']=y
  12.     stu_obj['stu_gender']=z
  14. stu_obj={
  15.     'stu_school':'oldboy',
  16.     'stu_name':'egon',
  17.     'stu_age':18,
  18.     'stu_gender':'male',
  19.     'tell_stu_info': tell_stu_info,
  20.     'set_info':set_info
  21. }
  23. stu1_obj={
  24.     'stu_school':'oldboy',
  25.     'stu_name':'lili',
  26.     'stu_age':19,
  27.     'stu_gender':'female',
  28.     'tell_stu_info': tell_stu_info,
  29.     'set_info':set_info
  30. }
  34. # 课程的数据
  35. course_name='python'
  36. course_period='6mons'
  37. course_score=10
  39. # 课程的功能
  40. def tell_coure_info():
  41.     print('课程信息：名字：%s 周期：%s 学分：%s' %(course_name,course_period,course_score))

实现面向对象

定义类

  1. # 类是对象相似数据与功能的集合体
  2. # 所以类体中最常见的是变量与函数的定义，但是类体其实是可以包含任意其他代码的
  3. # 注意：类体代码是在类定义阶段就会立即执行，会产生类的名称空间
  4. class Student:
  5.     # 1、变量的定义
  6.     stu_school='oldboy'
  8.     # 2、功能的定义
  9.     def tell_stu_info(stu_obj):
  10.         print('学生信息：名字：%s 年龄：%s 性别：%s' %(
  11.             stu_obj['stu_name'],
  12.             stu_obj['stu_age'],
  13.             stu_obj['stu_gender']
  14.         ))
  16.     def set_info(stu_obj,x,y,z):
  17.         stu_obj['stu_name']=x
  18.         stu_obj['stu_age']=y
  19.         stu_obj['stu_gender']=z
  21.     # print('========>')
  23. # print(Student.__dict__)

类属性

  1. # 1、访问数据属性
  2. # print(Student.stu_school) # Student.__dict__['stu_school']  返回的是类属性的内存地址
  3. # 2、访问函数属性
  4. # print(Student.set_info) # Student.__dict__['set_info']  返回的是类函数的内存地址
  6. # Student.x=1111 #Student.__dict__['x]=111      #为类添加属性
  7. # print(Student.__dict__)  #查看类属性

init方法推导

  1. # 二：再调用类产生对象
  2. stu1_obj=Student()
  3. stu2_obj=Student()
  4. stu3_obj=Student()
  7. # print(stu1_obj.__dict__)   #新创建的对象dict中的属性都为空
  8. # print(stu2_obj.__dict__)
  9. # print(stu3_obj.__dict__)
  12. # 为对象定制自己独有的属性
  13. # 问题1：代码重复
  14. # 问题2：属性的查找顺序
  15. # stu1_obj.stu_name='egon'   # stu1_obj.__dict__['stu_name']='egon'    #使用__init__方法，将这种赋值的方式改为传参
  16. # stu1_obj.stu_age=18        # stu1_obj.__dict__['stu_age']=18
  17. # stu1_obj.stu_gender='male' #  stu1_obj.__dict__['stu_gender']='male'
  18. # stu1_obj.xxxx='123'
  19. # # print(stu1_obj.__dict__)  #返回 {'stu_name': 'egon', 'stu_age': 18, 'stu_gender': 'male', 'xxxx': '123'}
  21. # stu2_obj.stu_name='lili'
  22. # stu2_obj.stu_age=19
  23. # stu2_obj.stu_gender='female'
  24. # # print(stu2_obj.__dict__)
  25. #
  26. # stu3_obj.stu_name='jack'
  27. # stu3_obj.stu_age=20
  28. # stu3_obj.stu_gender='male'
  29. # # print(stu2_obj.__dict__)
  32. # 解决问题一：
  33. # 解决方案一：
  34. # def init(obj,x,y,z):
  35. #     obj.stu_name=x
  36. #     obj.stu_age=y
  37. #     obj.stu_gender=z
  38. #
  39. # init(stu1_obj,'egon',18,'male')
  40. # init(stu2_obj,'lili',19,'female')
  41. # init(stu2_obj,'jack',20,'male')
  43. # 解决方案二：
  44. # 一：先定义类
  45. class Student:
  46.     # 1、变量的定义
  47.     stu_school='oldboy'
  49.     # 空对象,'egon',18,'male'
  50.     def __init__(obj,x,y,z):
  51.         obj.stu_name=x # 空对象.stu_name='egon'
  52.         obj.stu_age=y  # 空对象.stu_age=18
  53.         obj.stu_gender=z # 空对象.stu_gender='male'
  54.         # return None  必须返回none，否则报错
  56.     # 2、功能的定义
  57.     def tell_stu_info(stu_obj):
  58.         print('学生信息：名字：%s 年龄：%s 性别：%s' %(
  59.             stu_obj['stu_name'],
  60.             stu_obj['stu_age'],
  61.             stu_obj['stu_gender']
  62.         ))
  64.     def set_info(stu_obj,x,y,z):
  65.         stu_obj['stu_name']=x
  66.         stu_obj['stu_age']=y
  67.         stu_obj['stu_gender']=z
  69.     # print('========>')
  71. # 二：再调用类产生对象
  72. # 调用类的过程又称之为实例化，发生了三件事
  73. # 1、先产生一个空对象
  74. # 2、python会自动调用类中的__init__方法然将空对象已经调用类时括号内传入的参数一同传给__init__方法
  75. # 3、返回初始完的对象
  76. stu1_obj=Student('egon',18,'male') # Student.__init__(空对象,'egon',18,'male')
  77. # stu2_obj=Student('lili',19,'female')
  78. # stu3_obj=Student('jack',20,'male')
  80. # print(stu1_obj.__dict__)
  81. # print(stu2_obj.__dict__)
  82. # print(stu3_obj.__dict__)
  83. # print(Student.__dict__)  #此时再打印student属性还是和开始时一样，没有根据其创建的实例信息

init方法总结

  1. # 总结__init__方法
  2. # 1、会在调用类时自动触发执行，用来为对象初始化自己独有的数据
  3. # 2、__init__内应该存放是为对象初始化属性的功能，但是是可以存放任意其他代码，想要在
  4. #    类调用时就立刻执行的代码都可以放到该方法内
  5. # 3、__init__方法必须返回None
  7. # 该方法会在对象产生之后自动执行，专门为对象进行初始化操作，可以有任意代码，但一定不能返回非None的值

类的公有属性

  1. class Student:
  2.     # 1、变量的定义
  3.     stu_school='oldboy'
  4.     count=0
  6.     # 空对象,'egon',18,'male'
  7.     def __init__(self,x,y,z):
  8.         Student.count += 1    #每创建一个实例就会+1，可以反映创建了对少个实例。
  10.         self.stu_name=x # 空对象.stu_name='egon'
  11.         self.stu_age=y  # 空对象.stu_age=18
  12.         self.stu_gender=z # 空对象.stu_gender='male'
  13.         # return None
  15.     # 2、功能的定义
  16.     def tell_stu_info(self):
  17.         print('学生信息：名字：%s 年龄：%s 性别：%s' %(
  18.             self.stu_name,
  19.             self.stu_age,
  20.             self.stu_gender
  21.         ))
  23.     def set_info(self,x,y,z):
  24.         self.stu_name=x
  25.         self.stu_age=y
  26.         self.stu_gender=z
  28.     def choose(self,x):
  29.         print('正在选课')
  30.         self.course=x
  32. stu1_obj=Student('egon',18,'male') # Student.__init__(空对象,'egon',18,'male')
  33. stu2_obj=Student('lili',19,'female')
  34. stu3_obj=Student('jack',20,'male')
  36. # print(stu1_obj.count)  #都是3
  37. # print(stu2_obj.count)
  38. # print(stu3_obj.count)

推导类的绑定方法

  1. # 类中存放的是对象共有的数据与功能
  2. # 一：类可以访问：
  3. # 1、类的数据属性
  4. # print(Student.stu_school)
  5. # 2、类的函数属性
  6. # print(Student.tell_stu_info)
  7. # print(Student.set_info)
  10. # 二：但其实未实例化的类中的东西是给对象用的。对于变量属性是多个实例公用的。函数是绑定方法，内存地址不同
  11. # 1、类的数据属性是共享给所有对象用的，大家访问的地址都一样
  12. # print(id(Student.stu_school))
  14. # print(id(stu1_obj.stu_school))
  15. # print(id(stu2_obj.stu_school))
  16. # print(id(stu3_obj.stu_school))
  19. # 2种方法修改类的公有变量，函数是绑定方法，内存地址各不相同
  20. # Student.stu_school='OLDBOY'
  21. # stu1_obj.stu_school='OLDBOY'    #这样也会修改变量属性
  22. # print(stu1_obj.stu_school)

类实例方法的2种调用方式

  1. # 2、类中定义的函数主要是给对象使用的，而且是绑定给对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法，内存地址各不相同
  3. # 类调用自己的函数属性必须严格按照函数的用法来
  4. # print(Student.tell_stu_info)
  5. # print(Student.set_info)
  7. # Student.tell_stu_info(stu1_obj)
  8. # Student.tell_stu_info(stu2_obj)
  9. # Student.tell_stu_info(stu3_obj)
  11. # Student.set_info(stu1_obj,'EGON',19,'MALE')
  12. # Student.tell_stu_info(stu1_obj)
  14. # 绑定方法的特殊之处在于：谁来调用绑定方法就会将谁当做第一个参数自动传入
  15. # print(Student.tell_stu_info)   # Student.tell_stu_info(stu1_obj)
  16. # print(stu1_obj.tell_stu_info)
  17. # print(stu2_obj.tell_stu_info)
  18. # print(stu3_obj.tell_stu_info)
  20. # stu1_obj.tell_stu_info() #tell_stu_info(stu1_obj)
  21. # stu2_obj.tell_stu_info() #tell_stu_info(stu2_obj)
  22. # stu3_obj.tell_stu_info() #tell_stu_info(stu3_obj)
  24. #
  25. # stu1_obj.choose('python全栈开发')
  26. # print(stu1_obj.course)
  27. #
  28. # stu2_obj.choose('linux运维')
  29. # print(stu2_obj.course)
  30. #
  31. # stu3_obj.choose('高级架构师')
  32. # print(stu3_obj.course)
  34. # 调用类方法的区别
  35. # 由实例调用与类传实例调用区别，实例调用的第一个参数自动传入自己本身这个对象。类传实例调用需要传类实例

list列表的绑定方法与类

  1. # list是一个类
  2. l1=['aa','bb','cc'] # l=list([1,2,3])，类的实例化，实例化出l1
  3. l2=[111,222,333] # l=list([1,2,3])，实例化出l2，list是一个类
  5. # 内存地址不相同
  6. # print(l1.append)
  7. # print(list.append)
  9. # l1.append('dd')
  10. # l2.append('dd')
  11. # print(l1)
  12. # print(l2)
  14. # list.append(l1,'dd')  #与l1.append('dd')含义相同
  15. # list.append(l2,'dd')  #与l2.append('dd')含义相同
  16. # print(l1)
  17. # print(l2)

练习作业

  1. 选课系统项目中涉及到诸多数据与功能，要求引入面向对象的思想对其进行高度整合
  2. # 1、学校数据与功能整合
  3. # 2、课程数据与功能进行整合
  4. # 3、学生数据与功能进行整合
  5. # 4、讲师数据与功能进行整合
  6. # 5、班级数据与功能进行整合
  7. ps：不会写的同学，可以先用普通的方式，先把数据与功能都给写好，再考虑基于面向对象的思想进行整合
  9. 数据部分：
  10.      校区的名字：如"老男孩上海校区"
  11.      校区的地址：如"上海虹桥"
  13.      班级名字
  14.      班级所在校区
  16.      学生的学校
  17.      学生的姓名
  18.      学生的年龄
  19.      学号
  20.      学生的性别
  22.      课程名字
  23.      课程周期
  24.      课程价格
  26.      老师的名字
  27.      老师的年龄
  28.      老师的薪资
  29.      老师的等级
  32. 功能部分：
  33.      校区创建完毕后，可以为每个校区创建班级
  35.      班级创建完毕后，可以为每个班级创建课程
  37.      学生创建完毕后，学生可以选择班级
  39.      老师创建完毕后，可以为学生打分

代码

  1. # 整合->解耦合->扩展性增强
  3. class School:
  4.     school_name = 'OLDBOY'
  6.     def __init__(self, nickname, addr):
  7.         self.nickname = nickname
  8.         self.addr = addr
  9.         self.classes = []
  11.     def related_class(self, class_obj):
  12.         # self.classes.append(班级名字)
  13.         # self.classes.append(class_name)
  14.         self.classes.append(class_obj)
  16.     def tell_class(self): # 改
  17.         # 打印的班级的名字
  18.         print(self.nickname.center(60,'='))
  19.         # 打印班级开设的课程信息
  20.         for class_obj in self.classes:
  21.             class_obj.tell_course()
  24. # # 一：学校
  25. # #1、创建校区
  26. school_obj1=School('老男孩魔都校区','上海')
  27. school_obj2=School('老男孩帝都校区','北京')
  28. #
  29. # #2、为学校开设班级
  30. # # 上海校区开了:脱产14期，上海校区开了脱产15期
  31. # school_obj1.related_class("脱产14期")
  32. # school_obj1.related_class("脱产15期")
  33. #
  34. # # 北京校区开了:脱产29期
  35. # school_obj2.related_class("脱产29期")
  36. #
  37. # #3、查看每个校区开设的班级
  38. # school_obj1.tell_class()
  39. # school_obj2.tell_class()
  42. class Class:
  43.     def __init__(self, name):
  44.         self.name = name
  45.         self.course = None
  47.     def related_course(self, course_obj):
  48.         # self.course = course_name
  49.         self.course = course_obj
  51.     def tell_course(self):
  52.         print('%s' % self.name,end=" ")
  53.         self.course.tell_info() # 打印课程的详细信息
  55. # 二：班级
  56. # 1、创建班级
  57. class_obj1 = Class('脱产14期')
  58. class_obj2 = Class('脱产15期')
  59. class_obj3 = Class('脱产29期')
  61. # 2、为班级关联一个课程
  62. # class_obj1.related_course('python全栈开发')
  63. # class_obj2.related_course('linux运维')
  64. # class_obj3.related_course('python全栈开发')
  66. # 3、查看班级开设的课程信息
  67. # class_obj1.tell_course()
  68. # class_obj2.tell_course()
  69. # class_obj3.tell_course()
  71. # 4、为学校开设班级
  72. # 上海校区开了:脱产14期，上海校区开了脱产15期
  73. school_obj1.related_class(class_obj1)   #对象也可以存到列表中
  74. school_obj1.related_class(class_obj2)
  76. # 北京校区开了:脱产29期
  77. school_obj2.related_class(class_obj3)
  80. # school_obj1.tell_class()
  81. # school_obj2.tell_class()
  85. class Course:
  86.     def __init__(self,name,period,price):
  87.         self.name=name
  88.         self.period=period
  89.         self.price=price
  91.     def tell_info(self):
  92.         print('<课程名:%s 周期:%s 价钱:%s>' %(self.name,self.period,self.price))
  94. # 三：课程
  95. # 1、创建课程
  96. course_obj1=Course('python全栈开发','6mons',20000)
  97. course_obj2=Course('linux运维','5mons',18000)
  99. # 2、查看课程的详细信息
  100. # course_obj1.tell_info()
  101. # course_obj2.tell_info()
  103. # 3、为班级关联课程对象
  104. class_obj1.related_course(course_obj1)
  105. class_obj2.related_course(course_obj2)
  106. class_obj3.related_course(course_obj1)
  108. # class_obj1.tell_course()
  109. # class_obj2.tell_course()
  110. # class_obj3.tell_course()
  112. school_obj1.tell_class()
  113. school_obj2.tell_class()
  116. class Student:
  117.     pass

封装__属性方法

  1. # 一：封装介绍
  2. # 封装是面向对象三大特性最核心的一个特性
  3. # 封装<->整合
  6. # 二、将封装的属性进行隐藏操作
  7. # 1、如何隐藏：在属性名前加__前缀,就会实现一个对外隐藏属性效果
  8. # 该隐藏需要注意的问题：
  9. # I:在类外部无法直接访问双下滑线开头的属性，但知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如Foo._A__N，
  10. # 所以说这种操作并没有严格意义上地限制外部访问，仅仅只是一种语法意义上的变形。
  12. class Foo:
  13.     __x = 1  # _Foo__x
  15.     def __f1(self):  # _Foo__f1
  16.         print('from test')
  19. # print(Foo.__dict__)
  20. # # print(Foo._Foo__x)
  21. # # print(Foo._Foo__f1)
  26. # II：这种隐藏对外不对内,因为__开头的属性会在检查类体代码语法时统一发生变形
  27. class Foo:
  28.     __x = 1  # _Foo__x = 1
  30.     def __f1(self):  # _Foo__f1
  31.         print('from test')
  33.     def f2(self):
  34.         print(self.__x) # print(self._Foo__x)
  35.         print(self.__f1) # print(self._Foo__f1)
  37. # print(Foo.__x)
  38. # print(Foo.__f1)
  39. # obj=Foo()
  40. # obj.f2()
  44. # III: 这种变形操作只在检查类体语法的时候发生一次，之后定义的__开头的属性都不会变形
  45. class Foo:
  46.     __x = 1  # _Foo__x = 1
  48.     def __f1(self):  # _Foo__f1
  49.         print('from test')
  51.     def f2(self):
  52.         print(self.__x) # print(self._Foo__x)
  53.         print(self.__f1) # print(self._Foo__f1)
  55. Foo.__y=3
  56. print(Foo.__dict__)
  57. print(Foo.__y)
  59. class Foo:
  60.     __x = 1  # _Foo__x = 1
  62.     def __init__(self,name,age):
  63.         self.__name=name
  64.         self.__age=age
  66. obj=Foo('egon',18)
  67. # print(obj.__dict__)
  68. # print(obj.name,obj.age)

为何隐藏

  1. # 2、为何要隐藏？
  2. # I、隐藏数据属性"将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口(方法)来允许类外部间接地操作数据，
  3. 接口之上可以附加额外的逻辑来对数据的操作进行严格地控制：
  4. # 设计者：egon
  5. class People:
  6.     def __init__(self, name):
  7.         self.__name = name
  9.     def get_name(self):
  10.         # 通过该接口就可以间接地访问到名字属性
  11.         # print('小垃圾，不让看')
  12.         print(self.__name)
  14.     def set_name(self,val):
  15.         if type(val) is not str:
  16.             print('小垃圾，必须传字符串类型')
  17.             return
  18.         self.__name=val
  20. # 使用者：王鹏
  21. obj = People('egon')
  22. # print(obj.name) # 无法直接用名字属性
  23. # obj.set_name('EGON')
  24. obj.set_name(123123123)
  25. obj.get_name()
  26. # II、隐藏函数/方法属性：目的的是为了隔离复杂度

property装饰器-方法伪造属性

  1. # 装饰器是在不修改被装饰对象源代码以及调用方式的前提下为被装饰对象添加
  2. # 新功能的可调用对象
  3. # print(property)
  5. # property是一个装饰器，是用来绑定给对象的方法伪造成一个数据属性
  8. """
  9. 成人的BMI数值：
  10. 过轻：低于18.5
  11. 正常：18.5-23.9
  12. 过重：24-27
  13. 肥胖：28-32
  14. 非常肥胖, 高于32
  15. 　　体质指数（BMI）=体重（kg）÷身高^2（m）
  16. 　　EX：70kg÷（1.75×1.75）=22.86
  17. """

@property、@name.setter、@name.deleter 

  1. # 案例一：
  3. class People:
  4.     def __init__(self, name, weight, height):
  5.         self.name = name
  6.         self.weight = weight
  7.         self.height = height
  9. #     # 定义函数的原因1：
  10. #     # 1、从bmi的公式上看，bmi应该是触发功能计算得到的
  11. #     # 2、bmi是随着身高、体重的变化而动态变化的，不是一个固定的值
  12. #     #    说白了，每次都是需要临时计算得到的
  13. #
  14. #     # 但是bmi听起来更像是一个数据属性，而非功能
  15.     @property
  16.     def bmi(self):
  17.         return self.weight / (self.height ** 2)
  20. # obj1 = People('egon', 70, 1.83)
  21. # print(obj1.bmi())
  23. # obj1.height=1.86
  24. # print(obj1.bmi())
  26. # print(obj1.bmi)
  30. # # 案例二：
  31. class People:
  32.     def __init__(self, name):
  33.         self.__name = name
  35.     def get_name(self):
  36.         return self.__name
  38.     def set_name(self, val):
  39.         if type(val) is not str:
  40.             print('必须传入str类型')
  41.             return
  42.         self.__name = val
  44.     def del_name(self):
  45.         print('不让删除')
  46.         # del self.__name
  48.     name=property(get_name,set_name,del_name)
  50. obj1=People('egon')
  51. # print(obj1.get_name())
  52. # obj1.set_name('EGON')
  53. # print(obj1.get_name())
  54. # obj1.del_name()
  55. #
  56. #
  57. #
  58. # # 人正常的思维逻辑
  59. # print(obj1.name) #
  60. # # obj1.name=18
  61. # # del obj1.name
  66. # 案例三：  #装饰的3个方法名称都相同：name
  67. class People:
  68.     def __init__(self, name):
  69.         self.__name = name
  72.     @property
  73.     def name(self): # obj1.name
  74.         return self.__name
  76.     @name.setter
  77.     def name(self, val): # obj1.name='EGON'
  78.         if type(val) is not str:         #增加了判断，修改是否合法
  79.             print('必须传入str类型')
  80.             return
  81.         self.__name = val
  83.     @name.deleter
  84.     def name(self): # del obj1.name   #阻止删除
  85.         print('不让删除')
  86.         # del self.__name
  89. obj1=People('egon')
  90. # 人正常的思维逻辑
  91. print(obj1.name) #
  92. # obj1.name=18
  93. # del obj1.name

继承

  1. # 1、什么是继承
  2. # 2、为何要用继承：用来解决类与类之间代码冗余问题
  3. # I:继承是一种创建新类的方式，新建的类可称为子类或派生类，父类又可称为基类或超类,子类会遗传父类的属性
  5. # II:需要注意的是：python支持多继承
  6. #          在Python中，新建的类可以继承一个或多个父类

新式类与经典类

新式类与经典类在多继承查找父类时，新式类广度优先，经典类深度优先

  1. class Parent1(object):
  2.     x=1111
  4. class Parent2(object):
  5.     pass
  7. class Sub1(Parent1): # 单继承
  8.     pass
  10. class Sub2(Parent1,Parent2): # 多继承
  11.     pass
  13. print(Sub1.__bases__)
  14. print(Sub2.__bases__)
  16. # print(Sub1.x)
  18. # ps1: 在python2中有经典类与新式类之分
  19. # 新式类：继承了object类的子类，以及该子类的子类子子类。。。
  20. # 经典：没有继承object类的子类，以及该子类的子类子子类。。。
  22. # ps2:在python3中没有继承任何类，那么会默认继承object类，所以python3中所有的类都是新式类
  23. print(Parent1.__bases__)    #__bases__内置方法，查看该类的父类
  24. print(Parent2.__bases__)

实现继承

  1. # 3、如何实现继承
  2. # # 示范1：类与类之间存在冗余问题
  3. class Student:
  4.     school='OLDBOY'
  6.     def __init__(self,name,age,sex):
  7.         self.name=name
  8.         self.age=age
  9.         self.sex=sex
  11.     def choose_course(self):
  12.         print('学生%s 正在选课' %self.name)
  15. class Teacher:
  16.     school='OLDBOY'
  18.     def __init__(self,name,age,sex,salary,level):
  19.         self.name=name
  20.         self.age=age
  21.         self.sex=sex
  22.         self.salary=salary
  23.         self.level=level
  25.     def score(self):
  26.         print('老师 %s 正在给学生打分' %self.name)
  31. # 示范2：基于继承解决类与类之间的冗余问题
  32.     class OldboyPeople:                         #定义基类
  33.         school = 'OLDBOY'
  35.         def __init__(self, name, age, sex):
  36.             self.name = name
  37.             self.age = age
  38.             self.sex = sex
  41. # student继承
  42.     class Student(OldboyPeople):               #继承基类，可以不使用init方法
  43.         def choose_course(self):
  44.             print('学生%s 正在选课' % self.name)
  46.     # stu_obj = Student('lili', 18, 'female')   #必须传入父类的init参数
  47.     # print(stu_obj.__dict__)
  48.     # print(stu_obj.school)
  49.     # stu_obj.choose_course()
  53. # teacher继承
  54.     class Teacher(OldboyPeople):
  55.         #           老师的空对象，'egon',18,'male',3000,10
  56.         def __init__(self, name, age, sex, salary, level):  #将父类的参数也传进去；子类重写init方法，必须调用一次父类init方法
  57.             # 指名道姓地跟父类OldboyPeople去要__init__
  58.             OldboyPeople.__init__(self,name,age, sex)    #调用父类的init方法
  59.             self.salary = salary
  60.             self.level = level
  62.         def score(self):
  63.             print('老师 %s 正在给学生打分' % self.name)
  65.     tea_obj=Teacher('egon',18,'male',3000,10)
  66.     # print(tea_obj.__dict__)
  67.     # print(tea_obj.school)
  69.     tea_obj.score()

多继承的菱形问题-mro

  1. # 一：菱形问题介绍与MRO
  2. # mro列表打印，类名.mro()，mro是一个父类读取顺序列表
  3.     class A(object):
  4.         # def test(self):
  5.         #     print('from A')
  6.         pass
  8.     class B(A):
  9.         def test(self):
  10.             print('from B')
  11.         pass
  13.     class C(A):
  14.         # def test(self):
  15.         #     print('from C')
  16.         pass
  18.     class D(C,B):
  19.         # def test(self):
  20.         #     print('from D')
  21.         pass
  22.     #
  23.     # print(D.mro()) # 类D以及类D的对象访问属性都是参照该类的mro列表
  24.     #
  25.     # # obj = D()
  26.     # # obj.test()
  27.     #
  28.     # # print(D.test)
  29.     #
  30.     # # print(C.mro()) # 类C以及类C的对象访问属性都是参照该类的mro列表
  31.     # # c=C()
  32.     # # c.test()
  33.     #
  34.     # # 总结：类相关的属性查找（类名.属性，该类的对象.属性），都是参照该类的mro
  37. # # 二：如果多继承是非菱形继承，经典类与新式的属性查找顺序一样：
  38. # #    都是一个分支一个分支地找下去，然后最后找object
  39.     class E:
  40.         # def test(self):
  41.         #     print('from E')
  42.         pass
  44.     class F:
  45.         def test(self):
  46.             print('from F')
  49.     class B(E):
  50.         # def test(self):
  51.         #     print('from B')
  52.         pass
  54.     class C(F):
  55.         # def test(self):
  56.         #     print('from C')
  57.         pass
  59.     class D:
  60.         def test(self):
  61.             print('from D')
  64.     class A(B, C, D):
  65.         # def test(self):
  66.         #     print('from A')
  67.         pass
  69.     # 新式类
  70.     # print(A.mro()) # A->B->E->C->F->D->object
  72.     obj = A()
  73.     obj.test() # 结果为：from F
  76. # 三：如果多继承是菱形继承，经典类与新式类的属性查找顺序不一样：
  77. #    经典类：深度优先，会在检索第一条分支的时候就直接一条道走到黑，即会检索大脑袋（共同的父类）
  78. #    新式类：广度优先，会在检索最后一条分支的时候检索大脑袋
  79.     class G: # 在python2中，未继承object的类及其子类，都是经典类
  80.         # def test(self):
  81.         #     print('from G')
  82.         pass
  84.     class E(G):
  85.         # def test(self):
  86.         #     print('from E')
  87.         pass
  89.     class F(G):
  90.         def test(self):
  91.             print('from F')
  93.     class B(E):
  94.         # def test(self):
  95.         #     print('from B')
  96.         pass
  98.     class C(F):
  99.         def test(self):
  100.             print('from C')
  102.     class D(G):
  103.         def test(self):
  104.             print('from D')
  106.     class A(B,C,D):
  107.         # def test(self):
  108.         #     print('from A')
  109.         pass
  111.     # 新式类
  112.     # print(A.mro()) # A->B->E->C->F->D->G->object(从左到右，每个参数纵向向上查找，不达到最深的一个父类，再往右)
  114.     # 经典类：A->B->E->G->C->F->D
  115.     obj = A()
  116.     obj.test() #
  119. # 总结：
  120. # 多继承到底要不用？？？
  121. # 要用，但是规避几点问题
  122. # 1、继承结构尽量不要过于复杂
  123. # 2、推荐使用mixins机制：在多继承的背景下满足继承的什么"是"什么的关系

多继承mixins机制

  1. # 多继承的正确打开方式：mixins机制
  2. # mixins机制核心：就是在多继承背景下尽可能地提升多继承的可读性
  3. # ps：让多继承满足人的思维习惯=》什么"是"什么
  5.     class Vehicle:    #交通工具类
  6.         pass
  8.     class FlyableMixin:  #可以飞，作为所有飞机的mixin父类
  9.         def fly(self):
  10.             pass
  12.     class CivilAircraft(FlyableMixin,Vehicle):  # 民航飞机，mixin父类写在继承最左边
  13.         pass
  15.     class Helicopter(FlyableMixin,Vehicle):  # 直升飞机
  16.         pass
  18.     class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
  19.         pass
  22.     import socketserver
  23.     # 补充：通常Mixin结果的类放在左边

调用其他类的功能、super

  1. # 在子类派生的新方法中如何重用父类的功能
  2. # 方式一：指名道姓调用某一个类下的函数=》不依赖于继承关系
  3. class OldboyPeople:
  4.     def __init__(self,name,age,sex):
  5.         self.name=name
  6.         self.age=age
  7.         self.sex=sex
  9.     def f1(self):
  10.         print('%s say hello' %self.name)
  13. class Teacher(OldboyPeople):
  14.     def __init__(self,name,age,sex,level,salary):
  15.         OldboyPeople.__init__(self,name,age,sex)
  17.         self.level = level
  18.         self.salary=salary
  20. tea_obj=Teacher('egon',18,'male',10,3000)
  21. print(tea_obj.__dict__)
  23. # 方式二：super()调用父类提供给自己的方法=》严格依赖继承关系
  24. #        调用super()会得到一个特殊的对象，该对象会参照发起属性查找的那个类的mro,去当前类的父类中找属性
  25. class OldboyPeople:
  26.     def __init__(self,name,age,sex):
  27.         self.name=name
  28.         self.age=age
  29.         self.sex=sex
  31.     def f1(self):
  32.         print('%s say hello' %self.name)
  35. class Teacher(OldboyPeople):
  36.     def __init__(self,name,age,sex,level,salary):
  37.         # super(Teacher,self).__init__(name,age,sex)  #python2
  38.         super().__init__(name,age,sex) # 调用的是方法，自动传入对象
  40.         self.level = level
  41.         self.salary=salary
  43. # print(Teacher.mro())   #打印[<class '__main__.Teacher'>, <class '__main__.OldboyPeople'>, <class 'object'>]
  44. tea_obj=Teacher('egon',18,'male',10,3000)
  45. print(tea_obj.__dict__)
  48. # super()案例
  49. class A:
  50.     def test(self):
  51.         print('from A')
  52.         super().test()
  54. class B:
  55.     def test(self):
  56.         print('from B')
  58. class C(A,B):
  59.     pass
  62. obj=C()
  63. obj.test()
  65. print(C.mro())
  69. class A:
  70.     def test(self):
  71.         print('from A')
  72.         super().test1()   #报错，没有将C类当参数传进来，所以调用不了
  74. class B:
  75.     def test(self):
  76.         print('from B')
  78. class C(A,B):
  79.     def test1(self):
  80.         print('from C')
  82. obj=C()
  83. obj.test()
  85. print(C.mro())

多态

子类调用父类相同的方法

  1. # 1、什么多态：同一事物有多种形态
  2. class Animal:
  3.     pass
  5. class People(Animal):
  6.     pass
  8. class Dog(Animal):
  9.     pass
  11. class Pig(Animal):
  12.     pass
  15. # 2、为何要有多态=》多态会带来什么样的特性，多态性
  16. #    多态性指的是可以在不考虑对象具体类型的情况下而直接使用对象
  17. class Animal: # 统一所有子类的方法
  18.     def say(self):
  19.         print('动物基本的发声频率。。。',end=' ')
  21. class People(Animal):
  22.     def say(self):
  23.         super().say()    #使用父类的方法，不写super调用父类的say，则相当于重写了sya
  24.         print('嘤嘤嘤嘤嘤嘤嘤')
  26. class Dog(Animal):
  27.     def say(self):
  28.         super().say()
  29.         print('汪汪汪')
  31. class Pig(Animal):
  32.     def say(self):
  33.         super().say()
  34.         print('哼哼哼')
  37. obj1=People()
  38. obj2=Dog()
  39. obj3=Pig()
  42. obj1.say()
  43. obj2.say()
  44. obj3.say()
  46. # 定义统一的接口，接收传入的动物对象
  47. # 此处多态的接口是使用一个方法来调用所有类似对象的相同方法
  48. # 封装所说的接口，是使用一个接口函数来调用其他多个函数
  49.     def animal_say(animal):
  50.         animal.say()
  52.     animal_say(obj1)
  53.     animal_say(obj2)
  54.     animal_say(obj3)

绑定方法与非绑定方法

绑定方法有：

  • 绑定给对象的方法即：类在实例化时self作为一个参数自动传入=====self
  • 绑定给类的方法，类作为一个参数自动传入，：调用类的方法来实例化类（调用init方法，并传入固定参数）=====@classmethod

非绑定方法：

  • 静态方法staticmethod：在类声明中的函数中，返回其他对象的方法。不需要传入第一个参数。
  1. # 一：绑定方法：特殊之处在于将调用者本身当做第一个参数自动传入
  2. #    1、绑定给对象的方法：调用者是对象，自动传入的是对象
  3. #    2、绑定给类的方法：调用者类，自动传入的是类
  4. import settings
  6. class Mysql:
  7.     def __init__(self,ip,port):
  8.         self.ip=ip
  9.         self.port=port
  11.     def func(self):
  12.         print('%s:%s' %(self.ip,self.port))
  14.     @classmethod # 将下面的函数装饰成绑定给类的方法
  15.     def from_conf(cls):
  16.         print(cls)
  17.         return cls(settings.IP, settings.PORT)
  18.     #导入的settings.py文件内容，IP='127.0.0.1',PORT=3306
  20. obj1=Mysql('1.1.1.1',3306)
  22. obj2=Mysql.from_conf()
  23. print(obj2.__dict__)
  25. # 二：非绑定方法-》静态方法：
  26. #    没有绑定给任何人：调用者可以是类、对象，没有自动传参的效果
  28. class Mysql:
  29.     def __init__(self,ip,port):
  30.         self.nid=self.create_id()
  31.         self.ip=ip
  32.         self.port=port
  34.     @staticmethod # 将下述函数装饰成一个静态方法
  35.     def create_id():
  36.         import uuid
  37.         return uuid.uuid4()
  39.     @classmethod
  40.     def f1(cls):
  41.         pass
  43.     def f2(self):
  44.         pass
  45. obj1=Mysql('1.1.1.1',3306)
  47. # print(Mysql.create_id)
  48. # print(obj1.create_id)
  50. # Mysql.create_id(1,2,3)
  51. # obj1.create_id(4,5,6)
  53. print(Mysql.create_id)
  54. print(Mysql.f1)
  55. print(obj1.f2)

内置函数

02-python面向对象 - 图1

  1. print(abs(-1))
  2. print(all([1,'aaa','1']))
  3. print(all([]))
  5. print(any([0,None,1]))
  6. print(any([]))
  8. print(bin(11))
  9. print(oct(11))
  10. print(hex(11))
  12. print(bool(''))
  14. def func():
  15.     pass
  16. class Foo:
  17.     pass
  18. print(callable(Foo)) # 方
  20. print(chr(65))
  21. print(ord('A'))
  23. # 不可变集合
  24. s=frozenset({1,2,3})   #frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
  26. # hash(不可变类型)
  28. print(round(1.5))
  29. print(round(1.4))
  32. # 10 ** 2 % 3
  33. print(pow(10,2,3))
  34. s=slice(1,4,2)
  35. l1=['a','b','c','d','e']
  36. l2=['aaa','bbb','ccc','ddd',444]
  37. #
  38. print(l1[1:4:2]) # l1[s]
  39. print(l2[1:4:2]) # l2[s]
  42. # =================》掌握
  43. v1='hello'
  44. v2=[111,222,333,444,5555,6666]
  45. res=zip(v1,v2)
  46. print(list(res))
  48. # =================》掌握
  49. print(divmod(10000,33))
  51. # =================》掌握
  52. class Foo:
  53.     pass
  54. obj=Foo()
  55. obj.xxx=1111
  56. print(dir(obj)) # obj.哪些属性
  58. # =================》掌握
  59. for i,v in enumerate(['a','b','c']):
  60.     print(i,v)
  62. # =================》掌握
  63. res=eval('{"a":1}') # 执行字符串中的表达式
  64. print(res,type(res))
  67. # =================》掌握
  68.   class Foo:
  69.       pass
  70.   obj=Foo()
  72.   print(isinstance(obj,Foo))   #isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
  73.   print(isinstance([],list)) # 类型判断推荐使用isinstance
  74.   print(type([]) is list) # 不推荐使用
  76. # =================》掌握
  77. # import 'time' # 错误
  78. time=__import__('time')
  79. time.sleep(3)
  81. # 下个周：反射
  82. # setattr
  83. # getattr
  84. # delattr
  85. # hasattr

反射

反射推导过程

dir(对象)可以查看对象具有哪些属性列表；dic可以查看对象属性对应属性值的字典。

判断对象是否具有某种属性或者函数，然后再调用

  1. # 什么是反射？
  2. # 指的是在程序运行过程中可以"动态（不见棺材不掉泪）"获取对象的信息
  4. # 为何要用反射？
  6. # 如何实现反射？
  7. class People:
  8.     def __init__(self,name,age):
  9.         self.name=name
  10.         self.age=age
  12.     def say(self):
  13.         print('<%s:%s>' %(self.name,self.age))
  15. obj=People('辣白菜同学',18)
  19. # 实现反射机制的步骤
  20. # 1、先通过多dir：查看出某一个对象下可以.出哪些属性来
  21. # print(dir(obj))
  23. # 2、可以通过字符串反射到真正的属性上，得到属性值
  24. # print(obj.__dict__[dir(obj)[-2]])

反射的四个函数

  1. # 四个内置函数的使用:通过字符串来操作属性值
  2.     # 1、hasattr() #判断对象obj是否有name属性
  3.     # print(hasattr(obj,'name'))
  4.     # print(hasattr(obj,'x'))
  6.     # 2、getattr() #获取属性值
  7.     # print(getattr(obj,'name'))
  9.     # 3、setattr()  #为对象的属性设置值
  10.     # setattr(obj,'name','EGON') # obj.name='EGON'
  11.     # print(obj.name)
  13.     # 4、delattr()  #删除对象属性
  14.     # delattr(obj,'name') # del obj.name
  15.     # print(obj.__dict__)
  18.     # res1=getattr(obj,'say') # obj.say
  19.     # res2=getattr(People,'say') # People.say
  20.     # print(res1)
  21.     # print(res2)
  24. # obj=10
  25. # if hasattr(obj,'x'):
  26. #     print(getattr(10,'x'))
  27. # else:
  28. #     pass
  30. # print(getattr(obj,'x',None))
  33. # if hasattr(obj,'x'):
  34. #     setattr(obj,'x',111111111) # 10.x=11111
  35. # else:
  36. #     pass
  40.  class Ftp:
  41.     def put(self):
  42.     print('正在执行上传功能')
  44.     def get(self):
  45.     print('正在执行下载功能')
  47.     def interactive(self):
  48.     method=input(">>>: ").strip() # method='put'
  50.     if hasattr(self,method):
  51.     getattr(self,method)()
  52.     else:
  53.     print('输入的指令不存在')
  56.     # obj=Ftp()
  57.     # obj.interactive()

内置方法

类的内置方法，在对类使用某种操作时会触发

比如

  • init方法，类实例化时触发
  • str，print（类）时触发
  • del，del 类 时触发

02-python面向对象 - 图2

str

  1. # 1、什么是内置方法？
  2. # 定义在类内部，以__开头并以__结果的方法
  3. # 特点：会在某种情况下自动触发执行
  5. # 2、为何要用内置方法？
  6. # 为了定制化我们的类or对象
  8. # 3、如何使用内置方法
  9. # __str__:在打印对象时会自动触发，然后将返回值（必须是字符串类型）当做本次打印的结果输出
  10. class People:
  11.     def __init__(self, name, age):
  12.         self.name = name
  13.         self.age = age
  15.     def __str__(self):
  16.         # print('运行了...')
  17.         return "<%s:%s>" %(self.name,self.age)
  20. obj = People('辣白菜同学', 18)
  22. # print(obj.__str__())
  23. print(obj)  # <'辣白菜同学':18>
  25. # obj1=int(10)
  26. # print(obj1)

del方法

  1. # __del__：在清理对象时触发，会先执行该方法
  2. class People:
  3.     def __init__(self, name, age):
  4.         self.name = name
  5.         self.age = age
  6.         self.x = open('a.txt',mode='w')
  7.         # self.x = 占据的是操作系统资源
  9.     def __del__(self):
  10.         # print('run...')
  11.         # 发起系统调用，告诉操作系统回收相关的系统资源
  12.         self.x.close()
  14. obj = People('辣白菜同学', 18)
  15. # del obj # obj.__del__()
  16. print('============>')

call

功能类似于在类中重载 () 运算符，使得类实例对象可以像调用普通函数那样，以“对象名()”的形式使用。相当于使用普通函数

  1. class CLanguage:
  2.     # 定义__call__方法
  3.     def __call__(self,name,add):
  4.         print("调用__call__()方法",name,add)
  6. clangs = CLanguage() #类实例化  
  8. # 以下含义相等
  9. clangs("C语言中文网","http://c.biancheng.net")   #返回：调用__call__()方法 C语言中文网 http://c.biancheng.net
  10. # 相等
  11. clangs.__call__("C语言中文网","http://c.biancheng.net")

针对函数

  1. def say():
  2.     print("Python教程：http://c.biancheng.net/python")
  3. say()
  4. say.__call__()  #函数自带call属性

用 call() 弥补 hasattr() 函数的短板

使用hasattr判断类是否有属性A，再使用hasattr(A,”call“)判断该属性是否具有函数调用属性，如果有则A是函数属性。

  1. class CLanguage:
  2.     def __init__ (self):
  3.         self.name = "C语言中文网"
  4.         self.add = "http://c.biancheng.net"
  5.     def say(self):
  6.         print("我正在学Python")
  7. clangs = CLanguage()
  8. if hasattr(clangs,"name"):
  9.     print(hasattr(clangs.name,"__call__"))
  10. print("**********")
  11. if hasattr(clangs,"say"):
  12.     print(hasattr(clangs.say,"__call__"))  #say是函数属性

new

重写父类的new方法

  1. class demoClass:
  2.     instances_created = 0
  3.     def __new__(cls,*args,**kwargs):
  4.         print("__new__():",cls,args,kwargs)
  5.         instance = super().__new__(cls)
  6.         instance.number = cls.instances_created  #为父类创建的空对象添加属性。
  7.         cls.instances_created += 1
  8.         return instance
  9.     def __init__(self,attribute):
  10.         print("__init__():",self,attribute)
  11.         self.attribute = attribute
  12. test1 = demoClass("abc")
  13. test2 = demoClass("xyz")
  14. print(test1.number,test1.instances_created)
  15. print(test2.number,test2.instances_created)

自定义元类中使用new

  1. #定义一个元类
  2. class FirstMetaClass(type):
  3.     # cls代表动态修改的类
  4.     # name代表动态修改的类名
  5.     # bases代表被动态修改的类的所有父类
  6.     # attr代表被动态修改的类的所有属性、方法组成的字典
  7.     def __new__(cls, name, bases, attrs):
  8.         # 动态为该类添加一个name属性
  9.         attrs['name'] = "C语言中文网"
  10.         attrs['say'] = lambda self: print("调用 say() 实例方法")
  11.         return super().__new__(cls,name,bases,attrs)

使用自定义元类

  1. #定义类时，指定元类
  2. class CLanguage(object,metaclass=FirstMetaClass):
  3.     pass
  4. clangs = CLanguage()
  5. print(clangs.name)
  6. clangs.say()

元类

元类type介绍

  1. #一：引入：
  2. # 一切都源自于一句话：一切皆为对象
  4. #二：什么是元类？
  5. # 元类就是用来实例化产生类的类
  6. # 关系：元类---实例化---->类（People）---实例化---->对象（obj）
  7.     class People:
  8.         def __init__(self,name,age):
  9.             self.name=name
  10.             self.age=age
  12.         def say(self):
  13.             print('%s:%s' %(self.name,self.name))
  14.     #
  15.     #
  16.     # print(People.__dict__)
  17.     # 如何得到对象
  18.     # obj=调用类()
  19.     obj=People('egon',18)
  20.     print(type(obj))
  22. # 如果说类也是对象
  23. # People=调用类(。。。)
  27. # 查看内置的元类：
  28.     # 1、type是内置的元类
  29.     # 2、我们用class关键字定义的所有的类以及内置的类都是由元类type实例化产生
  30.     # print(type(People))   # 返回<class 'type'>
  31.     # print(type(int))      # 返回<class 'type'>

type创建类的过程

  1. # 三：class关键字创造类People的步骤
  2. # 类有三大特征：
  3. # # 1、类名
  4. class_name="People"
  6. # # 2、类的基类
  7. class_bases=(object,)
  9. # # 3、执行类体代码拿到类的名称空间
  10.     class_dic={}
  11.     class_body="""
  12.     def __init__(self,name,age):
  13.         self.name=name
  14.         self.age=age
  16.     def say(self):
  17.         print('%s:%s' %(self.name,self.name))
  18.     """
  19.     exec(class_body,{},class_dic)
  20.     # print(class_dic)
  22. # # 4、调用元类type创建类
  23. People=type(class_name,class_bases,class_dic) #class_name="people"，class_bases=(object,),类属性

自定义元类修改属性

自定义元类控制类的产生,只有继承了type类才是元类

  1. # 四：如何自定义元类来控制类的产生
  2. class Mymeta(type): # 只有继承了type类的类才是元类
  3.     #            空对象,"People",(),{...}
  4.     def __init__(self,x,y,z):
  5.         print('run22222222222....')
  6.         print(self)
  7.         # print(x)
  8.         # print(y)
  9.         # print(z)
  10.         # print(y)
  11.         # if not x.istitle():
  12.         #     raise NameError('类名的首字母必须大写啊！！！')
  14. # 当前所在的类，调用类时所传入的参数
  15.     def __new__(cls, *args, **kwargs):
  16.         # 造Mymeta的对象
  17.         print('run1111111111.....')
  18.         # print(cls,args,kwargs)
  19.         # return super().__new__(cls,*args, **kwargs)
  20.         return type.__new__(cls,*args, **kwargs)  #调用type类的__new__
  21. #
  22. #
  23. # People=Mymeta("People",(object,),{...})
  24. # # 调用Mymeta发生三件事，调用Mymeta就是type.__call__
  25. # # 1、先造一个空对象=>People,调用Mymeta类内的__new__方法
  26. # # 2、调用Mymeta这个类内的__init__方法，完成初始化对象的操作
  27. # # 3、返回初始化好的对象
  28. #
  29. class People(metaclass=Mymeta):  #需要指定metaclass元类是mymeta
  30.     def __init__(self,name,age):
  31.         self.name=name
  32.         self.age=age
  34.     def say(self):
  35.         print('%s:%s' %(self.name,self.name))
  36. #
  37. # # 强调：
  38. # # 只要是调用类，那么会一次调用
  39. # # 1、类内的__new__
  40. # # 2、类内的__init__

call

  1. # 五：__call__
  2. class Foo:
  3.     def __init__(self,x,y):
  4.         self.x=x
  5.         self.y=y
  7.     #            obj,1,2,3,a=4,b=5,c=6
  8.     def __call__(self,*args,**kwargs):
  9.         print('===>',args,kwargs)
  10.         return 123
  12. obj=Foo(111,222)
  13. # print(obj) # obj.__str__
  14. res=obj(1,2,3,a=4,b=5,c=6) # res=obj.__call__()
  15. print(res)
  17. # 应用：如果想让一个对象可以加括号调用，需要在该对象的类中添加一个方法__call__
  18. # 总结：
  19. # 对象()->类内的__call__
  20. # 类()->自定义元类内的__call__
  21. # 自定义元类()->内置元类__call__

自定义元类控制类的调用

  1. # 六：自定义元类控制类的调用=》类的对象的产生
  2. class Mymeta(type): # 只有继承了type类的类才是元类
  3.     def __call__(self, *args, **kwargs):
  4.         people_obj=self.__new__(self)                        # 1、Mymeta.__call__函数内会先调用People内的__new__
  5.         self.__init__(people_obj,*args, **kwargs)  # 2、Mymeta.__call__函数内会调用People内的__init__
  6.         people_obj.__dict__['xxxxx']=11111          # print('people对象的属性：',people_obj.__dict__)
  7.         return people_obj                                # 3、Mymeta.__call__函数内会返回一个初始化好的对象
  9. # 类的产生
  10. # People=Mymeta()=》type.__call__=>干了3件事
  11. # 1、type.__call__函数内会先调用Mymeta内的__new__
  12. # 2、type.__call__函数内会调用Mymeta内的__init__
  13. # 3、type.__call__函数内会返回一个初始化好的对象
  15. class People(metaclass=Mymeta):
  16.     def __init__(self,name,age):
  17.         self.name=name
  18.         self.age=age
  20.     def say(self):
  21.         print('%s:%s' %(self.name,self.name))
  23.     def __new__(cls, *args, **kwargs):
  24.         # 产生真正的对象
  25.         return object.__new__(cls)  #一般是调用父类的new方法
  27. # 类的调用
  28. # obj=People('egon',18) =》Mymeta.__call__=》干了3件事
  29. # 1、Mymeta.__call__函数内会先调用People内的__new__
  30. # 2、Mymeta.__call__函数内会调用People内的__init__
  31. # 3、Mymeta.__call__函数内会返回一个初始化好的对象
  33. obj1=People('egon',18)
  34. obj2=People('egon',18)
  35. # print(obj)
  36. print(obj1.__dict__)
  37. print(obj2.__dict__)

属性查找

  1. # 属性查找的原则：对象-》类-》父类
  2. # 切记：父类 不是 元类
  4. class Mymeta(type):
  5.     n=444
  7.     def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
  8.         obj=self.__new__(self) # StanfordTeacher.__new__
  9.         # obj=object.__new__(self)
  10.         print(self.__new__ is object.__new__) #True
  11.         self.__init__(obj,*args,**kwargs)
  12.         return obj
  14. class Bar(object):
  15.     # n=333
  17.     # def __new__(cls, *args, **kwargs):
  18.     #     print('Bar.__new__')
  19.     pass
  21. class Foo(Bar):
  22.     # n=222
  24.     # def __new__(cls, *args, **kwargs):
  25.     #     print('Foo.__new__')
  26.     pass
  28. class StanfordTeacher(Foo,metaclass=Mymeta):
  29.     # n=111
  31.     def __init__(self,name,age):
  32.         self.name=name
  33.         self.age=age
  36. obj=StanfordTeacher('lili',18)
  37. print(obj.__dict__)
  38. # print(obj.n)
  39. # print(StanfordTeacher.n)

补充

链式操作

  1. # coding:utf8
  2. # author:jason
  5. class MyClass(object):
  6.     def func1(self):
  7.         print('func1')
  8.         return self  #返回self对象
  10.     def func2(self):
  11.         print('func2')
  12.         return self
  15. obj = MyClass()
  16. obj.func1().func2()