Python函数02/函数的动态参数/函数的注释/名称空间/函数的嵌套/global以及nolocal的用法

Python函数02/函数的动态参数/函数的注释/名称空间/函数的嵌套/global以及nolocal的用法

目录

• Python函数02/函数的动态参数/函数的注释/名称空间/函数的嵌套/global以及nolocal的用法
  • 内容大纲
  • 1.函数的动态参数
  • 2.函数的注释
  • 3.名称空间
  • 4.函数的嵌套
  • 5.global及nolocal的用法
  • 6.今日总结

内容大纲

1.函数的动态参数

2.函数的注释

3.名称空间

4.函数的嵌套

5.global以及nolocal的用法

1.函数的动态参数

# def func(a,b=1):
#     print(a,b)
#
# func(1)

def func(a,b,*args):
	print(a,b,args)	  # * 聚合
    print(a,b,*args)  # * 打散
func(1,2,3,4,5,6,7,8,9,0)  
*args 是万能(接受任意多个)的位置参数 在函数定义的时候叫做聚合

# def func(a,b,*args):  
# *args 是万能(接受任意多个)的位置参数 *在函数定义的时候叫做聚合
#
# func(1,2,3,4,5,6,7,8,9,0)
 位置参数 > 动态位置参数 > 默认参数

# def func(*args,a=1,b=2):
#     print(a,b,args)  # 元组(接受的位置参数)
# func(12,15,16,19,10)

# def func(a,b,**kwargs):
#     print(a,b,kwargs)  # 字典(接受的关键字的参数)
# func(1,2,c=1,d=2)

# def func(a,b,*args,c=1,d=2):
#     print(a,b,*args,c,d)
# func(1,2,3,4)

def func(a,b,*args,c=1,d=2,**kwargs):
     print(a,b,*args,c,d,kwargs)   
 *kwargs -- 获取到的字典的键
# func(1,2,3,4,c=8,d=10,e="alex",f="wusir")

def func(*agrs,**kwargs):  # 万能传参
    print(agrs,kwargs)
func(1,2,3,4,5,6,7,8,a=1,b=2,c=3)

参数的优先级: 位置参数 > 动态位置参数 > 默认参数(关键字参数) > 动态关键字参数
1.万能传参: 动态位置参数,动态关键字参数 (最常用******)
2.位置参数,动态位置参数
3 动态位置参数,关键字参数,动态关键字参数

2.函数的注释

写好函数的定义后,换行,三个双引号回车自动弹出所需注释的内容
    每次写函数需要写注释
    函数名__doc__
# def func(a,b):
#     """
#     逻辑判断...
#     :param a: str
#     :param b: int
#     :return: bool
#     """
#     print(a,b)


# def func1(user,password):
#     """
#     密码加密
#     :param user: 用户名 str
#     :param password: 密码 str
#     :return: 加密的密码 MD5
#     """
#     print(user,password)

# print(func.__doc__)
 print(func1.__doc__)
 print(func.__name__)

3.名称空间

# print(11)
# a = 10
#
# def func():
#     b = 20
#     print(b)


内置空间 : Python解释器自带的,print input len
全局空间 : 当前py文件需要开辟的空间存放在全局空间
局部空间 : 函数中开辟的空间就是局部空间

加载顺序:
    # 内置空间 > 全局空间 > 局部空间

取值顺序:
    # 局部空间 > 全局空间 > 内置空间(找不到就报错了!)

作用域:
    # 全局作用域: 内置空间 + 全局空间
    # 局部作用域: 局部空间

4.函数的嵌套

# def func():
#     print(1)
#     def f1():
#         print(2)
#     return f1()
# func()
#结果:1 2
# def func():
#     print(1)
#     def f1():
#         print(2)
#     return func()
# func()
#结果:无限循环1

不管在什么位置,只要是函数名+() 就是在调用此函数
函数调用执行后,函数体中开辟的空间就自动销毁了

# def func():
#     a = 1
#     def foo():
#         b = 2
#         print(b)  # 2
#         print(a)  # 1
#         def f1():
#             print(b) # 2
#         return f1()
#     return foo()
# print(func())
#2
#1
#2
#None

# 函数互相引用

# def func():
#     a = 1
#     foo()
#     print(a)
#
# def foo():
#     b = 2
#     print(b)
# func()
#结果:
#2
#1

# def a():
#     a1 = 1
#     c()
#     print(c)
# def b():
#     b1 = 2
#     print(b1)
# def c():
#     c1 = 3
#     print(a)
# def run():
#     a()
# run()
#结果:返回是a,c的地址
#<function a at 0x000000141BA21E18>
#<function c at 0x000000141D93AA60>

# def func():
#     a = 1
#     def b():
#         print(a)
#
# def foo():
#     b = 1
#     def z():
#         print(func)
#         print(b)
#     ret = z()
#     func()
#     return ret
# 
# def run():
#     foo()
# print(run())
#结果:
#<function func at 0x00000012E4CE1E18>
#1
#None
切记返回值,不写的时候默认返回None

# def func(a):
#     foo(a) #10
# def foo(e):
#     b(e) # return 10
# def b(c):
#     print(c)
#     return 10
# print(func(5))
#结果:
#5
#None
由于中间没有return,所以在返回的途中断掉传送

5.global及nolocal的用法

# def func():
#     global a  
 声明修改全局变量的值
 只会改变全局变量的值
#     a += 1
#     print(a)
# func()
# print(a)

# a = 10
# def f1():
#     a = 10
#     def f2():
#         a = 15
#         def f3():
#             global a
#             a += 1
#             print(a)  # 11
#         print(a)  # 15
#         f3()
#     print(a)  # 10
#     f2()
# f1()
#结果:
#10
#15
#11

# a = 10
# def func():
#     def f1():
#         global a
#         a += 1
#         def foo():
#             nonlocal a
#             a += 1
#             print(a)   # 31
#         foo()
#         print(a) # 31
#     f1()
# func()
# print(a)   # 10

 global : 修改全局空间的变量对应的值
 nonlocal :在外层的函数中,修改局部空间的变量值.完全不涉及全局变量,
 只修改离它最近的一层,最近的一层没有变量继续向上找,直到找到最外层函数

nolocal例子:
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)
结果:
1
2
3
4
3
3
1

6.今日总结

# 1.函数的动态参数
# *args,**kwargs (能够接受动态的位置参数和动态的关键字参数)
# 定义阶段(*args,**kwargs) 聚合
#     *args -  tuple
#     **kwargs -- dict
# 使用阶段*args,*kwargs 打散
#     *args - 源数据类型
#     *kwargs - 打散是字典的键
# 优先级: 位置 > 动态位置> 默认 > 动态关键字

# lst = [12,23,3,4,5,6]
# def func(*args):
#     print(*args)
# func(lst[0],lst[1]) # 笨的办法
# func(*lst)

# dic = {"key":1,"key1":34}
# def func(**kwargs):
#     print(kwargs)
# func(**dic)

# 2.函数的注释
"""
每次写函数的时候需要写注释
函数名.__doc__
"""

# 3.名称空间
# 内置空间: python解释器自带的
# 全局空间:当前文件(.py文件)
# 局部空间:函数体开辟的空间

# 加载顺序: 内置 > 全局> 局部
# 取值顺序: 局部 > 全局 > 内置

# 作用域:
# 全局作用域 内置 + 全局
# 局部作用域: 局部

# 4.函数嵌套
# 函数中套函数
# 函数嵌套调用
# 函数嵌套参数的传递
# 函数嵌套返回值的传递

# 5.global nonlocal
# global : 修改全局空间的变量对应的值
# nonlocal :在外层的函数中,修改局部空间的变量值.完全不涉及全局变量,
# 只修改离它最近的一层,最近的一层没有变量继续向上找,直到找到最外层函数

# 6.三元运算符
# a = 10
# b = 20
# c = a if a> b else b
# 变量名 = 条件成立的结果 条件 条件不成立的结果