标签：基本 nta 默认 实参 ring hidden 分享图片 简单 12px
def lenght(s):
l = 0
for i in s: # 关于for 循环的基本用法是时候做一波总结了
l = l + 1
return l
a = ‘ssssssss‘
print(lenght(a))
>>> 8
return 是一个关键字，这个词翻译过来就是“返回”，所以我们管写在return后面的值叫“返回值”，要研究返回值，我们还要知道返回值有几种情况：分别是没有返回值、返回一个值、返回多个值
不写return的情况下，会默认返回一个None：我们写的第一个函数，就没有写return，这就是没有返回值的一种情况。
def lenght(s):
l = 0
for i in s: # 关于for 循环的基本用法是时候做一波总结了
l = l + 1
a = ‘ssssssss‘
print(lenght(a))
>>> None
def ret_demo():
print(111)
return
print(222)
ret = ret_demo()
print(ret)
>>>111
None
刚刚我们已经写过一个返回一个值的情况，只需在return后面写上要返回的内容即可。
可以返回任意多个、任意数据类型的值
# return 返回多个值
def func():
return 1, 2, 3, 4
func()
print(func())
>>>(1, 2, 3, 4) #返回值为一个元组
# 返回多个值的接收
def func():
return 1, 2, 3, 4
a, b, c, d = func()
print(a, b, c, d)
>>>1 2 3 4
def lenght(s): # 形参
L = 0
for i in s: # 关于for 循环的基本用法是时候做一波总结了
L = L + 1
return L
a = ‘ssssssss‘
print(lenght(a)) # 实参
>>> 8
# 函数传递多个参数
def sum01(x, y):
return x if x > y else y # 三元运算符
print(sum01(1, 2))
>>>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
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
def stu_info(name,sex = "male"): # 形参
"""打印学生信息函数，由于班中大部分学生都是男生，
所以设置默认参数sex的默认值为‘male‘
"""
print(name,sex)
stu_info(‘pontoon‘, ‘female‘) # 实参
>>> pontoon female
def sum_func(*args):
x = 0
for i in args:
x = i + x
return x
print(sum_func(1, 2, 3, 4))
>>> 10
当函数接收到的参数是一个可变数据类型时，则会共享引用！
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]
函数的执行顺序：
位置参数，*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关键字，将局部变量转换成了全局变量
# 函数之间的调用
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
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
标签：基本 nta 默认 实参 ring hidden 分享图片 简单 12px
原文地址：https://www.cnblogs.com/pontoon/p/10238248.html
