1.2、Python基础-函数

Python基础

1、创建函数

有时候需要在程序中多次执行同一块代码，如果每次都写相同的代码，程序就会显得又长又繁琐，可读性也不好，此时可以将这一项特定的任务写为函数体，在程序需要的时候调用执行该函数即可，这样一来，程序的编写、可读性、测试和修改都将变得更加容易。

def msg_print():
    """打印消息"""   #这行是文档字符串的注释，用来解释函数的功能
    print('Hello World!') #后面的所有缩进行构成了函数体

msg_print()  #调用函数
1
2
3
4
5

2、函数传递参数的写法

2.1、位置实参

使用位置实参要求实参的顺序与形参的顺序相同，否则在调用函数的过程中会发生类型错误或者逻辑错误。java中就是用这种传参的

def user_info(name, fruit):
    """打印用户信息"""
    print('My name is ' + name.title() + '.')
    print('I like ' + fruit + ' best.')
    
user_info('emma','apple')   #正确调用，实参与形参顺序一一对应
1
2
3
4
5
6

2.2、关键字实参

关键字实参中每个实参都是由变量名和值组成的，它传递给函数的实参是名称值对，因为在实参中将名称和值已经关联起来了，所以无需再考虑函数调用中的实参顺序。

def user_info(name, fruit):
    """打印用户信息"""
    print('My name is ' + name.title() + '.')
    print('I like ' + fruit + ' best.')

user_info(name = 'emma',fruit = 'apple')
user_info(fruit = 'apple', name = 'emma')
1
2
3
4
5
6
7

2.3、给形参指定默认值

声明函数时，可给每个形参指定默认值，若调用的函数提供了实参，Python将使用指定的实参值，如果没有提供实参，将使用形参的默认值。因此，给形参指定默认值后，可在函数调用中省略相应的实参。

def user_info(name='emma', fruit='apple'):  #给形参指定默认值
    """打印用户信息"""
    print('My name is ' + name.title() + '.')
    print('I like ' + fruit + ' best.')

user_info()   #省略已有默认值的实参
user_info('alice')   #只传一个实参，默认传给第一个位置
user_info(fruit='pear')   #如果要传参给非第一位置，使用关键字实参的方法
user_info('lisa', 'banana')   #提供实参则覆盖默认值
1
2
3
4
5
6
7
8
9

3、函数返回值

函数并非总是直接显示输出，它也可以处理一些数据并返回一个或一组值，函数返回的值被称为返回值。在函数中，可使用return语句将值返回到调用函数的代码行。
注意：任何数据类型都可以返回的。
如果函数体里不写return，默认返回None。

def name(first_name, last_name):
    """返回用户全名"""
    full_name = first_name.title() + ' ' +last_name.title()
    return full_name

print(name('lebron','james')) #调用函数并打印
1
2
3
4
5
6

4、全局变量和局部变量

全局变量是在函数外部声明的变量。全局变量具有全局范围，这意味着可以在整个程序中使用访问它们，包括在函数中。

num = 100
def add_one():
    print(num + 1)

add_one() # 输出：101
1
2
3
4
5

局部变量是在函数内声明的变量，只能在声明它们的函数中访问它们。
如果在函数外面直接访问局部变量，程序会报错。

def add_one():
    num = 100
    print(num + 1)

add_one() # 输出：101
1
2
3
4
5

使用 global 声明全局变量： 通常，当在函数内创建的变量，就是局部变量，不能在函数之外使用此变量。但是，我们可以使用 global 关键字在函数中创建全局变量。

def add_one():
    global num # 定义全局变量
    num = 100
    print(num + 1)

add_one() # 输出：101
print(num) # 输出：100
1
2
3
4
5
6
7

程序中，局部变量和全局变量可以使用相同的变量名。在这种情况下，局部变量将在局部范围内起作用，全局变量将在全局范围内使用。

num = 200
def add_one():
    num = 100
    print(num + 1)

add_one() # 输出：101
print(num) # 输出：200
1
2
3
4
5
6
7

只需要在函数外部声明全局变量一次，就可以从程序中的所有函数或模块中访问全局变量，当多个函数访问相同的数据时，全局变量很有用。但是，过多的声明全局变量，将会占用更多的内存，程序执行完成才被释放。这可能会导致内存不足的问题。
如果多个地方需要更改全局变量的值，则结果可能是不可预测的。将其声明为局部变量可以解决此问题，可以为每个任务都将创建自己的局部变量。声明的局部变量，一旦函数使用结束，局部变量占用的内存就会被释放，节约资源。

5、函数传递可变和不可变对象

当传给形参的对象是不可变的对象，例如元组，数字，字符串，函数。且要对这些不可变对象进行修改时，就会把这些不可变对象重新复制一份，然后对这个复制的对象进行修改，原来对象不会变。

当传给形参的对象是可变的对象，例如列表，字典，集合等，由于传的是地址，如果进行修改，则会在原来的基础上进行修改。

a = 520
li = [1, 2, 3]

print(a, id(a))
print(li, id(li))

def test(a, li):
    a = 521
    li.append(666)
    print(a, id(a)) #很明显不可变对象数字521的id已经改变了


test(a, li)
print(a, id(a))
print(li, id(li)) # 很明显，li列表虽然添加了一个值，但是id没有改变
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6、lambda表达式与匿名函数

lambda 表达式可以用来声明匿名函数。 lambda 函数是一种简单的、在同一行中定义函数的方法。 lambda 函数实际生成了一个函数对象。lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值。
lambda 表达式的基本语法如下：
lambda args1,args2,args3... : <表达式>

f = lambda a, b, c: a + b + c
print(f)
print(f(1, 2, 3))
1
2
3

7、嵌套函数

嵌套函数（内部函数）是指定义在一个函数内部的函数，可以理解为它是外层函数的一个变量。

def out():  # 外层函数
    out1 = 1  # 定义一个外层变量
    print(out1, 'and id is', id(out1))  # 打印外层变量的信息

    def inn():  # 定义内部函数
        print(out1, 'and id is', id(out1))  # 内部函数用了外部变量（只是使用，并没有修改），看看信息有无变化

    inn()  # 执行内部函数
out()  # 执行外部函数
1
2
3
4
5
6
7
8
9

8、nonlocal关键字

def out():  # 外层函数
    out1 = 1  # 定义一个外层变量
    print(out1, 'and id is', id(out1))  # 打印外层变量的信息
 
    def inn():  # 定义内部函数
        out1 = 520
        print(out1, 'and id is', id(out1))  # 内部函数修改了外部变量，看看信息有无变化
 
    print(out1, 'and id is', id(out1))  # 打印外层变量的信息
    inn()  # 执行内部函数
 
out()  # 执行外部函数
1
2
3
4
5
6
7
8
9
10
11
12

内部函数对外部函数的变量进行了修改，可以发现对象已经改变，但是外部变量并没发生变化。因为在内部函数对外部函数变量进行修改时，会创建一个新对象来把外部变量隐藏。
那么如何才能使内部函数也能修改外部变量呢？
可以使用nonlocal关键字来声明，必须在内部函数里声明，且变量名要与外部变量相同。

def out():  # 外层函数
    out1 = 520  # 定义一个外层变量
    print(out1, 'and id is', id(out1))  # 打印外层变量的信息

    def inn():  # 定义内部函数
        nonlocal out1  # 声明为非本地变量
        out1 = 520  # 内部函数修改了外部变量，
        print(out1, 'and id is', id(out1))  # 看看信息有无变化

    inn()  # 先执行内部函数
    print(out1, 'and id is', id(out1))  # 再打印外层变量的信息
out()  # 执行外部函数
1
2
3
4
5
6
7
8
9
10
11
12