python基础之Day7 函数的用法和底层分析_文档字符串调用是什么意思-优快云博客

本文链接：https://blog.youkuaiyun.com/little_yueyue/article/details/108210843

本文深入讲解Python函数的定义、调用、参数传递、作用域、效率测试等核心内容，涵盖内置、标准库、第三方库及自定义函数的使用技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

函数是 可重用的程序代码块。通常一个函数完成 一个功能。
Python 中函数分为如下几类：

内置函数
标准库函数
第三方库函数
用户自定义函数

函数的用法

函数的定义和调用

语法格式

def 函数名 ([参数列表]) :
$\qquad$ ’‘‘文档字符串’’’
$\qquad$ 函数体/若干语句

文档字符串是对函数的说明，相当于注释.
note:
我们使用 def 来定义函数，然后就是一个空格和函数名称。Python 执行 def 时，会创建一个函数对象(python中一切皆对象)，并绑定到函数名变量上。
在这里插入图片描述

调用函数之前，必须要先定义函数，即先调用 def 创建函数对象
(1) 内置函数对象会自动创建
(2) 标准库和第三方库函数，通过 import 导入模块时，会执行模块中的 def 语句

形参和实参

实例：
def printMax(a,b):
$\qquad$ ’‘‘实现两个数的比较，并返回较大的值’’’
$\qquad$ if a>b:
$\qquad$ $\qquad$ print(a,‘较大值’)
$\qquad$ else:
$\qquad$ $\qquad$ print(b,‘较大值’)
printMax(10,20)

形参：

定义时写的 def printMax(a,b)中的a 和 b 称为“形式参数”
形式参数是在定义函数时使用的，是局部变量

实参：

在调用函数时，传递的参数称为“实际参数”，简称“实参”
printMax(a,b)中的10 和 20 是实际参数。

note:
(1) 圆括号内是形式参数列表，有多个参数则使用逗号隔开
(2) 形式参数不需要声明类型，也不需要指定函数返回值类型
(3) 无参数，也必须保留空的圆括号
(4) 实参列表必须与形参列表一一对应

文档字符串

也称“函数的注释”，三个单引号或者三个双引号来实现
调用 help(函数名.__doc__)可以打印输出函数的文档字符串

def print_star(n):
    '''根据传入的 n，打印多个星号'''
    print("*"*n)
help(print_star.__doc__)
#No Python documentation found for '根据传入的 n，打印多个星号'.
#Use help() to get the interactive help utility.
#Use help(str) for help on the str class.

返回值

返回值要点：

如果函数体中包含 return 语句，则结束函数执行并返回值；
如果函数体中不包含 return 语句，则返回 None 值。
要返回多个返回值，使用列表、元组、字典、集合将多个值“存起来”即可。

内存底层分析

执行 def 定义函数后，系统就创建了相应的函数对象。可将其复制给某个变量。

变量的作用域(全局变量和局部变量)

变量起作用的范围称为变量的作用域，不同作用域内同名变量之间互不影响。变量分为：全局变量、局部变量。

$\quad$	全局变量	局部变量
位置	函数和类定义之外声明的变量	在函数体中（包含形式参数）声明的变量
作用域	定义的模块，从定义位置开始直到模块结束	函数体中
特点	降低了函数的通用性和可读性。应尽量避免全局变量的使用	比全局变量快，优先考虑使用
注意事项	一般做常量使用。函数内要改变全局变量的值，使用 global 声明	和全局变量同名，则在函数内隐藏全局变量，只使用同名的局部变量
输出	locals()	globals()

a = 100 #全局变量
def f1():
    #print(a)这行如果不注释掉会报错，函数对不能一会是全局变量一会是局部变量
    global a #如果要在函数内改变全局变量的值，增加 global 关键字声明
    print('a=',a) #打印全局变量 a 的值
    a = 300
f1()
print('a=',a)
#a= 100
#a= 300

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

将函数外的math.sqrt()这一全局变量赋值给了b局部变量

import math
import time
def test01():
    start = time.time()
    for i in range(10000000):
        math.sqrt(30)
    end = time.time()
    print(" 耗 时{0}".format((end-start)))

def test02():    
    start = time.time()
    b = math.sqrt
    for i in range(10000000):
        b(30)
    end = time.time()
    print(" 耗 时{0}".format((end-start)))
test01()
test02()
#耗 时1.4267876148223877
#耗 时1.1075809001922607

参数传递

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

可变对象	不创建新的对象拷贝，直接修改所传递的对象	赋值操作都是引用的赋值
不可变对象	不可变对象无法修改，系统会新创建一个对象	赋值操作都是引用的赋值

b=[1,2]
print('函数运行前全局的b的id',id(b))
def f2(m):
    print('函数内m的id',id(m))
    m.append(30)
    print('函数内m的id',id(m))
f2(b)
print('b=',b)
print('函数运行后全局的b的id',id(b))
#函数运行前全局的b的id 2357681138312
#函数内m的id 2357681138312
#函数内m的id 2357681138312
#b= [1, 2, 30]
#函数运行后全局的b的id 2357681138312

传递可变对象

b=100
print('函数运行前全局的b的id',id(b))
def f2(m):
    print('函数内m的id',id(m))
    m=600
    print('函数内m的id',id(m))
f2(b)
print('b=',b)
print('函数运行后全局的b的id',id(b))
#函数运行前全局的b的id 140705183084016
#函数内m的id 140705183084016
#函数内m的id 2357681098576
#b= 100
#函数运行后全局的b的id 140705183084016

在这里插入图片描述

“=”,浅拷贝和深拷贝

“=”：拷贝对象的引用（参数传递的实质）
浅拷贝copy：不拷贝子对象的内容，只是拷贝子对象的引用。
深拷贝deepcopy：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象(注意是全部拷贝，任意修改都不会影响到源对象)

在这里插入图片描述

参数的几种类型

位置参数

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

默认值参数

为某些参数设置默认值，这样这些参数在传递时就是可选的。默认值参数必须位于普通位置参数后面。

命名参数

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

def f1(a,b,c):
    print(a,b,c)
f1(1,2,3) #位置参数
f1(c=3,a=1,b=2) #命名参数，可以不按位置顺序来
#1 2 3个
#1 2 3

可变参数

可变参数指的是“可变数量的参数”。

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

def f3(a,b,*c,**d):
    print(a,b,c,d)
f3(1,2,3,4,name='yueyue',age=18)#3,4和name='yueyue',age=18交换位置会报错
#1 2 (3, 4) {'name': 'yueyue', 'age': 18}

强制命名参数

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

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)
#(2,) 3 4

lambda 表达式和匿名函数

lambda 表达式可以用来声明匿名函数。lambda 函数实际生成了一个函数对象。lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值。

语法结构

lambda arg1,arg2,arg3… : <表达式>
arg1，arg2，arg3 …为函数的参数

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

eval()函数

语法结构

eval(source[, globals[, locals]]) -> value
参数：
source：一个 Python 表达式或函数 compile()返回的代码对象
globals：可选。必须是 dictionary
locals：可选。任意映射对象

dict1 = dict(a=100,b=200)
d = eval("a+b",dict1)
print(d)
#300

功能：将字符串 str 当成有效的表达式来求值并返回计算结果。
通过eval()可以将代码传进来

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

递归函数

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

终止条件：表示递归什么时候结束。一般用于返回值，不再调用自己。
递归步骤：把第 n 步的值和第 n-1 步相关联。

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

def t(n):
    print('n为{}'.format(n),end='\t')
    if n==0:
        print('gameover')
    else:
        t(n-1)
    print('n为{}'.format(n),end='\t')
t(3)
#n为3	n为2	n为1	n为0	gameover
#n为0	n为1	n为2	n为3

在这里插入图片描述

嵌套函数

在函数内部定义的函数

def outer():
    print('outer running...')
    def inner():
        print('inner running...')
    inner()
outer()
#outer running...
#inner running...
inner()#会报错，因为inner是内部函数，外部无法调用