程序员臻叔

2020-04-16 21:51 已编辑天津工业大学测试开发

关注

python函数的用法解析

给你一个获取“新冠病毒”每日疫情数据的函数，你想要么？

数据来源丁香医生，仅供学习参考！

首先，浏览器打开丁香医生的疫情地图链接，然后 F12 看看数据是怎么来的。

其次，用 python 实现获取数据

看不懂？没关系，我来带你一起复习一下python的函数。

先上目录

1、函数是什么

2、定义函数

3、空函数

4、多个返回值

5、函数的参数

6、递归函数

7、函数的作用域

8、函数式编程

9、函数作为返回值返回

10、函数的闭包

11、匿名函数 lambda

函数是什么？

定义：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

作用：函数能提高应用的模块性，和代码的重复利用率。

函数是 python 的一等公民，函数也是对象。

使用函数有两个步骤：

1、定义函数 def 函数名(): 函数体

2、调用函数 函数名()

定义函数

用 def 关键字来定义对象。

# 无参无返回值
def foo():
    语句
# 有参无返回值
def foo(x, y):
    z = x + y
    
# 无参有返回值
def foo():
    x =1
    return x + 1
# 有参有返回值
def foo(x, y):
    return x + y

空函数

暂时还没有想好怎么去定义函数，可以用 pass 占个坑。

def emptyfunc():
    pass

多个返回值

return多个值，其实是返回一个元组。

def foo():
    x, y, z = 1, 2, 3
    return x,y,z

# 返回一个元组
tup = foo()

# 元组拆包
x1, y1, z1 = foo()

函数的参数

必选参数

def foo(x, y, z):
    pass

默认参数

假如不传 x 参数的话，x 默认是等于 1

def foo(x=1):
    pass

可变参数（*）

定义：

def foo(*args):
    pass

调用：

（1）不定长传参

foo(1,2,3,4,5)

（2）元组和列表的压包

foo(*(1,2,3,4,5)) 
# or 
foo(*[1,2,3,4,5])

关键字参数（**）

定义：

def foo(**kwargs):
    pass

其中kwargs是一个字典。

调用：

（1）传入键值对

foo(k1=v1, k2=v2)

（2）传入字典变量（d是一个字典变量）

foo(**d)

命名关键字参数（ * ）

定义：

def foo(a, b, *, k1, k2, k3):
    pass

a, b是普通参数，k1, k2, k3 是命名关键字参数
命名关键字参数需要一个特殊分隔符 *，后面的参数被视为命名关键字参数
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符 * 了

调用：

foo(a, b, k1=v1, k2=v2, k3=v3)

参数组合

定义：

def fun(parameter, *args, keyparameter, **kwargs):
    pass

参数定义顺序：

函数的递归

# 典型案例：斐波那契数列
def fib_recursion(idx):
    if idx <= 2:
        return 1
    else:
        return fib_recursion(idx-1) + fib_recursion(idx-2)

注意：

必须设置函数终止条件
使用递归优点是逻辑简单清晰，缺点是过深调用导致栈溢出

函数的作用域

外部不能访问函数内部变量
函数内部能够访问外部变量
函数内部不能修改外部变量，强行修改需要加 global 外部变量 = 新值
函数内部和函数外部变量名可以相同，但需要注意访问优先级

# 例子一，内部访问同名变量，不要在内部变量定义之前去访问
g = 1

def foo():
    print(g)  # 报错 UnboundLocalError: local variable 'g' referenced before assignment 
    g = 2
    print(g)  # 2

foo()
print(g)  # 1

# -------------------- #

# 例子二，采用global关键字，会把内部变量g声明成全局变量，从而在函数内部可以改变全局变量
g =1

def foo():
    global g
    print(g) # 1
    g =2
    print(g) # 2

foo()
print(g) # 2

函数式编程

高阶函数

map

用法：map(函数名，列表/元组/集合/字符串)

说明：把传入的函数依次作用于每个元素，处理完后返回的是生成器类型，需要用list生成数据

li =[1, 2, 3, 4, 5]

def add1(x):
    return x +1

add_li =list(map(add1, li)) # [2, 3, 4, 5, 6]

filter

用法：filter(函数名, 列表/元组/集合/字符串)

说明：filter()把传入的函数依次作用于每个元素，然后根据返回值是 True 还是 False 决定保留还是丢弃该元素，处理完后返回的是生成器类型，需要用list生成数据

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

def ven_num(n):
    if n%2==0:
        return n

even_li =list(filter(even_num, li)) # [2,4,6]

reduce()

用法：reduce(函数名，列表/元组/集合/字符串)

说明：reduce() 用于对参数序列中元素进行累积。python3 中，reduce 已经被从全局名字空间里移除了，它被放置在functools模块里

from functools importreduce


li =[1, 2, 3, 4, 5]
m =reduce(lambda x, y : x+y, li)   # m=15

返回函数（函数名作为返回值返回）

def outer_foo(*args):
    def inner_foo():
        for i in args:
            print(i)
    return inner_foo

f = outer_foo(1, 2, 3, 4, 5)
f()  # 1 2 3 4 5

函数的闭包

# 典型案例1:
# 外部函数只是返回了函数名的列表，但并没有调用。等到内部函数被调用的时候，外部函数已经迭代完毕，最终的i变成3，所以f1()、f2()、f3()相当于执行了三次f(),返回3*3=9

def count():
    fs =[]
    for i inrange(1, 4):
        def f():
            return i*i
        fs.append(f)
    return fs
    
f1, f2, f3 = count()
print(f1())   # 9
print(f2())   # 9
print(f3())   # 9

# 典型案例2:
# 外部函数返回的是内部函数名的调用，所以结果和案例1不相同
def count():
    def f(j):
        def g():
            return j*j
        return g
    fs =[]
    for i inrange(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

f1,f2,f3 = count()
print(f1())  # 1
print(f2())  # 4
print(f3())  # 9

匿名函数

语法：lambda 形参:含形参的表达式