文章目录
函数是可重用的程序代码块。函数的作用,不仅可以实现代码的复用,更能实现代码的一致性。
函数简介
函数的基本概念:
- 一个程序由一个个任务组成;函数就是代表一个任务或者一个功能。
- 函数是代码复用的通用机制。
python函数分类:
- 内置函数,str()、list()、len()
- 标准库函数,通过import语句导入库,然后使用其中定义的函数
- 第三方库函数, Python社区也提供了很多高质量的库,下载安装这些库后,也是通过import语句导入,然后可以使用这些第三方库的函数
- 用户自定义函数
函数的定义和调用
函数的语法:
- 我们使用def来定义函数,然后就是一个空格和函数名称,python执行def时,会创建一个函数对象,并绑定到函数名变量上
- 参数列表:
(1) 圆括号内是形式参数列表,有多个参数则使用逗号隔开
(2) 形式参数不需要声明类型,也不需要指定函数返回值类型
(3) 无参数,也必须保留空的圆括号
(4) 实参列表必须与形参列表一一对应 - return返回值:
(1) 如果函数体中包含return语句,则结束函数执行并返回值
(2) 如果函数体中不包含return语句,则返回None值 - 调用函数之前,必须要先定义函数,即先调用def创建函数对象
(1) 内置函数对象会自动创建
(2) 标准库和第三方库函数,通过import导入模块时,会执行模块中的def语句
def 函数名 ([参数列表]) :
'''文档字符串'''
函数体/若干语句
形参和实参
#形参和实参
def max(a,b):
'''测试两个数最大值'''
if a>b:
print("最大值{0}".format(a))
else:
print("最大值{0}".format(b))
max(1,2)
文档字符串(函数的注释)
三个单引号或者三个双引号,help(函数名.doc)可以打印输出函数的文档字符串
返回值
- 如果函数体中包含return语句,则结束函数执行并返回值
- 如果函数体中不包含return语句,则返回None值
- 要返回多个返回值,使用列表、元组、字典、集合将多个值“存起来”即可
#打印n个*,无返回值
def print_star(n):
print("*"*n)
print_star(5)
#返回两个数平均值的函数
def avg_num(a,b):
return (a+b)/2
c = avg_num(1,2)
print(c)
函数也是对象,内存底层分析
执行def定义函数后,系统就创建了相应的函数对象
def print_star(n):
print("*"*n)
print(print_star)
print(id(print_star))
c = print_star
c(3)
变量c和print_star都是指向了同一个函数对象,执行c(3)和执行print_star(3)的效果是完全一致的,圆括号意味着调用函数。在没有圆括号的情况下,Python会把函数当做普通对象。
变量的作用域
全局变量:
- 在函数和类定义之外声明的变量。作用域为定义的模块,从定义位置开始直到模块结束。
- 全局变量降低了函数的通用性和可读性。应尽量避免全局变量的使用。
- 全局变量一般做常量使用。
- 函数内要改变全局变量的值,使用global声明一下
局部变量:
- 在函数体中(包含形式参数)声明的变量。
- 局部变量的引用比全局变量快,优先考虑使用。
- 如果局部变量和全局变量同名,则在函数内隐藏全局变量,只使用同名的局部变量
#案例1:
a = 100
def f1():
global a #如果要在函数内改变全局变量的值,增加global关键字
print(a) #打印全局变量a的值
a = 300
f1()
print(a)
#案例2:
a = 100
def f1():
a = 3 #同名的局部变量
print(a)
f1()
print(a)
#案例3:
a = 100
def f1(a,b,c):
print(a,b,c)
print(locals()) #打印输出的局部变量
print("+++++++")
print(globals()) #打印输出的全局变量
f1(2,3,4)
#案例4:测试全局变量和局部变量效率
import math
import time
#在特别强调效率的地方或者循环次数较多的地方,可以通过将全局变量转为局部变量提高运行速度。
def test01():
start01 = time.time()
for i in range(10000):
math.sqrt(30)
end01 = time.time()
print("耗时{0}".format(end01-start01))
def test02():
a = math.sqrt
start02 = time.time()
for i in range(10000):
a(30)
end02 = time.time()
print("耗时{0}".format(end02-start02))
test01()
test02()
参数的传递
实质上从实参到形参的赋值操作,Python中参数的传递都是“引用传递”,不是“值传递”。
- 对“可变对象”进行“写操作”,直接作用于原对象本身。
- 对“不可变对象”进行“写操作”,会产生一个新的“对象空间”,并用新的值填充这块空间。
#传递可变对象
b = [10,20]
def f2(m):
print("m",id(m)) #b和m是一个对象
m.append(30) #由于m是可变对象,不创建对象拷贝直接修改这个对象
f2(b)
print("b",id(b))
print(b)
#传递不可变对象
a = 100
def f1(n):
print("n",id(n))
n = n+200
print("n:",id(n))
print(n)
f1(a)
print("a:",id(a))
深拷贝和浅拷贝
copy(浅拷贝):不拷贝子对象的内容,只拷贝子对象的引用
deepcopy(深拷贝):会连子对象的内存也全部拷贝一份,对子对象的修改不会影响源对象
#测试浅拷贝和深拷贝
import copy
def testCpoy():
a= [10,20,[5,6]]
b = copy.copy(a)
print("a",a)
print("b",b)
b.append(30)
b[2].append(7)
print("浅拷贝……")
print("a",a)
print("b",b)
def testDeepCopy():
a = [10,20,[5,6]]
b = copy.deepcopy(a)
print("a",a)
print("b",b)
b.append(30)
b[2].append(7)
print("深拷贝……")
print("a",a)
print("b",b)
testCpoy()
testDeepCopy()
传递不可变对象包含的子对象是可变的情况
不可变对象里面包含的子对象是可变的,则方法内修改了这个可变对象,源对象也发生了变化
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)
参数的几种类型
位置参数:函数调用时,实参默认按位置顺序传递,需要个数和形参匹配。不匹配报错。
def f(a,b,c):
print(a,b,c)
f(2,3,4)
f(2)
默认值参数:我们可以为某些参数设置默认值,这样这些参数在传递时就是可选的。默认值参数必须位于普通位置参数的后面
def f(a,b,c=10,d=20):
print(a,b,c,d)
f(1,2)
f(1,2,3,4)
命名参数:按照形参的名称传递参数
def f(a,b,c):
print(a,b,c)
f(c=1,a=4,b=5)
可变参数:可变数量的参数。1. *param(一个星号),将多个参数收集到一个“元组”对象中。2、**param(两个星号),将多个参数收集到一个“字典”对象中。
def f(a,b,*c):
print(a,b,c)
f(1,2,3,4,5)
def f1(a,b,**c):
print(a,b,c)
f1(8,9,name='zmx',age=18)
强制命名参数:在带星号的“可变参数”后面增加新的参数,必须在调用的时候“强制命名参数”。
def f(*a,b,c):
print(a,b,c)
# f(2,3,4) 会报错,由于a是可变参数,将2,3,4全部收集。造成b和c没有赋值。
f(2,b=3,c=4)
lambda表达式和匿名函数:lambda表达式可以用来声明匿名函数。lambda函数实际生成了一个函数对象。lambda arg1,arg2,arg3… : <表达式>
f = lambda a,b,c:a+b+c
print(f)
print(f(2,3,4))
g = [lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g[0](6),g[1](7),g[2](8))
eval()函数:将字符串str当成有效的表达式来求值并返回计算结果,eval(source[, globals[, locals]]) -> value,字符串中含有删除文件的语句慎用
s = "print('abcd')"
eval(s)
a = 10
b = 20
c = eval("a+b")
print(c)
dict1 = dict(a=100,b=300)
d=eval("a+b",dict1)
print(d)
递归函数:自己调用自己的函数,在函数体内部直接或间接的自己调用自己。必须包含:1、终止条件,表示递归什么时候结束 2、递归步骤,把第n步的值和第n-1步相关联;递归函数由于会创建大量的函数对象、过量的消耗内存和运算能力。在处理大量数据时,谨慎使用。
def f(n):
if n==1:
return n;
else:
return n*f(n-1);
for i in range(1,6):
print(i,"!=",f(i))
嵌套函数(内部函数):在函数内部定义的函数
一般在什么情况下使用嵌套函数?
- 封装 - 数据隐藏 外部无法访问“嵌套函数”。
- 贯彻 DRY(Don’t Repeat Yourself) 原则 嵌套函数,可以让我们在函数内部避免重复代码。
- 闭包
def f1():
print("f1 running")
def f2():#f2()就是定义在f1函数内部的函数。f2()的定义和调用都在f1()函数内部。
print("f2 running")
f2()
f1()
#中文名和英文名(嵌套函数避免代码重复)
def printName(isChinese,name,familyName):
def inner_print(a,b):
print("{0}{1}".format(a,b))
if isChinese:
inner_print(familyName,name)
else:
inner_print(name,familyName)
printName(True,"mengxi","zhu")
nonlocal关键字
nonlocal用来声明外层的局部变量,global用来声明全局变量
a=100
def outer():
b=10
def inner():
nonlocal b #声明外部函数的局部变量
print("inner b:",b)
b=20
global a #声明全局变量
a=1000
inner()
print("outer b",b)
outer()
print("inner a",a)
LEGB原则
Local–>Enclosed–>Global–>Built in
Local 指的就是函数或者类的方法内部
Enclosed 指的是嵌套函数(一个函数包裹另一个函数,闭包)
Global 指的是模块中的全局变量
Built in 指的是Python为自己保留的特殊名称。