10 动态参数 命名空间和作用域 global.nonlocal

1. 动态参数

　　位置参数的动态参数

def chi(*food):
    print("我要吃",food)
chi("小米粥","绿豆粥","八宝粥")                       #多个参数传递进去,收到的是元祖tuple

def func(a,b,c,*args,d=5):
    print(a,b,c,d,args)
func(1,2,3)
func(1,2,3,4,56,7)
func(1,2,3,4,5,6,7,"马大哈")

　　关键字参数的动态参数

def func(**food):   # **food动态接收关键字参数
    print(food) # 接收到的是字典

func(good_food="盖浇饭", bad_food="辣条", drink="冰封")      #结果是我要吃 {'good_food': '火锅', 'bad_food': '快餐'}

　　顺序:位置参数,*args,默认值,**args

　　这个函数可以接受所有的参数(无敌)

可以接收所有的参数(无敌的)
def func(*args, **kwargs):
    print(args)
    print(kwargs)
func(1, 2, 5, 6, name="taibai",age=18, sex="不详")

　　在形参上*聚合,**聚合;在实参上*打散,**打散.

# 把列表中的每一个元素作为参数, 传递给函数. 一次都传过去
def func(*args,**kwargs):                   #*表示聚合,所有的位置参数,聚合成元祖
    print(args)
    print(kwargs)
lst = ["马虎疼","大眼哥","小花生","毛尖妹妹"]
func(*lst)                                   #实参打散,迭代产生的.            #结果是('马虎疼', '大眼哥', '小花生', '毛尖妹妹')

　　

def func(*args,**kwargs):                     #**表示聚合成字典
    print(args)
    print(kwargs)
dic={"name":"太白","alex":"wusir"}
func(**dic)                                   #将字典打散,以key:value的形式进行传参.

　　给函数传递任意个整数,返回和.

#给函数传递任意个整数,返回和
# def func(*n):
#     s = 0
#     for i in n:
#         s = s + i
#     return s
# print(func(1,3,5,6,8))

注意点:

def func(*args, **kwargs):
    # args = (1,2,3)                    #接收的是元祖
    #kwargs = {'name':'alex,'age':23}   #接受的是字典
    print(*args)     # print(*(1,2,3))                         #print(函数中有*args对象)     打印1,2,3
    print(**kwargs)  # print(**{'name':'alex', 'age':1000})    #print(函数中没有**args对象)   报错
# 当定义一个函数的时候:* 代表 聚合.
# 当执行一个函数的时候:* 代表 打散.
func(1, 2, 3, name='alex', age=1000)

2. 命名空间和作用域:

　　命名空间:

　　　1.内置命名空间:python解释器内部运行时的变量函数

　　　2.全局命名空间:我们在py文件中直接声明出来的变量,函数

　　　3.局部命名变量:在函数内部声明的变量和函数

　　作用域:

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

　　　　2.局部作用域:局部

　　　　globals()查看全局作用域中的名字

　　　　locals()查看当前作用域中的名字

a = 10
def func():
    a = 20
    print(a)
    print(globals())  #globals()  获取到全局作用域(内置,全局)中的所有名字
    print(locals())   #locals()   查看当前作用域中的所有名字
func()

3. global和nonlocal

　　glocal:把全局变量拿到局部来用

a = 20
def func():
    global a              #a不在是局部变量,是全局变量
    a = 30                #把全局中的a重新赋值成30
    print(a)             30
func()
print(a)　　　　　　　　　　30

　　nonlocal:把离他最近的一层变量拿过来,不会找全局.

a = 10
def fun1():
    a = 3
    def func2():
        nonlocal a              # 找局部作用域中 离他最近的那个变量引入进来
        a = 20
        print(a)          #结果是:20
    func2()
    print(a)              #结果是:20
fun1()

　接收n个参数,返回最大值和最小值

接收n个参数. 返回最大值和最小值(字典)
def func(*args):
    m = args[0] # 假设第0项就是最大值
    mi = args[0]
    for el in args:
        if el > m:
            m = el # 当前这个元素比假设的那个大. 记录当前这个比较大的数
        if el < mi:
            mi = el
    return {"最大值":m, "最小值":mi}

　如果默认值参数是一个可变的数据类型,如果有人调用的时候改变了他,其他的位置看到的也跟着改变了.

# 如果默认值参数是一个可变的数据类型, 如果有人调用的时候改变了他. 其他位置看到的也跟着改变了
def extendList(val, list=[]):
    list.append(val)
    return list
list1 = extendList(10)                       #列表[10],列表指向的内存地址中存有10
list2 = extendList(123, [])                  #给了一个空的列表,默认值参数改变了成[],此时向里加了[123]
list3 = extendList('a')                      #此时向列表中加a,列表指向的是同一个内存地址,所以是[10,a]
print('list1=%s' % list1)  [10,a]          #如果默认值参数是一个可变的数据类型, 如果有人调用的时候改变了他. 其他位置看到的也跟着改变了
print('list2=%s' % list2)  [123 ]
print('list3=%s' % list3)  [10,a]

　9*9乘法表

a = 1
while a <=9:
    b = 1
    while b <= a:
        print("%dx%d=%d\t" % (a, b, a*b), end="")
        b = b + 1
    print() # 换行
    a = a + 1

　考试题;

user_list=[
        {"name": "alex", "hobby": "抽烟"},
        {"name": "alex", "hobby": "喝酒"},
        {"name": "alex", "hobby": "烫头"},
        {"name": "wusir", "hobby": "喊麦"},
        {"name": "wusir", "hobby": "街舞"},
        {"name": "alex", "hobby": "泡吧"},
        {"name":"太白", "hobby":"开车"}
         ]
# [{"name": "alex", "hobby_list": ["抽烟","喝酒","烫头","泡吧"]},{"name": "wusir", "hobby_list": ["喊麦", "街舞"]},]

result = [] # {'name': 'alex', 'hobby_list': ['抽烟']}
for user in user_list:
    # 1.判断是否在result里面存在了这个人, 如果存在. 把hobby_list添加一个hobby
    # 2.不存在. 创建一个新字典
    for new_user in result:
        if user['name'] == new_user['name']:
            new_user['hobby_list'].append(user['hobby'])
            break
    else:
        dic = {}
        dic["name"] = user['name']
        dic['hobby_list'] = [user['hobby']]
        result.append(dic)
print(result)