Python刻意练习_Task 05:函数与Lambda表达式

Python:函数与Lambda表达式

学习资料：
https://www.liaoxuefeng.com/wiki/1016959663602400/1017105145133280

引入：当我们用相同的数据关系多次带入不同数据执行时，多次输入很麻烦，于是将数据关系抽象成函数来简化步骤，方便操作。

Part 01 函数

1.Python内置函数（直接用）

• Python官网查看内置函数：http://docs.python.org/3/library/functions.html#abs
  或者在Python3直接运行help(函数名)查看函数信息。

>>> help(abs)
Help on built-in function abs in module builtins:

abs(x, /)
    Return the absolute value of the argument.

• 可以把函数名赋给另一个变量，相当于给函数起一个别名，函数一样可以运行。

a=abs
print(a(-9))#9

2.定义函数
A.自定义函数：
在Python中，定义一个函数要用def_自定义函数名（自变量）:语句，然后回车自动缩进块中编写函数体，函数的返回值用return语句返回。函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。
例：

def mytype(x):
    if x> 18:
        return "mature"
    else:
        return "oh youth"
        #>>> mytype(17)
        'oh youth'

B.参数检查：
当使用内置函数时输入错误数据类型系统会显示TypeError进行错误自查。但自定义函数没有这一功能，我们可以通过完善定义函数完成
数据类型自查。
例：如只允许整数和浮点数类型的参数，可以用内置函数isinstance()实现

def mytype(x)：
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x> 18:
        return "mature"
    else:
        return "oh youth"

Note:

• 若要输入数学函数可用import math语句，类似C语言中的#include<math.h>

• 定义函数时，需要确定函数名和参数个数；

• 如果有必要，可以先对参数的数据类型做检查；

• 函数可以同时返回多个值，但其实就是一个tuple。
  廖老师例：

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny
    # move(100,100,60,math.pi/6)
(151.96152422706632, 70.0)

C.空函数：

def 函数名()
    pass#占位，避免语法错误

3.函数的参数
A.默认参数

• 好处是可以简化函数的调用。
• 当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面作为默认参数。
• 必选参数在前，默认参数在后。

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
>>> power(5)
25
>>> power(5, 3)
125

定义默认参数要牢记一点：默认参数必须指向不变对象

B.可变参数
可变参数就是传入的参数个数是可变的，可以是任意个，还可以是0个。要定义出一个函数，我们必须确定输入的参数。由于参数个数不确定，在定义的参数前加一个*，则调用该函数时，可以传入任意个参数，包括0个参数。这些可变参数在函数调用时自动组装为一个tuple。

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
# calc(1,3,6)
46
>>> calc()
0

若已经有一个数组，可用*数组名把list或tuple的所有元素作为可变参数传进去。

nums = [1, 2, 3]
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum#>>> calc(*nums)
                   14 

C.关键字参数
关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。这可以扩展函数的功能。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
或者
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
#**extra表示把extra这个dict的所有信息用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra

D.命名关键字参数
用此限制关键字参数的名字，只接收命名关键字的信息，但是调用者仍可以传入不受限制的关键字参数。

def person(name, age, *, city, job):
    print(name, age, city, job)

• 特定分隔符后*后的参数是命名关键字。但如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要*

def person(name,age,*args,city,job):
    print(name,age,args,city,job)

• 命名关键字必须传入参数名，否则报错。

E.参数组合
在Python中定义函数，5种参数可以组合使用，但是这5种参数定义的顺序必须是：必选参数，默认参数，可变参数，命名关键字参数和关键字参数。

def func(a,b,c=3,*,d,**kw):
    print(a,b,c,d,kw)
>>>func(1,2,c=0,d=2,Iam=66)
1 2 0 2 {'Iam': 66}

• 对于任意函数，都可以通过类似function(*srga,**kw)的形式调用。
• 参数不要使用太多组合，否则函数接口的可理解性很差。

4.递归函数
在一个函数内部调用自身本身。

def fact(n):
    if n==1:
        return 1
    else:
        return n * fact(n-1)
>>>fact(5)
>>>120(并未调试成功)

• 递归调用次数太多，会导致栈（stack）溢出。通过尾递归解决，即在函数返回时，调用自身本身且return语句不能包含表达式。

def fun_iter(num,product):
    if num==1:
       return product
    return fact_iter(num-1,num*product)#把每次乘积传入到递归函数中

Part 02 Lambda表达式

匿名函数，省去函数名。

fun=lanbda 参数1，参数2,...:表达式
print(fun)

• filter()用于过滤序列，过滤掉不符合条件的元素。
• map()用于映射