七,Python之函数(函数的概述,定义,调用,底层原理,参数的传递,类型) (递归函数,匿名函数,嵌套函数) (深拷贝与浅拷贝)(全局变量与局部变量)

• 学习：知识的初次邂逅
• 复习：知识的温故知新
• 练习：知识的实践应用

目录

一,本章知识简介

二,函数的概述

三,函数的定义与调用

1,核心定义

2,形参与实参

3,函数的注释

4,函数的返回值

四,函数的底层分析

五,变量的作用域

六,参数的传递

1,传递可变对象的引用

2,传递不可变对象的引用

3,浅拷贝与深拷贝

4,传递不可变对象包含的子对象是可变的情况

七,参数的类型

1,位置参数

2,默认值查参数

3,命名参数

4,可变参数

5,强制命名参数

八,lambda匿名函数

九,eval()函数

十,递归函数

十一,嵌套函数

十二,局部变量 nonlocal

十三,LEGB规则

---

一,本章知识简介

主线A:函数

• 函数的概述
• 函数的定义与调用
• 函数的底层分析
• 函数的作用域
• 函数参数的传递
• 函数参数的类型
• lambda匿名函数
• eval()函数
• 递归函数
• 嵌套函数
• nonlocal关键字
• LEGB规则
• 函数综合练习

 回顾前面的知识

pyhthon学习路线:

• 前置:
  • pyhton的概述
  • pyhton环境安装;
• 基础:
  • 注释
  • 标识符
  • 关键字
  • 变量
  • 数据类型
  • 输入
  • 输出
  • 运算符
• 控制语句
  • 选择分支 
  • 循环结构
• 序列(容器)
  • 字符串
  • 列表
  • 元组
  • 字典
  • 集合

  回顾前面的知识的链接:

一,邂逅Python,搭建python环境,基础语法介绍:python注释,关键字,标识符,变量,数据类型,print()输出,input()输入,数据类型转换等-CSDN博客

二,PyCharm软件的使用,Python运算符,变量的介绍与运用,以及本章综合测试-CSDN博客

三,python控制语句 (条件分支与循环结构)-CSDN博客

四,python之字符串. [字符串的特点,操作,常用方法,遍历,综合测试]-CSDN博客

五,Python之列表与元组 [列表和元组的特点,操作,常用方法,遍历]-CSDN博客

六,Pyhton之字典,集合 {字典和集合的增删改查,以及综合练习}-CSDN博客

二,函数的概述

在Python函数中，有几个重要概念：

（1）函数名

（2）参数

（3）返回值

在编写函数时，函数体中的代码写法和我们前面讲述的基本一致，只是对代码实现了封装，并增加了函数调用、传递参数、返回计算结果等内容。

函数 (function) 的基本概念

1 一个程序由一个一个的任务组成；函数就是代表一个任务或者一个功能(function)。

2 函数是代码复用的通用机制

Python 函数分为如下几类：

内置函数

我们前面使用的 str() 、 list() 、 len() 等这些都是内置函数，我们可以拿来直接使用。

标准库函数

我们可以通过 import 语句导入库，然后使用其中定义的函数

第三方库函数

Python 社区也提供了很多高质量的库。下载安装这些库后，也是通过 import 语句导入，然后可以使用这些第三方库的函数

用户自定义函数

用户自己定义的函数，显然也是开发中适应用户自身需求定义的函数。今天我们学习的就是如何自定义函数。

=总结：==

（1）当将一些代码进行封装在一块，并给这块代码取了个名字，就叫做函数；

（2）定义函数时，需要使用（）关键字。== def ==；

三,函数的定义与调用

1,核心定义

语法:

def 函数名([参数, ..]):
    代码1
    代码2
    ...
    [return 具体的值]

简单定义一个函数

def add(a,b,c):
    '''完成三个数的加法，并返回他们的和'''
    sum = a+b+c
    print("{0}、{1}、{2}三个数的和是：
{3}".format(a,b,c,sum))
    return sum
add(10,20,30)
add(30,40,50)

总结:

我们使用 def 来定义函数，然后就是一个空格和函数名称；

• Python执行 def 时，会创建一个函数对象，并绑定到函数名变量上。

参数列表

• 圆括号内是形式参数列表，有多个参数则使用逗号隔开
• 定义时的形式参数不需要声明类型，也不需要指定函数返回值类型
• 调用时的实际参数必须与形参列表一一对应

return 返回值

• 如果函数体中包含 return 语句，则结束函数执行并返回值；
• 如果函数体中不包含 return 语句，则返回 None 值。

调用函数之前，必须要先定义函数，即先调用 def 创建函数对象

• 内置函数对象会自动创建
• 标准库和第三方库函数，通过 import 导入模块时，会执行模块中的def语句

2,形参与实参

形参和实参的要点：

• 圆括号内是形式参数列表，有多个参数则使用逗号隔开
• 定义时的形式参数不需要声明类型，也不需要指定函数返回值类型
• 调用时的实际参数必须与形参列表一一对应

定义一个函数，实现两个数的比较，并返回较大的值

def test(a,b):
    if a>b:
        print(a)
        return a
    else:
        print(b)
        return b
test(1,2)  # 2
test(2,1)  # 1

上面的 test 函数中，在定义时写的 test(a,b) 。 a 和 b 称为 “ 形式参数” ，简称 “ 形参 ” 。也就是说，形式参数是在定义函数时使用的。 形式参数的命名要符合 “ 标识符 ” 命名规则 。

在调用函数时，传递的参数称为 “ 实际参数 ” ，简称 “ 实参 ” 。

上面代 test(10,20) ， 10 和 20 就是实际参数。

3,函数的注释

      程序的可读性最重要，一般建议在函数体开始的部分附上函数定义说明，这就是“ 文档字符串 ” ，也有人成为 “ 函数的注释 ” 。我们通过三个单引号或者三个双引号来实现，中间可以加入多行文字进行说明

测试文档字符串的使用

鼠标悬浮在上面可以看到我们的函数注释

我们调用 help(函数名) 可打印输出函数的文档字符串。结果如下：

4,函数的返回值

return 返回值要点：

1 如果函数体中包含 return 语句，则结束函数执行并返回值

2 如果函数体中不包含 return 语句，则返回 None 值

3 要返回多个值，使用列表、元组、字典、集合将多个值“存起来”即可

定义一个打印n个星号的无返回值的函数

def print_start(n):
    print('*'*n)
print_start(5)  #*****

定义一个返回两个数平均值的函数

def fn1_avg(a,b):
    print((a+b)/2)

fn1_avg(5,9) #7.0

返回一个列表

def printShape(n):
    s1 = "#"*n
    s2 = "$"*n
    return [s1,s2]

s = printShape(5)
print(s)

四,函数的底层分析

Python 中， “ 一切都是对象 ” 。实际上，执行 def 定义函数后，系统就创建了相应的函数对象。

我们执行如下程序，然后进行解释：

def print_star(n):                
    print("*"*n)
print(print_star)
print(id(print_star))
c = print_star
c(3)

<function print_star at 0x0000000002BB8620>

45844000

上面代码执行 def 时，系统中会创建函数对象，并通过 print_star 这个变量进行引用：

我们执行 c=print_star 后，显然将 print_star 变量的值赋给了变量 c ，内存图变成了：

显然，我们可以看出变量 c 和 print_star 都是指向了同一个函数对象。因此，执行 c(3) 和执行 print_star(3) 的效果是完全一致的。

python中，圆括号意味着调用函数。在没有圆括号的情况下，Python会把函数当做普通对象。

五,变量的作用域

变量起作用的范围被称为 变量的作用域

不同的作用域同名变量之间互不影响

变量分为:全局变量,局部变量

全局变量：

1 在函数和类定义之外声明的变量。作用域为定义的模块，从定义位置开始直到模块结束。

2 全局变量降低了函数的通用性和可读性。应尽量避免全局变量的使用。

3 要在函数内改变全局变量的值，使用 global 声明一下

局部变量：

1 在函数体中（包含形式参数）声明的变量。

2 局部变量的引用比全局变量快，优先考虑使用

3 如果局部变量和全局变量同名，则在函数内隐藏全局变量，只使用同名的局部变量

说明：

（1）全局变量是指与函数处于同一级别的变量；

（2）注意：当函数中的局部变量与全局变量同名时，在函数中使用的是局部变量的值。

全局变量的作用域测试

a = 100  #全局变量
def f1():
    global a #如果要在函数内改变全局变量的值，增加global关键字声明
    print(a) #打印全局变量a的值
    a = 300

f1()  #100
f1() #300
print(a) #300

全局变量和局部变量同名测试

a = 300
def f1():
    a = 100
    print(a)
f1() #100
print(a) #300

输出局部变量和全局变量

# 1.定义全局变量
# a = 100
# print(a)
#
# def func():
#     print(f"输出变量值:{a}")
#
# func()   # 问题: 程序不好阅读??  -->该如何处理?

# 2.修改全局变量值
# number = 140
#
# def test():
#     # 对齐: 程序报错了,才需要改错.
#     global number
#     number += 2
#     print(f"修改后的number值为:{number}")
#
# test()

# 3.定义同名变量
age = 18

def show():
    age = 34
    print(f"输出age的值为:{age}")

# show()
print(f"age = {age}")
# 升级: 实际上,对于不可变类型的全局变量要修改值, 需要使用global声明;
# 但是对于可变类型的数据内容-全局变量, 可以不需要声明.

=总结：==

（1）当要定义一个作用在整个模块的变量时，就可以使用全局变量；

（2）注意：当要给全局变量修改值时，需要先使用（）关键字来声明。==A、global==；

局部变量和全局变量效率测试

局部变量的查询和访问速度比全局变量快，优先考虑使用，尤其是在循环的时候。

# 全局变量 global   局部变量 locals  局部变量
# 测试全局变量和局部变量的效率
import time
a=101
def a1():
    s=time.time()
    global a
    for i in range(100000000):
        a=a+1
    e=time.time()
    print(s-e)

def a2():
    s=time.time()
    c=101
    for i in range(100000000):
        c=a+1
    e=time.time()
    print(s-e)
a1()  #-3.955960988998413
a2()  #-3.0249297618865967

六,参数的传递

函数的参数传递本质上就是：从实参到形参的赋值操作。 Python 中 “一切皆对象 ” ，所有的赋值操作都是 “ 引用的赋值 ” 。所以， Python 中参数的传递都是“ 引用传递 ” ，不是 “ 值传递 ”

具体操作时分为两类：

1 对“可变对象”进行“写操作”，直接作用于原对象本身。

2 对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的值填充这块空间。

可变对象有：

• 字典、列表、集合、自定义的对象等

不可变对象有：

• 数字、字符串、元组、function等

1,传递可变对象的引用

        传递参数是可变对象（例如：列表、字典、自定义的其他可变对象等），实际传递的还是对象的引用。在函数体中不创建新的对象拷贝，而是可以直接修改所传递的对象。

参数传递：传递可变对象的引用

a=[10,20]
def a1(m):
    print(id(m))  #1543622164352
    m.append(30)
a2=0
while a2<3:
    a2=a2+1
    # a.append(30)
    a1(a)  #循环这个函数  而调用这个函数 实际上和上面的一句话  得到的结果一样

print(a) #[10, 20, 30, 30, 30]  批量获得后面连续添加的30
print(id(a))  #1543622164352

2,传递不可变对象的引用

   传递参数是不可变对象（例如： int 、 float 、字符串、元组、布尔值），实际传递的还是对象的引用。在”赋值操作”时，由于不可变对象无法修改，系统会新创建一个对象。

参数传递：传递不可变对象的引用

a = 100
def f1(n):
    print(n,id(n))  # 100 a的地址  100 3137341033808
    n=n+200
    print(n,id(n))  #300  n的地址 300 3137342075152

print(a,id(a))  #100 3137341033808
f1(a)

显然，通过 id 值我们可以看到 n 和 a 一开始是同一个对象。给 n 赋值后，n 是新的对象。

3,浅拷贝与深拷贝

我们可以使用内置函数： copy ( 浅拷贝 ) 、 deepcopy ( 深拷贝)

浅拷贝： 拷贝对象，但不拷贝子对象的内容，只是拷贝子对象的引用。

深拷贝： 拷贝对象，并且会连子对象的内存也全部（递归）拷贝一份，对子对象的修改不会影响源对象

import copy
def test_copy():
    '''测试浅拷贝'''
    a = [1,2,3,[2,2]]
    b = copy.copy(a)

    print(a,b)  #值必然一样
    print(id(a),id(b))   #地址不一样 因为是可变对象,在拷贝的时候会开辟一个新的内存空间 1695163965376 1695163962880
    b.append(5) # 改变b  [1, 2, 3, [2, 2]] [1, 2, 3, [2, 2], 5]
    print(a,b) #  值不一样  a = [1,2,3,[2,2]] b=[1,2,3,[2,2],5]
    print(id(a),id(b))  #地址不一样  1695163965376 1695163962880
    #[1, 2, 3, [2, 2, 2]] [1, 2, 3, [2, 2, 2], 5]
    b[3].append(2)  #改变内部的子对象 但是浅拷贝并不会修改内部的内存地址  所以修改的其实也是a的地址
    print(a,b) # a = [1,2,3,[2,2,2]] b=[1,2,3,[2,2,2],5]
    print(id(a),id(b)) #地址不一样  1695163965376 1695163962880

test_copy()

内存示意图:

def test_deep_copy():
    '''这是一个深拷贝的测试函数'''
    a=[1,2,3,[2,2]]
    b=copy.deepcopy(a)

    print(a,b)  #值必然一样  [1, 2, 3, [2, 2]] [1, 2, 3, [2, 2]]
    print(id(a),id(b))  #深度拷贝 连同子对象的内存地址也全部递归一份,如果还是可变的就开辟新的内存空间存储 必然不一样
    #2056309595712 2056309309120
    b.append(5)  #修改b的值   #[1, 2, 3, [2, 2]]   [1, 2, 3, [2, 2], 5]
    print(a,b)  #修改b的值关我a啥事儿  #
    print(id(a),id(b))  #内存地址不一样 2056309595712 2056309309120

    b[3].append(2) #修改子对象的值 [1, 2, 3, [2, 2]] [1, 2, 3, [2, 2, 2], 5]
    print(a,b) #b都完全独立出来,  修改b的值,关我a的值啥事儿
    print(id(a),id(b))  #内存地址不一样  2056309595712 2056309309120


# test_copy()
test_deep_copy()

4,传递不可变对象包含的子对象是可变的情况

# 传递不可变对象时。不可变对象里面包含的子对象是可变的。则方法内修改了这个可变对象，源对象也发生了变化。

#传递不可变对象时。不可变对象里面包含的子对象是可变的。则方法内修改了这个可变对象，源对象也发生了变化。
a = (10,20,[5,6])
print("a:",id(a))
def test01(m):
    print("m:",id(m))
    m[2][0] = 888
    print(m)
    print("m:",id(m))
test01(a)
print(a)

a = (1,2,3,[1,2])
print(a,id(a)) #(1, 2, 3, [1, 2]) 2916325750192
def test_tuple_copy():
    '''测试元组的浅拷贝'''
    b = a
    print(b,id(b))   #(1, 2, 3, [1, 2]) 2916325750192
    b[3].append(5)  #修改子对象
    print(a,b)  # a也会跟着变化  (1, 2, 3, [1, 2, 5]) (1, 2, 3, [1, 2, 5])
    print(id(a),id(b))  # 他们的地址还是一样  不可变对象 地址依旧一样 2916325750192 2916325750192

test_tuple_copy()

七,参数的类型

1,位置参数

函数调用时，实参默认按位置顺序传递，需要个数和形参匹配。按位置传递的参数，称为：“ 位置参数 ” 。

测试位置参数

def f1(a,b,c):
    print(a,b,c)

f1(1,2,3)
f1(1,2,c=3)  #赋值传参
f1(a=1,b=2,c=3)
f1(b=2,a=1,c=3)
f1(1,3) #报错

2,默认值查参数

      我们可以为某些参数设置默认值，这样这些参数在传递时就是可选的。称为“ 默认值参数 ” 。默认值参数放到位置参数后面。

def f1(a,b,c=10,d=20):   #默认值参数必须位于普通
位置参数后面
    print(a,b,c,d)
f1(8,9)
f1(8,9,19)
f1(8,9,19,29)

3,命名参数

我们也可以按照形参的名称传递参数，称为 “ 命名参数 ” ，也称 “ 关键字参数” 。

def f1(a,b,c):
    print(a,b,c)
f1(8,9,19)          #位置参数
f1(c=10,a=20,b=30)  #命名参数

4,可变参数

可变参数指的是 “ 可变数量的参数 ” 。分两种情况：

*param （一个星号），将多个参数收集到一个“元组”对象中。

**param （两个星号），将多个参数收集到一个“字典”对象中。

测试可变参数处理（元组、字典两种方式）

def f1(a,b,**c):
    print(a,b,c)
f1(1,2,c=3)  #1 2 {'c': 3}

def f2(a,b,*c):
    print(a,b,c)
f2(1,2,(3),(4))  #1 2 (3, 4)

def f3(a,b,*c,**d):
    print(a,b,c,d)
f3(1,2,3,4,4,fm=1)  #1 2 (3, 4, 4) {'fm': 1}

5,强制命名参数

在带星号的 “ 可变参数 ” 后面增加新的参数，必须在调用的时候 “ 强制命名参数” 。

def f1(*a,b,c):
    print(a,b,c)
#f1(2,3,4)   #会报错。由于a是可变参数，将2,3,4全部收集。造成b和c没有赋值。
f1(2,b=3,c=4)

八,lambda匿名函数

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

lambda  arg1,arg2,arg3... :  <表达式>

arg1 arg2 arg3 为函数的参数。 < 表达式 > 相当于函数体。运算结果是：表达式的运算结果

lambda表达式使用

f=lambda a,b:a+b
print(f)  #<function <lambda> at 0x0000022CDC1DC5E0>
print(f(2,3))  #5

g=[lambda a,b:a+b,lambda a,b:a-b,lambda a,b:a*b]
print(g[0](2,3),g[1](2,3),g[2](2,3))  #5 -1 6

九,eval()函数

功能：将字符串 str 当成有效的表达式来求值并返回计算结果。

语法： eval(source[, globals[, locals]]) - > value

参数：

source ：一个Python表达式或函数 compile() 返回的代码对象

globals ：可选。必须是 dictionary

locals ：可选。任意映射对象

s="print('abc')"
eval(s)  #abc

a=1
b=2
print(eval('a+b')) #3

dict1=dict(a1=1,b1=2)
d=eval('a1+b1',dict1)
print(d)  #3

⚠️⚠️⚠️ eval函数 会将字符串当做语句来执行，因此会被注入安全隐患。比如：字符串中含有删除文件的语句。那就麻烦大了。因此，使用时候，要慎重！！！

十,递归函数

递归(recursion)是一种常见的算法思路，在很多算法中都会用到。比如：深度优先搜索（DFS:Depth First Search）等。

递归的基本思想就是“自己调用自己

递归函数指的是：自己调用自己的函数，在函数体内部直接或间接的自己调用自己。每个递归函数必须包含两个部分：

终止条件

表示递归什么时候结束。一般用于返回值，不再调用自己。

递归步骤

把第 n 步的值和第 n-1 步相关联。

⚠️ 递归函数由于会创建大量的函数对象、过量的消耗内存和运算能力。在处理大量数据时，谨慎使用。

def my_digui(n):
    """
    这是一个递归函数，用于计算从 n 到 1 的整数之和。

    当 n 为 1 时，直接返回 1，这是递归的终止条件。
    当 n 不为 1 时，函数首先计算 n 加上 my_digui(n - 1)的值。
      这意味着它会先计算 my_digui(n - 1)，即计算从 n - 1 到 1 的整数之和，然后再加上 n。

    以 n 为 5 为例，运算过程如下：
    1. 第一次调用 my_digui(5)：
       - 由于 5 不等于 1，执行 return 5 + my_digui(4)。
       - 此时需要计算 my_digui(4)。
    2. 第二次调用 my_digui(4)：
       - 4 不等于 1，执行 return 4 + my_digui(3)。
       - 此时需要计算 my_digui(3)。
    3. 第三次调用 my_digui(3)：
       - 3 不等于 1，执行 return 3 + my_digui(2)。
       - 此时需要计算 my_digui(2)。
    4. 第四次调用 my_digui(2)：
       - 2 不等于 1，执行 return 2 + my_digui(1)。
       - 此时需要计算 my_digui(1)。
    5. 第五次调用 my_digui(1)：
       - 由于 n 等于 1，直接返回 1。
    6. 然后逐步回溯：
       - my_digui(2) 返回 2 + 1 = 3。
       - my_digui(3) 返回 3 + 3 = 6。
       - my_digui(4) 返回 4 + 6 = 10。
       - my_digui(5) 返回 5 + 10 = 15。
    """
    if n == 1:
        return 1
    else:
        return n + my_digui(n - 1)

print(my_digui(5))  # 15

使用递归函数计算阶乘(factorial)

#练习 使用递归计算阶乘
def jiecheng(n):
    if n==1:
        return 1
    else:
        return n*jiecheng(n-1)
print(jiecheng(5))  #5*4*3*2*1

十一,嵌套函数

嵌套函数：在函数内部定义的函数！

经典案例 

def outer(a):
    def inner(b):
        return a+b
    return inner
f=outer(1)
print(f(2))

一般在什么情况下使用嵌套函数？

封装 - 数据隐藏

外部无法访问“嵌套函数”。

贯彻 DRY(Don’t Repeat Yourself) 原则

嵌套函数，可以让我们在函数内部避免重复代码。

使用嵌套函数避免重复代码

def print1(a,b):
    print(a,b)
def print2(a,b):
    print(b,a)

#把上面2个函数 合二为一
def test(isa,a,b):
    def inner(a,b):
        print('{0} {1}'.format(a,b))
    if isa:
        inner(a,b)
    else:
        inner(b,a)

test(True,1,2)  #1 2
test(False,1,2)  #2 1

十二,局部变量 nonlocal

nonlocal 用来在内部函数中，声明外层的局部变量。

global 函数内声明全局变量，然后才使用全局变量

使用nonlocal声明外层局部变量

a=100
def outer():
    b=10
    def inner():
        nonlocal b
        b=20
        print(a,b)  #100,20
    inner()
    print(a,b) #100,20
outer()
print(a)  #100

十三,LEGB规则

如果某个 name 映射在局部 local 命名空间中没有找到，

接下来就会 在闭包作用域 enclosed 进行搜索，

如果闭包作用域也没有找到， Python就会到全局 global 命名空间中进行查找，

最后会在内建 built- in 命名空间搜索 （如果一个名称在所有命名空间中都没有找到，就会产生一个 NameError ）

s='global'
print('我是全局变量',s)
def outer():
    s='outer'
    print('我是外部函数',s)
    def inner():
        s='inner'
        print('我是内部函数',s)
    inner()
outer()
''''
我是全局变量 global
我是外部函数 outer
我是内部函数 inner
'''

• 学习：知识的初次邂逅
• 复习：知识的温故知新
• 练习：知识的实践应用