Python学习记录 #4、函数

1. 函数的使用

1.1 定义

def 函数名(参数):

        代码1

        代码2

        ......

1.2 调用

函数名(参数)

注意：

• 不同的需求，参数可有可无。
• 在Python中，函数必须’先定义后使用‘。 

2. 函数说明文档

         保存函数解释说明的信息，各个参数的含义。

2.1 形式

def 函数名(参数):

        """ 说明文档的位置 """

        代码

        ......

2.2 查看说明文档

 help(函数名)

3. 参数

3.1 分类

形参：函数定义时书写的参数(非真实数据)。

实参：函数调用时书写的参数(真实数据)。

3.2 写法

3.2.1 位置参数

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

def  函数名(参数1, 参数2, 参数3):       

        """ 说明文档的位置 """

        代码

        ......

函数名(参数1, 参数2, 参数3)

3.2.2 关键字参数

        通过“键=值”形式加以指定。函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

def  函数名(参数1, 参数2, 参数3):       

        """ 说明文档的位置 """

        代码

        ......

函数名(参数1, 参数3 = 值x, 参数2 = 值y)

3.2.3  缺省参数 (默认参数)

        函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。用于定义函数，为参数提供默认值。

def 函数名(name, age, gender='男'):

        print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

函数名('TOM', 20)            #您的名字是TOM, 年龄是20, 性别是男

函数名('Rose', 18, '女')    #您的名字是Rose, 年龄是18, 性别是女

3.2.4 不定长参数 (可变参数)

        不确定调用的时候会传递多少个参数(不传参也可以)

 ① 包裹(packing)位置参数

def 函数名(*args):

        print(args)

# ('TOM',)

函数名('TOM')

# ('TOM', 18)

函数名('TOM', 18)

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

② 包裹关键字参数

def 函数名(**kwargs):

        print(kwargs)

# {'name': 'TOM', 'age': 18, 'id': 110}

函数名(name='TOM', age=18, id=110)

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

4. return返回值

4.1 作用

• 负责函数返回值（谁调用，返回给谁，也可作为参数传递）；
• 退出当前函数：导致return下方的所有代码(函数体内部)不执行。

4.2 写法

4.2.1 单返回值

return 值

4.2.2 多返回值

 return 值1, 值2

注意：

•  多返回值，默认是元组类型；
• return后面可以连接列表、元组或字典，以返回多个值

5. 变量作用域

5.1 局部变量

        定义在函数体内部的变量，即只在函数体内部生效。当函数执行结束后，局部变量就会被销毁(除了一些特殊情况)。

5.2 全局变量

        在函数体内、外都能生效的变量

5.3 global关键字

        关键字声明全局变量

5.4 体验变量作用域

a = 4

# 全局变量

def 函数1 ():

        a = 17

        # 局部变量

        print("在函数中1 a = ", a)

def 函数2 ():

        print("在函数中2 a = ", a)

函数1 ()              #在函数中1 a = 17

函数2 ()              #在函数中2 a = 4

print("a = ", a)    # a = 4

6.  函数嵌套

        一个函数里面又调用了另外一个函数。

 def testB():

        print('---- testB start----')                                        二

        print('这里是testB函数执行的代码...(省略)...')       三

        print('---- testB end----')                                         四

def testA():

        print('---- testA start----')                                         一

        testB()

        print('---- testA end----')                                          五

testA()    # 一 二 三 四 五

7.  匿名函数-lambda

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

7.1 语法

lambda 参数列表 ： 表达式

7.2 体验 

def fn1(x,y):                                                

        return x+y 

result = fn(4,5)  # 9

#使用匿名函数后

fn1 = lambda x, y : x + y

print(fn(4,5))      # 9

#三元运算换成匿名函数

fn2 = lambda x, y : x * y if x > y else x / y

print(fn2(2,5))   # 0.4

8. 高阶函数

        把函数作为参数传入

8.1 map

8.1.1 语法

map(func， lst)

         将传入的函数变量func作用到lst变量的每个元素中，对lst里面的列表执行func里的表达式 。

8.1.2 体验

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

squared = list(map(lambda x: x**2, numbers))

print(squared) # 输出: [1, 4, 9, 16, 25]

8.2 reduce(func，lst)

8.2.1 语法

reduce(func，lst)

        每次func计算的结果继续和序列的下一个元素做累积计算

注意：reduce()传入的参数func必须接收2个参数

8.2.2 体验

# 导入模块

import functools

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

# 方法一

def func(a, b):

        return a + b

result = functools.reduce(func, list1)

print(result) # 15

#方法二

result2 = functools.reduce(lambda x, y: x + y, list1)

print(result2)

8.3 filter

8.3.1 语法

filter(func, lst)

        用于过滤序列, 过滤掉不符合条件的元素, 返回一个 filter 对象 

8.3.2 体验 

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

def func(x):

        return x % 2 == 0

        result = filter(func, list1)

        print(result)     # <filter object at 0x0000017AF9DC3198>

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