python result函数用法_Python_6(函数lambda高阶用法)

基于上次的公共操作和简单的推导式运算，本次学习函数的相关知识。

函数

函数基本形式1

2

3

4

5

6

7def f(a,b):

"""

说明文档内容

"""

代码

return a + b

# 调用时，help(f)查看说明文档

局部变量和全局变量

如何在函数体内修改全局变量？

1

2

3

4

5

6

7

8

9

10a = 100

def testA():

print(a)

def testB():

#global 关键字声明a是全局变量

global a

a = 200

print(a)

返回值返回多个值，return a,b，默认是返回元组类型

return后面可以连接列表、元组或字典，以返回多个值

参数

调用有参数的函数时，参数可有多种方式写入。

关键字参数1

2

3

4

5def user_info(name, age, gender):

print()

user_info('Tom', 20, '男')

user_info('小明', gender='男', age=16)

缺省参数1

2

3

4def user_info(name, age, gender='男'):

print()

#带有缺省值的参数可以不输入

user_info('Tom', 20)

不定长参数包裹位置传递

1

2

3

4def user_info(*args):

print(args)

user_info('Tom', 18) # ('Tom',18)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)。

包裹关键字传递

1

2

3

4def user_info(**kwargs):

print(kwargs)

user_info(name='Tom',age=18) # {'name': 'Tom','age': 18}

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

拆包元组拆包

1

2

3

4def return_num():

return 100, 200

num1, num2 = return_num()

字典拆包

1

2

3

4

5

6

7

8dict1 = {'name': 'Tom', 'age': 18}

a, b = dict1

#对字典进行拆包，取出来的是字典的key

print(a) # name

print(b) # age

print(dict1[a]) #Tom

交换变量值定义第三变量传值

1

2

3c = a

a = b

b = c

方法二

1

2a, b = 1, 2 # 把1和2分别赋值给a和b

b, a = a, b

引用

在python中，值是靠引用传递的。

可以用方法id(变量) ，得到变量的地址

int数据类型不可变(数值改变地址改变)，列表数据类型可变(数值改变地址不变)

可变和不可变类型

所谓可变不可变：即该数据能否直接修改，如果直接修改那么可变(不改变内存地址)，否则不可变。

可变类型列表

字典

集合

不可变类型整型

浮点型

字符串

元组

lambda表达式(匿名函数)

如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化。

语法1lambda 参数列表 : 表达式

注意：

lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用

lambda表达式能接受任何数量的参数但只能返回一个表达式的值

lambda的参数形式

无参数1

2

3

4

5

6

7

8# 函数

def fn1():

return 200

#lambda表达式

fn2 = lambda: 100

print(fn2) # lambda内存地址

print(fn2()) # 对应的函数的返回值

有参1

2

3

4

5

6

7

8

9# 计算a + b

# 函数实现

def add(a, b):

return a + b

print(add(1,2))

#lambda实现

fn1 = lambda a, b: a + b

print(fn1(1, 2))

默认参数1fn1 = lambda a = 0, b = 0: a + b

可变参数：*args1

2fn1 = lambda *args: args

print(fn1(1, 2, 3))

注意：这里的可变参数传入到lambda中，返回的类型为元组

可变参数：**kwargs1

2fn1 = lambda **kwargs: kwargs

print(fn1(name = 'python', age = 20))

返回字典类型。

以上与函数部分的规则完全一致。

lambda的应用

带判断的lambda1

2fn1 = lambda a, b: a if a > b else b

print(fn1(1, 2))

列表数据按字典key的值排序1

2

3

4

5

6

7

8

9

10

11

12

13

14students = [

{'name':'Tom', 'age': 20},

{'name':'Rose', 'age': 19},

{'name':'Jack', 'age': 22}

]

# 按name值升序排序

students.sort(key = lambda x: x['name'])

print(students)

# sort函数：如果要排序的列表里数据为字典，则指定key值则可排序

# 按name值降序排序

students.sort(key = lambda x: x['name'], reverse = True)

print(students)

高阶函数

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

示例：任意两个数字，求绝对值abs(或四舍五入 round)后进行求和。

方法1

1

2

3def add_num(a, b):

return abs(a) + abs(b)

result = add_num(-1, 2)

方法2

1

2

3

4

5

6def sum_num(a, b, f):

return f(a) + f(b)

#灵活性变高

result = sum_num(-1, 2, abs)

result = sum_num(-1, 2, round)

内置高阶函数

map()

map(func, lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的迭代器返回。

例子：

1

2

3

4

5

6list1 = [1, 2, 3, 4, 6]

def func(x):

return x ** 2

result = map(func, list1)

print(result) #为地址

print(list(result)) # list()，将数据转换为列表 [1, 4, 9, 16, 25]

reduce()

reduce(func, lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累计计算。

例子：计算list1序列中各个数字的累加和

1

2

3

4

5

6

7

8

9import functools # 导入reduce所需的functools模块

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

def func(a, b):

return a + b

result = functools.reduce(func, list1)

print(result) # 15

filter()

filter(func,lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象，如果转换为列表类型，用list()来转换。

1

2

3

4

5

6

7

8

9list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def func(x):

return x % 2 == 0

result = filter(func, list1)

print(result) # filter对象

print(list(result)) # [2, 4, 6, 8, 10]