python基础（19）——类的函数 & 封装 & 多态 & 多继承 & 函数重写 & 迭代器

一、用于类的函数

issubclass(cls, class_or_tuple)

判断一个类是否继承自其它的类,如果此类cls是class或tuple中一个派生子类则返回True,否则返回False

示例:
     class A:
         pass
     class B(A):
         pass
     class C(B):
         pass
     issubclass(C, B) # True
     issubclass(B, A) # True
     issublcass(A, C) # False

二、封装 enclosure

封装是指隐藏类的实现细节,让使用者不关心这些细节
封装的目的是让使用者通过尽可能少的方法(或属性)操作对象

私有属性和方法
   python类中,以双下划线('__') 开头,不以双下划线结尾的标识符为私有成员,私有成员只能使用该类的方法来进行访问和修改
     1. 以__开头的属性为私有属性
     2. 以__开头的方法为私有方法

class A:
    def __init__(self):
        self.__p1 = 100  # <<--- __p1为私有属性
        # self.__p2__ = 200  # 这人不是私有属性

    def show_info(self):
        print(self.__p1)  #此对象的实例方法可以访问和修改私有属性
        self.__m()  # 调用私有方法

    def __m(self):
        print("A类对象的__m方法被调用")

a = A()
a.show_info()  # 100
# a.__m()  # 出错, 除A类的实例方法外,不能调用a对象的私有方法
# print(a.__p1)  # 不允许访问私有属性
# print(a.__p2__)

用私有属性和私有方法来实现封装.py

注:
python 的封装是假的封装(模拟的封装)

三、多态 polymorphic

字面意思：'多种状态'
多态：是指在有继承/派生关系的类中,调用基类对象的方法,实际能调用子类的覆盖方法的现象叫多态

状态:
静态(编译时状态)
动态(运行时状态)
说明:
1. 多态调用的方法与对象相关,不写类型相关
2. Python全部对象都只有"运行时状态(动态)", 没有"C++语言"里的编译时状态(静态)

 1 class Shape:
 2     def draw(self):
 3         print("Shape的draw()被调用")
 4 
 5 class Point(Shape):
 6     def draw(self):
 7         print('正在画一个点!')
 8 
 9 class Circle(Point):
10     def draw(self):
11         print('正在画一个圆!!!')
12 
13 def my_draw(s):
14     s.draw()  # <<<--- 此处显示出多态中的"动态"
15 
16 s1 = Circle()  # 创建一个圆对象
17 s2 = Point()  # 创建一个点对象
18 my_draw(s1)
19 my_draw(s2)

poly.py

四、多继承 multiple inheritance

1、多继承：是指一个子类继承自两个或两个以上的基类

2、语法:
class 类名(基类名, 基类名2, .....):
pass
3、说明:
一个子类同时继承自多个父类,父类中的方法可以同时被继承下来
如果两个父类中有同名的方法,而在子类中又没有覆盖此方法时,调用结果难以确定

 1 class Car:
 2     '''汽车类'''
 3     def run(self, speed):
 4         print("汽车以", speed, '公里/小时的速度行驶')
 5 
 6 class Plane:
 7     '''飞机类'''
 8     def fly(self, height):
 9         print("飞机以海拔", height, '米的高度飞行')
10 
11 class PlaneCar(Car, Plane):
12     '''PlaneCar类同时继承自汽车类和飞机类'''
13 
14 p = PlaneCar()  # 创建一个飞行汽车对象
15 p.fly(10000)
16 p.run(300)

此示例示意多继承的定义语法的基本用法.py

4、多继承的问题(缺陷)
标识符冲空问题
(要谨慎使用多继承)

 1 # 小张写了一个类A:
 2 class A:
 3     pass
 4     # def m(self):
 5     #     print("A.m() 被调用")
 6 
 7 # 小李写了一个类B:
 8 class B:
 9     def m(self):
10         print("B.m() 被调用")
11 
12 # 小王感觉小张和小李写的两个类自己都可以用
13 class AB(A, B):
14     pass
15     # def m(self):
16     #     print("AB.m() 被调用")
17 
18 ab = AB()
19 ab.m()  # 请问调用谁? 为什么?

multiple_inherit.py

5、多继承的 MRO(Method Resolution Order) 问题
python3的类的__mro__属性
作用: 用来记录类的方法查找顺序

 1 class A:
 2     def go(self):
 3         print("A")
 4 
 5 class B(A):
 6     def go(self):
 7         print("B")
 8         super().go()  # C
 9 
10 class C(A):
11     def go(self):
12         print("C")
13 
14 class D(B, C):
15     def go(self):
16         print("D")
17         super().go()  # 调用谁?
18 
19 d = D()
20 d.go()

mro.py

6、super() 函数就是根据__mro__来调用上层的方法

练习:
     写一个农民类Peasant 有方法:
         def farm(self, plant):
            ....
     写一个工人类Worker
       有方法如下:
         def work(self, that):
            ...
     创建一个农民工为MigrantWorker,让此类的对象拥有上面两个类的全部方法

    person = MigrantWorker()
     person.farm('水稻') # 正在种植水稻
     person.work('汽车') # 正在制造汽车

查看各个类的__mro__属性

7、面向对象编程语言的特征:
继承
封装
多态

五、函数重写 overwrite

1、什么是函数重写

在自定义的类内添加相应的方法,让自定义的类创建的实例能够使用内建函数进行操作

2、对象转字符串函数

repr(x)
返回一个能表示python对象的表达式字符串,通常 eval(repr(obj)) == obj
str(x) 通过给定的对象返回一个字符串(这个字符串通常供人阅读)

示例:
     s = "I'm a teacher"
     print(str(s)) # I'm a teacher
     print(repr(s)) # "I'm a teacher"

3、对象转字符串函数的重写方法:

   repr() 函数的重写方法:
       def __repr__(self):
           return 字符串

   str() 函数的重写方法:
       def __str__(self):
           return 字符串

str(obj) 函数调用方法说明:
1. str(obj) 函数先查找obj.__str__(方法), 调用此方法并返回结果
2. 如果 obj.__str__() 方法不存在.则调用obj.__repr__方法并返回结果
3. 如果 obj.__repr__方法不存在,则调用 object类的__repr__实例方法显示<__main__.XXXX object at 0xXXXXXXX> 格式的字符串

 1 class MyNumber:
 2     def __init__(self, val):
 3         self.data = val  # 在每个对象内部都创建一个实例变量来绑定数据
 4 
 5     def __str__(self):
 6         # print("__str__方法被调用")
 7         return "自定义数字: %d" % self.data
 8 
 9     def __repr__(self):
10         '''此方法返回来的字符串一定是能表示self对象的表达式字符串'''
11         return "MyNumber(%d)" % self.data
12 
13 n1 = MyNumber(100)
14 print('str(n1) =', str(n1))  # 自定的数字:100
15 print('repr(n1) =', repr(n1))  # MyNumber(100)
16 
17 n2 = MyNumber(200)
18 print(str(n2))
19 print(n2.__str__())
20 print(n2)  # 在print内部会将n2用str(x) 转为字符串再写到sys.stdout

对象转字符串函数的重写方法.py

4、内建函数重写

方法名函数名
def __abs__(self): abs(obj) 函数调用
def __len__(self): len(obj) 函数调用
def __reversed__(self): reversed(obj) 函数调用
def __round__(self): round(obj) 函数调用

len_overwrite.py

5、数值转换函数的重写:

   def __complex__(self):     complex(obj) 函数调用
   def __int__(self): int(obj)
   def __float__(self): float(obj)
   def __bool__(self): bool(obj)

 1 class MyNumber:
 2     def __init__(self, val):
 3         self.data = val
 4 
 5     def __repr__(self):
 6         return "MyNumber(%d)" % self.data
 7 
 8     def __int__(self):
 9         '''重写int(obj) 函数'''
10         return int(self.data)
11 
12     def __float__(self):
13         return float(self.data)
14 
15 
16 n1 = MyNumber(100)
17 n = int(n1)  # 出错
18 print(n)
19 
20 f = float(n1)
21 print(f)
22 
23 c = complex(n1)  # 当没有n1.__complex__() 时会调用n1.__float__() + 0j
24 print(c)

示意数值转换函数的重写.py

6、布尔测试函数的重写

   格式:
     def __bool__(self):
         ...
   作用:
用于bool(obj) 函数取值
用于if语句真值表达式中
用于while语句的真值表达式中
   说明:
1. 当自定义类内有__bool__(self) 方法时,此方法的返回作为bool(x)的返回值
2. 当不存在__bool__(self) 方法时,返回__len__(self) 方法的返回值是否为非零来测式布尔值
3. 当不存在__len__(self) 方法时,则直接返回True

 1 class MyList:
 2     def __init__(self, iterable=()):
 3         self.data = [x for x in iterable]
 4 
 5     def __repr__(self):
 6         return 'MyList(%s)' % self.data
 7 
 8     def __len__(self):
 9         print("__len__方法被调用")
10         return len(self.data)
11 
12     def __bool__(self):
13         print("__bool__方法被调用")
14         for x in self.data:
15             if x:
16                 return True
17         return False
18         # return any(self.data)
19 
20 myl = MyList([False, 0, 0.5])
21 print(bool(myl))
22 if myl:
23     print(myl, '的布尔值为True')
24 else:
25     print(myl, '的布尔值为False')

bool.py

7、对象的属性管理函数:

getattr(obj, name[,default]) 从一个对象用字符串name得到对象的属性,getattr(x, 'y')等同于x.y;当属性不存在时,如果给定default参数则返回default,如果没有给出default 则触发一个AttributeError错误

hasattr(obj, name) 用给定的name字符串返回obj是否有此属性,此种做法可以避免在getattr(obj, name) 时引发错误

setattr(obj, name, value), 给对象obj的名为name的属性设置相应的值value, setattr(x, 'y', v) 等同于 x.y = v

delattr(obj, name) 删除对象obj中的name属性 del(x, 'y') 等同于 del x.y

六、迭代器(高级)

1、什么是迭代器
由iter(x) 函数返回,可以通过next(it) 函数取值的对象就是迭代器

2、迭代器协议:
迭代器协议是指对象能够使用next()函数获取下一项数据,在没有下一项数据时触发一个StopIteration异常来终止迭代的约定

3、迭代器协议的实现方法:
     def __next__(self):
         ....
  注:此方法需要实现迭代器协议

4、什么是可迭代对象
是指能用iter(obj) 函数返回迭代器的对象(实例)
可迭代对象内部要定义__iter__(self) 方法来返回迭代器对象

 1 class MyList:
 2     def __init__(self, iterable=()):
 3         self.data = [x for x in iterable]
 4 
 5     def __repr__(self):
 6         return 'MyList(%s)' % self.data
 7 
 8     def __iter__(self):
 9         '''此方法用于返回一个能访问self对象的迭代器'''
10         print("__iter__被调用")
11         return MyListIterator(self.data)  # 创建迭代器并返回
12 
13 
14 class MyListIterator:
15     '''此类用来描述能够访问MyList类型的对象的迭代器'''
16     def __init__(self, lst):
17         self.data_lst = lst
18         self.cur_index = 0   # 迭代器访问的起始位置
19 
20     def __next__(self):
21         '''此方法用来实现迭代器协议'''
22         print('__next__方法被调用')
23         if self.cur_index >= len(self.data_lst):
24             raise StopIteration
25 
26         r = self.data_lst[self.cur_index]
27         self.cur_index += 1
28         return r
29 
30 
31 myl = MyList([2, 3, 5, 7])
32 it = iter(myl)  # 等同于调用 it = myl.__iter__()
33 print(next(it))  # 2
34 # print(next(it))  # 3
35 # print(next(it))  # 5
36 # print(next(it))  # 7
37 # print(next(it))  # StopIteration
38 
39 for x in myl:
40     print(x)
41 
42 L = [x**2 for x in myl]
43 print(L)

将自定义的类MyList创建的对象制作成为可迭代对象 myiterator.py

练习:

1. 实现原学生信息管理系统的Student类的封装,让除Student实例方法外的函数或其它方法都不能访问姓名,年龄,成绩等属性

2. 写一个实现迭代器协议的类,让此类可以生成从b 开始的n个素数
     class Prime:
         def __init__(self, b, n):
             ...
         def __iter__(self):
            ....

L = [x for x in Prime(10, 4)]
print(L) # L = [11, 13, 17, 19]

 1 #方法一：两个类
 2 class Prime:
 3     def __init__(self, b, n):
 4         self.begin = b
 5         self.count = n
 6 
 7     def __iter__(self):
 8         return PrimeIterator(self.begin, self.count)
 9 
10 class PrimeIterator:
11     def __init__(self, b, n):
12         self.begin = b  # 开始时起始数字
13         self.count = n  # 需要创建的数据的个数
14         self.cur_count = 0  # 表示已经生成了的素数的个数
15 
16     def __isprime(self, x):
17         '''用来判断x是否是素数'''
18         if x < 2:
19             return False
20         for i in range(2, x):
21             if x % i == 0:
22                 return False
23         return True
24 
25     def __next__(self):
26         # 判断已提供数据的数据个数,和要提供的数据个数来决定是否终止
27         if self.cur_count >= self.count:
28             raise StopIteration
29         while True:
30             if self.__isprime(self.begin):
31                 # 得到下一个素数
32                 r = self.begin
33                 # 然后把self.begin 加1
34                 self.begin += 1
35                 # 已生成个数要加1
36                 self.cur_count += 1
37                 # 返回当前的素数
38                 return r
39             self.begin += 1  # 准备判断下一个数是否为素数
40 
41 # L = []
42 # it = iter(Prime(10, 4))
43 # while True:
44 #     try:
45 #         x = next(it)
46 #         L.append(x)
47 #     except StopIteration:
48 #         break
49 # print(L)
50 
51 L = [x for x in Prime(10, 4)]
52 print(L)  # L = [11, 13, 17, 19]

方法一：两个类

 1 #方法二：示意让Prime创建的对象即是可迭代对象,也是迭代器
 2 class Prime:
 3     def __init__(self, b, n):
 4         self.begin = b  # 开始时起始数字
 5         self.count = n  # 需要创建的数据的个数
 6 
 7     def __iter__(self):
 8         self.cur_count = 0  # 表示已经生成了的素数的个数
 9         return self
10 
11     def __isprime(self, x):
12         '''用来判断x是否是素数'''
13         if x < 2:
14             return False
15         for i in range(2, x):
16             if x % i == 0:
17                 return False
18         return True
19 
20     def __next__(self):
21         # 判断已提供数据的数据个数,和要提供的数据个数来决定是否终止
22         if self.cur_count >= self.count:
23             raise StopIteration
24         while True:
25             if self.__isprime(self.begin):
26                 # 得到下一个素数
27                 r = self.begin
28                 # 然后把self.begin 加1
29                 self.begin += 1
30                 # 已生成个数要加1
31                 self.cur_count += 1
32                 # 返回当前的素数
33                 return r
34             self.begin += 1  # 准备判断下一个数是否为素数
35 
36 # L = []
37 # it = iter(Prime(10, 4))
38 # while True:
39 #     try:
40 #         x = next(it)
41 #         L.append(x)
42 #     except StopIteration:
43 #         break
44 # print(L)
45 
46 L = [x for x in Prime(10, 4)]
47 print(L)  # L = [11, 13, 17, 19]

方法二：示意让Prime创建的对象即是可迭代对象,也是迭代器

3. 写一个类Fibonacci实现迭代器协议,此类的对象可以作为可迭代对象生成斐波那契数列
          1 1 2 3 5 8 13 ....
     class Fibonacci:
         def __init__(self, n):
             ...
         ...
     for x in Fibonacci(10):
         print(x) # 打印 1 1 2 3 5 8 ...

posted on 2018-10-12 17:40 破天荒的谎言、谈敷衍阅读(355) 评论(0) 收藏举报

刷新页面返回顶部