函数动态参数

函数的动态参数

# 函数的动态参数
# def cen(a,b,c):
# #     print(a,b,c)
# # cen("xiao","da","duo")


# def eat(a,b,c):
#     print(a,b,c)
# eat("麻辣烫","大烧饼","大煎饼")
# 动态位置参数  args大家都用的可以修改，但是不建议修改
                #kwargs大家都用
#
# def eat(*e):#函数的定义阶段*聚合（打包）
#     print(e)#tuple
#     print(*e)#函数体中的* 打散（解包）
# eat("麻辣烫","大烧饼","大煎饼","羊蹄","猪蹄")
# 结果
# ('麻辣烫', '大烧饼', '大煎饼', '羊蹄', '猪蹄')
# 麻辣烫 大烧饼 大煎饼 羊蹄 猪蹄

# def eat(a,b,c,*args,d=2): #位置参数>动态参数>默认参数>动态默认参数
#     print(a,b,c,args,d)#args是tuple类型
# eat("麻辣烫","大烧饼","大煎饼","羊蹄","猪蹄",d="花卷")
# 结果：
# 麻辣烫 大烧饼 大煎饼 ('羊蹄', '猪蹄') 花卷

# def eat(a,b,c,*args,d=2): #位置参数>动态参数>默认参数
#     print(a,b,c,args,d)#e是tuple类型不论吃多少都是元组
# eat("麻辣烫","大烧饼","大煎饼")
# 结果
# 麻辣烫 大烧饼 大煎饼 () 2
# def eat(a,b,c,d,*e,**kwargs): #位置参数>动态参数>默认参数
#     print(a,b,c,*e,d,*kwargs)#e是tuple类型 kwargs字典类型解压后是键不是键值对
# eat("麻辣烫","大烧饼","大煎饼","羊蹄","猪蹄",d1="花卷")
# 结果
# 麻辣烫 大烧饼 大煎饼 猪蹄 羊蹄 d1

# def eat(a,b,*args,d=2,**kwargs):  # 位置参数 > 动态位置参数 > 默认参数 > 动态默认参数
#     print(a)
#     print(b)
#     print(d)
#     print(args)     # tuple
#     print(kwargs)        # dict
#
# eat("面条","米饭","大烧饼","大煎饼",d="nihao ",a1=1,b1=2)        # 位置 > 关键字
#结果
# 面条
# 米饭
# nihao
# ('大烧饼', '大煎饼')
# {'a1': 1, 'b1': 2}


# def eat(*args,**kwargs):  # (万能传参)
#     print(args) # tulpe
#     print(kwargs) #dict
# lst = [1,23,4,6,7]
# dic = {"key1":1,"key2":3}
# eat(lst,dic)#将整个列表和字典添加到元组中
# eat(*lst,**dic)#将元组和字典打散后分别加到args和kwargs中
# 结果
# ([1, 23, 4, 6, 7], {'key1': 1, 'key2': 3})
# {}
# (1, 23, 4, 6, 7)
# {'key1': 1, 'key2': 3}

#给数据库里传值
# json = {
#
#     "101":{1:{"日魔":"对象"},
#          2:{"隔壁老王":"王炸"},
#          3:{"乔碧萝":("日魔","炮手","宝元")},
#          },
#     "102":{1:{"汪峰":{"国际章":["小苹果","大鸭梨"]}},
#          2:{"邓紫棋":["泡沫","信仰","天堂","光年之外"]},
#          3:{"腾格尔":["隐形的翅膀","卡路里","日不落"]}
#          },
#     "103":{1:{"蔡徐坤":{"唱":["鸡你太美"],
#                    "跳":["钢管舞"],
#                    "rap":["大碗面"],
#                    "篮球":("NBA形象大使")}},
#
#          2:{"JJ":{"行走的CD":["江南","曹操","背对背拥抱","小酒窝","不潮不花钱"]}},
#          3:{"Jay":{"周董":["菊花台","双节棍","霍元甲"]}}},
#
#     "201":{
#         1:{"韦小宝":{"双儿":"刺客","建宁":{"公主":{"吴三桂":"熊"}},"龙儿":{"教主老婆":"教主"}}}
#     }
# }
# # def eat(*args,**kwargs):  # (万能传参)
# #     print(args) # tulpe
# #     print(kwargs) #dict
# # eat(**json)
#
#
# # 总结:
#
#     # *args(聚合位置参数)      大家伙都用的名字, 可以进行修改但是不建议修改
#     # **kwargs(聚合关键字参数) 大家伙都用的名字, 可以进行修改但是不建议修改
#
#     # 函数的定义阶段 * 和 ** 都是聚合
#     # 函数体中 * 就是打散, *args将元组中的元组进行打散  *kwargs将字典的键获取
#
#     # 形参:
#     #     位置参数:
#     #     动态位置参数: 先执行位置参数,位置参数接受后额外的参数动态位置参数进行接受 获取的是一个元组
#     #     默认参数:
#     #     动态关键字参数(默认): 先执行默认参数,默认参数接受后额外的默认参数动态默认参数进行接受,获取的是一个字典
#
#     # 实参和函数体:
#     #     * 打散
#     #     ** 实参时能够使用目的是将字典一个一个添加到 **kwargs中
#

函数的注解

# def a(a:int,b:int):
#     """
#     求和
#     :param a: int
#     :param b: int
#     :return:  int
#     """
#     return a + b


# def b(a:int,b:int):
#     """
#     求差
#     :param a: int
#     :param b: int
#     :return:  int
#     """
#     return a - b
#
# print(a.__doc__)
# print(b.__doc__)  # 查看函数的注释
# print(a.__name__) # 查看函数的名字
# def cen(a:int,b:int):
#     """
#     求积
#     :param a: int
#     :param b: int
#     :return: int
#     """
#     return a*b
# print(cen.__doc__)
# print(cen.__name__)

名称空间

# 名称空间
    # 1.内置空间 : Python解释器自带的空间
    # 2.全局空间 : py文件中顶格写的就是全局空间
    # 3.局部空间 : 函数体中就是局部空间

    # 加载顺序:
        # 1.内置空间
        # 2.全局空间
        # 3.局部空间

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

    # 取值顺序:
        # 1.局部空间
        # 2.全局空间
        # 3.内置空间

        # a = 10
        # def func():
        #     print(a)
        # func()

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

函数嵌套

 混合嵌套:
# def f1():
#     print(11)
#
# def f2():
#     print(22)
#     f1()
#
# def f3():
#     print(33)
#     f1()
#
# def run():
#     f3()
#     f2()
#     f1()
# run()
#
# def func(a):
#     print(a)
#     return f1(foo(a))
#
# def foo(b):
#     print(b)
#     return b + 5
#
# def f1(args):
#     return args + 10
#
# print(func(5))

# def foo(a):
#     a = 10
#     def f1(b):
#         c = b
#         def foo(c):
#             print(c)
#             print(foo.__doc__)
#         foo(c)
#         print(b)
#     f1(a)
#     print(a)
# foo(25)


# def foo():
#     a = 10
#     func(a)
#
# def func(a):
#     print(a)
#
# foo()

global 和nonlocal

# global : 只修改全局
# nonlocal : 只修改局部,修改离nonlocal最近的一层,上一层没有继续向上上层查找.只限在局部

# a = 10
# def func():
#     global a
#     a = a - 6
#     print(a)
#
# print(a)
# func()
# print(a)

# a = 100
# def func():
#     b = 10#局部变量b=10
#     def foo():
#         b = a #将a的值赋给b为100后修改为105
#         def f1():
#             nonlocal b #修改局部变量b为105
#             b = b + 5
#             print(b)  # 105
#         f1()
#         print(b)  # 105
#     foo()
#     print(b) # 10
# func()
# print(a) # 100

总结

# 1.1 动态参数
    #   *args       动态位置参数
    #   **kwargs    动态默认参数
    #   位置 > 动态位置 > 默认 > 动态默认
        # 定义的时候是    聚合
        # 函数体和实参时  打散
        # *args,**kwargs

# 1.2 函数的注释

    # def 函数名():
    #     """
    #     注释信息
    #     :return:
    #     """
    #     函数体

    # 函数名.__doc__ 查看注释内容
    # 函数名.__name__ 查看函数名称


# 1.3 名称空间

    # 1.加载
    #     内置空间 > 全局空间 > 局部空间
    # 2.取值
    #     局部空间 > 全局空间 > 内置空间 (就近原则)

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


# 1.4 函数的嵌套
#     不管在什么位置,只要是函数名()就是在调用函数

# 1.5 global nonlocal
    # global : 只修改全局变量,如果全局没有创建一个新的.
    # nonlocal :只修改局部修改离声明nonlocal 最近的一层,上一层没有继续向上上层查找.只限在局部 找不到就报错!

# def foo():
#     global a
#     a = 10
#     print(a)
# foo()
# print(a)

 对于可变数据类型直接进行改变
lst = ["麻花藤", "刘嘉玲", "詹姆斯"]
def func():
    lst.append("⻢云")
    print(lst)
func()
print(lst)

转载于:https://www.cnblogs.com/python25/p/11402540.html