[Python学习篇] Python函数

定义函数

语法：使用关键字 def

def 函数名(参数):
    代码1
    代码2
    ......

调用函数

语法：

函数名(参数)

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

示例：

# 定义函数
def hello(name):
    print("Hello my name is " + name)

# 调用函数
hello("Tom") # 打印 Hello my name is Tom

函数的形参和实参

形参：定义函数的同时定义了参数。

实参：调用函数时传入参数的真实数据叫实参。

函数的返回值

语法：关键字 return

def 函数名():

    return 返回值

示例：

# 定义函数
def add(a, b):
    return a + b

# 调用函数
result = add(1, 2)
print(result)  # 打印 3

函数的多个返回值

语法：多个返回值使用英式逗号分割

def 函数名():

    return 返回值1,  返回值2, 返回值n

注意：

1，多个变量接收函数多个返回值，变量和返回值顺序一一对应。
2，一个变量接收函数多个返回值，返回的变量类型默认是元组类型。

3，return 可以返回列表、元组或者字典，用于表示返回多个值。

示例：

# 定义函数
def test():
    return 1, 10, 'a'

# 多个变量接收函数多个返回值，变量和返回值顺序一一对应
a, b, c = test()
print(a)  # 1
print(b)  # 10
print(c)  # a

# 一个变量接收函数多个返回值，返回的变量类型是元组类型
t1 = test()
print(t1)  # (1, 10, 'a')

函数的说明文档

定义语法：

def 函数名(参数):
    """ 说明⽂档的位置，必须是函数内部第一行的注释"""
    代码
    ......

使用语法：

help(函数名)             # 使用内置函数help，查看函数说明文档

示例：

# 定义
def add(a, b):
    """加法运算，返回运算结果"""
    return a + b

# 查看函数说明文档
help(add)

 

变量的作用域

• 局部变量

局部变量是定义在函数体内部的变量，即只在函数体内部⽣效。局部变量的作用是在函数体内部，临时保存数据，即当函数调⽤完成后，则销毁局部变量。

• 全局变量

全局变量是在函数体内、外都能⽣效的变量。

修改全局变量，使用 global 关键字

a = 100

def testA():
    a = 200
    print(a)  # 打印函数内变量a，这时a是局部变量，修改a=200,不影响全局变量a的值

testA()
print(a)  # 打印 100，在testA中修改的值，不影响全局变量a

# 演示局部内修改全局变量的值
def testB():
    # 使用 global 关键字声明a为全局变量
    global a
    a = 200  # 声明后再修改变量a的值，此时就是修改全局变量a的值
    print(a)  # 打印 200

testB()
print(a)  # 打印 200

函数的参数

• 位置参数

调用函数时根据函数定义的参数位置来传递参数。例如形参有2个，实参就需要传入2个。形参实参数据按照顺序一一对应。

示例：

def hello(name, age):
    print(f"您的名字是{name}, 年龄是{age}")

hello("Tom", 20)  # 您的名字是Tom, 年龄是20

• 关键字参数

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

示例：

def hello(name, age, gender):
    print(f"您的名字是{name}, 年龄是{age}, 性别是{gender}")

hello("Tom", gender="男", age=20)  # 您的名字是Tom, 年龄是20, 性别是男

• 缺省参数

缺省参数也叫默认参数，用于定义函数时，为参数提供默认值，调用函数时缺省参数不传值，此时使用参数的默认值。缺省参数传值时使用传入的值（注意：定义函数和调用函数时，默认参数要写在所有参数的后面）。

def hello(name, age, gender='男'):
    print(f"您的名字是{name}, 年龄是{age}, 性别是{gender}")

hello("Tom", 20)  # 您的名字是Tom, 年龄是20, 性别是男
hello("Jerry", 19, '女')  # 您的名字是Jerry, 年龄是19, 性别是女

• 可变参数

可变参数也叫不定长参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时，可以包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递（组包的过程），会显得非常方便。

可变参数有两种类型：

1. 包裹位置参数
2. 包裹关键字参数

1. 包裹位置参数

def hello(*args):
    print(args)    # args是元组类型

hello(100)  # (100,)
hello('Tom', 'John', 'Smith')  # ('Tom', 'John', 'Smith')

2. 包裹关键字参数

def hello(**kwargs):
    print(kwargs)  # kwargs 是字典类型

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

拆包

组包是将零散的数据组合成一个元组或者列表或者字典过程，拆包就是将一个组合的数据拆成零散的变量数据。

• 元组拆包

def hello():
    return 100, 200

a, b = hello()
print(a)  # 100
print(b)  # 200

• 字典拆包

dict1 = {'name': 'Tom', 'age': 20}
# 拆包，得到字典的key
a, b = dict1
print(a)  # name
print(b)  # age

# 通过key，得到value
print(dict1[a])  # Tom
print(dict1[b])  # 20

交换变量

a = 10
b = 20

a, b = b, a
print(a)  # 20
print(b)  # 10

引用传递和值传递

• 引用传递

在函数传递变量的过程中，引用传递的是变量的引用地址（栈内存空间指向存储变量数据的堆内存地址），并不是变量本身。这意味着函数内部对变量数据的修改会影响原变量数据。

• 值传递

值传递是指在函数传递变量的过程中，程序把变量值复制了一份存储在新的堆内存地址中（新创建了一个变量，变量的值相同）后把新创建的变量本身传入到函数中，当函数对传入的变量值进行了修改后，不影响原变量的数据，原数据不变。

注意：

• 在Python中，数据的传递都是通用引用的方式传递的，没有值传递没有值传递没有值传递。
• 在引用传递过程中，原有的变量值是否改变又取决于变量的数据类型是可变类型还是不可变类型
  • 对于不可变对象，修改操作会创建新的对象，因此看起来像是值传递。
  • 对于可变对象，修改操作会影响到原来的对象，体现了引用传递的特性。

lambda 表达式

lambda 也叫匿名函数，如果一个函数有一个返回值，并且只有一行代码时，就可以使用lambda表达式简化代码。

语法：

lambda 参数列表: 返回值

注意：

lambda的参数是可选项，lambda只能有一个返回值。

示例：无参数

# 普通函数
def fn1():
    return 200

# lambda 表达式的函数
fn2 = lambda: 200  # lambda不推荐将返回值赋值给一个变量，推荐直接把lambda当函数参数使用
print(fn2)  # <function <lambda> at 0x000001C9CD61C9A0> # 直接打印变量打印的是内存地址
print(fn2())  # 200  # 这样写就可以打印返回值

示例：有参数

# 普通函数
def fn1(a, b):
    return a + b

# lambda 表达式 带参数
fn2 = lambda a, b: a + b
print(fn2)  # <function <lambda> at 0x000001C9CD61C9A0> # 直接打印变量打印的是内存地址
print(fn2(100, 200))  # 300  # 这样写就可以打印返回值

示例：给列表排序

shops = [{'name': 'Tom', 'age': 25}, {'name': 'Jerry', 'age': 19}, {'name': 'Spike', 'age': 22}]

# lambda 按照age降序排序
shops.sort(key=lambda x: x['age'], reverse=True)
print(shops)  # [{'name': 'Tom', 'age': 25}, {'name': 'Spike', 'age': 22}, {'name': 'Jerry', 'age': 19}]

高阶/内置函数

• id

id()函数用于返回对象的唯一标识符，这个标识符在对象的生命周期内是唯一且不变的。对于同一个对象，在不同的调用中返回的id是相同的。

a = 10
b = 20
c = 10
print(id(a))  # 140710097603288
print(id(b))  # 140710097603608
print(id(c))  # 140710097603288

• abs

计算数字的绝对值。

print(abs(-10))  # 10

def add(a, b, f):
    return f(a) + f(b)

print(add(-1, 2, abs))  # 3

• round

表示对一个数字进行四舍五入。

传入第二个参数，表示从第几位开始进行四舍五入。

# 四舍五入
print(round(1.29999))  # 1
print(round(1.59999))  # 2

# 从第几位开始进行四舍五入
print(round(1.21699, 2))  # 1.22
print(round(1.563453, 4))  # 1.5635

• map

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

list1 = [1, 3, 6, 7]

def fun1(x):
    return x + 1

map1 = map(fun1, list1)
print(map1)  # <map object at 0x000001A8ECEFE080> # 内存地址
print(type(map1))  # 类型
print(list(map1))  # 打印结果

• reduce

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

import functools

list1 = [1, 1, 1, 1, 1]

def fun1(a, b):
    return a + b

result = functools.reduce(fun1, list1)
print(result) # 5

• filter

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

示例一：熟悉基本的语法使用

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

def fun1(x):
    return x % 2 == 0

result = filter(fun1, list1)
print(list(result))  # [2, 4, 6, 8]

示例二：过滤掉不符合条件的对象

shops = [{'name': 'Tom', 'age': 25}, {'name': 'Jerry', 'age': 11}, {'name': 'Spike', 'age': 15}]

def fun1(x):
    return x['age'] >= 18

result = filter(fun1, shops)
print(list(result))  # [{'name': 'Tom', 'age': 25}]

示例三：过滤掉不符合条件的对象，lambda表达式的方式

shops = [{'name': 'Tom', 'age': 25}, {'name': 'Jerry', 'age': 11}, {'name': 'Spike', 'age': 15}]

result = filter(lambda x: x['age'] >= 18, shops)
print(list(result))  # [{'name': 'Tom', 'age': 25}]