Python高阶函数 filter 、排序、返回函数、闭包、装饰器、偏函数------21

利用给定函数进行判断
• 返回值一定是bool
• 调用格式：filter（f,data),f是过滤函数，data为数据

In [8]:

#filter案例

#对一个列表进行过滤，只要偶数

def Isdou(n):

return n%2==0

l = [12,23,456,4,23,7,453,6,865,3,347,58,43,347,32]

rst = filter(Isdou,l)

print(rst)

print(type(rst))

​

print([i for i in rst])

​

<filter object at 0x7fbecc187128>
<class 'filter'>
[12, 456, 4, 6, 58, 32]

高阶函数-排序

• 把一个序列按照给定的算法排序
• key: 在排序前对每一个元素进行key函数运算

• sorted 语法：

  [code]  - sorted(iterable[, cmp[, key[, reverse]]])

• 参数说明：

  iterable -- 可迭代对象。
• cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回重新排序的列表。

In [9]:

#排序案例

a = [123,35,678,23,6785,2343,67,1,444,245]

al = sorted(a,reverse=True)

print(al)

[6785, 2343, 678, 444, 245, 123, 67, 35, 23, 1]

In [11]:

#排序案例2

a = [-323,34325,-346345,232,-54,678]

al = sorted(a,key=abs,reverse=True)##abs指的是绝对值，即 按照绝对值降序排列

print(al)

[-346345, 34325, 678, -323, 232, -54]

In [12]:

#排序案例3

asr = ['Avds','asf','avds','hahaha']

str1 = sorted(asr)

print(str1)

str2 = sorted(asr,key=str.lower)

print(str2)

['Avds', 'asf', 'avds', 'hahaha']
['asf', 'Avds', 'avds', 'hahaha']

返回函数

• 函数可以返回具体的值
• 也可以返回一个函数作为结果

In [16]:

#普通函数

def Haa(a):

print('hahahah')

return None

​

a = Haa('q')

print(a)

hahahah
None

In [19]:

#函数作为返回值返回，被返回的函数在函数体内定义

def Myfu1():

def Myfu2():

print('In Myfu1')

return 2

return Myfu2

​

#调用函数

#调用Myfu1,返回一个函数Myfu2,赋值给f3

f3 = Myfu1()

print(type(f3))

print(f3)

f3()

<class 'function'>
<function Myfu1.<locals>.Myfu2 at 0x7fbecc9e77b8>
In Myfu1

Out[19]:

2

In [21]:

#返回函数例子

#args:参数列表

#1.myF3定义函数，返回内部定义的函数myF4

#2.myF4使用外部变量，这个变量是myF3的参数

def myF3(*args):

def myF4():

n = 0

for i in args:

n += i

return n

return myF4

f4 = myF3(1,2,3,4,5,6,7,8,9,0)

f4()

​

Out[21]:

45

闭包（closure）

• 当一个函数在内部定义函数，并且内部的函数应用外部函数的参数或者局部变量，当外部函数被当做返回值的时候，相关参数被保存在返回函数中，这种结果叫闭包
• 如上述函数myF3

In [23]:

#闭包常见的坑

def count ():

#定义列表，列表里存放的是定义的函数

fs =[]

for i in range(1,4):

#f为一个闭包结构

def f():

return i*i

fs.append(f)

return fs

f1,f2,f3 = count()

print(f1())#代表第一次循环，按理说该返回1   1*1

print(f2())#代表第二次循环，按理说该返回4   2*2

print(f3())#代表第三次循环，按理说该返回9   3*3

9
9
9

出现上述问题原因：返回函数引用变量i,i并非立即执行，而是等到三个函数都返回的时候才统一使用，这时的i已经变成3，最终调用时返回值都为3*3

返回闭包时，返回函数不能引用任何循环变量

解决方案： 再创建一个函数，用该函数的参数绑定循环变量当前值，无论循环变量如何改变，已绑定函数参数值不再改变

In [28]:

def count2():

def f(j):

def g():

return j*j

return g

fs =[]

for i in range(1,4):

fs.append(f(i))

return fs

​

f1,f2,f3 = count2()

print(f1())

print(f2())

print(f3())

1
4
9

装饰器

• 实质 他们是修改其他函数的功能的函数,一旦定义可以修饰任何函数。
• 他们有助于让我们的代码更简短，也更Pythonic（Python范儿）。
• 不改动原有代码，实现新功能
• 一个返回函数的高阶函数

在每次要扩展到函数定义前使用@+函数名

授权(Authorization)
• 日志(Logging)

In [31]:

#实例

​

#对Hello函数进行功能扩展，在每次打印时输出时间

import time

#高阶函数

def PrintTime (f):

def war(*args, **Kwargs):

print('Time :',time.ctime())

return f(*args, **Kwargs)

return war

​

#使用装饰器时需要用@，即语法糖

@PrintTime

def Hello ():

print('Hello world!')

Hello()

Time : Thu Dec 27 08:36:10 2018
Hello world!

In [52]:

# 不使用语法糖，手动执行修饰器

def Hello1():

print('我是手动的')

Hello1 = PrintTime(Hello1)

Hello1()

p = PrintTime(Hello1)

p()

Time : Thu Dec 27 08:48:49 2018
我是手动的
Time : Thu Dec 27 08:48:49 2018
Time : Thu Dec 27 08:48:49 2018
我是手动的

偏函数（Partial function）

• 参数固定的函数，相当于一个有特定参数的函数体
• functools.partial的作用是把一个函数的某些函数固定，返回一个新函数
• partial(func,args, *keywords)

In [54]:

#把字符串转化为十进制数字

int('12345')

##把八进制字符串转化为十进制数字

int('12345',base = 8) #base代表几进制

Out[54]:

5349

In [66]:

#新建一个函数，输入字符串为十六进制，返回十进制

def int16(x,base=16):

return int(x,base)

int16('12345')

Out[66]:

74565

In [67]:

#偏函数实例

import functools

#实现上面int16的功能

int17 = functools.partial(int,base = 16)

int17('12345')

Out[67]:

74565