python内置高阶函数_七. python进阶(内置函数和高阶函数)

一. 内置函数

查看链接

#zip

li1=["张三","李四","王五"]

li2=["22","33","55"]

li4=["15kg","85kg","99kg"]

bb=zip(li1,li2,li4)#print("__iter__" in bb)

print(bb)for i inbb:print(i)#eval()

ss="[22,33,'zhansg']"ret=eval(ss)print(ret)

st="8+9"

print(eval(st))

stre="for i in range(66): print(i)"c=compile(stre,"","exec")print(c)

二. 内置高阶函数

高阶函数 函数接收的参是一个函数名 返回值包含函数

把函数当作一个参数传给另一个函数

defa(n):print(n)defb(name):print('my name is 哈哈哈')

a(b('111111111111111111111111111111111'))#my name is 哈哈哈

#None

defa(n):print(n) #

defb():print('my name is 哈哈哈')

a(b)

1. sum() 方法对系列进行求和计算。

#sum() 方法对系列进行求和计算。#

#语法#以下是 sum() 方法的语法:#

#sum(iterable[, start])#参数#iterable -- 可迭代对象，如：列表、元组、集合。#start -- 指定相加的参数，如果没有设置这个值，默认为0。"""

print(sum([0,1,2])) #3

print(sum((2, 3, 4), 1) ) #10 元组计算总和后再加 1

print( sum([0,1,2,3,4], 2) ) #12 列表计算总和后再加 2

2. callback()判断是否能调用 来检查函数能否调用

print(callable(print)) #True

a=111

print(callable(a)) #false

def aa():pass

print(callable(aa)) #True

importtimedefcallback():print("这是一个callback函数")deftest_callback(call):print("这是在test_callback中哦")#模拟延时效果

time.sleep(1)print("开始调用callback函数")

time.sleep(1)#开始回调

call()print("调用完成")#这是在test_callback中哦#开始调用callback函数#这是一个callback函数#调用完成

test_callback(callback)print(callable(test_callback))#True

print(callable(callback)) #True

3.查看帮助信息help()

#查看帮助信息help()

print(help(dict))print(help(list))print(help(tuple))print(help(set))print(help(str))#哈希

print(hash("aaaaaaaaaaaaaaaaaaa"))

4. all(x)如果all(x)参数x对象的所有元素不为0、''、False或者x为空对象，则返回True，否则返回False

#函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。#元素除了是 0、空、None、False 外都算 True。#all()

print(all(['a','',123])) #False

print(all(['aaa',123])) #True

print(all(['','',123])) #False

5.any(x)判断x对象是否为空对象，如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true

#如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。#any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。#元素除了是 0、空、FALSE 外都算 TRUE。

#列表list，元素都不为空或0

print(any(())) #空列表 False

print(any([])) #空元组 False

any((0, '', False)) #元组tuple，元素全为0,'',false

print(any(('a', 'b', 'c', 'd'))) #元组tuple，元素都不为空或0

any(('a', 'b', 'c', 'd')) #元组tuple，元素都不为空或0 True

print(any([1,'',99])) True

6.zip()

函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [1,2,3]

b= [4,5,6]

c= [4,5,6,7,8]

d=('*','**',[1,2],'6666')

f={'k1':1,'k2':3}print(zip(a,b,c))for i inzip(a,b,c,d,f):print(i)#(1, 4, 4, '*', 'k1')#(2, 5, 5, '**', 'k2')

print(list(zip(('a','n','c'),(1,2,3))))#[('a', 1), ('n', 2), ('c', 3)]

print(list(zip(('a','n','c'),(1,2,3,4))))#[('a', 1), ('n', 2), ('c', 3)]

p={'name':'张三','age':18,'爱好':'上网','地址':'南充'}print(list(zip(p.keys(),p.values())))#[('name', '张三'), ('age', 18), ('爱好', '上网'), ('地址', '南充')]

#求出列字典最大值

aa={"age1":11,"age2":16,"age3":20,"age4":28,"age5":90}#这样比较不知到对应哪个key和value的值 不合理

print(max(aa.values())) #90

print(max(aa)) #age5

print('*********************1111111****************')#借用zip()函数来比较字典里面的大小 这样逻辑清晰 就是key和value都知道

cc={"age1":11,"age2":16,"age3":20,"age4":28,"age5":90}

q=max(zip(cc.values(),cc.keys()))print(q) #(90, 'age5')

print('********************2222222*****************')

E={"age1":11,"age2":16,"age3":20,"age4":28,"age5":90}for item inzip(E.values(),E.keys()):print(item)#(11, 'age1')#(16, 'age2')#(20, 'age3')#(28, 'age4')#(90, 'age5')

#总结 早出最大的年龄和对应的人名

vv=[

{"name":"张三","age":15},

{"name":"哈哈","age":22},

{"name":"往往","age":33},

{"name":"李四","age":60},

]

B=max(vv,key=lambda dic:dic['age'])print(B) #{'name': '李四', 'age': 60}

7.filter() 函数

原型 : filter (fn,lsd)

参数1 为函数

参数2 为序列

功能: 过滤

白话文 ： 把传入的函数依次作用与序列每个元素，

根据返回的是True还是False 决定是否保留改元素

listl=[1,2,3,4,5,6,7,8,9]#筛选条件

deffunc (num):#偶数保留

if num%2==0:returnTrue#奇数剔除

returnFalse

L=filter(func,listl)print(list(L)) #[2, 4, 6, 8]

data=[["姓名","年龄","爱好"],["tom",25,"无"],["tom",2555500000,"金钱"]]deffunc2(v):

v=str(v)if v=="无":returnFalsereturnTruefor line indata:

m=filter(func2,line)print(list(m))#['姓名', '年龄', '爱好']#['tom', 25]#['tom', 2555500000, '金钱']

v = [4,5,6,7]defdd(x):return x%2==1re=filter(dd,v)print(re)for i inre:print(i)#5 7

print("***********************************************8")#和上面filter同等

ret=[i for i in [1,2,3,4,5,6] if i%2==1]print(ret) #[1, 3, 5]

defis_odd(n):return n % 2 == 1newlist= filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])for i innewlist:print(i)print("***********************************************8")#过滤列表中所有字符串

defst(n):if type(n)==str:returnTrue

aa=filter(st,[1,"hello","我是",2,77,"good"])print(aa)for i inaa:print(i)#hello#我是#good

print("***********************************************8")#过滤列表中所有空

defem(n):return n andstr(n).strip()

jj=filter(em,[1,"hello","我是",None,77,"",[],66])for i injj:print(i)

j=str([])print(type(j))

jf=str(None)print(type(jf))#1#hello#我是#77#66##

print("***********************************************8")importmathdefgg(n):if math.sqrt(n)%2==0:returnn

l=filter(gg,[12,64,25,36,88,77])for i inl:print(i)#64#36

8. map()函数

map函数的原型是map(function, iterable, …)，它的返回结果是一个列表。

参数function传的是一个函数名，可以是python内置的，也可以是自定义的。

参数iterable传的是一个可以迭代的对象，例如列表，元组，字符串这样的。

map 返回的是一个迭代器类型

原型: map(fn,lsd)

参数1 是函数

参数2 是序列

功能: 将传入的函数依次作用在序列的每一个元素,

并把结果作为新的Iterator返回

#map() 会根据提供的函数对指定序列做映射。#第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

ret=map(abs,[1,-3,-4,-5,6])for i inret:print(i)print("***************************************")def square(x) : #计算平方数

return x**2aa=map(square, [1,2,3,4,5])for i inaa:print(i)

list2=[2,4,6,8,10]

res=map(lambda x:x-1,list2)print(res) #

for i inres:print(i)#1#3#5#7#9

defadd (x):return x-1list3=[2,4,6,8,10]print(list(map(add,list3)))#[1, 3, 5, 7, 9]

msg="abcdef"

print(list(map(lambdax:x.upper(),msg)))#['A', 'B', 'C', 'D', 'E', 'F']

9.reduce ()函数

#求一序列的和

list2=[1,2,3,4,5]#1+2#1+2+3#1+2+3+4#1+2+3+4+5

defaa(x,y):return x+y

r=reduce(aa,list2)print("r=",r) #15

from functools importreduce

reduce(fn ,lsd)

参数1为函数

参数2为列表

功能 一个函数作用在序列上,这个函数必须接受两个参数,

reduce 把结果继续和序列的下一个元素累计计算

例如:

reduce(f,[a,b,c,d]) 相当于 f(f(f(a,b),c),d)

num=[2,4,6,8,10]

res=0for i innum:

res+=iprint(res) #30

print("**********************************************")#利用函数

defaa (arr):

ser=0for i inarr:

ser+=ireturnser

b=aa(num)print(b) #30

print("**********************************************")from functools importreduce#利用 reduce

defaa(x,y):return x+y

r=reduce(aa,num)print("r=",r) #30

print("**********************************************")#利用匿名函数

num=[2,4,6,8,10]defcc (func,arr):

res=arr.pop(0)#print(res) 2

for i inarr:

res=func(res,i)returnres

b=cc(lambda x,y:x*y,num)print(b) #3840

print("**********************************************")#利用reduce函数

num2=[1,2,3,4,5,6]

AA=reduce(lambda x,y:x+y,num2)print(AA)#21

10.sorted() 和 sort()

#sorted() 函数对所有可迭代的对象进行排序操作。 生成了个新列表

f=[5,7,-6,3,4,1,2]print(sorted(f))print(f)#sort() 在原有的基础上排序

l=[1,-2,33,-4,-9]

l.sort(key=abs)print(l)#按照列表长度排序

h=[' ',[1,2],'hellossaaa','66']

new=sorted(h,key=len)print(new)#[[1, 2], '66', ' ', 'hellossaaa']

#ord() 函数是 chr() 函数（对于8位的ASCII字符串）#或 unichr() 函数（对于Unicode对象）的配对函数

print(ord('A')) #65

#求 平方

print(pow(3,3)) #27

#四舍五入

print(round(3.5))#把字符串变成字典

print(set('hello'))#{'o', 'l', 'h', 'e'}

#排序

l=[5,8,9,4]print(sorted(l))#[4, 5, 8, 9]

"""# 列表字典排序

vv=[

{"name":"张三","age":15},

{"name":"哈哈","age":90},

{"name":"往往","age":222},

{"name":"李四","age":60}

],

print(sorted(vv,key=lambda dic: dic ['age']))

# [{'name': '张三', 'age': 15}, {'name': '李四', 'age': 60}, {'name': '哈哈', 'age': 90}, {'name': '往往', 'age': 222}]"""

#字典排序

name={"张三":52,"小孩":23,"校长":280,"吕老师":999,"A":8888,

}print(sorted(name))#['A', '吕老师', '小孩', '张三', '校长'] 按照values字母大小排序

print(sorted(name,key=lambdakey:name[key]))#['小孩', '张三', '校长', '吕老师', 'A'] # 按照keys价钱从小到大排序

print(sorted(zip(name.values(),name.keys()))) #keys和values 排序#[(23, '小孩'), (52, '张三'), (280, '校长'), (999, '吕老师'), (8888, 'A')]

print(str('1')) #1

aa=str({'a':1})print(eval(aa)) #{'a': 1}

#求和、

a=[1,5,9,5,10]print(sum(a)) #30

print(sum(range(4))) #6

#查看类型

print(type(1)) #

"""65

27

4

{'h', 'e', 'o', 'l'}

[4, 5, 8, 9]

['A', '吕老师', '小孩', '张三', '校长']

['小孩', '张三', '校长', '吕老师', 'A']

[(23, '小孩'), (52, '张三'), (280, '校长'), (999, '吕老师'), (8888, 'A')]

1

{'a': 1}

30

6

"""

11. enumerate()

#enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。#Python 2.3. 以上版本可用，2.6 添加 start 参数。

seasons= ['Spring', 'Summer', 'Fall', 'Winter']

p=list(enumerate(seasons))print(p)#[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

print("********************************************")

i=0

seq= ['one', 'two', 'three']for element inseq:print(element,i)

i+= 1

#one 0#two 1#three 2

12.divmod() 函数把除数和余数运算结果结合起来

divmod() 函数把除数和余数运算结果结合起来，#返回一个包含商和余数的元组(a // b, a % b)。

print(divmod(10,2)) #(4, 0)

print(divmod(11,2)) #(5, 1)

print(divmod(20,2)) #(10, 0)

print(divmod(11,3)) #(3, 2)

13.进制转换

#进制转换

print(bin(10)) #10进制到2进制 # 0b1010

print(hex(12)) #10进制到16进制 # 0xc

print(oct(11)) #10进制到8进制 0o13

14.isinstance() 函数来判断一个对象是否是一个已知的类型

#isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

print(isinstance(1,int)) #True

print(isinstance('abcdef',str)) #True

print(isinstance([],list)) #True

print(isinstance({},dict)) #True

15.functools模块用于高阶函数

importfunctools#functools模块用于高阶函数：作用与或者返回其它函数的函数。#一般来说，对于该模块，任何可调用对象都可以视为一个函数。#偏函数

def int2(str,base=2):returnint(str,base)print(int2("11111"))#把一个参数固定住 形成一个新的函数

int3=functools.partial(int,base=2)print(int3("111"))#进制的换算

#31#7