第十章

day 10

第十章

1、函数进阶:

def eat(a,b,c,d,e,f)
	print(a,b,c,e,f)
eat("麻辣烫","大烧饼","大煎饼","大腰子","韭菜","羊蝎子")

如何解决参数数量太多?

(1)动态位置参数:

  • def eat(*args):    # 函数的定义阶段 *聚合(打包)    
        print(args)    # tuple    
        print(*args)   # 函数体中的 *    打散(解包)
    eat("麻辣烫","大烧饼","大煎饼","大腰子","韭菜","羊蝎子")
    
  • def eat(a,b,*c):       #位置参数 > 动态位置参数
        print(a)    
        print(b)    
        print(c)     # tuple
    eat("面条","米饭","馒头","大饼")
    
  • def eat(a,b,*args,d=2,**c):  # 位置参数 > 动态位置参数 > 默认参数 > 动态默认参数   
        print(a)    
        print(b)   
        print(d)    
        print(args)     # tuple  
        print(c)        # dict
    eat("面条","米饭","大烧饼","大煎饼",a1=1,b1=2)        # 位置 > 关键字
    
  • def eat(*args,**kwargs):  # (万能传参)   
        print(args) # tulpe    
        print(kwargs) #
        lst = [1,23,4,6,7]
        dic = {"key1":1,"key2":3}应用场景
     eat(lst,dic)
     eat(*lst,**dic) # eat(1,23,4,6,7,"key1"=1,"key2"=2)
    
  • 总结:

    1. *args(聚合位置参数)大家伙都用的名字,可以进行修改但是不建议修改
    2. **kwargs(聚合关键字参数)大家伙都用的名字,可以进行修改但是不建议修改
      • 函数的定义阶段 * 都是聚合
      • 函数体中*就是打散 * args 将元组进行打散,** kwargs将字典的键获取

(2)形参:

  1. 位置参数

    动态位置参数:先执行位置参数,位置参数接受后额外的参数由动态位置参数进行接受,获取的是一个元组

  2. 默认参数

    动态关键字参数(默认):先执行默认参数,默认参数额外后的由默认进行接受,获取的是一个字典

    实参和函数体:

    • *打散
    • **实参时能够使用

2、函数的注释:

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
  1. 函数名. __ doc __ 查看函数的注释
  2. 函数名. __ name __ 查看函数的名字

3、命名空间

  1. 内置空间:python解释器自带的空间

  2. 全局空间:py文件中顶个写的就是全局空间

  3. 局部空间:函数体中就是局部空间

    1. 加载顺序:

      • 内置空间

      • 全局空间

      • 局部空间

        def func():
            a = 1
            print(a)
        func()
        
    2. 取值顺序:

      • 局部空间

      • 全局空间

      • 内置空间

        a = 10
        def func():
            print(a)
        func()
        
  4. 作用域:

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

4、函数嵌套:

不管在什么位置,只要是函数名()就是在调用一个函数

  • 混合嵌套:

    def f1():
        print(11)
    def f2():
        print(22)
        f1()
    def f3():
        print(33)
        f1()
    def run():
        f3()
        f2()
        f1()
    run()
    
    def foo():
        a = 10
        def f1(b):
            c = b
            def foo(c):
                print(c)
                print(foo.__doc__)
            foo()
            print(b)
        f1()
        print(a)
    foo(25)
            
    

5、global 只修改全局

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

a = 10
def func():
    global a
    a = a - 6
    print(a)
print(a)
func()
print(a)
a = 100
def func():
    b = 10
    def foo():
        b = a
        def f1():
            nonlocal b
            b = b + 5
            print(b)
    	f1()
    	print(b)
    foo()
    print(b)
func()
print(a)
 
     

enumerate() 默认从0开始数,第一个参数是可迭代对象,第二个对象是起始值

posted @ 2019-09-10 23:15  袁昌旺  阅读(106)  评论(0编辑  收藏  举报