python_面向对象进阶（7）

第1章 面向对象特性—继承（补充）
1.1 接口类、抽象类介绍 
1.2 接口类
1.3 接口类应用过程
1.3.1 第一版：完成多种支付方式接口
1.3.2 第二版: 归一化设计，统一支付方式
1.3.3 第三版：野生程序员的乱搞
1.3.4 第四版：制定规范，统一方法名
1.3.5 第五版本：强制性制定规定
1.4 抽象类
1.4.1 解释：
1.4.2 为什么要有抽象类
1.4.3 抽象类实际应用理论
1.4.4 抽象类的使用方法
1.5 接口类和抽象类的区别
1.6 继承注意问题
第2章 面幸对象特征—多态
2.1 鸭子类
2.2 多态实例
第3章 面向对象特征—封装
3.1 封装定义
3.2 广益封装
3.3 狭义封装
3.3.1 特点
3.3.2 1)私有静态字段（静态变量）
3.3.3 私有字段外部调用方法
3.3.4 私有字段内部访问方式
3.3.5 2)私有普通变量（私有对象属性）
3.3.6 3)私有方法
3.3.7 4)私有成员实际应用
第4章 面向对象进阶
4.1 面向对象整体结构及成员
4.1.1 字段：
4.1.2 方法：
4.1.3 属性
4.2 @peroperty
4.2.1 将方法变为属性
4.2.2 私有属性的外部显示
4.2.3 @age.setter修改私有属性
4.2.4 自动触发的三要素
4.2.5 peroperty匹配的三种方法
4.3 类方法：
4.3.1 @classmethod
4.3.2 静态方法直接引用@staticmethod
4.4 *****getattr()反射
4.4.1 在类中
4.4.2 在对象中
4.4.3 在模块中
4.4.4 在当前模块中
4.4.5 通过字符串去到 类名 中取值
4.4.6 hasattr/ getattr/ setattr/ delattr
4.5 *****hasattr()
4.6 其他方法
4.6.1 isinstance()
4.6.2 issubclass()
4.7 __len__
4.8 __hash__
4.9 __str__
4.10 __repr__
4.11 ***__call__
4.12 __eq__
4.13 __del__
4.14 ****__new__
4.15 __item__

第1章 面向对象特性—继承（补充）

1.1 接口类、抽象类介绍

解释：接口类和抽象类是一种规范，写代码时的规范

1.2 接口类

继承有两种用途：

l  继承基类的方法，并且做出自己的改变或者扩展（代码重用）

l  声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能

实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。

接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

1.3 接口类应用过程

1.3.1 第一版：完成多种支付方式接口

class QQpay:

def pay(self,money):

print('您已经通过qq支付了%s元' %money)

class Alipay:

def pay(self,money):

print('您已经通过支付宝支付了%s元' %money)

a = QQpay()

b = Alipay()

a.pay(100)

b.pay(200)

输出：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

您已经通过qq支付了100元

您已经通过支付宝支付了200元

缺点:

若果十个支付方式.py()支付方式不统一，写了十次太麻烦

1.3.2 第二版: 归一化设计，统一支付方式

class QQpay:

def pay(self,money):

print('您已经通过qq支付了%s元' %money)

class Alipay:

def pay(self,money):

print('您已经通过支付宝支付了%s元' %money)

def pay(obj,money):

obj.pay(money)

输出：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

您已经通过qq支付了100元

您已经通过支付宝支付了200元

缺点：确实统一了支付方式，但是新增接口时并无任何提示，及相关接口的保护

1.3.3 第三版：野生程序员的乱搞

class QQpay:

def pay(self,money):

print('您已经通过qq支付了%s元' %money)

class Alipay:

def pay(self,money):

print('您已经通过支付宝支付了%s元' %money)

class Wechatpay:

def fukuan(self,money):

print('您已经通过微信支付了%s元' %money)

def pay(obj,money):

obj.fukuan(money) ###野生程序员更改了支付方式的代码

c = Wechatpay()

pay(c,200)

a = QQpay()   ###原接口已经被改变，不能使用

pay(a,100)

输出：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

您已经通过微信支付了200元

Traceback (most recent call last):

File "D:/python/untitled2/python_7/lession2.py", line 61, in <module>

pay(a,100)

File "D:/python/untitled2/python_7/lession2.py", line 55, in pay

obj.fukuan(money)

1.3.4 第四版：制定规范，统一方法名

class Payrole:

def pay(self):pass

class QQpay(Payrole):

def pay(self,money):

print('您已经通过qq支付了%s元' %money)

class Alipay(Payrole):

def pay(self,money):

print('您已经通过支付宝支付了%s元' %money)

class Wechatpay(Payrole):

def pay(self,money):

print('您已经通过微信支付了%s元' %money)

def pay(obj,money):

obj.pay(money)

缺点：归一化了付款接口，但是谁来都可以随意改动

1.3.5 第五版本：强制性制定规定

解释：from abc import ABCMeta,abstractclassmethod #从abc文件中引用两个模块

如果不用pay方法就会报错：

例：

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):    # 抽象类 接口类  规范和约束  metaclass指定的是一个元类

@abstractmethod

def pay(self):pass  # 抽象方法

class Alipay(Payment):

def pay(self,money):

print('使用支付宝支付了%s元'%money)

class QQpay(Payment):

def pay(self,money):

print('使用qq支付了%s元'%money)

class Wechatpay(Payment):

def pay(self,money):

print('使用微信支付了%s元'%money)

def recharge(self):pass

def pay(obj,money):

obj.pay(money)

a = Wechatpay()

b = QQpay()

c = Alipay()

pay(a,100)

pay(b,200)

pay(c,201)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

使用微信支付了100元

使用qq支付了200元

使用支付宝支付了201元

1.4 抽象类

1.4.1 解释：

与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

1.4.2 为什么要有抽象类

如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

1.4.3 抽象类实际应用理论

　 比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子……..你永远无法吃到一个叫做水果的东西。

从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

　  从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案

1.4.4 抽象类的使用方法

l  组合

面向对象的组合用法，软件重用的重要方式除了继承之外还有另外一种方式，即：组合

组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合

例1）：攻击类

class Person:

def __init__(self,nickname,sex,hp,ad):

self.nickname = nickname

self.sex = sex

self.hp = hp

self.ad = ad

def attack(self,p1):

p1.hp -= self.ad

print('%s攻击了%s,%s还剩%s血量'%(self.nickname,p1.nickname,p1.nickname,p1.hp))

def weapon_attack(self,wea):

# 武器类的对象封装到人的对象中当做一个属性.就叫做组合.

self.weapon = wea

class Weapon:

def __init__(self,name,att):

self.name = name

self.att = att

def Aux_attack(self,p,p1):

p1.hp -= self.att

print('%s利用%s打了%s%s滴血,%s还剩%s滴血' %(p.nickname,self.name,p1.nickname,self.att,p1.nickname,p1.hp))

# alex = Person('alex','男',100,20)

# barry = Person('太白','男',200,50)

# axe = Weapon('斧子',30)

# barry.weapon_attack(axe)

# barry.weapon.Aux_attack(barry,alex)

# axe.Aux_attack(alex)

# alex.attack(barry)

# alex.attack(barry)

例2）：计算类

圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。

这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用

from math import pi

class Circle:

'''

定义了一个圆形类；

提供计算面积(area)和周长(perimeter)的方法

'''

def __init__(self,radius):

self.radius = radius

def area(self):

return pi * self.radius * self.radius

def perimeter(self):

return 2 * pi *self.radius

circle =  Circle(10) #实例化一个圆

area1 = circle.area() #计算圆面积

per1 = circle.perimeter() #计算圆周长

print(area1,per1) #打印圆面积和周长

class Ring:

'''

定义了一个圆环类

提供圆环的面积和周长的方法

'''

def __init__(self,radius_outside,radius_inside):

self.outsid_circle = Circle(radius_outside)

self.inside_circle = Circle(radius_inside)

def area(self):

return self.outsid_circle.area() - self.inside_circle.area()

def perimeter(self):

return  self.outsid_circle.perimeter() + self.inside_circle.perimeter()

ring = Ring(10,5) #实例化一个环形

print(ring.perimeter()) #计算环形的周长

print(ring.area()) #计算环形的面积

例3）

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程

class BirthDate:

def __init__(self,year,month,day):

self.year=year

self.month=month

self.day=day

class Couse:

def __init__(self,name,price,period):

self.name=name

self.price=price

self.period=period

class Teacher:

def __init__(self,name,gender,birth,course):

self.name=name

self.gender=gender

self.birth=birth

self.course=course

def teach(self):

print('teaching')

p1=Teacher('egon','male',

BirthDate('1995','1','27'),

Couse('python','28000','4 months')

)

print(p1.birth.year,p1.birth.month,p1.birth.day)

print(p1.course.name,p1.course.price,p1.course.period)

'''

运行结果:

27

python 28000 4 months

'''

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

1.5 接口类和抽象类的区别

抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。

抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计

在python中，并没有接口类这种东西，即便不通过专门的模块定义接口，我们也应该有一些基本的概念。

1.6 继承注意问题

l  多继承问题

在继承抽象类的过程中，我们应该尽量避免多继承；

而在继承接口的时候，我们反而鼓励你来多继承接口

l  接口隔离原则

使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。

l  方法的实现

在抽象类中，我们可以对一些抽象方法做出基础实现；

而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现

第2章 面幸对象特征—多态

2.1 鸭子类

Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”

2.2 多态实例

python对于一些相似的功能不用强制规定直接约定俗成，默认支持多态，自带多态

class F1:

pass

class S1(F1):

def show(self):

print 'S1.show'

class S2(F1):

def show(self):

print 'S2.show'

# 由于在Java或C#中定义函数参数时，必须指定参数的类型

# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类

# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):

"""Func函数需要接收一个F1类型或者F1子类的类型"""

print obj.show()

s1_obj = S1()

Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj = S2()

Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

Python伪代码实现Java或C#的多态

Python伪代码实现java C#多态

第3章 面向对象特征—封装

3.1 封装定义

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

l  将内容封装到某处

l  从某处调用被封装的内容

3.2 广益封装

class Pesrson:

country = 'China'

def __init__(self,name,age):

self.name = name

self.age = age

def func(self):

print(self.name)

#创建了两个对象

p1 = Pesrson('wang',100)

p2 = Pesrson('li',200)

p1.func()#封装到对象中的属性是一种封装

3.3 狭义封装

定义：也称私有性封装

3.3.1 特点

只要类执行，将类的内容加载到内存时，发现“__变量名” ，自动将其转化成"_类名__变量名"，所以找不到。

私有静态字段，类的内部都可以访问，父类以及类的外部都不能访问

3.3.2 1)私有静态字段（静态变量）

实例：私有静态变量调用结果

class Pesrson:

country = 'China' #共有静态字段/变量

__name == 'lili'##私有静态字段/变量

def __init__(self,name,age):

self.name = name

self.age = age

def func(self):

print(self.name)

print(Pesrson.__name)

p1 = Pesrson('wang',100)

p2 = Pesrson('li',200)

输出：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

Traceback (most recent call last):

File "D:/python/untitled2/python_7/lession2.py", line 79, in <module>

class Pesrson:

File "D:/python/untitled2/python_7/lession2.py", line 81, in Pesrson

__name == 'lili'##私有静态字段/变量

NameError: name '_Pesrson__name' is not defined

在类的外部谁都不能调用

3.3.3 私有字段外部调用方法

class Pesrson:

country = 'China' #共有静态字段/变量

__name = 'lili'##私有静态字段/变量

def __init__(self,name,age):

self.name = name

self.age = age

def func(self):

print(self.name)

p1 = Pesrson('wang',100)

p2 = Pesrson('li',200)

print(Pesrson.__dict__['_Pesrson__name'])

print(p1._Pesrson__name)

输出：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

lili

lili

注意：虽然可以访问但工作中没有这样访问的

3.3.4 私有字段内部访问方式

解释：对于私有字段，在子类派生类也不可访问父类的私有静态字段，只能在本类使用

class Person:

country = 'China' #共有静态字段/变量

__name = 'lili'##私有静态字段/变量

__age = 23

def __init__(self,name,age):

self.name = name

self.age = age

def func(self):

return self.__name

p1 = Person('liu',19)

print(p1.func())

输出：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

lili

3.3.5 2)私有普通变量（私有对象属性）

class Person:

def __init__(self,name,age):

self.name = name #公有普通字段

self.__age = age #私有普通字段

p1 = Person('wang',18)

print(p1.name)

print(p1.__age)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

Traceback (most recent call last):

File "D:/python/untitled2/python_7/lession2.py", line 112, in <module>

print(p1.__age)

wang

AttributeError: 'Person' object has no attribute '__age'

3.3.6 3)私有方法

class Person:

def __init__(self,name,age):

self.name = name #公有普通字段

self.__age = age #私有普通字段

def __func(self):#私有方法

print(666)

p1 = Person('wang',18)

print(p1.name)

p1.__func()

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

Traceback (most recent call last):

File "D:/python/untitled2/python_7/lession2.py", line 116, in <module>

p1.__func()

AttributeError: 'Person' object has no attribute '__func'

wang

3.3.7 4)私有成员实际应用

对只想让类内部使用的成员，要设置成私有成员

例1）：密码加密方法

class Person:

def __init__(self,username,password):

self.username = username

self.__password = self.__encryption(password)

def __encryption(self,pwd):

'''

加密处理

:param pwd:

:return:

'''

return '%s xyz123' % pwd

p1 = Person('wang','123')

print(p1._Person__password)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

123 xyz123

例2）：

类的执行顺序：有先找__init__

class A:

def __init__(self):

self.func()

def func(self):

print('in A')

class B(A):

def func(self):

print('in B')

b = B()

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

in B

执行逻辑：

b è B(A) è A() è __init__ èfunc() è B.func() è print('in B')

例3）

class A:

def __init__(self):

self.__func()

def __func(self):

print('in A')

class B(A):

def __func(self):

print('in B')

b = B()

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

in A

执行逻辑：

b è B(A) è A() è __init__ èself.__func() == self._A__func() è A.func() è print('in A')

第4章 面向对象进阶

4.1 面向对象整体结构及成员

4.1.1 字段：

普通字段和静态字段

4.1.2 方法：

普通方法和属性

1）普通：一般是由对象调用的 init

class A:

name = 'lili'

def __init__(self,name,age):

self.name = name

self.age = age

def func(self):

print(666)

p1 = A('li',19)

print(p1.name)

print(p1.age)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

li

19

4.1.3 属性

例一

BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：

过轻：低于18.5

正常：18.5-23.9

过重：24-27

肥胖：28-32

非常肥胖, 高于32

　　体质指数（BMI）=体重（kg）÷身高^2（m）

　　EX：70kg÷（1.75×1.75）=22.86

class People:

def __init__(self,name,weight,height):

self.name = name

self.__weight = weight

self.__height = height

def bmi(self):

return self.__weight /self.__height **2

p1 = People('wang',75,1.78)

print(p1.bmi())

输出：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

23.671253629592222

4.2 @peroperty

4.2.1 将方法变为属性

解释：property 将你的 ‘一些方法伪装为属性，虽然在代码是哪个没有提高，让其看起来合乎情理’

例：

class People1:

def __init__(self,name,weight,height):

self.name = name

self.__weight = weight

self.__height = height

@property

def bmi(self):

return self.__weight /self.__height **2

p2 = People1('wang',75,1.78)

print(p2.bmi)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

23.671253629592222

4.2.2 私有属性的外部显示

class People1:

def __init__(self,name,weight,height,age):

self.name = name

self.__weight = weight

self.__height = height

self.__age = age

def age(self):

return self.__age

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

<class 'float'>

<bound method People1.age of <__main__.People1 object at 0x00000000021D8B00>>

加@property 后

class People1:

def __init__(self,name,weight,height,age):

self.name = name

self.__weight = weight

self.__height = height

self.__age = age

@property

def age(self):

return self.__age

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

<class 'float'>

16

4.2.3 @age.setter修改私有属性

class People1:

def __init__(self,name,weight,height,age):

self.name = name

self.__weight = weight

self.__height = height

self.__age = age

@property

def age(self):

return self.__age

@age.setter

def age(self,new_age):

if type(new_age) == int:

self.__age = new_age

else:

return '请输入一个整数'

p1 = People1('lili',45,1.6,23)

print(p1.age)

p1.age = 22

print(p1.age)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

23

22

4.2.4 自动触发的三要素

m  方法名相同

m  对方法赋值

m  调用方法setter

4.2.5 peroperty匹配的三种方法

l  getattr(object, name, default=None)

l  setattr(x, y, v) 设置增加或修改

l  delattr(x, y）

class People1:

def __init__(self,name,weight,height,age):

self.name = name

self.__weight = weight

self.__height = height

self.__age = age

@property

def age(self):

return self.__age

@age.setter

def age(self,new_age):

if type(new_age) == int:

self.__age = new_age

else:

return '请输入一个整数'

@age.deleter

def age(self):

print(666)

p1 = People1('lili',45,1.6,23)

print(p1.age) #触发@property 方法

p1.age = '1234' #触发@aage.setter 装饰器方法

del p1.age #触发 @age.deleter装饰的方法

print(p1.age)

一个属性只能对应一个值

class People:

def __init__(self,name,age,sex):

self.name = name

self.__age = age

self.__sex = sex

def age(self):

return  self.__age

p1 = People('wang','25','男')

print(p1.name)

print(p1.age)

输出

C:\python3\python.exe D:/python/untitled2/lianxi/lianxi.py

wang

<bound method People.age of <__main__.People object at 0x00000000021F8940>>

输出年龄

class People:

def __init__(self,name,age,sex):

self.name = name

self.__age = age

self.__sex = sex

@property

def age(self):

return  self.__age

p1 = People('wang','25','男')

print(p1.name)

print(p1.age)

练习：水果折扣价格

class Goods:

def __init__(self,name,origin_price,discount):

self.name  = name

self.__origin_price = origin_price

self.__discount = discount

@property

def price(self):

return self.__origin_price*self.__discount

@price.setter

def price(self,new_price):

self.__origin_price = new_price

obj1 = Goods('apple',5,0.8)

print(obj1.price)

obj1.price = 8

print(obj1.price)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

4.0

6.4

4.3 类方法：

一般用类名直接调用

有些情况对于类内部的方法，无需对象直接调用，而用类名直接调用即可

例1：（对象调用）

class Goods:

__discount = 0.8

def __init__(self,name,origin_price):

self.name = name

self.__origin_price = origin_price

@property

def price(self):

return self.__origin_price * Goods.__discount

def discount(self,new_discount):

Goods.__discount = new_discount

p1 = Goods('apple',5)

print(p1.price)

p1.discount(0.85)

print(p1.price)

输出：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

4.0

4.25

4.3.1 @classmethod

例2 （类名调用）

cls 默认接受类名本身

class Goods:

__discount = 0.8

def __init__(self,name,origin_price):

self.name = name

self.__origin_price = origin_price

@property

def price(self):

return self.__origin_price * Goods.__discount

@classmethod

def discount(cls,new_discount):

Goods.__discount = new_discount

p1 = Goods('apple',5)

Goods.discount(0.85)

print(p1.price)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

4.25

4.3.2 静态方法直接引用@staticmethod

不用类cls或者对象self 传值，直接调用即可

class A:

def __init__(self):

pass

@staticmethod

def login(username,password):

print(username,password)

A.login('wang',134)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

wang 134

4.4 *****getattr()反射

概念：python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

4.4.1 在类中

解释：通过字符串去到 类名  中获取值。

特殊：在python中，一切皆对象，凡是通过  什么.什么 ，通过 反射都能取到。

要求：输入字段即可获取字段

class A:

role = 'Teacher'

def func(self):

print(666)

eval exec用法注意:写死的时候可以用

普通方法：

class A:

role = 'Teacher'

def func(self):

print(666)

msg = input('>>')

print(A.__dict__[msg])

输出：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

>>role

Teacher

升级后：反射

class A:

role = 'Teacher'

def func(self):

print(666)

# msg = input('>>')

# print(A.__dict__[msg])

print(getattr(A,'role'))

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

Teacher

完整形式：

class A:

role = 'Teacher'

def func(self):

print(666)

msg = input('>>')

print(getattr(A,msg))

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

>>role

Teacher

4.4.2 在对象中

class Foo:

f = '类的静态变量'

def __init__(self,name,age):

self.name=name

self.age=age

def say_hi(self):

print('hi,%s'%self.name)

obj=Foo('egon',73)

#检测是否含有某属性

print(hasattr(obj,'name'))

print(hasattr(obj,'say_hi'))

#获取属性

n=getattr(obj,'name')

print(n)

func=getattr(obj,'say_hi')

func()

print(getattr(obj,'aaaaaaaa','不存在啊')) #报错

#设置属性

setattr(obj,'sb',True)

setattr(obj,'show_name',lambda self:self.name+'sb')

print(obj.__dict__)

print(obj.show_name(obj))

#删除属性

delattr(obj,'age')

delattr(obj,'show_name')

delattr(obj,'show_name111')#不存在,则报错

print(obj.__dict__)

对实例化对象的示例

4.4.3 在模块中

#一个模块中的代码

def test():

print('from the test')

"""

程序目录：

module_test.py

index.py

当前文件：

index.py

"""

# 另一个模块中的代码

import module_test as obj

#obj.test()

print(hasattr(obj,'test'))

getattr(obj,'test')()

4.4.4 在当前模块中

import sys

def s1():

print 's1'

def s2():

print 's2'

this_module = sys.modules[__name__]

hasattr(this_module, 's1')

getattr(this_module, 's2')

4.4.5 通过字符串去到 类名 中取值

class A:

role = 'Teacher'

def func(self):

print(666)

msg = input('>>')

getattr(A,msg)(111)

输出

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

>>func

666

4.4.6 hasattr/ getattr/ setattr/ delattr

解释：通过字符串到类中判断是否存

l  hasattr(object,name)

l  getattr(object, name, default=None)

l  setattr()

l  delattr() 删除

应用实例：

class BlackMedium:

feature='Ugly'

def __init__(self,name,addr):

self.name=name

self.addr=addr

def sell_house(self):

print('%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼' %self.name)

def rent_house(self):

print('%s 黑中介租房子啦,傻逼才租呢' %self.name)

b1=BlackMedium('万成置地','回龙观天露园')

#检测是否含有某属性

print(hasattr(b1,'name'))

print(hasattr(b1,'sell_house'))

#获取属性

n=getattr(b1,'name')

print(n)

func=getattr(b1,'rent_house')

func()

# getattr(b1,'aaaaaaaa') #报错

print(getattr(b1,'aaaaaaaa','不存在啊'))

#设置属性

setattr(b1,'sb',True)

setattr(b1,'show_name',lambda self:self.name+'sb')

print(b1.__dict__)

print(b1.show_name(b1))

#删除属性

delattr(b1,'addr')

delattr(b1,'show_name')

delattr(b1,'show_name111')#不存在,则报错

print(b1.__dict__)

4.4.7 *****hasattr()

通过字符串操作对象进行判断，先判断有没有值，再用getattra取值

class A:

role = 'Teacher'

def __init__(self,name,age):

self.name = name

self.age = age

a1 = A('wang',18)

print(hasattr(a1,'name'))

print(hasattr(a1,'alex'))

输出

C:\python3\python.exe D:/python/untitled2/lianxi/练习2.py

True

False

结合getatter用法

class A:

role = 'Teacher'

def __init__(self,name,age):

self.name = name

self.age = age

a1 = A('wang',18)

print(hasattr(a1,'name'))

print(hasattr(a1,'alex'))

print(getattr(a1,'name'))

4.5 其他方法

4.6 ****__new__

解释：创建对象的根源

源码解释：

def __new__(cls, *more): # known special case of object.__new__

""" Create and return a new object.  See help(type) for accurate signature. """

pass

案例分析

class A:

def __init__(self):

self.x = 1

print('in init function')

def __new__(cls, *args, **kwargs):

print('in new function')

return object.__new__(A, *args, **kwargs)

a = A()

print(a.x)

设计模式：单例模式（一个类只能实例化一个对象）

class A:

__instance = None

def __new__(cls, *args, **kwargs):

if cls.__instance is None:

obj = object.__new__(cls)

cls.__instance = obj

return cls.__instance

4.7 ***__call__

解释：对象加()自动执行__call__方法

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:

def __init__(self):

pass

def __call__(self, *args, **kwargs):

print('__call__')

obj = Foo() # 执行 __init__

obj()       # 执行 __call__

4.8 isinstance()

对象属不属于这个类是不是输入这个类的派生类

class A: pass

class B(A): pass

abj = B()

print(isinstance(abj,B)) #true

print(isinstance(abj,A)) #true

4.9 issubclass()

第一类是第二个类的后代就是true

class A: pass

class B(A): pass

abj = B()

print(issubclass(B,A)) #true

4.10 __len__

解释：len方法能不能用，归结于对象中有没有__len__方法

class A:

def __init__(self):

self.a = 1

self.b = 2

def __len__(self):

return len(self.__dict__)

a = A()

print(len(a)

4.11 __hash__

解释：能不能hash 看对象中有没有__hash__

class A:

def __init__(self):

self.a = 1

self.b = 2

def __hash__(self):

return hash(str(self.a)+str(self.b))

a = A()

print(hash(a))

4.12 __str__

类中如果有__str__方法，打印或者str() 即可执行str

class A:

def __init__(self):

pass

def __str__(self):

return '太白'

a = A()

print(a)

print('%s' % a)

4.13 __repr__

解释：如果一个类中定义了__repr__方法，那么在repr(对象) 时，默认输出该方法的返回

class A:

def __init__(self):

pass

def __repr__(self):

return 'lili'

a = A()

print(repr(a))

print('%r'%a)

4.14 __eq__

class A:

def __init__(self):

self.a = 1

self.b = 2

def __eq__(self,obj):

if  self.a == obj.a and self.b == obj.b:

return True

a = A()

b = A()

print(a == b)

4.15 __del__

析构方法：自动执行

析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class A:

def __init__(self):

self.a =1

self.b =2

def __del__(self):

print(222)

return 666

obj1 = A()

解释：

C:\python3\python.exe D:/python/untitled2/python_7/lession2.py

222

4.16 __item__

class Foo:

def __init__(self,name):

self.name=name

def __getitem__(self, item):

print(self.__dict__[item])

def __setitem__(self, key, value):

self.__dict__[key]=value

def __delitem__(self, key):

print('del obj[key]时,我执行')

self.__dict__.pop(key)

def __delattr__(self, item):

print('del obj.key时,我执行')

self.__dict__.pop(item)

f1=Foo('sb')

print(f1.__dict__)

f1['age']=18

print(f1.__dict__)

f1['age1']=19

print(f1.__dict__)

del f1.age1

print(f1.__dict__)

del f1['age']

print(f1.__dict__)

f1['name']='alex'

print(f1.__dict__)

输出

C:\python3\python.exe D:/python/untitled2/lianxi/练习2.py

{'name': 'sb'}

{'name': 'sb', 'age': 18}

{'name': 'sb', 'age': 18, 'age1': 19}

del obj.key时,我执行

{'name': 'sb', 'age': 18}

del obj[key]时,我执行

{'name': 'sb'}

{'name': 'alex'}