内置函数
eval和exec
eval :执行字符串中的代码并将结果返回给执行者,有返回值
exec:执行字符串中的代码,往往用于执行流程语句,没有返回值.
s1 = '1+2's2 = 'print(666)'print(eval(s1))eval(s2)print(exec(s1))exec(s2)3666None666
compile() python是编译型语言, compile可以预加载(编译)一些代码.只能部分提升代码的运行效率
compile(代码,文件,执行模式) 给文件不给代码,给代码不给文件
code = 'for i in range(10): print(i)'c1 = compile(code,'',mode='exec')exec(c1)0123456789
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 = "123"print(id(l1))3077824753992
help() 查询对象的所有用法
print(help(str)) #查看str的所有用法
callable()判断一个变量是否可调用,即加括号可执行
a1 = "adad"def aa():print(666)print(callable(a1)) #a1变量名为字符串不可调用print(callable(aa))#aa变量名为函数,加括号可调用FalseTrue
range()一个可控制范围的数字列表
for i in range(1,3):print(i)12
next() 等于__next__ 迭代器返回下一个项目
l1 = [1, 2, 3]l2 = iter(l1) #将列表转为迭代器print(next(l2))print(next(l2))print(next(l2))123
进制转换 bin,oct,hex
print(bin(255)) #bin十进制转2进制print(oct(255))#oct十进制转8进制print(hex(255))#hex十进制转16进制0b111111110o3770xff
divmod()计算除数与被除数的结果,返回一个包含商和余数的元组.
print(divmod(5,3)) #得出一个元组,商1余2(1, 2)
sum()对可迭代对象进行求和计算(可设置初始值)
print(sum([i for i in range(10)])) #求和一个可迭代对象45print(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, '2', 3, '4', 5, '6')print(list(tup))[1, '2', 3, '4', 5, '6']
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 = 1print(type(str(aa)))<class 'str'>
format() 与具体数据相关,用于计算各种小数,精算等.
print(format('wk', '<20'))print(format('wk', '>20'))print(format('wk', '^20'))#字符串 <左对齐 ^居中 >右对齐 并设置字符串长度wk wkwk
用于保留小数多少位
import timeprint(format(1.32432432, '.2f')) c = time.time()print(c)print(format(c, '.2f')) 1.321547973835.81582861547973835.82
bytes() 用于不同编码之间的转化
s1 = '钰磐龙'b1 = s1.encode('utf-8')#unicode 转 utf-8 bytesprint(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 wk01 wk12 wk23 wk34 wk45 wk56 wk67 wk78 wk89 wk9
可自定义开始序号
l1 = ['wk%s' % i for i in range(10)]for i,x in enumerate(l1,10):#从10 开始 print(i,x)10 wk011 wk112 wk213 wk314 wk415 wk516 wk617 wk718 wk819 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))FalseTrueTrueTrue
zip() 拉链,将可迭代对象的对应位置拉到同一元组,取最小参数个数的数量拉
l1 = [0, 1, 2]l2 = [4, 2, 7, 6]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 ** 2print(map(aa, l1))#将列表作用到一个函数中,形成一个迭代器
print(list(map(aa, l1)))
<map object at 0x000001FEC7C09828>
[1, 4, 9, 16]
ord(根据汉字找位置) 与 (chr根据位置找汉字 )
print(ord('王'))print(chr(29579))29579王
匿名函数
匿名函数:一句话函数,一行代码实现的函数,只有参数和返回值
lambda 匿名海曙关键字,相当于函数的def.
变量名 =lambda 参数: 返回值
fun = lambda x,y : x + yprint(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) #递归函数允许开启10000def func(x):print(x)x+=1func(x)func(1)
慎用 在某些条件下特别好使
#用递归写一个 1-100相加的函数def aa(x): if x == 1: #当x为1时返回1 return 1elif 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..+1print(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 1elif 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 = sexself.ad = adself.hp = hpp1 = (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 = nameself.sex = sexself.ad = adself.hp = hpdef xixi(self):print(321)p1 = (Game('exe', 'girl', 30, 450))print(p1.name)Game('exe', 'girl', 30, 450).xixi()p1.xixi()#类中的动态方法通过对象去的调用exe321321
工作中; 类的静态属性一般通过类名去调用或者改变,类中的动态方法一般通过对象去调用和执行
self ;类中的方法的第一个参数要设定为self,在调用对象时,会自动将对象空间传给self
对象查看自己的空间属性.
全部查看:__dict__
class Game:area = '德玛西亚'def __init__(self, name, sex, ad, hp):self.name = nameself.sex = sexself.ad = adself.hp = hpdef 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 = nameself.sex = sexself.ad = adself.hp = hpdef 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 = nameself.sex = sexself.ad = adself.hp = hpdef 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 = nameself.sex = sexself.ad = adself.hp = hpdef 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 = nameself.sex = sexself.ad = adself.hp = hpclass wuqi:#类 定义武器类型和属性def __init__(self,wuq,shangh):self.wuq = wuqself.shangh = shanghdef 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)#定义对象 p1p2 = Game('dt','man',50,300) #定义对象 p2s3 = 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 = nameself.sex = sexself.ad = adself.hp = hp def lldx(self,ss): #优化 将s3当做参数传入到类的函数中,使p1.sc = s3self.sc = ssclass wuqi:def __init__(self,wuq,shangh):self.wuq = wuqself.shangh = shanghdef dadou(self,s1,s2):s2.hp = s2.hp - s1.ad - self.shanghprint('%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 = s3p1.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 = nianlingself.xingbie = xingbieself.zhongliang = zhongliangclass gou:def __init__(self, nianling, xingbie, zhongliang):self.nianling = nianlingself.xingbie = xingbieself.zhongliang = zhongliangclass mao:def __init__(self, nianling, xingbie, zhongliang):self.nianling = nianlingself.xingbie = xingbieself.zhongliang = zhongliang
定义一个属性类,通过继承让人狗猫三个类继承属性类的属性
继承方法:
class shuxing:#定义一个属性的类def __init__(self, nianling, xingbie, zhongliang):self.nianling = nianlingself.xingbie = xingbieself.zhongliang = zhongliangclass ren(shuxing):#继承ren(shuxing)使人继承了属性的类passclass gou(shuxing):passclass 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 = nianlingself.xingbie = xingbieself.zhongliang = zhongliangclass 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,zhongliangself.shengao = shengao #接收最后一个参数shengao passclass gou(shuxing):passclass mao(shuxing):passp1 = ren(25,'男',68,185)#定义一个ren类的对象p1 并传入所有参数print(p1.shengao)#查看对象p1 的身高属性185
方法二:
class shuxing:def __init__(self, nianling, xingbie, zhongliang):self.nianling = nianlingself.xingbie = xingbieself.zhongliang = zhongliangclass 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 = shengaopassclass gou(shuxing):passclass mao(shuxing):passp1 = ren(25,'男',68,185)print(p1.shengao)
在调用子类函数的同时调用父类函数
class shuxing:def __init__(self, nianling, xingbie, zhongliang):self.nianling = nianlingself.xingbie = xingbieself.zhongliang = zhongliangdef aa(self):#父类函数aa 打印123print(123)class ren(shuxing):def __init__(self,a,b,c,shengao):super().__init__(a, b, c)self.shengao = shengaodef aa(self):#子类函数super().aa()#super().父类函数 可以在执行子类函数时调用父类函数print(456)p1 = ren(25,'男',68,185)p1.aa()123456
多继承
class A:passclass B(A):passclass C():passclass D(C):passclass E():passclass F(E,D,B):passprint(F.mro())#类名.mro()查看多继承的类的继承顺序[<class '__main__.F'>, <class '__main__.E'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
如果觉得《python笔记4 内置函数 匿名函数.递归函数 面向对象(基础 组合 继承)》对你有帮助，请点赞、收藏，并留下你的观点哦！
