python day10

1. 昨日内容回顾
函数: 将代码或功能封装到一起. 供后面的程序使用.
语法:
def 函数名(形参列表):
函数体(代码块)
函数名和变量名一样
调用:
函数名(实参列表)
return: 返回值, 如果程序执行到return. 终止函数的执行
1. return或者不写return . 返回None
2. return 返回值返回一个值
3. return 返回值,返回值, 返回值. 接收的是一个tuple
参数:
形参: 函数声明的位置的变量叫形参. 形式参数
实参: 函数调用的地方给函数传递的信息. 实际参数
传参: 把实参传递给形参

站在实参角度:
1. 位置参数. 按照位置给形参赋值
2. 关键字参数. 按照形参的命名给函数传递参数
3. 混合使用. 先写位置参数, 然后再写关键字参数
站在形参角度:
1. 位置参数.
2. 默认值参数. 如果给值. 用你得个值. 如果不给传值.使用默认值

二. 今日主要内容
1. 动态传参, 可以接收任意的参数
顺序: 位置参数 *args 默认值参数 **kwargs
形参的一种方式
1. 位置参数的动态传参写法: *参数名例如: *args
接收的参数是tuple类型
2. 关键字参数的动态传参. 写法: **参数名例如: **kwargs
接收的参数是dict类型
无敌传参:
def func(*args, **kwargs):
pass
*,** 的作用:
在形参: 聚合
在实参: 打散


# def eat(good_food, junk_food, drink):
#     print(good_food, junk_food, drink)
# eat("盖浇饭", "麻辣烫", "冰封")
# eat("盖浇饭", "冰封")  # 出错

# def eat(*food):
#     print(food)
# eat("盖浇饭", "麻辣烫", "冰封")
# eat("胡辣汤",name="abc")
# eat("盖浇饭", "冰封")
# eat("火锅")

# def func(a, b, c, *args, d=110):
#     print(a, b, c,d,  args)
#
# func(1, 4, 7, 3, 6, 9, 1231,12,3,3,3,54,56,67,5,44,)

# def eat(**kwargs):  # ** 关键字参数
#     print(kwargs)
# eat(good_food='盖浇饭', junk_food="麻辣烫", drink="脉动")

# def func(a, b, c, *args, d = 110, **kwargs):
#     print(a, b, c, args, d, kwargs)
#
# func(1,4,7,3,5,8,dd=5,f=7,abc=9)

# 这个函数的参数.就可以接收所有的参数
# def func(*args, **kwargs):
#     print(args, kwargs)
# func(1, 4, a=8, b = 9, c= 10)

# def eat(*fruit):    # 聚合成元组
#     print(fruit)
#
# lst = ["香蕉", "茄子", "黄瓜", "辣椒", "大白梨"]
# # eat(lst[0], lst[1], lst[2], lst[3], lst[4])
# eat(*lst)   # 这里的*表示的是把lst打散

# def eat(**kwargs):  #  把所有的关键字参数聚合成字典
#     print(kwargs)
# dic = {"a":1, "b":2, "c":3}
# # eat(a = dic['a'], b = dic['b'], c=dic['c'])
# eat(**dic)  # 打散字典,依次传参

# def read(*args):
#     print(args)
#
# read(*"你好啊")


# def eat(good_food, junk_food, drink):
#     print(good_food, junk_food, drink)
# eat("盖浇饭", "麻辣烫", "冰封")
# eat("盖浇饭", "冰封")  # 出错

# def eat(*food):
#     print(food)
# eat("盖浇饭", "麻辣烫", "冰封")
# eat("胡辣汤",name="abc")
# eat("盖浇饭", "冰封")
# eat("火锅")

# def func(a, b, c, *args, d=110):
#     print(a, b, c,d,  args)
#
# func(1, 4, 7, 3, 6, 9, 1231,12,3,3,3,54,56,67,5,44,)

# def eat(**kwargs):  # ** 关键字参数
#     print(kwargs)
# eat(good_food='盖浇饭', junk_food="麻辣烫", drink="脉动")

# def func(a, b, c, *args, d = 110, **kwargs):
#     print(a, b, c, args, d, kwargs)
#
# func(1,4,7,3,5,8,dd=5,f=7,abc=9)

# 这个函数的参数.就可以接收所有的参数
# def func(*args, **kwargs):
#     print(args, kwargs)
# func(1, 4, a=8, b = 9, c= 10)

# def eat(*fruit):    # 聚合成元组
#     print(fruit)
#
# lst = ["香蕉", "茄子", "黄瓜", "辣椒", "大白梨"]
# # eat(lst[0], lst[1], lst[2], lst[3], lst[4])
# eat(*lst)   # 这里的*表示的是把lst打散

# def eat(**kwargs):  #  把所有的关键字参数聚合成字典
#     print(kwargs)
# dic = {"a":1, "b":2, "c":3}
# # eat(a = dic['a'], b = dic['b'], c=dic['c'])
# eat(**dic)  # 打散字典,依次传参

# def read(*args):
#     print(args)
#
# read(*"你好啊")

2. 作用域的问题
1. globals() 获取全局作用域中的内容
2. locals() 获取局部作用域中的内容

a = 10  # 全局
def func(): # 全局
    a = 40  # 局部
    b = 20  # 局部
    def abc():  # 局部
        d = 30 # 是局部
        print("哈哈")
        print(a, b) # 这⾥使⽤的是局部作⽤域
        print(locals())
    abc()

    # print(globals()) # 打印全局作用域中的内容
    # print(locals()) # 打印局部作用域中的内容,locals()打印当前这个函数局部作用与中的内容
func()

print(globals())
# print(globals()) # 打印全局作用域中的内容

3. 函数嵌套--函数的执行流程
所有的()表示的是函数的调用

# def fun1():
#     print(111)
#
# def fun2():
#     print(222)
#     fun1()
#
# fun2()
# print(333)

# def fun2():
#     print(222)
#     def fun3():
#         print(666)
#     print(444)
#     fun3()
#     print(888)
#
# print(33)
# fun2()
# print(555)
# def func():
#     print("哈哈哈")
# a = func # 函数可以赋值 .相当于. a和func是一回事儿
# func()
# a()

4. global和nonlocal
global: 寻找全局作用域中的内容
nonlocal: 寻找上一级作用域中的内容, 但不能是全局的

# a = 10
# def func():
#     global a # 这里用的a是全局的
#     a = 20
#     print(a)
# func()
# print(a)    # 20

a = 10
def func1():
    a = 20
    print(a)
    def fun2():
        nonlocal a # 上一级, 且不能是全局
        a = 30
        print(a)
    fun2()
    print(a)

func1()
print(a)

猜你喜欢