学习Python Task 6 函数与Lambda表达式笔记

最新推荐文章于 2021-07-19 08:48:22 发布

xc194

最新推荐文章于 2021-07-19 08:48:22 发布

阅读量269

点赞数

文章标签： python

本文链接：https://blog.csdn.net/xc194/article/details/107636709

版权

1. 函数

在Python中，函数也是对象，可以从另一个函数中返回出来而去构建高阶函数，比如：参数是函数，返回值是函数。

函数的定义

注意：冒号，缩进，return

def functionname(parameters):
    "函数_文档字符串"
    function_suite
    return [expression]

函数文档

def MyFirstFunction(name):
    "函数定义过程中name是形参"
    # 因为Ta只是一个形式，表示占据一个参数位置
    print('传递进来的{0}叫做实参，因为Ta是具体的参数值！'.format(name))

MyFirstFunction('老马的程序人生')  
# 传递进来的老马的程序人生叫做实参，因为Ta是具体的参数值！

print(MyFirstFunction.__doc__)  
# 函数定义过程中name是形参

help(MyFirstFunction)
# Help on function MyFirstFunction in module __main__:
# MyFirstFunction(name)
#    函数定义过程中name是形参

函数参数

位置参数：在调用函数时，参数位置要固定。

def functionname(arg1):
    "函数_文档字符串"
    function_suite
    return [expression]

默认参数：调用函数时，默认参数的值如果没有传入，则被认为是默认值。默认参数一定要放在位置参数后面，不然程序会报错。

def functionname(arg1, arg2=v):
    "函数_文档字符串"
    function_suite
    return [expression]

Python 允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

可变参数：传入参数数量可变，*args可以是任意个参数，自动组成元组（加 * 的参数会存储所有未命名的变量参数）。

def printinfo(arg1, *args):
    print(arg1)
    for var in args:
        print(var)
printinfo(10)  # 10
printinfo(70, 60, 50)
# 70
# 60
# 50

关键字参数：带两个 * ，可以是任意个参数，键值形式自动组成字典。

def printinfo(arg1, *args, **kwargs):
    print(arg1)
    print(args)
    print(kwargs)
printinfo(70, 60, 50)
# 70
# (60, 50)
# {}
printinfo(70, 60, 50, a=1, b=2)
# 70
# (60, 50)
# {'a': 1, 'b': 2}

命名关键字参数
星号 * ，nkw 为命名关键字参数，用户想要输入的关键字参数，定义方式是在 nkw 前面加个分隔符 *。调用时，nkw 参数名不能忽略。

def printinfo(arg1, *, nkw, **kwargs):
    print(arg1)
    print(nkw)
    print(kwargs)
printinfo(70, nkw=10, a=1, b=2)
# 70
# 10
# {'a': 1, 'b': 2}
printinfo(70, 10, a=1, b=2)
# TypeError: printinfo() takes 1 positional argument but 2 were given

参数组合：上面5种参数可以组合使用，但是要注意参数定义的顺序，必须是：位置参数、默认参数、可变参数和关键字参数；位置参数、默认参数、命名关键字参数和关键字参数。

其他

函数返回值
变量作用域：局部变量（函数内定义），全局变量（函数外定义）。当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了。

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num)  # 1
    num = 123
    print(num)  # 123
fun1()
print(num)  # 123

内嵌函数

def outer():
    print('outer函数在这被调用')
    def inner():
        print('inner函数在这被调用')
    inner()  # 该函数只能在outer函数内部被调用
outer()
# outer函数在这被调用
# inner函数在这被调用

闭包
函数式编程。如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。通过闭包可以访问外层非全局作用域的变量，这个作用域称为闭包作用域。闭包的返回值一般是函数。
闭包在外部（全局范围内）也可以直接调用。

def funX(x):
    def funY(y):
        return x * y
    return funY
i = funX(8)
print(type(i))  # <class 'function'>
print(i(5))  # 40

如果要修改闭包作用域中的变量则需要 nonlocal 关键字。

def outer():
    num = 10
    def inner():
        nonlocal num  # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()
# 100
# 100

递归：在函数内部调用它本身。

def recur_fibo(n):
    if n <= 1:
        return n
    return recur_fibo(n - 1) + recur_fibo(n - 2)
lst = list()
for k in range(11):
    lst.append(recur_fibo(k))
print(lst)  
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

设置递归的层数，Python默认递归层数为 100。

import sys
sys.setrecursionlimit(1000)

2. Lambda 表达式

匿名函数的定义

使用 lambda 关键字创建，没有函数名。结构：lambda argument_list: expression，lambda argument_list 参数类型和 def 定义的函数参数类型相同。expression 本身结果就是返回值。
匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
函数式编程是指代码中每一块都是不可变的。对于相同的输入，总会有相同的输出，没有任何副作用。即对于输入的参数没有影响。
匿名函数常常应用于函数式编程的高阶函数中，主要有两种形式：参数是函数 (filter, map)；返回值是函数 (closure)。

filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

odd = lambda x: x % 2 == 1
templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist))  # [1, 3, 5, 7, 9]

map(function, *iterables) 根据提供的函数对指定序列做映射。

m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1))  
# [1, 4, 9, 16, 25]
m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(m2))  
# [3, 7, 11, 15, 19]

自定义高阶函数

def apply_to_list(fun, some_list):
    return fun(some_list)
lst = [1, 2, 3, 4, 5]
print(apply_to_list(sum, lst))
# 15
print(apply_to_list(len, lst))
# 5
print(apply_to_list(lambda x: sum(x) / len(x), lst))
# 3.0

3. 练习

怎么给函数编写⽂档？
在函数体内直接编写字符串。
print(function.doc)
help(function)
怎么给函数参数和返回值注解？
举例说明：在函数对应形参后面冒号说明类型，在def的括号后面箭头说明返回值类型。

def func(x: int, y: int) -> int:

闭包中，怎么对数字、字符串、元组等不可变元素更新。
需要使用 nonlocal 关键字。
分别根据每一行的首元素和尾元素大小对二维列表 a = [[6, 5], [3, 7], [2, 8]] 排序。(利用lambda表达式)

a = [[6, 5], [3, 7], [2, 8]]
print(a)
a = sorted(a, key=lambda x: x[0], reverse=False)
print(a)
a = sorted(a, key=lambda x: x[1], reverse=False)
print(a)
# [[6, 5], [3, 7], [2, 8]]
# [[2, 8], [3, 7], [6, 5]]
# [[6, 5], [3, 7], [2, 8]]

利用python解决汉诺塔问题？有a、b、c三根柱子，在a柱子上从下往上按照大小顺序摞着64片圆盘，把圆盘从下面开始按大小顺序重新摆放在c柱子上，尝试用函数来模拟解决的过程。（提示：将问题简化为已经成功地将a柱上面的63个盘子移到了b柱）。

# 递归
def move(n,a,b,c):
    if n == 1:
        print(a, "->", c)
    else:
        move(n-1, a, c, b)
        move(1, a, b, c)
        move(n-1, b, a, c)
move(64, 'a', 'b', 'c')