小学生都能学会的python(函数的进阶)

小学生都能学会的python(函数的进阶)

1. 动态传参
形参:
1. 位置参数
2. 默认值参数
3. 动态传参
*args 动态接收位置参数
**kwargs 动态接收关键字参数
def func(*args, **kwargs):
在形参上用*,** 表示聚合. 实参表示打散

顺序:
位置 *args 默认值 **kwargs

# def chi(*food): # * 表示的是不定参数. 可以传递任意个信息 参数名是food, 接受到的是元组
#     print("我要吃", food)
#
# chi("一锅大米饭", "一箱辣条", "一桶方便面", "4L可乐")
# chi("方便面")
# chi("一大锅米饭", "一小锅小米饭", "一箱辣条", "一桶方便面", "4L可乐")

# * 表接收位置参数的动态传参
# 传参的顺序
# 位置 *args 默认值 **kwargs
#
# 如果默认值参数在*args前面. 如果想让默认值生效. *args将永远接不到值
# def func( a, b, *args,c = 5): # arguments参数
#     print(a, b, c, args)
#
# func(1,2,3,4,5,6,8,c = 10)

# 关键字的动态传参
# *args 位置参数 接收到的是元组
# **kwargs 关键字的动态传参, 接收到的是字典
# def func(**kwargs): # key word arguments
#     print(kwargs)
#
# func(a=10, b=20, jay="周杰伦", jj="林俊杰")

# 无敌模式. 所有的参数都能接收
# def func(*args, **kwargs):
#     print(args)
#     print(kwargs)
#
# func(1, 2, 5, jj="陶喆", jay="zhoujielun", soup="胡辣汤")

# def func(*args): # 在这里. 其实相当于把传进来的参数做了一次聚合, 聚合成一个元组
#     print(args)
#
# lst = "娃哈哈"
# func(*lst) #  在实参位置 * 表示打散, 打散的是可迭代对象


# def func(**kwargs): # ** 把接收到的关键字参数打包(聚合)成字典
#     print(kwargs) # 一定是字典
#
# dic = {"张无忌": "明教教主", "谢逊": "金毛狮王", "范瑶": "光明右使"}
#
# # func(张无忌=dic['张无忌'], 谢逊=dic['谢逊'], 范瑶=dic['范瑶'])
# func(**dic) # 这里的** 是把字典打散. 字典的key作为参数的名字, 字典的值作为参数的值传递给形参

# 在形参上
#   1. 位置参数
#   2. 默认值参数
#   3. 动态参数
#       1. *args  位置参数的动态传参. 系统会自动的把所有的位置参数聚合成元组
#       2. **kwargs  关键字的动态传参. 系统会自动把所有的关键字参数聚合成字典
#       3.  def func(*args, **kwargs): 无敌传参
#       4. 顺序:  位置参数, *args, 默认值, **kwargs
#       5. 在使用的时候, 可以任意的进行搭配
#   4. 在实参上. *, **表示的打散.  在形参. *,** 表示聚合

　　

2. 作用域
名称空间:
1. 内置
2. 全局
3. 局部

作用域:
1. 全局作用域: 内置+全局
2. 局部作用域: 局部

globals() 查看全局作用域中的内容
locals() 查看当前作用域中的内容

# 最开始会开辟一个自己的命名空间- 内置名称空间
# a = 10
# print(a)
# # 直接在py文件一个层面上是全局名称空间
# def func():
#     hasakey = 10
# # 在函数内部属于局部名称空间
# func()
# 加载顺序: 内置 => 全局 => 局部
# 取值顺序: 局部 => 全局 => 内置

# a = 10 # 全局
# def func():
#     # a = 20
#     print(a)
#
# func()

# 作用域: 变量或者函数的声明周期
# 全局作用域: 全局名称空间+内置名称空间
# 局部作用域: 局部名称空间
# a = 10 # 全局
# def func():
#     liuwei = "刘伟"

# 1. globals() 查看全局作用域中的所有内容
# qiao = "乔峰"
# def 抗收音机():
#     bgm = "难念的经"
#     print("娃哈哈")
#     print(locals())
# 抗收音机()

# # print(globals()) # 查看全局作用域中的内容
# # print(locals()) # locals()查看的是当前作用域中的内容

　　

3. global nonlocal
global: 在局部引入全局变量
nonlocal: 在局部, 引入离他最近的那一层的变量

关于函数的嵌套

# def func1():
#     print("我是func1")
#
# def func2():
#     print("我是func2")
#     func1()
#
# def func3():
#     func2()
#     print("我是func3")
# func3()
# 这样的代码不是嵌套. 互相调用

# 函数可以互相嵌套
# def outer():
#     def inner():
#         print("我是内部")
#     print("我是外部")
#     inner()
#
# outer()

# def outer():
#     print("我是外面的")
#     def inner_1():
#         def inner_2():
#             print("我是里面的2")
#         inner_2()
#         print("我是里面的1")
#     inner_1()
#     print("我是外面的收尾")
#
# outer()

# a = 10
# def func():
#     global a #表示在当前作用域中的使用的a是全局中的变量
#     a = 20 # 所有的a都是外面的了
#     print(a) # 现在只有看的权利
#
# print(a) # 10
# func() # 20
# print(a) # 20


# def outer():
#     a = 10
#     def inner():
#         nonlocal a # 找的是局部当中, 离他最近的上层的那个变量
#         a = 20
#         print(a)
#     print(a) # 10
#     inner() # 20
#     print(a) # 20
# outer()



# a = 1
# def fun_1():
#     a = 2
#     def fun_2():
#         nonlocal a
#         a = 3
#         def fun_3():
#             a = 4
#             print(a)
#         print(a)
#         fun_3()
#         print(a)
#     print(a)
#     fun_2()
#     print(a)
# print(a)
# fun_1()
# print(a)

# global 引入全局变量, 可以定义全局变量
# nonlocal 引入局部中离他最近的外层变量

# def func():
#     global a # 没有也得有. 自动帮你创建
#     a = 20
#
# func()
# print(a)