Python匿名函数、高阶函数、偏函数

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/cymy001/article/details/78188342

局部作用域v.s.全局作用域

a_string = "This is a global variable"
def foo():
    a_string = "test" # 1
    print(locals())
foo()   #{'a_string': 'test'}
a_string # 2   #'This is a global variable'

#全部变量可以被访问(如果是可变类型,甚至可以被修改)但是(默认)不能被赋值。在函数 #1 处,实际上是创建了一个和全局变量相同名字的局部变量,并且“覆盖”了全局变量。通过在函数 foo 中打印局部命名空间可以印证这一点,并且发现局部命名空间有了一项数据。在 #2 处的输出可以看到,全局命名空间里变量 a_string 的值并没有改变。

函数参数

位置参数
关键字参数
*位置参数包裹:解包裹成位置参数
** 关键字参数包裹:解包裹成关键字参数
定义时元组/字典包裹,调用函数时传入元组列表/字典解包

def foo(x, y=0): # 1
    return x - y

foo(3, 1) # 2

foo(3) # 3

foo() # 4 TypeError: foo() takes at least 1 argument (0 given)

foo(y=1,x=3) # 5

foo(y=5,4) # 6 positional argument follows keyword argument
def sum1(*tup):
    for i in range(len(tup)):
        print(tup[i])
    return max(tup)

l1=[1,2,53,43]
sum1(*l1)
def score(**dic):
    print(type(dic))
    for k,v in dic.items():
        print(k,v)
#score(啊=1,哦=2)
dd={'a':1,'b':2,'c':3}
score(**dd)

函数对象,参数是函数

#在 Python 中函数只是常规的值,就像其他任意类型的值一样。这意味着可以将函数当做实参传递给函数,或者在函数中将函数作为返回值返回。
def foo():pass
foo.__class__ # 1 function
issubclass(foo.__class__, object)
#函数也是对象
#issubclass(int, object)

def add(x, y):
    return x + y
def sub(x, y):
    return x - y
def apply(func, x, y): # 1
    return func(x, y) # 2
apply(add, 2, 1) # 3
#在 #1 处可以看到变量接收一个就像其他普通变量一样的函数。在 #2 处调用了传递给 apply 的函数 fun——在 Python 中(双括号是调用操作符),调用变量名包含的值。在 #3 处展示了在 Python 中把函数作为值传参。

函数是返回值,()调用操作符

def outer():
    def inner():
        print("Inside inner")
    return inner # 1

foo = outer() #2
foo   # <function __main__.outer.<locals>.inner>
foo()   #Inside inner
#在 #2 处将获得返回值即函数 inner,并赋值给新变量 foo。可以看到如果鉴定 foo,它确实包含函数 inner,通过使用(调用操作符)来调用它。

闭包:函数记住其外层作用域的事实

def outer(x):
    def inner():
        print(x) # 1
    return inner
print1 = outer(1)
print2 = outer(2)
print1()   #return: 1
print2()   #return: 2
#闭包——函数记住其外层作用域的事实——可以用来构建本质上有一个硬编码参数的自定义函数。虽然没有直接给 inner 函数传参 1 或 2,但构建了能“记住”该打印什么数的 inner 函数自定义版本。Python 支持一种名为函数闭包的特性,意味着在非全局作用域定义的 inner 函数在定义时(记得外层命名空间)是怎样的。inner 函数包含了外层作用域变量,通过查看它的 func_closure 属性可以看出这种函数闭包特性。

高阶函数

该函数的参数可以接收指向函数对象的函数,另一个参数是可迭代对象
格式:funname(fun,inter)

#自己写的高阶函数maxf
def maxf(sum,lis):return sum(lis)
maxf(sum,[1,2,3,4])
#python内置的高阶函数filter,map,reduce
def dele(score):
    if score>=60:
        return True
    else:
        return False

list(filter(dele,[100,55,70]))
list(filter(dele,(99,55,43,65)))
from functools import reduce  #两两操作
reduce(lambda a,b:max(a,b),(33,23,44,55))
list(map(lambda x:x**2,[1,4,0]))  #一一映射

匿名函数

foo=lambda a,b,c:max(a,b,c)
type(foo)
foo(3,4,5)
d1={'china':15,'India':9,'USA':2,'Japan':1.5}
sorted(d1.items(),key=lambda x:(x[0],x[1]))

偏函数

import functools
hex2int2=functools.partial(int,base=16)
hex2int2('5')
hex2int2('F')

装饰器

用一个包装的函数,替换包含函数的变量,实现装饰函数
使用装饰器很简单!虽说写类似 staticmethod 或者 classmethod 的实用装饰器比较难,但用起来仅仅需要在函数前添加 @装饰器名 即可!

def outer(some_func):
    def inner():
        print("before some_func")
        ret = some_func() # 1
        return ret + 1
    return inner
def foo():
    return 1

decorated = outer(foo) # 2
decorated()
#outer的参数是foo,返回inner赋给decorated,decorated()就是inner(),调用inner函数,此时由于闭包结构,inner函数记住了外部some_func=foo
#打印“before some_func”,ret=foo(),foo()返回1,所以ret=1,最终返回2
#变量 decorated 是 foo 的装饰版——即 foo 加上一些东西。
#事实上,如果写了一个实用的装饰器,可能会想用装饰版来代替 foo,这样就总能得到“附带其他东西”的 foo 版本。
foo=outer(foo)
foo()   #现在任意调用 foo() 都不会得到原来的 foo,而是新的装饰器版!
import datetime
def extrafoo(func):
    def inner():
        print('extra:',datetime.datetime.now())
        print('from inner to execute:',func.__name__)
        print('the',func.__name__,'result:',func())
    return inner

def foo1():
    return 'this is foo1 function--'

foo1=extrafoo(foo1)   #在foo1外包裹了一层extrafoo作用,再调用foo1就不是原来简单定义的foo1了,而是extrafoo(foo1)
foo1()
import datetime
def extrafoo(func):
    def inner():
        print('extra:',datetime.datetime.now())
        print('from inner to execute:',func.__name__)
        print('the',func.__name__,'result:',func())
    return inner
@extrafoo
def foo1():
    return 'this is foo1 function--'
foo1()
展开阅读全文

没有更多推荐了,返回首页