python函数

Posted 2020-11-23 birdfish

1.可变长参数:在调用函数时，实参值得个数不固定

   实参的形式有：位置实参和关键字实参

   形参的解决方案为 *，**

   位置形参例子：

　　def foo(x,y,*args):

            print(x,y)
            print(*args)

       foo(1,2,*[3,4,5,6,7])
       #先将位置打散（1,2,3,4,5,6,7）在一一对应
    关键字形参例子，会被**保存成字典的形式

       def foo(x,y,**kwargs):

             print(x,y)

             print(kwargs)

  foo(x=1,**{\'y\':2,\'a\':3,\'b\':4,\'c\':5})
   #先将位置打散在一一对应
   #foo(x=1,y=2,a=3,b=4,c=5)

2.函数对象函数是第一类对象：指的是函数可以当数据传递

      1.可以被引用 x=1,y=x

　          def func(x,y):

                    print(x,y)

             f=func

             f(1,2)

      2.可以当做函数的参数传入

            def foo():

                  print(\'aaa\')

            def  bar(func)

                  print(func)

            bar(foo)

      3.可以当做函数的返回值

            def foo():

                  print(\'aaa\')

            def  bar():

                 return foo

           f=bar()

           f()

      4.可以当做容器类型的元素

         def foo():

               print(\'aaa\')

        def bar():

               return foo

        l=[foo,bar]

        l[0]()

3.函数的嵌套调用：调用了一个函数的过程中又调用了另一个函数

def my_max(x,y):

       if x>=y:
          return x
       else:
          return y
   def max_max4(a,b,c,d):
      res1=my_max(a,b)
      res2=my_max(res1,c)
      res3=my_max(res2,d)
      return res3
   a=max_max4(5,6,4,2)
   print(a)
1函数的嵌套定义：内部定义的函数还是要在内部调用
      def fu1():
          def fu2():
          print(fu2)
2.名称空间：存放名字的地方，通过名字拿到内存地址后调用方法
   1.内置命名空间(解释器启动就有) python内置解释器内置的名字如len max min
   2.全局名称空间（执行Python文件时生效）
   3.局部名称空间（函数调用时生效，结束失效） 函数内部定义的名字
　   加载顺序 内置》》》》全局》》》》局部名称空间
    访问名字的顺序：局部名称空间==》全局===》内置
    

        

      #全局作用域：（全局范围）内置名称空间与全局名称空间的名字，全局有效(globals())

        globals将变量设置为全局变量

      #局部作用域：（局部范围）局部名称空间的名字，局部有效locals()

 　　nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量

      #打破函数层级限制来调用函数:通过对象的概念

           def outter():

                 def inner():

                      print(\'inner\')

                 return inner

          f=outter()

          f()

 

      #函数的作用域关系是在函数定义阶段就已经固定了，与调用位置无关

         x=111

         def outter():

        def inner():
           print(\'inner\',x)
       return inner
   f = outter()
   def bar():
       f()
   x=1111111111111111111111
   bar()

4.闭包函数：1.定义在函数内部的函数2.该函数的函数体代码包含对外部作用域(而不是全局作用域)名字的引用

                     3.通常将闭包函数用return返回，然后可以在任意使用

5.无参装饰器

         1.开放封闭原则:对扩展开放，对修改是封闭的

         2.装饰它人的，器指的是任意可调用对象，现在的场景装饰器------>函数

            原则：1.不修改被装饰对象的源代码 2.不修改被装饰对象的调用方式

            装饰器的目的：在遵循1,2的前提下为被装饰对象添加上新功能

            在被装饰对象的正上方写上@装饰器名

     def timmer(func):
        def inner():
           start=time.time()
           func()
           end=time.time()
           print(\'run time is %s\'%(end-start))
        return inner
      \'\'\'当解释器读取到@时会将@下方的函数名当做参数
         传递给timmer\'\'\'
    @timmer #==index=timmer(index)
    def index():
       time.sleep(3)
       print(\'welecome to index\')
   index()
1.1inner函数带返回值

        import time
        def timmer(func):
              \'\'\'inner函数带返回值\'\'\'
             def inner():
                start=time.time()
                res=func()
                end=time.time()
                print(\'run time is %s\'%(end-start))
             return res
        return inner
         \'\'\'当解释器读取到@时会将@下方的函数名当做参数
           传递给timmer\'\'\'
         @timmer #==index=timmer(index)
         def index():
               time.sleep(3)
               print(\'welecome to index\')
              return 1111
       res=index()
       print(res)

  1.2inner函数传参
   import time
   def timmer(func):
      def inner(*args,**kwargs):
           \'\'\'inner函数传参\'\'\'
            start=time.time()
            res=func(*args,**kwargs)
            end=time.time()
            print(\'run time is %s\'%(end-start))
       return res
    return inner
     \'\'\'当解释器读取到@时会将@下方的函数名当做参数
       传递给timmer\'\'\'
     @timmer #==index=timmer(index)
   def home(name):
         print(\'welecome %s to index\'%name)
   home(\'aa\')