python函数相关学习总结

一、函数

函数：是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用该名称即可实现对应需求，函数需先定义再使用

变量作用域

• 局部变量：定义在函数体内的变量，用于临时保存数据，函数调用完后即销毁局部变量，只在函数体内部生效
• 全局变量：指在函数体内、外都能生效的变量

二、函数的参数

2.1 位置参数（必备参数）

位置参数：调用函数时根据函数定义的参数位置来传递参数，形参和实参的顺序和个数必须一致

2.2 关键字参数

函数调用通过“键=值”形式指定，能让函数更加清晰和更容易使用，同时去除了参数的顺序需求

若函数调用时有位置参数，则位置参数须在关键字参数之前，关键字参数间无先后顺序

2.3 缺省参数（默认参数）

用于定义函数为参数提供默认值，写法为key=value，函数调用时可不用传带默认值参数的值

在函数定义和调用时所有位置参数须在默认参数前

2.4 不定长参数（可变参数）

用于不确定在调用时会传递多少个参数(可不传)的场景，可用以下两种方式传参

• 不定长位置参数：包裹位置传递，如下，传进的所有参数都会被args变量手机，其会根据传递仅参数的位置合并为一个元组(tuple)，args为元组类型，即收集所有位置参数，返回一个元组
• 不定长关键字参数：包裹关键字传递，收集所有关键字参数，返回一个字典

举例如下

def student(name, age, gender):
    print(f'姓名是{name},年龄是{age},性别是{gender}')
student('XX', 20, '男')  # 位置参数,形参和实参的顺序和个数须一致
student('YX', age=20, gender='女')   # 关键字参数，位置参数YX须放在关键字参数之前

def student1(name, age, gender='男'):
    print(f'姓名是{name},年龄是{age},性别是{gender}')
student1('XY', 20)  # 缺省（默认）参数，位置参数须出现在默认参数前

def student2(*args):
    print(args)   # 收集所有位置参数，输出一个元组
student2('XY')   # 不定长参数，包裹位置传递，以元组类型输出
student2('XX', 22, '男')

def student3(**kwargs):
    print(kwargs)   # 收集所有关键字参数，输出一个字典
student3(name='YX', age=20)   # 包裹关键字传递，以字典类型输出

输出：
姓名是XX,年龄是20,性别是男
姓名是YX,年龄是20,性别是女
姓名是XY,年龄是20,性别是男
('XY',)
('XX', 22, '男')
{'name': 'YX', 'age': 20}

三、拆包和交换变量值

3.1 拆包

举例如下 

print('---------拆包---元组、字典---------')
def tuple():
    return 'XX', 22
t = ('男', 23)
n1, n2 = tuple()   # 元组拆包
n3, n4 = t
print(n1, n2, n3, n4)  # 输出元组内数据

d1 = {'name': 'XY', 'age': 20}
a, b = d1  # 字典拆包
print(a, b, d1[a], d1[b])  # 输出字典键和值

输出：
---------拆包---元组、字典---------
XX 22 男 23
name age XY 20

3.2 交换变量值

举例如下 

print('---交换变量值---法1---')
a, b, temp = 20, 18, 0
temp = a  # 临时存放
a = b
b = temp
print(a, b)
print('-----法2-----')
c, d = 20, 21
d, c = c, d  # 直接交换
print(c, d)

输出：
---交换变量值---法1---
18 20
-----法2-----
21 20

• 引用：值是靠引用来传递的，用id()判断两个变量是否为同一个值的引用，id(变量)值即为内存地址标识
• 可变类型：数据能直接修改，有列表、字典、集合
• 不可变类型：数据不能直接修改，有字符串、元组整型、浮点型

举例如下

e = 2
f = e
print(id(e), id(f))  # 获取e、f地址标识，即内存地址
e = 3
print(id(e), id(f), e)  # e重新赋值后地址改变，说明int型数据和地址一一对应，为不可变类型
e1 = [2, 3]
f1 = e1
print(id(e1), id(f1))
e1.append(3)
print(id(e1), id(f1), e1)  # 追加3后地址未变，说明列表中数据可修改，为可变类型

输出：
140706412635984 140706412635984
140706412636016 140706412635984 3
1388632764736 1388632764736
1388632764736 1388632764736 [2, 3, 3]

四、lambda匿名函数

语法：lambda 参数列表：表达式

应用场景：适用于函数有一个返回值，且只有一句代码

参数可省，函数参数在lambda中完全适用，可接收任意数量的参数并只能返回一个表达式的值

4.1 参数形式

1. 无参数
2. 一个参数
3. 默认参数
4. 可变参数：*args
5. 可变参数：**kwargs

举例如下 

def f1():
    return 20
print(f1, f1())  # 输出函数f1地址和函数返回值
# 语法：lambda 参数列表：表达式
f2 = lambda :21  # 参数可省，函数参数在lambda中完全适用，可接收任意数量的参数并只能返回一个表达式的值
print(f2, f2())   # 输出f2的lambda地址和表达式值
f3 = lambda a, b: 5 + a + b
print(f3(1, 2))   # f3中几个参数就传几个值
print('---------lambda参数形式---------')
print((lambda: 22)())   # 无参数
print((lambda i: i)('Python'))   # 一个参数
print((lambda a, b, c=10: a + b +c)(10, 12))   # 默认参数c=10
print((lambda *args: args)(10, 10, 12))   # 参数传入lambda后，返回值为元组
print((lambda **kwargs: kwargs)(name='XY', id=1, age=20))   # 返回值为字典

输出：
<function f1 at 0x0000020B017B0940> 20
<function <lambda> at 0x0000020B017B09D0> 21
8
---------lambda参数形式---------
22
Python
32
(10, 10, 12)
{'name': 'XY', 'id': 1, 'age': 20}

4.2 lambda应用

• 带判断的lambda
• 列表数据按字典key值排序 

举例如下

print('----------带判断的lambda----------')
print((lambda a, b: a if a > b else b)(20, 22))   
print('------列表数据按字典key值排序-------')
students = [
    {'name': 'XX', 'age': 22},
    {'name': 'YX', 'age': 20},
    {'name': 'XY', 'age': 21}
]
students.sort(key=lambda k: k['name'], reverse=True)   # 按name值降序排序
print(students)
students.sort(key=lambda k: k['age'])   # 按age值升序排序
print(students)

输出：
----------带判断的lambda----------
22
------列表数据按字典key值排序-------
[{'name': 'YX', 'age': 20}, {'name': 'XY', 'age': 21}, {'name': 'XX', 'age': 22}]
[{'name': 'YX', 'age': 20}, {'name': 'XY', 'age': 21}, {'name': 'XX', 'age': 22}]

五、高阶函数

高阶函数：把函数作为参数传入，是函数式编程的体现，指高度抽象的编程范式

内置高阶函数

• map(f，l)：将传入的函数变量f作用到l变量的每个元素中，并将结果组成新的列表或迭代器返回，返回的是map对象，用list()转为列表
• reduce(f(x,y)，l)：f须有两个参数，每次f计算结果继续和序列的下一个元素做累积运算
• filter(f，l)：用于过滤序列中不符合条件的元素，返回一个filter对象，用list()转为列表         

举例如下 

print('---------高阶函数---------')
l = [1, 2, 3, 4, 5, 6]
def f(i):
    return i ** 2
result = map(f, l)   # 将函数f作用到列表l中的每个元素，并将结果组成新列表返回，返回map对象
print(result, list(result))

import functools
def f1(a, b):
    return a + b
result1 = functools.reduce(f1, l)   # 每次f1计算的结果继续和列表l中的下一个元素做累积计算，返回累积结果
print(result1)

def f3(i):
    return i % 2 == 0
result3 = filter(f3, l)   # 过滤掉不符合条件的元素，返回filter对象
print(result3, list(result3))

输出：
---------高阶函数---------
<map object at 0x0000014B8C3AEF40> [1, 4, 9, 16, 25, 36]
21
<filter object at 0x0000014B8C3AEFA0> [2, 4, 6]

导航：http://xqnav.top/