函数用法和底层分析
Python函数分类
- 内置函数
str() list() len()等都是内置函数，可以直接拿来用 - 标准库函数
可通过import导入库，然后使用库中的函数 - 第三方库函数
除了标准库以外，还有海量的第三方库。依然是通过import导入使用其中的函数。 - 用户自定义函数
用户在开发中满足自身需求的函数
函数定义、调用
- 定义函数的语法：
def 函数名([参数列表])
'''文档字符串-函数的注释'''
函数体、若干语句
- 参数列表
- 圆括号内的参数是形式参数，形参不需要声明类型、不需要指定函数返回值类型；
- 多个参数逗号隔开；
- 没有参数也要保留小括号；
- 实参列表要和形参列表一一对应；
- return 返回值
- 如果函数体中有return语句，则结束函数并返回值
- 不含return则返回None；
栗子
def printMax(a,b):
'''实现两个数的比较，并返回较大的值'''
if a>b:
print(a,'较大值')
else:
print(b,'较大值')
printMax(10,20)
printMax(30,5)
- 形参：a,b
- 实参：10，20 、 30，5
- 函数注释使用三个单引号或者三个双引号，可以多行注释
函数也是对象，内存底层分析
def print_star(n):
print("*"*n)
print(print_star)
print(id(print_star))
c = print_star
c(3)
执行结果:
<function print_star at 0x0000000002BB8620>
45844000
***
全局变量、局部变量
- 全局变量
- 在函数和类定义之外，声明的变量。作用域从定义位置开始一直到模块结束；
- 全局变量降低了函数通用性和可读性，尽量避免使用
- 全局变量一般做常量使用
- 如果函数内部要去改变全局变量的值，使用global声明一下
- 局部变量
- 在函数体内声明的变量
- 局部变量的引用比全局变量快，优先考虑使用
- 如果全局和局部变量重名，则在函数内部会隐藏全局变量，使用局部变量的值；
局部变量和全局变量效率
在循环次数较多或者强调效率的地方应该把全局变量改成局部变量
#测试局部变量、全局变量的效率
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():
b = math.sqrt
start = time.time()
for i in range(10000000):
b(30)
end = time.time()
print("耗时{0}".format((end-start)))
test01()
test02()
结果：
耗时0.6849961280822754
耗时0.40373921394348145
可变对象有:
字典、列表、集合、自定义的对象等
不可变对象有:
数字、字符串、元组、function 等
传递可变对象的引用
在函数体中不创建新的对象拷贝，而是可以直接修改所传递的对象。
b = [10,20]
def f2(m):
print("m:",id(m))
m.append(30)
f2(b)
print("b:",id(b))
print(b)
结果：
m: 4308600576
b: 4308600576
[10, 20, 30]
传递不可变对象的引用
在”赋值操作”时，由于不可变对象无法修改，系统会新创建一个对象。
a = 100
def f1(n):
print("n:",id(n))
n = n+200
print("n:",id(n))
print(n)
f1(a)
print("a:",id(a))
结果：
n: 4301067728
n: 4316971824
300
a: 4301067728
浅拷贝和深拷贝
- 浅拷贝:不拷贝子对象的内容，只是拷贝子对象的引用。
- 深拷贝:会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象
import copy
def testCopy():
'''测试浅拷贝'''
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)
testCopy()
print("*************")
testDeepCopy()
结果：
a [10, 20, [5, 6]]
b [10, 20, [5, 6]]
浅拷贝......
a [10, 20, [5, 6, 7]]
b [10, 20, [5, 6, 7], 30]
*************
a [10, 20, [5, 6]]
b [10, 20, [5, 6]]
深拷贝......
a [10, 20, [5, 6]]
b [10, 20, [5, 6, 7], 30]
浅拷贝：
深拷贝：
参数类型
- 位置参数
形参和实参一一对应匹配 - 默认值参数
默认值参数放到普通形参后面去定义
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)
结果：
8 9 10 20
8 9 19 20
8 9 19 29
- 命名参数
按照形参的名称传递参数，称为“命名参数”，也称“关键字参数”
def f1(a,b,c):
print(a,b,c)
f1(8,9,19) #位置参数
f1(c=10,a=20,b=30) #命名参数
结果：
8 9 19
20 30 10
- 可变参数
可变参数指的是“可变数量的参数”。分两种情况:- *param(一个星号)，将多个参数收集到一个“元组”对象中。
- **param(两个星号)，将多个参数收集到一个“字典”对象中
def f1(a,b,*c):
print(a,b,c)
f1(8,9,19,20)
def f2(a,b,**c):
print(a,b,c)
f2(8,9,name='gaoqi',age=18)
def f3(a,b,*c,**d):
print(a,b,c,d)
f3(8,9,20,30,name='gaoqi',age=18)
结果：
8 9 (19, 20)
8 9 {‘name’: ‘gaoqi’, ‘age’: 18}
8 9 (20, 30) {‘name’: ‘gaoqi’, ‘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 arg1,arg2,arg3… : <表达式>
arg1/arg2/arg3 为函数的参数。<表达式>相当于函数体。
运算结果是:表达式的运算结果。
f = lambda a,b,c:a+b+c
print(f)
print(f(2,8,4))
g = [lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g[0](6),g[1](7),g[2](8))
结果：
<function <lambda> at 0x10730b3a0>
14
12 21 32
nonlocal 关键字
- nonlocal 用来声明外层的局部变量
- global 用来声明全局变量
#测试 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("a:",a)
结果：
inner b: 10
outer b: 20
a: 1000
432
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
