Python-10.1-面向对象
Python的面向对象
- 面向对象编程
- 基础
- 共有私有
- 继承
- 组合，Mixin
- 魔法函数
- 魔法函数概述
- 构造类魔法函数
- 运算类魔法函数
一：面向对象概述(ObjectOriented, OO)
- 面向对象中的对象(Object)通常是指客观世界中存在的对象，具有唯一性
- 对象之间各不相同，各有各的特点
- 每一个对象都有自己的运动规律和内部状态
- 对象与对象之间又是可以相互联系，相互作用的
- 面向对象是一种编程思想，是一种通过多个对象相互协互相完成功能处理流程的编程思路
- 主要分为
- 类的声明和定义
- 对象的创建和使用
- 面向对象拥有的特征有：
- 封装
- 对象对敏感数据的保护
- 继承
- 代码复用和功能扩展
- 多态
- 不同操作环境下代码的多样性
- 封装
1、OOP思想
- 接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型构成的
- oop编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述
2、名词
- OO:面向对象
- OOA:面向对象的分析
- OOD:面向对象的设计
- OOI:xxx的实现
- OOP:xxx的编程
- OOA -> OOD -> OOI :面向对象的实现过程
二：类和对象的概念
- 类
- 抽象名词，代表一个集合，共性的事物
- 具有相同属性和行为的一类实体
- 对象
- 具象的事物，单个个体
- 类跟对象的关系
- 一个具象，代表一类事物的某一个个体
- 一个抽象，代表的是一大类事物
- 类中的内容，具有两个内容
- 表明事物的特征，叫做属性(变量)
- 表明事物功能或动作，称为成员方法(函数)
三：类的基本实现
- 类的命名
- 声明一个类
- 实例化类
- 访问对象成员
- 通过默认内置变量检查类和对象的所有成员
1、类的命名
- 遵守变量命名的规范
- 大驼峰(由一个或者多个单词构成，每个单词首字母大写，单词跟单词直接相连)
- 尽量避开跟系统命名相似的命名
2、声明一个类
- 必须用 class 关键字
- 类由属性和方法构成，其他不允许出现
- 成员属性定义可以直接使用变量赋值，如果没有，则使用None
3、实例化类
- 变量 = 类名()
- 实例化了一个对象
4、访问对象成员
- 使用点操作符
- obj.成员属性名称
- obj.成员方法
# 定义一个空的类
class Student():
# 一个空类，pass代表直接跳过
pass
# 定义一个对象
jack = Student()
# 再定义一个类，用来描述学习Python的学生
class StudyPython():
# 用None给不确定的值赋值
name = None
age = 18
course = 'Python'
# 需要注意
# 1、def do_homework的缩进层次
# 2、系统默认由一个self参数
def do_homework(self):
print("I doing homework now.")
# 推荐在函数末尾使用return语句
return None
# 实例化一个叫job的学生，是一个具体的人
job = StudyPython()
print(job.name)
print(job.age)
print(job.course)
# 注意成员函数的函数没有传递参数
job.do_homework()
None
18
Python
I doing homework now.
5、通过默认内置变量检查类和对象的所有成员
- 对象所有成员检查
- obj.dict
- 类所有的成员
- class_name.dict
# 类所有的成员
class A():
name = 'jack'
age = 18
# 1、对象所有成员检查
a = A()
print(a.__dict__)
# 2、类所有成员
A.__dict__
{}
mappingproxy({‘module’: ‘main’,
‘name’: ‘jack’,
‘age’: 18,
‘dict’: <attribute ‘dict’ of ‘A’ objects>,
‘weakref’: <attribute ‘weakref’ of ‘A’ objects>,
‘doc’: None})
四：类和对象的成员分析
- 类和对象都可以存储,成员可以归类所有，也可以归对象所有
- 类存储成员使用的是与类关联的对象
- 独享存储成员是存储在当前对象中
- 对象访问一个成员时
- 如果对象中没有该成员，尝试访问类中的同名成员
- 如果对象中由此成员，一定使用对象中的成员
- 创建对象的时候，类中的成员不会放入对象中，而是得到一个空对象，没有成员
- 通过对象对类中成员重新赋值或者通过对象添加成员时，对应成员会保存在对象中，而不会修改类成员
class Student():
name = 'jack'
age = 18
def descrite(self):
self.name = 'job'
self.age = 19
# 此案例说明
# 类实例的属性和其对象的实例的属性在不对对象的实例属性赋值的前提下
# 指向同一变量
# 此时，Student称为实例
print(Student.name)
print(Student.age)
# id可以鉴别一个变量是否和另一个变量是同一变量
print(id(Student.name))
print(id(Student.age))
print()
a = Student()
print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))
print("*"*50)
print(Student.name)
print(Student.age)
print(id(Student.name))
print(id(Student.age))
print()
a = Student()
# 查看Student内所有属性
print(Student.__dict__)
print(a.__dict__)
a.name = 'kevin'
a.age = 16
print(a.__dict__)
print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))
# 不会修改类成员
print(Student.name)
jack
18
1469999739152
140723228153184
jack
18
1469999739152
140723228153184
jack
18
1469999739152
140723228153184
{‘module’: ‘main’, ‘name’: ‘jack’, ‘age’: 18, ‘descrite’: <function Student.descrite at 0x0000015642BD61E0>, ‘dict’: <attribute ‘dict’ of ‘Student’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘Student’ objects>, ‘doc’: None}
{}
{‘name’: ‘kevin’, ‘age’: 16}
kevin
16
1469999739936
140723228153120
jack
五：关于self
- self:在对象的方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入当前方法的第一个参数中
- self并不是关键字，只是一个用于接受对象的普通参数，理论上可以用任何一个普通变量名代替
- 方法中
- self形参的方法成为非绑定类的方法，可以通过对象访问
- 没有self的是绑定类的方法，只能通过类访问
- 使用类访问绑定类的方法时
- 如果类方法中需要访问当前类的成员，可以通过__class__
class Student():
name = 'jack'
age = 16
def descrite(self):
print("{} is {} years old.".format(self.name.title(), self.age))
def hobby():
# 调用类的成员变量需要用__class__
print(__class__.name)
print(__class__.age)
print("I like football.")
jack = Student()
jack.descrite()
# 调用绑定类函数，只能通过类访问
Student.hobby()
Jack is 16 years old.
jack
16
I like football.
# 鸭子模型
class A():
name = 'aaa'
age = 18
def __init__(self):
self.name = 'bbb'
self.age = 19
def say(self):
print(self.name)
print(self.age)
class B():
name = 'ccc'
age = 20
a = A()
# 此时，系统默认把实例a作为第一个参数传入函数
a.say()
print()
# 此时，self被a代替
A.say(a)
print()
# 同样可以把A作为参数传入
A.say(A)
print()
# 此时，传入的时类实例B
# 因为B具有name和age属性，不会报错
A.say(B)
# 以上代码，利用了鸭子模型
bbb
19
bbb
19
aaa
18
ccc
20
六：面向对象的三大特性
- 封装
- 继承
- 多态
1、封装
- 封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类
- 封装的思想
- 类通常会对客户隐藏其实现细节
- 封装就是对对象的成员进行访问控制
- 封装的三个级别
- 公开:public
- 受保护的:protected
- 私有的:private
- public, private, protected不是关键字
- 判断对象的位置
- 对象内部
- 对象外部
- 子类中
(1)私有 private
- 私有成员最高级的封装，只能在当前类或对象中访问
- 在成员前面添加两个下划线即可
- Python的私有不是真私有，是一种成为name, mangling的改名策略，可以使用对象_classname__attributename访问(类名前面一个下划线)
# 私有变量案例
class Person():
# namw是共有的成员
name = 'jack'
# __age就是私有成员
__age = 18
p = Person()
# name是共有变量
print(p.name)
# __age是私有变量
# print(p.__age)
# 注意报错
print(Person._Person__age)
jack
18
(2)受保护的封装 protected
- 受保护的封装是将对象成员进行一定级别的封装
- 在类中或者子类中都可以进行访问，但在外部不可以
- 封装方法
- 在成员名称前添加一个下划线即可
(3)公开 public
- 公共的封装实例对成员没有任何操作，任何地方都可以访问
2、继承
- 继承就是一个类可以获得另一个类中成员和成员方法
(1)继承的作用
- 减少代码，增加代码的复用功能，同时可以设置类与类直接的关系
(2)继承与被继承
- 被继承的类叫父类，也叫基类，也叫超类
- 用于继承的类，也叫自类，也叫派生类
- 继承与被继承i顶存在 is - a 关系
# 继承的语法
# 在python中，任何类都有一个共同的父类object
class Person():
name = 'jack'
# 私有的
__score = 0
age = 16
# 受保护的，子类可以用，但不能公用
_petname = 'sec'
def sleep(self):
print("{} like sleeping.".format(self.name.title()))
# 父类写在括号内
class Teacher(Person):
teacher_id = 110
def teach(self):
print("{} can teach student.".format(self.name.title()))
# Teacher是一个类实例
print(Teacher.name)
t = Teacher()
print(t.name)
# 受保护的
print(t._petname)
# 私有的
print(Person._Person__score)
t.sleep()
t.teach()
jack
jack
sec
0
Jack like sleeping.
Jack can teach student.
(3)继承的特征
- 所有的类都继承自 object 类的子类
- 子类一旦继承父类，则可以使用父类中除私有成员外的所有内容
- 子类继承父类后并没有将父类成员完全赋值到子类中，而是通过引用关系访问调用
- 子类中可以定义独有的成员属性和方法
- 子类中定义的成员和父类成员如果相同，则优先使用子类成员
- 子类如果想扩充父类的方法，可以定义新方法的同时访问父类成员来进行代码重用
- 可以使用 父类名.父类成员 的格式来调用父类成员
- 也可以使用super().父类成员的格式来调用
# 子类扩充父类功能的案例
class Person():
name = 'jack'
age = 18
def work(self):
print("make money")
class Teacher(Person):
name = 'job'
def teach(self):
print("teach student")
def work(self):
# 扩充父类的功能只需调用父类相应的函数
Person.work(self)
# 扩充父类的另一种方法
# super代表得到父类
super().work()
self.teach()
t = Teacher()
t.work()
make money
make money
teach student
(4)继承变量函数的查找顺序问题
- 优先查找自己的变量，没有则查找父类
- 构造函数如果本类中没有定义，则自动查找调用父类构造函数
- 如果本类有定义，则不再继续向上查找
(5)构造函数
- 是一类特殊的函数，在类进行实例化之前进行调用
- 如果定义了构造函数，则实例化时使用构造函数，不查找父类构造函数
- 如果没定义，则自动查找父类构造函数
- 如果子类没定义，父类的构造函数带参数，则构造对象时的参数应该按父类参数构造
# 构造函数案例
class Animal():
def __init__(self):
print("super animal")
class Mammal(Animal):
def __init__(self, name):
self.name = name
print("{} is mammal.".format(self.name))
class Dog(Mammal):
# __init__就是构造函数
# 每次实例化的时候，第一个被自动的调用
# 主要的工作是进行初始化
def __init__(self):
print("I have a cute dog.")
# 实例化的时候，括号内的参数需要跟构造函数参数匹配
# 实例化的时候，自动调用了Dog的构造函数
# 因为找到了构造函数，则不再查找父类的构造函数
kaka = Dog()
print("*"*50)
class Cat(Mammal):
pass
# 此时应该自动调用构造函数
# 因为Cat没有构造函数，所以查找父类的构造函数
# 因为Mammal中查找到了构造函数，则停止向上查找
lala = Cat("lala")
print("*"*50)
print(type(super))
I have a cute dog.
lala is mammal.
<class ‘type’>
(6)super
- super不是一个关键字，而是一个类
- super的作用
- 获取MRP(MethodResolutionOrder)列表中的第一个类
- super与父类没有直接实质性关系，但通过super可以调用到父类
- super使用两个方法
- 参见在构造函数中调用父类的构造函数
class A():
pass
class B(A):
pass
print(type(super))
print(A.__mro__)
print(B.__mro__)
<class ‘type’>
(<class ‘main.A’>, <class ‘object’>)
(<class ‘main.B’>, <class ‘main.A’>, <class ‘object’>)
(7)单继承和多继承
- 单继承：每个类只能继承一个类
- 多继承：每个类允许继承多各类
- 单继承和多继承的优缺点
- 单继承
- 优点：传承有序逻辑清晰语法简单隐患少
- 缺点：功能不能无限扩展，只能在当前唯一的继承链中扩展
- 多继承
- 优点：类的功能扩展方便
- 缺点：继承关系混乱
- 单继承
# 多继承的例子
# 子类可以直接拥有父类的属性和方法，私有属性和方法除外
class Finsh():
def __init__(self, name):
self.name = name
def swim(self):
print("{} can swimming.".format(self.name.title()))
class Bird():
def __init__(self, name):
self.name = name
def fly(self):
print("{} can fly.".format(self.name.title()))
class Person():
def __init__(self, name):
self.name = name
def walk(self):
print("{} can walk.".format(self.name.title()))
# 多继承例子
class SuperMan(Person, Bird, Finsh):
def __init__(self, name):
self.name = name
s = SuperMan('jack')
s.fly()
s.swim()
print("*"*50)
# 单继承例子
class Student(Person):
def __init__(self, name):
self.name = name
stu = Student('job')
stu.walk()
Jack can fly.
Jack can swimming.
Job can walk.
(8)菱形继承/钻石继承
- 多个子类继承自同一个父类，这些子类被同一个类继承，于是继承关系图形成一个菱形图谱
- 关于多继承的MRO
- MRO就是多继承中，用于保存继承顺序的一个列表
- Python本身采用C3算法来多多继承的菱形继承进行计算的结果
- MRO列表的计算原则
- 子类永远在父类前面
- 如果多个父类，则根据继承语法中括号内类的书写顺序存放
- 如果多个类继承了同一父亲，孙子类中只会选取继承语法括号中第一个父类的父类
# 菱形继承问题
class A():
pass
class B(A):
pass
class C(A):
pass
class D(B, C):
pass
# MRO列表的计算原则
print(C.__mro__)
print(D.__mro__)
(<class ‘main.C’>, <class ‘main.A’>, <class ‘object’>)
(<class ‘main.D’>, <class ‘main.B’>, <class ‘main.C’>, <class ‘main.A’>, <class ‘object’>)
(9)总结
- 子类扩展父类的构造函数
- 调用父类构造函数
- 使用super调用
- 子类扩展父类的方法
- 调用父类构造函数
- 使用super调用
class Person():
def __init__(self, name):
self.name = name
def walk(self):
print("{} can walk.".format(self.name.title()))
# 子类扩展父类的构造函数
class Student(Person):
def __init__(self, name, age, fruit):
# version1.0
Person.__init__(self, name)
self.age = age
print("{} is {} years old.".format(self.name.title(), self.age))
# version2.0
super(Student, self).__init__(name)
self.fruit = fruit
print("{} favorite fruit is {}.".format(self.name.title(), self.fruit))
# 子类扩展父类的方法
class Teacher(Person):
def walk(self):
# version1.0
print("version 1.0")
Person.walk(self)
# version
print("version 2.0")
super(Teacher, self).walk()
s = Student("jack", 18, 'apple')
print("="*50)
t = Teacher('job')
t.walk()
print("="*50)
# 子类扩展父类后，并不会修改原有的属性与方法
p = Person('kevin')
p.walk()
Jack is 18 years old.
Jack favorite fruit is apple.
version 1.0
Job can walk.
version 2.0
Job can walk.
Kevin can walk.
3、多态
- 将父类对象应用于子类的特征就是多态
- 多态化的结构
- 当子类继承父类特征的同时，也具备了自己的特征，并且
- 多态就是同一个对象在不同情况下有不同的状态出现
- 多态不是语法，是一种设计思想
- 多态性：一种调用方式，不同的执行效果
- 多态：同一事物的多种形态，动物分为人类，狗类，猪类
七：Mixin设计模式
- 主要采用多继承方式对类的功能进行扩展
- 我们使用多继承语法来实现Mixin
- 使用Mixin实现多继承的时候非常小心
- 首先它必须表示某一单一功能，而不是某个物品
- 职责必须单一，如果有多个功能，则写多个Mixin
- Mixin不能依赖于子类的实现
- 子类即使没有继承这个Mixin类，也能照样工作，只是缺少了某个功能
- Mixin 优点：
- 使用Mixin可以在不对类进行任何修改的情况下，扩充功能
- 可以方便组织和维护不同功能组件的划分
- 可以根据需要任意调整功能类的组合
- 可以避免创建很多新的类，导致类的继承混乱
# Mixin案例
class Person():
name = 'jack'
age = 18
def eat(self):
print("{} can eat.".format(self.name.title()))
def drink(self):
print("{} can drink.".format(self.name.title()))
def sleep(self):
print("{} can sleep.".format(self.name.title()))
class Teacher(Person):
def work(self):
print("{} is working now.".format(self.name.title()))
class Student(Person):
def study(self):
print("{} is studying now.".format(self.name))
class Tutor(Teacher, Student):
pass
t = Tutor()
print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)
print("*"*70)
class TeacherMixin():
def work(self):
print("can work.")
class StudentMixin():
def study(self):
print("can study.")
class TutorM(Person, TeacherMixin, StudentMixin):
pass
tt = TutorM()
print(TutorM.__mro__)
print(tt.__dict__)
print(TutorM.__dict__)
(<class ‘main.Tutor’>, <class ‘main.Teacher’>, <class ‘main.Student’>, <class ‘main.Person’>, <class ‘object’>)
{}
{‘module’: ‘main’, ‘doc’: None}
(<class ‘main.TutorM’>, <class ‘main.Person’>, <class ‘main.TeacherMixin’>, <class ‘main.StudentMixin’>, <class ‘object’>)
{}
{‘module’: ‘main’, ‘doc’: None}
八：类相关的函数
1、检测一个类是否是另一个类的子类
- issubclass
# issubclass
class A():
pass
class B(A):
pass
class C():
pass
print(issubclass(B, A))
print(issubclass(A, B))
print(issubclass(C, object))
True
False
True
2、检测一个对象是否是另一个类的实例
- isinstance
# isinstance
class A():
pass
a = A()
print(isinstance(a, A))
print(isinstance(A, A))
True
False
3、检测一个对象是否有成员xxx
- hasattr
# hasattr
class A():
name = 'jack'
a = A()
print(hasattr(a, 'name'))
print(hasattr(a, 'age'))
True
False
4、获取对象的成员列表
- dir
# dir
class A():
def walk():
pass
a = A()
dir(a)
5、获取对象的属性值
- getattr
- getattr(obj, name[,defsult])
- 其中obj为对象名，name是对象中的字符串，必须为字符串
6、修改对象的属性值
- setattr
- setattr(obj, name, value)
- 其中obj为对象名，name是对象中的字符串，value是修改的值
7、删除对象的属性值
- delattr
- delattr(object, name)
- 其中obj为对象名，name是对象中的字符串，是要删除属性
class Person():
def __init__(self):
self.name = 'jack'
self.age = 18
self.fruit = 'apple'
p = Person()
# 1、获取对象的属性值
print(getattr(p, 'name'))
# 2、修改对象的属性值
setattr(p, 'age', 16)
print(getattr(p, 'age'))
# 3、删除对象的属性值
delattr(p, 'fruit')
# 检验属性fruit
print(hasattr(p, 'fruit'))
jack
16
False
九：类的成员描述符(属性)
- 类的成员描述符是为了在类中对类的成员属性进行相关操作而创建的一种方式
- get:获取属性的操作
- set:修改或者添加属性的操作
- delete:删除属性的操作
class Student():
def __init__(self, name, age):
self.name = name
self.age = age
self.setname(name)
self.setage(age)
def intro(self):
print("{} is {} years old.".format(self.name, self.age))
def setname(self, name):
self.name = name.title()
def setage(self, age):
self.age = int(age)
# 为什么要对类进行实例化？
# 类就好比是一类事物的抽象，是一个模板，拥有这一类事物的属性和功能
# 对于Stduent这个类，每个学生的属性和要做的又是不一样，所以需要实例化
# 实例对象就是类的具体对象
s = Student('JACK', 18.5)
s.intro()
print("*"*50)
# 属性的三种用法
print(s.__dict__)
# 1、读取
print(s.name)
# 2、赋值
s.name = 'job'
print(s.name)
# 3、删除
del s.name
print(a.__dict__)
Jack is 18 years old.
{‘name’: ‘Jack’, ‘age’: 18}
Jack
job
{’_age’: 18.8}
1、使用类的成员描述符的三种方法
- 使用类实现描述器
- 使用属性修饰符
- 使用property函数
- property函数很简单
- property(fget, fset, fdel, doc)
1、使用类的成员描述符的三种方法
- 使用类实现描述器
- 使用属性修饰符
- 使用property函数
(1)使用类实现描述器
(2)使用属性修饰符
- @property
- @property
- 被@property装饰的方法是获取属性值的方法，被装饰方法的名字会被用作属性名
- @属性名.setter
- 被@属性名.property装饰的方法是设置属性值的方法
- @属性名。deleter
- 被@属性名.deleter装饰的方法是删除属性值的方法
- @property
class Animal():
def __init__(self):
self._name = 'job'
self._age = 18.8
@property
def name(self):
print("Get attribute.")
return self._name
@name.setter
def name(self, name):
print("Set attribute.")
self._name = name.title()
@name.deleter
def name(self):
print("Deleter attribute.")
del self._name
a = Animal()
print(a.__dict__)
a.name = "KEVIN"
print(a.name)
del a.name
print(a.__dict__)
{’_name’: ‘job’, ‘_age’: 18.8}
Set attribute.
Get attribute.
Kevin
Deleter attribute.
{’_age’: 18.8}
(3)使用property函数
- property:
- fget:获取属性值的方法
- fset:设置属性值的方法
- fdel:删除属性值的方法
- doc:属性描述信息
- 应用场景:
- 在获取、设置和删除属性的时候，需要额外做一些工作
- 比如在游戏编程中，设置敌人死亡之后需要播放死亡动画
- 需要限制对象属性的设置和获取
- 比如用户年龄为只读，或者在设置用户年龄的时候有范围限制
- 这时就可以使用property工具
- 它把方法包装成属性，让方法可以以属性的形式被访问和调查
- 在获取、设置和删除属性的时候，需要额外做一些工作
class Student():
def __init__(self):
self._name = 'jack'
self._age = 16.5
# 获取属性时执行的代码
def fget(self):
print("Get attribute.")
return self._age
# 设置shuxing 时执行代码
def fset(self, age):
print("Set attribute.")
self._age = int(age)
# 删除属性时执行的代码
def fdel(self):
print("Deleter attribute.")
del self._age
age = property(fget, fset, fdel, "This is an example of ")
s = Student()
# 查看属性的文档字符串
print(s.__dict__)
# 设置属性
s.age = 18.6
# 获取属性
print(s.age)
del s.age
print(s.__dict__)
{’_name’: ‘jack’, ‘_age’: 16.5}
Set attribute.
Get attribute.
18
Deleter attribute.
{’_name’: ‘jack’}
2、无论哪种修饰符都是为了对成员属性进行相应的控制
- 类的方式：适合多个类中的多个属性公用一个描述符
- 属性修饰符：使用于当前类中使用，控制一个类中一个属性
- property：使用当前类中使用，可以控制一个类中多个属性
十：类的内置属性
- dict:以字典的方式显示类的成员组成
- doc:获取类的文档信息
- name:获取类的名称，如果在模块中使用，获取模块的名称
- bases:获取某个类的所有父类，以元组的方式显示
# 类的内置属性案例
class Person():
"""描述一个人"""
def __init__(self, name, age):
self.name = name
self.age = age
self.setage(age)
def describe(self):
print("{} is {} years old.".format(self.name.title(), self.age))
def setage(self, age):
self.age = int(age)
class Student(Person):
"""一个学生"""
pass
# 以字典的方式显示类的成员组成
print(Person.__dict__)
print()
# 获取类的文档信息
print(Person.__doc__)
print()
# 获取类的名称
print(Person.__name__)
print()
# 获取Student的所有父类
print(Student.__bases__)
{‘module’: ‘main’, ‘doc’: ‘描述一个人’, ‘init’: <function Person.init at 0x000001948AFDF6A8>, ‘describe’: <function Person.describe at 0x000001948AFDF8C8>, ‘setage’: <function Person.setage at 0x000001948AFDFF28>, ‘dict’: <attribute ‘dict’ of ‘Person’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘Person’ objects>}
描述一个人
Person
(<class ‘main.Person’>,)
十一：类的常用魔术方法
- 魔术方法就是不需要认为调用的方法，基本是在特定的时刻自动触发
- 魔术方法的统一的特征
- 方法名被前后各两个下划线包裹
1、操作类
- 魔术方法__init__
- 魔术方法__new__
- 魔术方法__call__
- 魔术方法__str__
- 魔术方法__repr__
(1) 魔术方法__init__
- 构造函数
(2) 魔术方法__new__
- 对象实例化方法，一般不需要使用
(3) 魔术方法__call__
- 对象当函数使用触发
(4) 魔术方法__str__
- 当对象被当做字符串使用的时候调用
# 常用的魔术方法
class A():
def __init__(self):
print("I was called.")
def __call__(self):
print("I was called again.")
def __str__(self):
return "I am superman."
# 实例化的时候自动调用
a = A()
# 对象当函数使用触发
a()
# 当对象被当做字符串使用的时候调用
print(a)
I was called.
I was called again.
I am superman.
(5) 魔术方法__repr__
- 返回字符串
- 在打印类的时候，控制类输出的字符串
# __repr__
class B():
def __init__(self, name):
self.name = name
print(B('asd'))
print("*"*50)
class C():
def __init__(self, fruit):
self.fruit = fruit
def __repr__(self):
return self.fruit
print(C('apple'))
<main.B object at 0x000001948AFED438>
apple
2、描述符相关
- 属性描述符的原理利用的是抽象的方法，把十几个字段共同的特性抽出来
- 每个字段都用这个特性，达到节省代码的目的
- 方法__set__
- 方法__get__
- 方法__delete__
(1) 方法__set__
(2) 方法__get__
(3) 方法__delete__
# 描述符相关的魔法函数
class IntNumber():
def __get__(self, instance, owner):
return self.value
def __set__(self, instance, value):
if isinstance(value, int) and 0 < value < 100:
self.value = value
print(self.value)
else:
print("Input legitimate number .")
def __delete__(self, instance):
pass
class Student():
# age本来是对象，放在类里当作了属性
age = IntNumber()
s = Student()
# 赋值时，自动调用IntNumber的方法
# 12.2给value
# self就是age
# instance就是s
s.age = 12.2
s.age = 13
Input legitimate number .
13
3、属性操作相关
(1) 方法__getattr__:访问一个不存在的属性时触发
# __getattr__案例
class A():
def __init__(self):
self.name = 'jack'
self.age = 16
self.tip = "This is None"
def __getattr__(self, tip):
return self.tip
a = A()
print(a.name)
print(a.aa)
jack
This is None
(2) 方法__setattr__:对成员属性进行设置的时候触发
- 参数:
- self用来获取当前对象
- 被设置的属性名称，以字符串形式出现
- 需要对属性名称设置的值
- 作用:
- 进行属性设置的时候进行验证或者修改
- 注意:
- 在该方法中不能对属性进行赋值操作，否则死循环
# __setattr__
class Person():
def __init__(self, name, age):
self.name = name
self.age = age
def __setattr__(self, name, value):
print("设置属性：{}".format(name))
# 下面语句会导致死循环
# self.name = value
# 此种情况，为了避免死循环，规定统一调用父类魔法函数
super().__setattr__(name, value)
p = Person('jack', 16)
print(p.__dict__)
p.fruit = 'apple'
print(p.__dict__)
设置属性：name
设置属性：age
{‘name’: ‘jack’, ‘age’: 16}
设置属性：fruit
{‘name’: ‘jack’, ‘age’: 16, ‘fruit’: ‘apple’}
4、运算分类相关魔术方法
- 魔术方法__gt__
- 魔术方法__lt__
(1) 魔术方法__gt__
- 进行大于判断的时候触发的函数
- 参数:
- self
- 第二个参数是第二个对象
- 返回值是任意值，推荐返回布尔值
# __gt__
class Student():
def __init__(self, name):
self.name = name
def __gt__(self, obj):
print("Is {} bigger than {}?".format(self.name, obj.name))
return print(self.name > obj.name)
job = Student('job')
jack = Student('jack')
job > jack
Is jack bigger than job?
False
(2) 魔术方法__lt__
- 进行小于判断的时候触发的函数
# __lt__
class Teacher():
def __init__(self, name):
self.name = name
def __lt__(self, obj):
print("Is {} smaller than {}?".format(self.name, obj.name))
return print(self.name < obj.name)
jully = Teacher('jully')
kevin = Teacher('kevin')
jully < kevin
Is jully smaller than kevin?
True
十二：类和对象的三种方法
- 面向对象的三种方法
- 实例方法
- 静态方法
- 类方法
- 三种方法的区别
1、实例方法
- 需要实例化对象才能使用的方法，使用过程中可能需要截至对象的其他对象的完成方法
- 第一个参数是self，它表示一个具体的实例本身
2、静态方法
- @staticmethod
- 不需要实例化，通过类直接访问
- 静态方法定义在类中，因为在类中定义但是没有self代表对象，所以静态方法不能操作类中的变量
- 静态方法可以在对象中共享，当对象没有实例化时可以直接通过类本身调用
3、类方法
- @classmethod
- 不需要实例化，通过类直接访问
- 第一个参数是cls，它表示这个类的本身
- 类方法是直接将类本身当成对象去操作
- 在实际应用中，只有我们需要操作类本身去操作类中的属性时，我们可以在类中定义类方法
# 三种方法案例
class Person():
# 实例方法
def walk(self):
print(self)
print("I often go for a work in the park.")
# 静态方法
# 不需要用第一个参数表示自身或者类
@staticmethod
def swim():
print("I like swimming.")
# 类方法
# 类方法的第一个参数，一般命名为cls，区别于self
@classmethod
def play(cls):
print(cls)
print("I like playing football.")
jack = Person()
# 实例方法
jack.walk()
print()
# 静态方法
jack.swim()
Person.swim()
print()
# 类方法
jack.play()
Person.play()
<main.Person object at 0x000002AC350C7780>
I often go for a work in the park.
I like swimming.
I like swimming.
<class ‘main.Person’>
I like playing football.
<class ‘main.Person’>
I like playing football.
3、三种方法的区别
- 实例方法只能被实例对象调用
- 静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法)，可以被类或类的实例对象调用
十三：抽象类
- 抽象方法
- 抽象类
- 包含抽象方法的类叫抽象类，通常称为ABC类
- 抽象类的使用需要借助abc模块
- 抽象类的使用
1、抽象方法
- 没有具体功能实现的方法为抽象方法
# 抽象方法
class Animal():
def sayHellow(self):
pass
class Dog(Animal):
def sayHellow(self):
print("Smell each other")
class Person(Animal):
def sayHellow(self):
print("Shake hands with each other.")
d = Dog()
d.sayHellow()
p = Person()
p.sayHellow()
Smell each other
Shake hands with each other.
2、抽象类
- 包含抽象方法的类叫抽象类，通常称为ABC类
- 抽象类的使用需要借助abc模块
- import ab
- 抽象类的使用
- 抽象类可以包含抽象方法，也可以包含具体方法
- 抽象类中可以有方法也可以有属性
- 抽象类不允许直接实例化
- 必须继承才可以使用，且继承的子类必须实现所有继承的来的抽象方法
- 假定子类没有实现所有继承的抽象方法，则子类也不能被实例化
- 抽象类的主要作用是设定类的标准，以便开发的时候具有同一的规范
# 抽象类的实现
import abc
# 声明一个类并且指定当前类的元类
class Human(metaclass=abc.ABCMeta):
# 定义一个抽象的方法
@abc.abstractmethod
def smoking(self):
pass
# 定义类抽象方法
@abc.abstractclassmethod
def drink():
pass
# 定义静态抽象方法
@abc.abstractstaticmethod
def play():
pass
# 可以定义具体方法
def sleep(self):
print("I like sleeping.")
十四：自定义类
- 类其实是一个类定义和各种方法的自由组合
- 可以定义类和函数，然后自己通过类直接赋值
- 可以借助于MethodType实现
- 借助type
1、函数名称当变量用
# 函数名称当变量用
def sayHellow(name):
print("{},Good afternoon.".format(name.title()))
sayHellow('jack')
# 函数名称当变量用
asd = sayHellow
asd('job')
Jack,Good afternoon.
Job,Good afternoon.
2、组装类
# 自己组装一个类1.0
class Person():
pass
def sayHellow(self, name):
print("{},Good evening.".format(name.title()))
sayHellow(a, 'kevin')
# 函数名当变量用
# version1.0
Person.sayHellow = sayHellow
jk = Person()
jk.sayHellow('jack')
Kevin,Good evening.
Jack,Good evening.
# 自己组装一个类2.0
from types import MethodType
class Animal():
pass
def sleep(self, name):
print("{} like sleeping.".format(name.title()))
sleep(6, "dog")
# 实例
# version2.0
a = Animal()
a.sleep = MethodType(sleep, Animal)
a.sleep('monkey')
Dog like sleeping.
Monkey like sleeping.
3、创建类
- 利用type创造一个类
# 利用type创造一个类
# 先定义类应该具有的成员函数
def walk(self, name):
print("{} often take a walk after dinner.".format(name.title()))
def swim(self, name):
print("{} like swimming.".format(name))
# 用type来创建一个类
A = type('People', (object, ), {'method_walk':walk, 'method_swim':swim})
a = A()
# 查看类 ：dir(a)
a.method_walk('jack')
Jack often take a walk after dinner.
4、利用元类实现 MetaClass
- 生产机器的机器
- 元类是类
# 元类演示
# 元类写法是固定的，必须继承type
# 元类一般命名以MetaClass结尾
class PersonMetaClass(type):
# 构造函数写法固定
def __new__(cls, name, bases, attrs):
# 自己的业务处理
print("元类")
# 初始化属性
attrs['name'] = 'jack'
attrs['age'] = 16
return type.__new__(cls, name, bases, attrs)
# 元类定义完就可以使用，注意写法
class Student(object, metaclass = PersonMetaClass):
pass
s = Student()
print(s.name)
print(s.age)
元类
jack
16
2892
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
