python笔记4 内置函数,匿名函数.递归函数 面向对象(基础, 组合,继承)

内置函数

eval和exec

eval :执行字符串中的代码并将结果返回给执行者,有返回值

exec:执行字符串中的代码,往往用于执行流程语句,没有返回值.

s1 = '1+2'
s2 = 'print(666)'
print(eval(s1))
eval(s2)
print(exec(s1))
exec(s2)

3
666
None
666

compile()  python是编译型语言, compile可以预加载(编译)一些代码.只能部分提升代码的运行效率

compile(代码,文件,执行模式)   给文件不给代码,给代码不给文件

code = 'for i in range(10): print(i)'
c1 = compile(code,'',mode='exec')
exec(c1)

dir()    查看对象的内置属性, ⽅方法. 访问的是对象中的__dir__()⽅方法

print ()

print(self, *args, sep=' ', end='\n', file=None)  #*args接收参数, sep设置连接符  end是以什么结尾   file写入文件基本不用

print(1, 2, 3, sep = "$", end = "," )
print(4, 5)

1$2$3,4 5

id()　　 用于获取内存地址

l1 = ""
print(id(l1))

3077824753992

help() 　　查询对象的所有用法

print(help(str))   #查看str的所有用法

callable()　　判断一个变量是否可调用,即加括号可执行

a1 = "adad"
def aa():
    print(666)
print(callable(a1))   #a1变量名为字符串不可调用
print(callable(aa))　　#aa变量名为函数,加括号可调用

False
True

range()　　一个可控制范围的数字列表

for i in range(1,3):
    print(i)

1
2

next() 等于__next__ 迭代器返回下一个项目

l1 = [1, 2, 3]
l2 = iter(l1)   #将列表转为迭代器
print(next(l2))
print(next(l2))
print(next(l2))

1
2
3

进制转换 bin,oct,hex

print(bin(255))   #bin十进制转2进制　　
print(oct(255))　　#oct十进制转8进制
print(hex(255))　　#hex十进制转16进制

0b11111111
0o377
0xff

divmod()计算除数与被除数的结果,返回一个包含商和余数的元组.

print(divmod(5,3))    #得出一个元组,商1余2
(1, 2)

sum()对可迭代对象进行求和计算(可设置初始值)

print(sum([i for i in range(10)]))   #求和一个可迭代对象
45
print(sum([i for i in range(10)], 100))     #迭代对象为初始值 继续相加
145

min()      返回一个可迭代对象的最小值,可加key,key为函数名,通过函数的规则返回最小值

print(min([i for i in range(1,10)]))
1

l1 = [('wk', 2), ('ww', 1), ('kk', 3)]   #定义一个列表
def aa(x):                               #第一一个函数
    return x[1]
print(min(l1, key=aa))    #key 将l1的每个元素传入到aa()函数中,x[1]就是l1列表中每个元素的第二个元素.然后根据第二个元素的值比大小

('ww', 1)

max()       返回一个可迭代对象的最大值,可加key,key为函数名,通过函数的规则返回最大值

print(min([i for i in range(1,10)]))
10

l1 = [('wk', 2), ('ww', 1), ('kk', 3)]              #和min相反
def aa(x):
    return x[1]
print(max(l1, key=aa))

('kk', 3)

list(),将一个可迭代对象转化为列表(如果是字典,默认将key作为列表的元素)

tup = (1, '', 3, '', 5, '')
print(list(tup))
[1, '', 3, '', 5, '']

tuple(),将一个可迭代对象转化为元组(如果是字典,默认将key作为元组的元素)

lis = [1, 2, 3, 4, 5]
print(tuple(lis))
(1, 2, 3, 4, 5)

reversed 返回一个新的翻转的迭代器,不改变原列表

l1 = [1, 2, 3, 4]
l1.reverse()         #用.reverse()翻转并改变原列表
print(l1)
l2 = reversed(l1)    #用reverse()翻转不改变原列表,而是新生成一个迭代器
print(l2)
print(list(l2))      #将迭代器转为列表

[4, 3, 2, 1]
<list_reverseiterator object at 0x00000131C586B208>
[1, 2, 3, 4]

str()将数据转化为字符串

aa = 1
print(type(str(aa)))
<class 'str'>

format()  与具体数据相关,用于计算各种小数,精算等.

print(format('wk', '<20'))
print(format('wk', '>20'))
print(format('wk', '^20'))     #字符串 <左对齐 ^居中 >右对齐 并设置字符串长度
wk
                  wk
         wk         

用于保留小数多少位

import time

print(format(1.32432432, '.2f'))
c = time.time()
print(c)
print(format(c, '.2f'))  

1.32
1547973835.8158286
1547973835.82

bytes() 用于不同编码之间的转化

s1 = '钰磐龙'
b1 = s1.encode('utf-8')     #unicode 转 utf-8 bytes
print(b1)
b2 = b1.decode('utf-8')
print(b2)

b'\xe9\x92\xb0\xe7\xa3\x90\xe9\xbe\x99'
钰磐龙

s1 = '钰磐龙'
b3 = bytes(s1,encoding='utf-8')
print(b3)

repr() 返回一个对象的string形式(原形毕露)

s1 = 'wk'
s2 = '[1, 2, 3]'
print(s1)
print(s2)
print(repr(s1))        #原形毕露,带引号的str 显示引号
print(repr(s2))

wk
[1, 2, 3]
'wk'
'[1, 2, 3]'

s3 = '我叫%s, 我是%r' %('wk', '运维')   #占位符%r也是原形毕露(带引号)
print(s3) 

我叫wk, 我是'运维'

sorted()排序,可以加key为所欲为的排序

l1 = [1, 4, 2, 3]
print(sorted(l1))
l2 = [('wk', 2), ('ww', 1), ('kk', 3)]
def aa(x):                      #和min的用法基本相同
    return x[1]
print(sorted(l2, key=aa))

[1, 2, 3, 4]
[('ww', 1), ('wk', 2), ('kk', 3)]

ls = ['asd','fdsfasdw','adasdasda','adsa']
def xx(c):
    return len(c)   #按字符长度排序
print(sorted(ls, key=xx ))
print(sorted(ls, key=xx,reverse=True))   #,reverse=True 倒序

['asd', 'adsa', 'fdsfasdw', 'adasdasda']
['adasdasda', 'fdsfasdw', 'adsa', 'asd']

enumerate()  枚举,返回一个枚举对象(在前边加上序号)

l1 = ['wk%s' % i for i in range(10)]
for i,x in enumerate(l1):         #enumerate(l1) 得到的是一个序号加列表值的元组(0, wk0)  i接收序号 x接收列表的值
    print(i,x)  

0 wk0
1 wk1
2 wk2
3 wk3
4 wk4
5 wk5
6 wk6
7 wk7
8 wk8
9 wk9

可自定义开始序号

l1 = ['wk%s' % i for i in range()]
for i,x in enumerate(l1,):      #从10 开始
    print(i,x)

 wk0
 wk1
 wk2
 wk3
 wk4
 wk5
 wk6
 wk7
 wk8
 wk9

all()和any

all() 可迭代对象中,全部是True才是True

any() 可迭代对象中,只要有一个是True就是True

l1 = [0, 1, 2, 3]
l2 = [1, 2, 3, 4]
print(all(l1))
print(all(l2))
print(any(l1))
print(any(l2))

False
True
True
True

zip() 拉链,将可迭代对象的对应位置拉到同一元组,取最小参数个数的数量拉

l1 = [,, ]
l2 = [, ,, ]
l3 = ['wk', 'kk', 'ww', 'xx', 'o']
print(zip(l1, l2, l3))           #zip()生成一个迭代器,不改变原列表
l4 = zip(l1, l2, l3)
for i in l4:                     #打印迭代器,zip将3个列表对应列的元素拉到同一个元组里,拉的元祖个数取决于最小元素的列表
    print(i)

<zip object at 0x000002BA7F2A7588>               #生成一个迭代器
(0, 4, 'wk')                 #第一列拉到一起
(1, 2, 'kk')                 #第二列拉到一起
(2, 7, 'ww')                 #第三列拉到一起,由于l1只有3个元素,所以只拉3列

filter()  类似列表推导式的筛选模式 返回的是迭代器,对已存在的列表进行筛选

l1 = [1, 2, 3, 4]
def aa(x):                     #x赋值l1列表的元素
    return x % 2 == 0          #筛选条件x除以2 结果为0的返回(偶数返回)
print(filter(aa, l1))     　　 #将列表l1的值传入aa函数,  函数在前列表在后
print(list(filter(aa, l1)))

<filter object at 0x0000023313F49828>
[2, 4]

map()返回一个迭代器 类比成列表推导式的循环模式

l1 = [1, 2, 3, 4]
def aa(x):
    return x ** 2
print(map(aa, l1))　　　　#将列表作用到一个函数中,形成一个迭代器
print(list(map(aa, l1)))        

<map object at 0x000001FEC7C09828> 
[1, 4, 9, 16]

ord(根据汉字找位置)  与 (chr根据位置找汉字 )

print(ord('王'))
print(chr())

王

匿名函数

匿名函数:一句话函数,一行代码实现的函数,只有参数和返回值

lambda 匿名海曙关键字,相当于函数的def.

变量名 = lambda  参数: 返回值

fun = lambda x,y : x + y
print(fun(1, 2))

3

匿名函数与内置函数相结合

l1 = [1, 2, 3, 4]
print(list(map(lambda x : x **2, l1)))    #map用法直接一行搞定

[1, 4, 9, 16]

dic = {'k1': 10, 'k2': 100, 'k3': 30}       #按值排序,返回键
print(max(dic, key= lambda x: dic[x]))    #将key赋值x代入函数, 返回值为dic[x]即根据key取值,并判断哪个值最大.
print(dic[max(dic, key= lambda x: dic[x])])

k2
100

递归函数

自己调用自己, 无限循环只能循环999次

import sys
sys.setrecursionlimit(10000)       #递归函数允许开启10000
def func(x):
    print(x)
    x+=1
    func(x)
func(1)

慎用 在某些条件下特别好使

#用递归写一个 1-100相加的函数
def aa(x):
    if x == 1:   #当x为1时返回1
        return 1
    elif x > 1:     #当x>1时 递归执行aa函数   带判断一定要return返回函数,要不然是在下的函数与最初函数不同级会报错
        return aa(x-1) + x   #执行为aa(100-1)+100→aa(99-1)+99+100→aa(98-1)+98+99+100.......到x=1停止100+99+98..+1
print(aa(100))                 

5050

用递归做斐波那契数列(第2第三个数为前两的和)

1  1   2   3   5   8   13

1   2  3   4   5   6    7

def xx(x):
     if x == 1 or x == 2:   #当x=1和x=2时结果都为1
         return 1
     elif x > 1:
         return xx(x-2) + xx(x-1)    #到第三个数时 结果为前两个数相加 即第三个数xx(x) = xx(x-2) + xx(x-1)
print(xx(7))

13

面型对象

相同功能的函数进行归类

面向对象的特点:它是将某些相关的功能(函数)封装到了一起.

类:具有相同属性和技能的一类事物

对象:类的具体表现.

创建一个类

class gailun:  　　　　　　　　　　#类名
    yingxiong = '德玛西亚'          #变量
    jineng = '审判'
    yuyan = '德玛西亚万岁'

    def hehe(self):　　　　　　　　　　#方法
        print('大宝剑')

    def xixi(self):
        print('勇往直前')

结构分析:类一般分为两部分:变量,方法

思想分析:创建一个类 公共模板,通过创建个体对象,可以调用公共方法

类的静态属性(变量)

方法一:

类名调用静态属性

print(gailun.__dict__)  　　#类名.__dict__以字典的形式显示类  只能查询 不能增删改, 类中所有的静态属性,动态方法.
{'__module__': '__main__', 'yingxiong': '德玛西亚', 'jineng': '审判', 'yuyan': '德玛西亚万岁', 'hehe': <function gailun.hehe at 0x0000025917C23950>, 'xixi': <function gailun.xixi at 0x0000025917C239D8>, '__dict__': <attribute '__dict__' of 'gailun' objects>, '__weakref__': <attribute '__weakref__' of 'gailun' objects>, '__doc__': None}

print(gailun.__dict__['yuyan'])
德玛西亚万岁

方法二:

万能的点.

print(gailun.yuyan)　　　　#用.查看一个变量
德玛西亚万岁

gailun.yuyan = '狡诈恶徒'   #用.修改一个变量
print(gailun.__dict__)
{'__module__': '__main__', 'yingxiong': '德玛西亚', 'jineng': '审判', 'yuyan': '狡诈恶徒', 'hehe': <function gailun.hehe at 0x0000020AA7153950>, 'xixi': <function gailun.xixi at 0x0000020AA71539D8>, '__dict__': <attribute '__dict__' of 'gailun' objects>, '__weakref__': <attribute '__weakref__' of 'gailun' objects>, '__doc__': None}

gailun.guojia = '德邦'     #用.增加一个变量
print(gailun.__dict__)
{'__module__': '__main__', 'yingxiong': '德玛西亚', 'jineng': '审判', 'yuyan': '德玛西亚万岁', 'hehe': <function gailun.hehe at 0x0000022B30C53950>, 'xixi': <function gailun.xixi at 0x0000022B30C539D8>, '__dict__': <attribute '__dict__' of 'gailun' objects>, '__weakref__': <attribute '__weakref__' of 'gailun' objects>, '__doc__': None, 'guojia': '德邦'}

del gailun.jineng　　　　　　#用.删除一个变量

类的动态属性

一般只使用类名调用类的静态属性(变量),不建议使用类名调用动态 方法(函数),

对象实例化:    类名()就是实例化对象的一个过程.

class Game:
    area = '德玛西亚'

    def aaa(self):
        print(666)
    def bbb(self):
        print(777)
p1 = Game()　　　　　　#实例化对象
print(p1)
得到一个内存地址

特殊的__init__方法,对象实例化自动执行__init__方法

class Game:
    area = '德玛西亚'

    def __init__(self):
        print(666)

Game()

666

class Game:
    area = '德玛西亚'

    def __init__(self, name, sex, ad, hp):
        self.name = name      #self相当于Game(对象名),self.name相当于定义一个变量
        self.sex = sex
        self.ad = ad
        self.hp = hp
p1 = (Game('exe', 'girl', 30, 450))
print(p1.name)

实例化对象的过程:

1.实例化对象在内存中产生一个对象的空间(内存地址).

2.自动执行__init__方法并且将对象空间传给了self参数.

3.在__init__方法中,给对象空间封装一些静态属性

class Game:
    area = '德玛西亚'
    def __init__(self, name, sex, ad, hp):
        self.name = name
        self.sex = sex
        self.ad = ad
        self.hp = hp
    def xixi(self):
        print(321)
p1 = (Game('exe', 'girl', 30, 450))
print(p1.name)
Game('exe', 'girl', 30, 450).xixi()
p1.xixi()　　　　　　　　　　#类中的动态方法通过对象去的调用

exe
321
321

工作中;   类的静态属性一般通过类名去调用或者改变,类中的动态方法一般通过对象去调用和执行

self ;类中的方法的第一个参数要设定为self,在调用对象时,会自动将对象空间传给self

对象查看自己的空间属性.

全部查看:__dict__

class Game:
    area = '德玛西亚'

    def __init__(self, name, sex, ad, hp):
        self.name = name
        self.sex = sex
        self.ad = ad
        self.hp = hp

    def xixi(self):
        print(321)

p1 = (Game('exe', 'girl', 30, 450))
print(p1.__dict__)   　　 #查看全部的

{'name': 'exe', 'sex': 'girl', 'ad': 30, 'hp': 450}

查看单个的  万能的.(增删改查都可以,而且是改变原先的参数的变化)

class Game:
    area = '德玛西亚'

    def __init__(self, name, sex, ad, hp):
        self.name = name
        self.sex = sex
        self.ad = ad
        self.hp = hp

    def xixi(self):
        print(321)

p1 = (Game('exe', 'girl', 30, 450))
# print(p1.__dict__)
print(p1.name)　　　　　　#查看单个的
exe

class Game:
    area = '德玛西亚'

    def __init__(self, name, sex, ad, hp):
        self.name = name
        self.sex = sex
        self.ad = ad
        self.hp = hp

    def xixi(self):
        print(321)

p1 = (Game('exe', 'girl', 30, 450))
# print(p1.__dict__)
p1.name = 'xxxx'   #改
del p1.ad  　　　　 #删
p1.wk = 'kk'　　　　#增
print(p1.__dict__)

{'name': 'xxxx', 'sex': 'girl', 'hp': 450, 'wk': 'kk'}

组合

对象与对象之间不能互相访问,彼此独立

对象可以访问类中的所有属性,类不能访问对象的属性 (因此两个对象需要交互要把另一个对象当参数传入)

组合的作用: 让一个类的对象与另一个类的对象发生关系

class Game:
    area = '德玛西亚'

    def __init__(self, name, sex, ad, hp):
        self.name = name
        self.sex = sex
        self.ad = ad
        self.hp = hp

    def xixi(self,xxx):
        xxx.hp = xxx.hp - self.ad              #对象2的血量 = 对象2的初始血量 - 对象1的伤害
        print('%s打了%s一下,%s掉了%s血还剩%s血'% (self.name, xxx.name, xxx.name, self.ad, xxx.hp))

p1 = Game('exe','girl',50,150)
p2 = Game('dt','man',50,300)
p2.xixi(p1)     　　　　　　#p2传给了self,p1传给了xxx

dt打了exe一下,exe掉了50血还剩100血   

组合,给英雄加上武器

class Game:　　　　　　　　　　　　　　　　　　　　　　　　#类 定义人物属性
    area = '德玛西亚'

    def __init__(self, name, sex, ad, hp):
        self.name = name
        self.sex = sex
        self.ad = ad
        self.hp = hp
class wuqi:　　　　　　　　　　　　　　　　　　　　　　　　#类 定义武器类型和属性
    def __init__(self,wuq,shangh):
        self.wuq = wuq
        self.shangh = shangh
    def dadou(self,s1,s2):
        s2.hp = s2.hp - s1.ad - self.shangh       #对象2的血量 = 对象2的血量 - 对象1的伤害 - 对象1的武器伤害
        print('%s 用 %s 打了 %s 一下, %s 剩余血量 %s' %(s1.name, self.wuq, s2.name, s2.name, s2.hp))

p1 = Game('exe','girl',50,150)　　　　　　　　#定义对象 p1
p2 = Game('dt','man',50,300)　　　　　　　　  #定义对象 p2
s3 = wuqi('鞭子',40)　　　　　　　　　　　　　　 #定义武器对象和打斗过程
s3.dadou(p1,p2)　　　　　　　　　　　　　　　　　#通过武器和打斗类完成打斗过程(等于将三个对象传入到一个类的函数里完成交互)

　exe 用 鞭子 打了 dt 一下, dt 剩余血量 210

上边的过程是武器为起者,需要优化为人物为发起者

执行过程:

定义人物类和武器类,

人物类里定义了人物属性 以及 将武器属性定义到人物里的函数

武器类里定义了武器属性以及打斗过程

调用武器对象的打斗函数为:  武器对象1.武器类的dadou函数(人物对象1,人物对象2)

执行过程为:定义人物对象1和人物对象2,定义武器对象1 通过人物类的函数lldx,将人物对象1.sc这个变量 = 武器对象1

最后    人物对象1.sz.武器类的dadou函数(人物对象1,人物对象2)  =  武器对象1.武器类的dadou函数(人物对象1,人物对象2)

class Game:
    area = '德玛西亚'

    def __init__(self, name, sex, ad, hp):
        self.name = name
        self.sex = sex
        self.ad = ad
        self.hp = hp  def lldx(self,ss):         　　　　　　#优化  将s3当做参数传入到类的函数中,使p1.sc = s3
        self.sc = ss
class wuqi:
    def __init__(self,wuq,shangh):
        self.wuq = wuq
        self.shangh = shangh
    def dadou(self,s1,s2):
        s2.hp = s2.hp - s1.ad - self.shangh
        print('%s 用 %s 打了 %s 一下, %s 剩余血量 %s' %(s1.name, self.wuq, s2.name, s2.name, s2.hp))

p1 = Game('exe','girl',50,150)
p2 = Game('dt','man',50,300)
s3 = wuqi('鞭子',40)
p1.lldx(s3)　　　　　　　　　　　　#调用人物类的lldx函数,将s3作为参数传入给ss,使 p1.sc = s3
p1.sc.dadou(p1,p2)　　　　　　　　#之前调用为s3.dadou(p1,p2),现在p1.sc = s3,所以 p1.sc.dadou(p1,p2) = s3.dadou(p1.p2)

exe 用 鞭子 打了 dt 一下, dt 剩余血量 210

继承

三个类;人狗猫,都有共同的属性年龄,性别,重量,这样代码重性太大,

class ren:
    def __init__(self, nianling, xingbie, zhongliang):
        self.nianling = nianling
        self.xingbie = xingbie
        self.zhongliang = zhongliang
class gou:
    def __init__(self, nianling, xingbie, zhongliang):
        self.nianling = nianling
        self.xingbie = xingbie
        self.zhongliang = zhongliang
class mao:
    def __init__(self, nianling, xingbie, zhongliang):
        self.nianling = nianling
        self.xingbie = xingbie
        self.zhongliang = zhongliang

定义一个属性类,通过继承让人狗猫三个类继承属性类的属性

继承方法:

class shuxing:　　　　　　　　　　　　　　　　#定义一个属性的类　　　　　　　　　　
    def __init__(self, nianling, xingbie, zhongliang):
        self.nianling = nianling
        self.xingbie = xingbie
        self.zhongliang = zhongliang
class ren(shuxing):　　　　　　　　　　　　#继承ren(shuxing)使人继承了属性的类
    pass
class gou(shuxing):
    pass
class mao(shuxing):
    pass
p1 = ren(25,'男',68)　　　　　　　　#定义对象p1 = ren类 传入参数,
print(p1.nianling)　　　　　　　　　#人继承了属性的类

25

上述继承:

　　shuxing类   为父类,基类

　　ren gou mao类   为子类,派生类,子类可以调用父类的类名,变量及方法

继承的好处: 节省代码,提高效率,让类之间产生关系

继承分为: 单继承和多继承

类分为: 经典类和新式类

经典类;  不继承object的类   python2经典类和新式类共存,

新式类:  继承object的类   python3中全部都是新式类,

单继承  上边的继承就是单继承

人有自己独特的属性身高,在继承公共属性后还需要将自己独特的身高属性传入到类里

方法一:

class shuxing:　　　　　　　　　　　　　　　　　　　　
    def __init__(self, nianling, xingbie, zhongliang):
        self.nianling = nianling
        self.xingbie = xingbie
        self.zhongliang = zhongliang　　
class ren(shuxing):　　　　　　　　　　　　　　#ren的类里还是继承shuxing类
    def __init__(self,a,b,c,shengao):　　　#定义一个ren类的__init__方法,并接受所有传入的参数.
        shuxing.__init__(self,a,b,c)　　　 #调用shuxing类里的__init__函数,并将init所接收的所有参数传入进去,self,a,b,c = self,nianling,xingbie,zhongliang
        self.shengao = shengao　　　　　　　 #接收最后一个参数shengao
    pass
class gou(shuxing):
    pass
class mao(shuxing):
    pass
p1 = ren(25,'男',68,185)　　　　　　　　#定义一个ren类的对象p1  并传入所有参数
print(p1.shengao)　　　　　　　　　　　　#查看对象p1 的身高属性

185

方法二:

class shuxing:
    def __init__(self, nianling, xingbie, zhongliang):
        self.nianling = nianling
        self.xingbie = xingbie
        self.zhongliang = zhongliang
class ren(shuxing):
    def __init__(self,a,b,c,shengao):
        super().__init__(a,b,c)      #python里的方法  super().__init__(a,b,c) = shuxing.__init__(self,a,b,c)
        self.shengao = shengao
    pass
class gou(shuxing):
    pass
class mao(shuxing):
    pass
p1 = ren(25,'男',68,185)
print(p1.shengao)        

在调用子类函数的同时调用父类函数

class shuxing:
    def __init__(self, nianling, xingbie, zhongliang):
        self.nianling = nianling
        self.xingbie = xingbie
        self.zhongliang = zhongliang
    def aa(self):　　　　　　　#父类函数aa 打印123　　　　　　　　　　　　　　　
        print(123)
class ren(shuxing):
    def __init__(self,a,b,c,shengao):
        super().__init__(a, b, c)
        self.shengao = shengao
    def aa(self):　　　　　　#子类函数
        super().aa()　　　　#super().父类函数 可以在执行子类函数时调用父类函数
        print(456)
p1 = ren(25,'男',68,185)
p1.aa()

123
456

多继承

class A:
    pass
class B(A):
    pass
class C():
    pass
class D(C):
    pass
class E():
    pass
class F(E,D,B):
    pass
print(F.mro())　　　　　　　　#类名.mro()查看多继承的类的继承顺序

[<class '__main__.F'>, <class '__main__.E'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]