Ⅶ 面向对象基础
面向对象
前面我们讲到基本数据类型用来表示最常见的信息。但是信息有无穷多种，为了更好的表达信息，我们可以创建自定义数据类型。
1. 类
1.1 类的概念
一种数据类型就是类。例如整数，浮点数，字符串。
1.2 类的定义
python 中通过关键字 class 可以定义一个自定义数据类型，基本语法如下：
class 类名:
属性
方法
注意：python 中类名规则同变量，首字母大写，一般使用 大驼峰 来表示。
案例
例如：创建一个 Point 类用于表示平面坐标系中的一个点
class Point:
"""
表示平面坐标系中的一个点
"""
print(Point)
<class '__main__.Point'>
<__main__.Point object at 0x0000021D799D4940>
2. 对象
2.1 对象的概念
某种数据类型的一个具体的数据称为这个类的一个对象或者实例。通过类创建对象叫做实例化。
所谓的面向对象，就是把一些数据抽象成类的思想。
python 是一门面向对象的编程语言，python 中一切皆对象。
前面学习的函数也是 python 中的一个类，定义的某个函数就是函数类的一个具体实例。
def func():
pass
print(type(func))
<class 'function'>
2.2 实例化
除了基本数据类型实例化的过程中用到的特殊的语法规范外，所有自定义类型进行实例化都是通过调用类名来实现的，非常简单，语法如下：
对象 = 类名(参数)
看起来和调用函数一样。
案例
给上面创建的 Point 类创建一个实例。
point = Point()
print(type(point))
print(point) # 查看对象分配的内存空间
<class 'main.Point'>
⭐ 实例化对象操作属性
3. 属性
类和对象的特征数据称为属性。
3.1 类属性
类的特征称为类属性。
3.1.1）类属性的定义
①直接在类中定义的变量（与 class 语句只有一个缩进），就是类属性。
案例：
给 Point 类创建一个 name 属性用来表示名称。
class Point:
"""
表示平面坐标系中的一个点
"""
name = '点'
⭐②类外面：类名.属性名 = '属性值'
⭐ 类属性有公有和私有两种，私有类属性是以两个下划线开头的。
⭐自定义的类，python会自动生成__dict__属性，这个属性可以获取到类所有的属性和方法，以字典形式返回
3.1.2）类属性的访问
类属性可以直接通过类名和对象以句点法访问，语法格式如下：
类名.类属性名 （-推荐使用）
对象.类属性名
案例：
print(Point.name) # 直接通过类名访问类属性
point=Point() # 创建一个实例
print(point.name) # 通过对象访问类属性
点
点
注意：如果不存在属性则抛出 AttributeError 的异常
print(Point.a)
AttributeError Traceback (most recent call last)
in
----> 1 print(Point.a)
AttributeError: type object 'Point' has no attribute 'a'
3.1.3）类属性的更新
3.2 对象属性(成员属性/实例属性)
对象的特征数据称为对象属性。
3.2.1）对象属性的定义
对象属性一般定义在构造方法中，详见下面构造方法一节。
通过句点法 对象.对象属性 以赋值的方式可以直接定义对象属性。
案例：
平面坐标系中的每个点都有 x 坐标和 y 坐标，通过类 Point 创建一个对象表示点（x=1，y=2）
point = Point()
# 通过赋值直接定义对象属性
point.x = 1
point.y = 2
注意：在定义对象属性时如果和类属性同名，那么通过对象将无法访问到类属性。
3.2.2）对象属性的访问
实例属性：只能通过这个实例对象访问 ； 通过句点法 `对象.对象属性` 可以访问对象属性。
案例：
访问上面案例中 point 的 x 坐标和 y 坐标
print(point.x)
print(point.y)
1
2
访问对象属性时，首先会检查对象是否拥有此属性，如果没有则去创建对象的类中查找有没有同名的类属性，如果有则返回，如果都找不到则抛出 AttributeError 的异常
3.2.3）对象属性的修改
3.3 内置属性
4. 方法
定义在类中的函数称为方法。通过调用的方式的不同，分为对象方法，类方法，静态方法和魔术方法。
4.1 对象方法
定义在类中的普通方法，一般通过对象调用称为对象方法。
4.1.1）对象方法的定义
为了讲清楚对象方法的定义和调用，我们先看下面的案例。
案例：
定义函数 my_print，它接收一个 Point 对象，然后打印这个点的 x，y 坐标。
def my_print(point):
print('({},{})'.format(point.x, point.y))
p = Point()
p.x = 1
p.y = 2
my_print(p)
(1,2)
定义函数 distance，它接收两个 Point 对象，然后返回这两个点的距离。
def distance(p1, p2):
return ((p1.x-p2.x)**2 + (p1.y-p2.y)**2)**0.5
p1 = Point()
p2 = Point()
p1.x = 1
p1.y = 2
p2.x = 3
p2.y = 4
res = distance(p1,p2)
print(res)
2.8284271247461903
观察上面的两个函数，发现它们都接收一个或多个 Point 的对象作为参数。为了显式的加强这样的联系，我们可以将它们定义在 Point 的类中。
class Point:
"""
表示平面坐标系中的一个点
"""
name = '点'
def my_print(point):
print('({},{})'.format(point.x, point.y))
def distance(p1, p2):
return ((p1.x-p2.x)**2 + (p1.y-p2.y)**2)**0.5
4.1.2）对象方法的调用
对象方法和属性一样，可以通过句点法进行调用。
类名.方法名(参数)
对象.方法名(参数)
通过类名调用方法时，和普通函数没有区别
# 更新了类，再次实例化对象
point = Point()
point.x = 1
point.y = 2
p1 = Point()
p2 = Point()
p1.x = 1
p1.y = 2
p2.x = 3
p2.y = 4
Point.my_print(point)
res = Point.distance(p1, p2)
print(res)
(1,2)
2.8284271247461903
通过对象调用方法时，对象本身会被隐式的传给方法的第一个参数
point.my_print()
res = p1.distance(p2)
print(res)
(1,2)
2.8284271247461903
因此，定义对象方法会习惯性的把第一个形参定义为 self，self代表对象本身；哪个对象调用方法，方法中的self代表的就是哪个对象
class Point:
"""
表示平面坐标系中的一个点
"""
name = '点'
def my_print(self):
print('({},{})'.format(self.x, self.y))
def distance(self, p2):
return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
方法中如果要自定义参数，参数定义在self之后
调用方法时，除了self不用传递，其他的参数传递和函数调用一样
实例方法：只能通过实例对象去调用，调用时会把对象传递给第一个参数self
⭐总结：
4.2 类方法
在类中通过装饰器 classmethod 可以把一个方法变成类方法。
类方法的第一个参数定义为：cls
类方法中的cls代表的是类本身
调用时一个类方法把类自己作为第一个实参传递给cls，就像一个实例方法把实例自己作为第一个实参传递给self。
案例
定义一个类方法 base_point 用来返回坐标原点。
class Point:
"""
表示平面坐标系中的一个点
"""
name = '点'
def my_print(self):
print('({},{})'.format(self.x, self.y))
def distance(self, p2):
return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
@classmethod
def base_point(cls):
bp = cls()
bp.x = 0
bp.y = 0
return bp
通过类本身或者是该类的实例都可以调用类方法；
p = Point()
bp1 = p.base_point()
bp1.my_print()
bp2 = Point.base_point()
bp2.my_print()
(0,0)
(0,0)
类方法一般都用来生成特殊对象。
4.3 类方法的进阶学习
4.3.1）类函数调用类属性
案例：
class SuperMan:
# 类的属性
name = 'nick'
def protect_people(self):
print('我是超人，我叫：%s'%self.name)
p = SuperMan()
p.protect_people()
输出结果：
我是超人，我叫：nick
class SuperMan:
# 类的属性
name = 'nick'
@classmethod
def protect_people(cls):
print('我是超人，我叫：%s' % cls.name)
print('我是超人，我叫：%s' % SuperMan.name)
print('我是超人，我叫：%s' % SuperMan().name)
p = SuperMan()
p.protect_people()
总结：
在函数里面调用类属性，必须通过实例对象和类去调用
4.3.2）类函数带有位置参数
案例：
参照类方法的
4.3.3）类函数带有默认参数
案例：
class SuperMan:
# 类的属性
name = 'nick'
def protect_people(self,name='毛毛'):
print('我是超人，我叫：%s' % name)
p = SuperMan()
p.protect_people('笑笑') # 传入参数
p.protect_people() # 不传入参数
输出结果：
我是超人，我叫：笑笑
我是超人，我叫：毛毛
4.3.4）类函数之间的相互调用
4.3.4.1）类函数调用不带参数的类函数
案例：
class SuperMan:
# 类的属性
name = 'nick'
def protect_people(self,name='毛毛'):
print('我是超人，我叫：%s' % name)
self.fly_to_sky()
def fly_to_sky(self):
print('我是超人，我可以飞上天！')
p = SuperMan()
p.protect_people('笑笑')
输出结果：
我是超人，我叫：笑笑
我是超人，我可以飞上天！
4.3.4.2）类函数调用带参数的类函数
案例：
class SuperMan:
# 类的属性
name = 'nick'
def protect_people(self,name='毛毛'):
print('我是超人，我叫：%s' % name)
def fly_to_sky(self,name):
self.protect_people(name)
print('我是超人，我可以飞上天！')
p = SuperMan()
p.fly_to_sky('非非')
输出结果：
我是超人，我叫：非非
我是超人，我可以飞上天！
4.3.5）类函数带有动态参数
案例：
class SuperMan:
# 类的属性
name = 'nick'
def protect_people(self,*args):
for name in args:
print('我是超人，我叫：%s' % name)
p = SuperMan()
p.protect_people('非非','毛毛','滔滔','思思')
输出结果：
我是超人，我叫：非非
我是超人，我叫：毛毛
我是超人，我叫：滔滔
我是超人，我叫：思思
4.3.6）类函数带有关键字参数
案例：
class SuperMan:
# 类的属性
name = 'nick'
def protect_people(self,**kwargs):
print('我是超人，我的个人信息是：%s' % kwargs)
p = SuperMan()
p.protect_people(name='非非',sex='girl',age=20)
输出结果：
我是超人，我的个人信息是：{'name': '非非', 'sex': 'girl', 'age': 20}
4.4 特殊方法（魔术方法）
在类中可以定义一些特殊的方法用来实现特殊的功能，也称为魔术方法。这些方法一般都以双下划线 __ 开头
__init__
__init__ 又叫构造方法，初始化方法，在调用类名实例化对象时，构造方法会自动被调用，类名括号 () 后的参数会传递给构造方法，那么对象就会有相应的实例属性，对象属性一般在这个方法中定义。
⭐self是对象本身，那么创建对象，调用__init__方法后，指定 self.属性名 = 属性值 ，就是为对象的对象属性赋值，把传进来的参数值给对应属性；
案例1：
上面案例中的 Point 类实例化后，需要手动创建对象属性 x 和 y，这显然容易出错和不规范，正确的做法应该是在构造方法中定义属性 x 和 y
class Point:
"""
表示平面坐标系中的一个点
"""
name = '点'
def __init__(self, x, y):
self.x = x
self.y = y
def my_print(self):
print('({},{})'.format(self.x, self.y))
def distance(self, p2):
return ((self.x - p2.x) ** 2 + (self.y - p2.y) ** 2) ** 0.5
@classmethod
def base_point(cls):
return cls(0, 0)
# 实例化
p1 = Point(1, 2)
p2 = Point(x=3, y=4)
p1.my_print() # 实例调用类的方法
p2.my_print()
print(p1.name) # 实例调用类的属性值
(1,2)
(3,4)
点
案例2：类函数调用初始化值
class SuperMan:
def __init__(self,name):
self.name = name
def protect_people(self):
print('我是超人，我叫：%s' % self.name)
p = SuperMan('nick')
p.protect_people()
输出结果：
我是超人，我叫：nick
如果类函数里面要调用初始化的值，可以直接调用，要记得加self关键字。
注意：对象属性只能通过对象调用
SuperMan.age=age 赋值给类属性则可以通过类来访问
__str__
__str__ 方法在对象被 print 函数打印时被调用，print 输出 __str__ 方法返回的字符串。
案例：
上面案例中 Point 类里的 my_print 方法可以去掉，定义一个 __str__ 方法
class Point:
"""
表示平面坐标系中的一个点
"""
name = '点'
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return '({},{})'.format(self.x, self.y)
def distance(self, p2):
return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
@classmethod
def base_point(cls):
return cls(0,0)
p = Point(2,2)
print(p)
(2,2)
更多的特殊方法详见
4.5 静态方法
在类中通过装饰器 staticmethod 可以把一个方法变静态方法。
静态方法不会接收隐式的第一个参数，它和普通的函数一样，只是被封装到类中。
通过类和对象都可以调用。
案例：
在 Point 类中定义一个静态方法，用来计算两个数的和。
class Point:
"""
表示平面坐标系中的一个点
"""
name = '点'
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return '({},{})'.format(self.x, self.y)
def distance(self, p2):
return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
@classmethod
def base_point(cls):
return cls(0,0)
@staticmethod
def sum(x,y):
return x+y
Point.sum(1,2)
3
p = Point(1,2)
p.sum(3,4)
7
4.6 类方法的不同使用场景？
①如果方法内部要使用对象的属性或调用对象的其他方法，方法定义为实例方法。
②如果方法内部要使用类的属性或其他的类方法，方法定义为类方法。
③如果方法中既不使用类的属性和方法，也不使用对象的属性和方法，定义为静态方法。
5. 类的继承
类还有一个重要的特性是继承。
在pyhton3中所有的类都有一个顶级的父类（基类）：object
5.1 继承
当定义一个类时，可以从现有的类继承，新的类称为子类(Subclass)，被继承的类称为基类，父类或超类(Base class,Super class).
子类可以继承父类的属性和方法。
注意：私有属性和方法不能继承
案例：
创建一个类用来表示三维的点。
class Point:
"""
表示平面坐标系中的一个点
"""
name = '点'
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return '({},{})'.format(self.x, self.y)
def distance(self, p2):
return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
@classmethod
def base_point(cls):
return cls(0,0)
@staticmethod
def sum(x,y):
return x+y
class TdPoint(Point):
"""
表示三维的点
"""
在上面的案例中 TdPoint 类继承了 Point 类。对于 TdPoint 来说 Point 是它的父类，对于 Point 类来说 TdPoint 是他的子类。
print(dir(TdPoint))
['class', 'delattr', 'dict', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'gt', 'hash', 'init', 'init_subclass', 'le', 'lt', 'module', 'ne', 'new', 'reduce', 'reduce_ex', 'repr', 'setattr', 'sizeof', 'str', 'subclasshook', 'weakref', 'base_point', 'distance', 'name', 'sum']
虽然在 TdPoint 类中没有定义任何的属性和方法，但它自动继承了父类 Point 的属性和方法。
5.2 多继承
一个子类可以同时继承多个父类：
5.2.1）类的多继承-类方法不同
案例：
class A:
def add(self,a,b):
print('类A中的加法',a+b)
class B:
def sub(self,a,b):
print('类B中的减法',a-b)
class C(A,B):
pass
C().add(1,2)
C().sub(1,2)
输出结果：
类A中的加法 3
类B中的减法 -1
子类C继承了父类AB的所有方法，调用的时候，就直接去父类里面取方法进行调用即可。
5.2.2）类的多继承-类方法相同
案例：
class A:
def add(self,a,b):
print('类A中的加法',a+b)
class B:
def add(self,a,b):
print('类B中的加法',a+b)
def sub(self,a,b):
print('类B中的减法',a-b)
class C(B,A):
pass
C().add(1,2)
C().sub(1,2)
输出结果：
类B中的加法 3
类B中的减法 -1
子类C调用的全部是父类B中的方法，这就是多继承的另一个特点：顺序继承。当出现同名方法的时候，会按照是顺序优先调用前面父类的同名方法。
5.3 重写
在上面的案例中，虽然 TdPoint 类继承了 Point 的属性和方法，但是三维的点比二维的点多了一个纬度，所以大部分方法和属性不合适，需要重写。
在子类中定义同名的方法和属性会覆盖父类的方法和属性。
class Point:
"""
表示平面坐标系中的一个点
"""
name = '点'
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return '({},{})'.format(self.x, self.y)
def distance(self, p2):
return ((self.x-p2.x)**2 + (self.y-p2.y)**2)**0.5
@classmethod
def base_point(cls):
return cls(0,0)
@staticmethod
def sum(x,y):
return x+y
class TdPoint(Point):
"""
表示三维的点
"""
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
def __str__(self):
return '({},{},{})'.format(self.x, self.y, self.z)
def distance(self, p2):
return ((self.x-p2.x)**2 + (self.y-p2.y)**2 + (self.z-p2.z)**2)**0.5
@classmethod
def base_point(cls):
return cls(0,0,0)
上面的代码中 TdPoint 类重写了父类中的init,str,distance,base_point 四个方法
p1 = TdPoint(1,2,3)
p2 = TdPoint(2,3,4)
print(p1)
(1,2,3)
p1.distance(p2)
1.7320508075688772
print(TdPoint.base_point())
(0,0,0)
⭐方法文档字符串注释的添加：在方法下打一对三引号""""""
5.4 拓展
子类可以重写父类中的方法
子类还可以拓展一些父类中没有的方法
5.5 super 方法
重写了父类方法后如果又要调用父类的方法怎么解决呢？
例如，三维点在计算点与点的距离时，要求同时返回投射到二维平面的点的距离。
class TdPoint(Point):
"""
表示三维的点
"""
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
def __str__(self):
return '({},{},{})'.format(self.x, self.y, self.z)
def distance(self, p2):
d2 = Point.distance(self, p2)
d3 = ((self.x-p2.x)**2 + (self.y-p2.y)**2 + (self.z-p2.z)**2)**0.5
return d2, d3
@classmethod
def base_point(cls):
return cls(0,0,0)
p1 = TdPoint(1,2,3)
p2 = TdPoint(2,3,4)
p1.distance(p2)
(1.4142135623730951, 1.7320508075688772)
可以直接通过类名的方式调用对应的方法。但是这种方法的耦合性太大，官方推荐使用 super 函数。
class TdPoint(Point):
"""
表示三维的点
"""
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
def __str__(self):
return '({},{},{})'.format(self.x, self.y, self.z)
def distance(self, p2):
d2 = super().distance(p2)
d3 = ((self.x-p2.x)**2 + (self.y-p2.y)**2 + (self.z-p2.z)**2)**0.5
return d2, d3
@classmethod
def base_point(cls):
return cls(0,0,0)
p1 = TdPoint(1,2,3)
p2 = TdPoint(2,3,4)
p1.distance(p2)
<super: <class 'TdPoint'>, >
(1.4142135623730951, 1.7320508075688772)
在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。
super()会返回一个代理对象，它会将方法调用委托给父类，这对于访问已在类中被重载的父类方法很有用。
class SoftWareTestEngineer:
def __init__(self,name,age):
self.name = name
self.age = age
def basic_skill(self):
print(self.name+'今年'+str(self.age)+'岁，可以做点点点功能测试')
class JuniorSoftWareEngineer(SoftWareTestEngineer):
def basic_skill(self):
print(self.name+'今年'+str(self.age)+'岁，可以按照完整的业务逻辑以及测试用例完成功能测试，达到99%的通过率')
def auto_test(self,code):
print(self.name+'能够做%s自动化测试'%code)
class SeniorSoftWareTestEngineer(JuniorSoftWareEngineer):
def auto_test(self, code):
super(SeniorSoftWareTestEngineer,self).auto_test(code)
print('我还可以利用Python代码写接口自动化、web自动化、APP自动化框架！')
SeniorSoftWareTestEngineer('summer',20).auto_test('python')
输出结果：
summer能够做python自动化测试
我还可以利用Python代码写接口自动化、web自动化、APP自动化框架！
super类写的是子类的类型，顺着子类的类名找到对应的父类，并调用父类的方法，实现超继承。
在子类中调用被重写的父类方法
# 方式一、:父类名.方法名(self,xxx,xx....)
PhoneV1.__init__(self,size, year)
# 方式二：super().方法名(xxx,xx....)
super().__init__(size, year)
5.6 多态
python 是一门动态语言，严格的来说 python 不存在多态。
def bark(animal):
animal.bark()
上面的函数 bark 接收一个对象，并调用了对象的 bark 方法。对于 python 来说只要传入的对象有 bark 方法这个函数就可以执行，而不必去检查这个对象的类型。
class Animal:
def bark(self):
print('嗷嗷叫！')
class Dog(Animal):
def bark(self):
print('汪汪叫！')
class Cat(Animal):
def bark(self):
print('喵喵叫！')
class Duck(Animal):
def bark(self):
print('嘎嘎叫！')
dog = Dog()
cat = Cat()
duck = Duck()
bark(dog)
bark(cat)
bark(duck)
汪汪叫！
喵喵叫！
嘎嘎叫！
上面的案例中 dog 是 Dog 类型的一个实例，同时它也是 Animal 的一个实例。但是反过来不成立。
对于静态语言来说函数 bark 如果需要传入 Animal 类型，则传入的对象必须是 Animal 类型或者它的子类，否则，不能调用 bark。
dog，cat，duck 都是 Animal 类型，但是它们执行 bark 后的输出又各不相同。一个类型多种形态，这就是多态。
对于 python 这样的动态语言来说，则不需要传入的一定是 Animal 类型，只要它具有一个 bark 方法就可以了。
⭐不继承也能实现多态，python的多态都是伪多态。
class SomeClass:
def bark(self):
print('随便叫！')
sc = SomeClass()
bark(sc)
随便叫！
⭐因为函数参数类型和函数参数长度没有限制，多以python无多态
⭐ 多态：定义好一个制式，按照这个制式向接口去提供对应的不同对象，根据你提供的不同对象执行不同的操作
# 常用的支付方式：微信支付 支付宝支付 银行卡支付
class PayMent():
def pay(self):
print("给钱")
class WeChat(PayMent):
def pay(self):
print("微信支付")
class AliPay(PayMent):
def pay(self):
print("支付宝支付")
class Card(PayMent):
def pay(self):
print("银行卡支付")
class StartPay(): # 没有继承
def pay(self,obj): # 也定义一个pay函数,定义一个变量，用来接收未知的对象
obj.pay()
s = StartPay()
ali = AliPay()
s.pay(obj=ali)
支付宝支付
5.7 私有化
python 中不存在那种只能在仅限从一个对象内部访问的私有变量。
但是，大多数 Python 代码都遵循这样一个约定：以一个下划线开头的名称 (例如 _spam) 应该被当作是 API 的非公有部分 (无论它是函数、方法或是数据成员)。 这应当被视为一个实现细节，可能不经通知即加以改变。
class A:
_arg1 = 'A'
def _method1(self):
print('我是私有方法')
a = A()
a._arg1
'A'
a._method1()
我是私有方法
这种以一个下划线开头的属性可以被类和实例调用。
只是在 from xxx import * 时不会被导入。
还有一种定义私有属性的方法是以两个下划线开头的名称（例如__spam)，这种方式定义的私有变量只能在类的内部访问。
class A:
__arg1 = 'A'
def __method1(self):
print('我是私有方法')
a = A()
a.__arg1
AttributeError Traceback (most recent call last)
in
1 a = A()
----> 2 a.__arg1
AttributeError: 'A' object has no attribute '__arg1'
这种限制访问的原理是，以双下划线开头的属性名(至少带有两个前缀下划线，至多一个后缀下划线)会被改写成 _classname__spam，所以在类外部通过原名称反问不到，但在类的内部使用原名称可以访问。
a._A__arg1
'A'
私有属性和私有方法也不能被继承。
⭐ 私有的实例属性，只能在自己内中调用（对象是独立的）
⭐内置属性
⭐私有方法和属性是用来实现内部逻辑的，外部不能直接调用
6.类的封装
6.1 实例方法封装
6.2 私有属性封装
6.3 装饰器@property
装饰器@property定义与调用
7.自省与反射机制
7.1 自省
在日常生活中，自省（introspection）是一种自我检查行为。
在计算机编程中，自省是指这种能力：检查对象以确定它是什么类型、它有哪些属性和哪些方法。自省向程序员提供了极大的灵活性和控制力。
type
type 函数可以返回一个对象的类型
type(1)
int
isinstance
检查一个对象是否是某个或某些类型的实例
isinstance(1,int)
True
issubclass
检查一个类是否是某个或某些类的子类
issubclass(bool, int)
True
dir
返回一个传入对象的属性名和方法名的字符串列表
print(dir(1))
['abs', 'add', 'and', 'bool', 'ceil', 'class', 'delattr', 'dir', 'divmod', 'doc', 'eq', 'float', 'floor', 'floordiv', 'format', 'ge', 'getattribute', 'getnewargs', 'gt', 'hash', 'index', 'init', 'init_subclass', 'int', 'invert', 'le', 'lshift', 'lt', 'mod', 'mul', 'ne', 'neg', 'new', 'or', 'pos', 'pow', 'radd', 'rand', 'rdivmod', 'reduce', 'reduce_ex', 'repr', 'rfloordiv', 'rlshift', 'rmod', 'rmul', 'ror', 'round', 'rpow', 'rrshift', 'rshift', 'rsub', 'rtruediv', 'rxor', 'setattr', 'sizeof', 'str', 'sub', 'subclasshook', 'truediv', 'trunc', 'xor', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
python 中的自省函数有很多，凡是可以检查对象状态的函数都可以称为自省函数。
7.2 反射
反射就是动态的操作对象。
简单的讲就是根据字符串形式的属性名方法名操作对应的对象。
hasattr
检查一个对象是否有给定名称的属性
hasattr([1,2,3],'append')
True
getattr
返回一个对象给定名称的属性
getattr(x,'y') 等价于 x.y
class Point:
name = '点'
getattr(Point,'name')
'点'
动态获取属性
参数1：对象（类）
参数2：属性名
参数3：属性不存在时返回的默认值（不写，则属性不存在时报错）
getattr(Point,double,None)
setattr
给一个对象/类 添加一个给定名称的属性
把动态的数据绑定为类或者对象的属性名和属性值
setattr(x, 'y', v) 等价于 x.y = v
setattr(Point,'x',1)
Point.x
1
⭐动态给类和对象设置属性，可以实现接口间依赖参数的传递，setattr getattr
delattr
删除对象的一个给定名称的属性
delattr(x, 'y') 等价与 del x.y
delattr(Point, 'x')
Point.x
AttributeError Traceback (most recent call last)
in
----> 1 Point.x
AttributeError: type object 'Point' has no attribute 'x'
自省和反射机制的理解需要大量的阅读源码。
练习1
class Students:
"""
学生类
"""
identity = '学生'
def __init__(self,name,age,gender,english,math,chinese):
self.name = name
self.age = age
self.gender = gender
self.english = english
self.math = math
self.chinese = chinese
def sum_score(self):
"""计算总分"""
res = self.english + self.math + self.chinese
return res
def avg_score(self):
"""计算平均分"""
# res = (self.english + self.math + self.chinese)/3
res = self.sum_score()/3
return res
def desc_info(self):
"""打印信息"""
print('学员名字:{}，年龄:{}，性别:{}...'.format(self.name,self.age,self.age))
练习2
print("~~~=欢迎使用花花老师的烤鸭店计算器=~~~")
projects = {}
# print("**** 准备开始录入商品 ****")变成装饰器
def decorator_01(func_name):
def pre_print(*args): # *args接收self
print("**** 准备开始录入商品 ****")
return func_name(*args)
return pre_print
class Duck():
@decorator_01
def input_goods(self): # 封装成类函数后要将self传给装饰器
"""录入商品的功能""" # 添加函数的注释
pro_list = [] # 列表要在if里面，不能在if上面，因为每一次进入while循环都会把列表清空一次，所以会查不出数据
load_txt = ["请输入商品的名称：", "请输入商品的成本价：", "请输入商品的出产地：", "请输入商品的生产日期：", "其他商品属性1：", "其他商品属性2："]
for i in load_txt:
name1 = input(f"{i}") # 这样也可以,还挺帅的
pro_list.append(name1)
projects[pro_list[0]] = pro_list # 此时要用这个
def select_goods(self):
# 这里还要做一个判断，如果字典里面没有Key值的时候如何处理？
# 查询商品的功能
load_name = input("输入你要查询的商品名称：") # key的名字是唯一的不允许重复
print("{}".format(projects[load_name]))
def cycle(self):
while True:
# 转义字符：键盘上有一部分键，不能在代码中显示
# 用英文去代替特殊键位
# 百度词典搜索 转义字符
ope_type = input("1 - 录入商品 \n2 - 查询商品\n3 - 退出系统\n请做出您的选择：")
# pro_list = []
if ope_type == "1":
self.input_goods() # 将鼠标移到函数上面，就能显示出来这个函数是用来做什么的，需不需要传参数
elif ope_type == "2":
self.select_goods()
elif ope_type == "3":
# 退出系统的功能
print("正在退出系统！！！")
break
else:
print("系统无法识别您的操作，即将关闭系统~")
break
duck = Duck()
duck.cycle()
