一、函数的定义与调用
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，这就是没有返回值的一种情况。
def lenght(s):
l = 0
for i in s: # 关于for 循环的基本用法是时候做一波总结了
l = l + 1
a = ‘ssssssss‘
print(lenght(a))
>>> None
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，结束整个函数
def ret_demo():
print(111)
return
print(222)
ret = ret_demo()
print(ret)
>>>111
None
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）形参与实参
def lenght(s): # 形参
L = 0
for i in s: # 关于for 循环的基本用法是时候做一波总结了
L = L + 1
return L
a = ‘ssssssss‘
print(lenght(a)) # 实参
>>> 8<span id="mce_marker" data-mce-type="bookmark"></span><span id="__caret">_</span><span id="mce_marker" data-mce-type="bookmark"></span><span id="__caret">_</span>
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、按照关键字传参
def mymax(x,y):
#此时x = 20,y = 10
print(x,y)
the_max = x if x > y else y
return the_max
ma = mymax(y = 10,x = 20)
print(ma)
>>>20 10
20
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、位置、关键字混着来
def mymax(x,y):
#此时x = 20,y = 10
print(x,y)
the_max = x if x > y else y
return the_max
ma = mymax(10,y = 20)
print(ma)
>>>10 20
20
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、默认参数
def stu_info(name,sex = "male"): # 形参
"""打印学生信息函数，由于班中大部分学生都是男生，
所以设置默认参数sex的默认值为‘male‘
"""
print(name,sex)
stu_info(‘pontoon‘, ‘female‘) # 实参
>>> pontoon female
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给函数体调用
def sum_func(*args):
x = 0
for i in args:
x = i + x
return x
print(sum_func(1, 2, 3, 4))
>>> 10
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是不一样的-------------------------------------------
当函数接收到的参数是一个可变数据类型时，则会共享引用！
def mutable(num_list):
num_list.extend([1, 2, 3])
print(num_list)
gl_list = [5, 6, 7] # 接收一个列表
mutable(gl_list) # 执行函数
print(gl_list)
>>>[5, 6, 7, 1, 2, 3]
[5, 6, 7, 1, 2, 3]
-----------------------------------------------------------------------------------
def demo(num, num_list):
print(‘函数内部代码‘)
num += num
num_list += num_list # 相当于执行num_list.extend(num_list)
print(num)
print(num_list)
print(‘内部代码完成‘)
gl_num = 9
gl_list = [1, 2, 3]
demo(gl_num, gl_list)
print(gl_num)
print(gl_list)
>>>函数内部代码
18
[1, 2, 3, 1, 2, 3]
内部代码完成
9
[1, 2, 3, 1, 2, 3]
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方法
看一段代码
# 这个函数时会报错的
def sss():
a = 10
print(a)
print(sss())
print(a)
>>>10
NameError: name ‘a‘ is not defined
-----------------------------------------------------------------------------------
# 加上global关键字就不会了
a = 20
def sss():
global a
a = 10
print(a)
print(a)
print(sss())
print(a)
>>> 20 # 全局作用域的a
10 # 调用函数是函数局部打印的a
None # 调用函数是由于没有返回值，所以返回None
10 # global关键字，将局部变量转换成了全局变量
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关键字，将局部变量转换成了全局变量
函数的嵌套和作用域链
函数的本质：是一个变量，变量可以作为函数的参数接收，变量也被函数返回，所以一个函数既可以接受函数也可以返回函数
函数的嵌套的本质：就是函数接收函数以及返回函数！
# 函数之间的调用
def max_func(x, y):
return x if x > y else y
def max_func01(a, b, c, d):
ret1 = max_func(a, b)
ret2 = max_func(c, ret1)
ret3 = max_func(ret2, d)
return ret3
print(max_func01(10, 32, -45, 22))
>>> 32
-------------------------------------------------------------------------------
# 函数嵌套
def outer():
print(‘outer‘)
def inner():
print(‘inner‘)
return inner
print(outer())
>>>outer
<function outer.<locals>.inner at 0x000000DBE7D73730> # 只调用了一层函数，return的是一个函数名，所以print的时候打印出了地址
print(outer()()) # 调用两层
>>>outer
inner
None # 内层的inner()函数没有返回值，所以print None
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
闭包
什么叫做闭包？
内部函数包含对外部作用域而非全局作用域名字的引用，该内部函数称之为闭包
为什么要用到闭包？
闭包的作用：当我们在调用完函数后，函数内部的变量都会被释放，但是使用了闭包函数，因为内部函数引用了外部函数的变量，所以外部函数的变量永远不会消失！所以闭包的作用就是储存内部函数的变量！
# 创建一个简单的闭包函数
def outer():
a = 2
def inner():
print(a)
return inner
print(outer()())
>>>2
None
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函数的概念就到此为止了。
span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }.cm-searching {background: #ffa; background: rgba(255, 255, 0, .4);}.cm-force-border { padding-right: .1px; }@media print { .CodeMirror div.CodeMirror-cursors {visibility: hidden;}}.cm-tab-wrap-hack:after { content: ""; }span.CodeMirror-selectedtext { background: none; }.CodeMirror-activeline-background, .CodeMirror-selected {transition: visibility 0ms 100ms;}.CodeMirror-blur .CodeMirror-activeline-background, .CodeMirror-blur .CodeMirror-selected {visibility:hidden;}.CodeMirror-blur .CodeMirror-matchingbracket {color:inherit !important;outline:none !important;text-decoration:none !important;}.CodeMirror-sizer {min-height:auto !important;}
-->
li {list-style-type:decimal;}.wiz-editor-body ol.wiz-list-level2 > li {list-style-type:lower-latin;}.wiz-editor-body ol.wiz-list-level3 > li {list-style-type:lower-roman;}.wiz-editor-body blockquote {padding: 0 12px;}.wiz-editor-body blockquote > :first-child {margin-top:0;}.wiz-editor-body blockquote > :last-child {margin-bottom:0;}.wiz-editor-body img {border:0;max-width:100%;height:auto !important;margin:2px 0;}.wiz-editor-body table {border-collapse:collapse;border:1px solid #bbbbbb;}.wiz-editor-body td,.wiz-editor-body th {padding:4px 8px;border-collapse:collapse;border:1px solid #bbbbbb;min-height:28px;word-break:break-word;box-sizing: border-box;}.wiz-hide {display:none !important;}
-->
原文地址：https://www.cnblogs.com/pontoon/p/10238248.html