python函数，,1.可变长参数:在调

python函数，,1.可变长参数:在调

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‘)

python函数