一、函数的定义与调用
11
1
def lenght(s):
2
l = 0
3
for i in s: # 关于for 循环的基本用法是时候做一波总结了
4
l = l + 1
5
return l
6
7
8
a = 'ssssssss'
9
print(lenght(a))
10
11
>>> 8
# 1 函数的返回值
1）return关键字的作用
return 是一个关键字，这个词翻译过来就是“返回”，所以我们管写在return后面的值叫“返回值”，要研究返回值，我们还要知道返回值有几种情况：分别是没有返回值、返回一个值、返回多个值
2）没有返回值
不写return的情况下，会默认返回一个None：我们写的第一个函数，就没有写return，这就是没有返回值的一种情况。
12
1
def lenght(s):
2
l = 0
3
for i in s: # 关于for 循环的基本用法是时候做一波总结了
4
l = l + 1
5
6
7
8
a = 'ssssssss'
9
print(lenght(a))
10
11
12
>>> None
3）只写return
只写return，后面不写其他内容，也会返回None，有的同学会奇怪，既然没有要返回的值，完全可以不写return，为什么还要写个return呢？这里我们要说一下return的其他用法，就是
一旦遇到return，结束整个函数
12
1
def ret_demo():
2
print(111)
3
return
4
print(222)
5
6
7
ret = ret_demo()
8
print(ret)
9
10
11
>>>111
12
None
4）返回一个值
刚刚我们已经写过一个返回一个值的情况，只需在return后面写上要返回的内容即可。
5）返回多个值
可以返回任意多个、任意数据类型的值
19
1
# return 返回多个值
2
def func():
3
return 1, 2, 3, 4
4
5
func()
6
print(func())
7
8
>>>(1, 2, 3, 4) #返回值为一个元组
9
10
11
# 返回多个值的接收
12
def func():
13
return 1, 2, 3, 4
14
15
16
a, b, c, d = func()
17
print(a, b, c, d)
18
19
>>>1 2 3 4
总结下函数的返回 return
1）
当函数没有return时：在调用函数的时候返回None
2）
当函数return后面没有传参数时：调用函数时也返回None
3）
return可以以元组的形式返回多个数据
# 2 函数的参数
1）形参与实参
11
1
def lenght(s): # 形参
2
L = 0
3
for i in s: # 关于for 循环的基本用法是时候做一波总结了
4
L = L + 1
5
return L
6
7
8
a = 'ssssssss'
9
print(lenght(a)) # 实参
10
11
>>> 8
2）传递多个参数
7
1
# 函数传递多个参数
2
def sum01(x, y):
3
return x if x > y else y # 三元运算符
4
5
print(sum01(1, 2))
6
7
>>>2
3)位置参数
1、按照位置传参
2、按照关键字传参
11
1
def mymax(x,y):
2
#此时x = 20,y = 10
3
print(x,y)
4
the_max = x if x > y else y
5
return the_max
6
7
ma = mymax(y = 10,x = 20)
8
print(ma)
9
10
>>>20 10
11
20
3、位置、关键字混着来
11
1
def mymax(x,y):
2
#此时x = 20,y = 10
3
print(x,y)
4
the_max = x if x > y else y
5
return the_max
6
7
ma = mymax(10,y = 20)
8
print(ma)
9
10
>>>10 20
11
20
4、默认参数
10
1
def stu_info(name,sex = "male"): # 形参
2
"""打印学生信息函数，由于班中大部分学生都是男生，
3
所以设置默认参数sex的默认值为'male'
4
"""
5
print(name,sex)
6
7
stu_info('pontoon', 'female') # 实参
8
>>> pontoon female
9
10
5、动态传参(*args, **kwargs)
面试题*args与**kwargs的区别？
*args 用来将参数打包成tuple给函数体调用
**kwargs 打包关键字参数成dict给函数体调用
10
1
def sum_func(*args):
2
x = 0
3
for i in args:
4
x = i + x
5
return x
6
7
8
print(sum_func(1, 2, 3, 4))
9
10
>>> 10
6、传递可变参数
------------------------------在函数中num = num+num与num += num是不一样的-------------------------------------------
38
1
当函数接收到的参数是一个可变数据类型时，则会共享引用！
2
def mutable(num_list):
3
num_list.extend([1, 2, 3])
4
print(num_list)
5
6
7
gl_list = [5, 6, 7] # 接收一个列表
8
mutable(gl_list) # 执行函数
9
print(gl_list)
10
11
>>>[5, 6, 7, 1, 2, 3]
12
[5, 6, 7, 1, 2, 3]
13
14
-----------------------------------------------------------------------------------
15
def demo(num, num_list):
16
print('函数内部代码')
17
18
num += num
19
num_list += num_list # 相当于执行num_list.extend(num_list)
20
21
print(num)
22
print(num_list)
23
print('内部代码完成')
24
25
26
gl_num = 9
27
gl_list = [1, 2, 3]
28
demo(gl_num, gl_list)
29
print(gl_num)
30
print(gl_list)
31
32
33
>>>函数内部代码
34
18
35
[1, 2, 3, 1, 2, 3]
36
内部代码完成
37
9
38
[1, 2, 3, 1, 2, 3]
7、顺序
函数的执行顺序：
位置参数，*args，默认参数，**kwargs
二，命名空间和作用域
三种命名空间之间的加载与取值顺序：
命名空间的本质：存放名字与值的绑定关系
加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)
取值顺序：
在局部调用：局部命名空间->全局命名空间->内置命名空间
在全局调用：全局命名空间->内置命名空间
综上所述，在找寻变量时，从小范围，一层一层到大范围去找寻。
作用域
作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。
全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
局部作用域：局部名称空间，只能在局部范围内生效
globals和locals方法
看一段代码
27
1
# 这个函数时会报错的
2
def sss():
3
a = 10
4
print(a)
5
6
print(sss())
7
print(a)
8
9
>>>10
10
NameError: name 'a' is not defined
11
12
-----------------------------------------------------------------------------------
13
# 加上global关键字就不会了
14
a = 20
15
def sss():
16
global a
17
a = 10
18
print(a)
19
20
print(a)
21
print(sss())
22
print(a)
23
24
>>> 20 # 全局作用域的a
25
10 # 调用函数是函数局部打印的a
26
None # 调用函数是由于没有返回值，所以返回None
27
10 # global关键字，将局部变量转换成了全局变量
函数的嵌套和作用域链
函数的本质：是一个变量，变量可以作为函数的参数接收，变量也被函数返回，所以一个函数既可以接受函数也可以返回函数
函数的嵌套的本质：就是函数接收函数以及返回函数！
35
1
# 函数之间的调用
2
def max_func(x, y):
3
return x if x > y else y
4
5
6
def max_func01(a, b, c, d):
7
ret1 = max_func(a, b)
8
ret2 = max_func(c, ret1)
9
ret3 = max_func(ret2, d)
10
return ret3
11
12
13
print(max_func01(10, 32, -45, 22))
14
15
>>> 32
16
-------------------------------------------------------------------------------
17
18
# 函数嵌套
19
def outer():
20
print('outer')
21
22
def inner():
23
print('inner')
24
return inner
25
26
print(outer())
27
28
>>>outer
29
<function outer.<locals>.inner at 0x000000DBE7D73730> # 只调用了一层函数，return的是一个函数名，所以print的时候打印出了地址
30
31
print(outer()()) # 调用两层
32
33
>>>outer
34
inner
35
None # 内层的inner()函数没有返回值，所以print None
函数的作用域链
函数的作用域链的本质：就是内部函数可以引用外部函数的变量，包括外部函数的形参
看三个例子
1 # 函数嵌套的定义——内部函数可以使用外部函数的变量 2 def outer(): 3 a = 1 4 5 def inner(): 6 b = 2 7 print(a) 8 print("inner") 9 10 def in_inner(): 11 print(a, b) 12 print("in_inner") 13 in_inner() 14 inner() 15 16 17 outer() 18 19 >>>1 20 inner 21 1 2 22 in_inner
1 a = 1 2 3 4 def outer(): 5 a = 1 6 7 def inner(): 8 b = 2 9 print(a) 10 print("inner") 11 12 def in_inner(): 13 global a 14 a += 1 15 print("in_inner") 16 in_inner() 17 inner() 18 print('函数内部a:', a) 19 20 21 outer() 22 print("全局变量a:", a) 23 24 >>>1 25 inner 26 in_inner 27 函数内部a: 1 28 全局变量a: 2
1 a = 1 2 3 4 def outer(): 5 a = 1 6 7 def inner(): 8 a = 2 9 print(a) 10 print("inner") 11 12 def in_inner(): 13 nonlocal a # 不同于global只将a返回给上一级，不能返回给全局 14 a += 1 15 print("in_inner") 16 in_inner() 17 print("in_inner a:", a) 18 inner() 19 print('函数内部 a:', a) 20 21 22 outer() 23 print("全局变量 a:", a) 24 25 >>> 2 26 inner 27 in_inner 28 in_inner a: 3 29 函数内部 a: 1 30 全局变量 a: 1
闭包
什么叫做闭包？
内部函数包含对外部作用域而非全局作用域名字的引用，该内部函数称之为闭包
为什么要用到闭包？
闭包的作用：当我们在调用完函数后，函数内部的变量都会被释放，但是使用了闭包函数，因为内部函数引用了外部函数的变量，所以外部函数的变量永远不会消失！所以
闭包的作用就是储存内部函数的变量！
x
1
# 创建一个简单的闭包函数
2
def outer():
3
a = 2
4
5
def inner():
6
print(a)
7
return inner
8
9
print(outer()())
10
11
>>>2
12
None
好吧至此python函数的概念就到此为止了。