动态传参,命名空间,嵌套,gloabal,nonlocal

一、动态传参

  动态接受位置参数:  *参数名

def eat(*food):
    print(food)                          #多个参数传递进去,收到的内容是元祖tuple
eat("盖浇饭", "麻辣烫", "冰封")            #('盖浇饭', '麻辣烫', '冰封')

  动态接收参数的时候要注意,动态参数必须在位置参数后面

  错误事例:

# def eat(*food, a, b):        
#     print(food, a, b)
# eat("盖浇饭", "麻辣烫", "冰封")       #程序会报错,因为传递进去的位置参数都被*food接收了,a和b永远接收不到参数

  正确事例:

# def eat(a, b, *food):
#     print(a, b, food)
# eat("盖浇饭", "麻辣烫", "冰封")       #盖浇饭 麻辣烫 ('冰封',)    #前两个参数用位置参数接收,后面的参数用动态参数接收
默认值参数写在动态参数前面,默认值只有一种情况可能会生效
#
def eat(a, b, c='馒头', *food): # print(a, b, c, food) # eat("盖浇饭", "麻辣烫") #盖浇饭 麻辣烫 馒头 () 默认值生效 # eat("盖浇饭", "麻辣烫", "冰封") #盖浇饭 麻辣烫 冰封 () # eat("盖浇饭", "麻辣烫", "冰封", "烧烤") #盖浇饭 麻辣烫 冰封 (‘烧烤’,)

  默认值参数写在动态参数后面,所有的默认值都生效

# def eat(a, b, *food, c='馒头'):
#     print(a, b, food, c)
# eat("盖浇饭", "麻辣烫")               #盖浇饭 麻辣烫 () 馒头     默认值生效
# eat("盖浇饭", "麻辣烫", "冰封")          #盖浇饭 麻辣烫 ('冰封',) 馒头      默认值生效
# eat("盖浇饭", "麻辣烫", "冰封", "烧烤")      #盖浇饭 麻辣烫 ('冰封', '烧烤') 馒头   默认值生效
 

  动态参数接收关键字参数: **参数名

# def eat(**food):  #  **关键字参数
#     print(food)                                 'good_food': '盖浇饭', 'junk_food': '麻辣烫', 'drink': '脉动'}
# eat(good_food='盖浇饭', junk_food="麻辣烫", drink="脉动")     参数传递进去,收到的内容是字典dict

  关键字参数必须要在位置参数后面,否则报错

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

  最终顺序:位置参数 > *args > 默认值参数 > **kwargs

  接收所有的参数

# def func(*args, **kwargs):
#     print(args, kwargs)
# func(1, 4, a=8, b = 9, c= 10)          (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 fun(*args):
    print(args)
s = '臣妾做不到'(可迭代对象)
fun(*s)                         #('臣', '妾', '做', '不', '到')   以最小单元为元素,输出元祖

  字典打散,聚合,还是字典

def fun(**kwargs):
    print(kwargs)
dic = {'a':1,'b':2}
fun(**dic)                        #{'a': 1, 'b': 2}

二、命名空间

  命名空间一共分为三种:

    全局命名空间:我们直接在py文件中,函数外声明的变量都属于全局命名空间

    局部命名空间:在函数中声明的变量会放在局部命名空间

    内置命名空间:存放了python解释器为我们提供的名字:input,print,str,list,tuple..都是内置命名空间

三种命名空间之间的加载与取值顺序:

加载顺序:内置命名空间(程序运行前加载)->全局命名空间(程序运行中:从上到下加载)->局部命名空间(程序运行中:调用时才加载)

取值顺序

  在局部调用:局部命名空间->全局命名空间->内置命名空间

  在全局调用:全局命名空间->内置命名空间

综上所述,在找寻变量时,从小范围,一层一层到大范围去找寻。

作用域:作用域就是作用范围,按照生效范围可以分为全局作用域和局部作用域

全局作用域:包含内置名称空间、全局名称空间,在整个文件的任意位置都能被引用、全局有效

局部作用域:局部名称空间,只能在局部范围内生效

a = 10  # 全局
def func(): # 全局
    a = 40  # 局部
    b = 20  # 局部
func() # 全局
 # print(globals()) # 打印全局作用域中的内容
 # print(locals())  # 打印局部作用域中的内容

三、函数嵌套

    目前为止,所有的()表示的就是函数的调用

def f1():
  print(111)
  def f2():   print(222) f2() f1() #111 222

四、global和nonlocal

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

# a = 10
# def func():
#     global a # 加了个global表示不在局部创建这个变量,直接使用全局的a
#     a = 20
#     print(a)
# func()
# print(a)  
a = 10
def func1():
    a = 20
    print(a)
    def fun2():
        nonlocal a #    调用上一级的变量, 且不能是全局
        a = 30
        print(a)
    fun2()
    print(a)
func1()
print(a)

 

posted @ 2018-06-12 16:40  小小猎魔人  阅读(213)  评论(0编辑  收藏  举报