上节课复习

位置实参，按照从左到右的顺序与形参一一对应

Regiser(‘egon’,18,’male’)

 

关键字参数：按照key=value形式指名道姓地为形参传值，可以完全不按照顺序

1，  关键字实参必须在位置参数后面

2，  可以混用实参，但是不能为同一个形参传值

Register(‘egon3’,sex=’female’,age=18)

 

默认参数

形参有默认值

Def register(name,age,sex=’male’)；
Pass
Register(‘egon’,18)

可变长参数

形参：*args,**kwargs

实参：

foo('a',*[1,2,3])#foo('a',1,2,3)
  foo(x='bbb',*[1,2,3],)
  foo(**{'x':1,'y':2})


新知识

函数的嵌套定义：在函数内又定义其他函数

def func1():
     print('from func1')
     def func2():
         print('form func2')
         print(func2)
     func2()
 func1()

 

重要重要重要

名称空间和作用域

1，  名称空间：存放名字与值绑定的地方

2，  名称空间分为三大类：

（1），内置名称空间：python解释器自带名字。在解释器启动时生效。解释器关闭失效

（2），全局名称的空间：文件级别的名字，x=1，在文件启动时生效时生效，在文件执行期间被删除或者文件结束

（3），局部名称：内部定义的，调用时才产生。存放函数内的名字，在函数调用时生效函数结束时失效，函数的参数以及函数内的名字，都存放与局部名称空间

 

加载顺序：内置名称空间——全局名称——局部名称空间

查找名字：局部——全局——内置

 

 

# len='global'
# def f1():
#     # len=1
#     def f2():
#         # len=2
#         print(len)
#     f2()
#
# f1()



   

  三，作用域

全局作用域：包含的是内置名称空间与全局名称空间的名字

特点:在任何位置都能够访问的到，访问范围内的名字会伴随程序整个生命同期

局部作用域：包含的是局部名称空间的名字

特点：

1，  只能在函数内使用

2，  调用函数时生效，调用结束失效

3，  #可以被引用x=1

y=x

def bar():
     print('from bar')
 f=bar
 f()

#2，可以当参数传入x=1
def func(a):
     print(a)
 func(x)

def bar():
     print('form bar')
def wrapper(func):
     func()
 wrapper(bar)

# 3，可以当函数中的返回值x=1
def foo():
     return x
 res=foo()
 print(res)

def bar():
     print('form bar')
def foo(func):
     return func
 print(bar)
 f=foo(bar)
 print(f)
 f()

#4,可以当容器类型的元素x=1
 l=[x,]
 print(1)

def get():
     print('from get')
def put():
     print('from put')
 l=[get,put]
 l[0]()

def func():
     print('from func')
     #func可以被引用
     #f=func
     #2 func可以当参数传给x
     def bar(x):
         print(x)
         x()
     bar(func)
     #3,func还可以当作返回值
     def bar(x):#x=func
         return x
     res=bar(func)
     print(res)
#4 可以当容器类型的元素def auth():
     print('登陆。。。')
def reigster():
     print('注册。。。。')
def sarch():
     print('查看。。。')
def transfer():
     print('转账。。。。')
def pay():
     print('支付。。。')

 dic={
     '1':auth,
     '2':reigster,
     '3':sarch,
     '4':transfer,
     '5':pay,
 }
def interactive():
     while True:
         print('''


        1,登陆
        2，注册
        3，查看
        4，转账
        5，支付

''')
         choice=input('>>: ').strip()
         if choice in dic:
             dic[choice]()
         else:
             print('非法操作')
 interactive()

 

重重重

   闭包函数

闭：☞的是定义在函数内部的函数

作用域关系 在函数定义阶段就规定死了，与调用位置无关

def outter():
     x=2
     def inner():
         print('form inne',x)
         
     return inner
 f=outter()
 print(f)
 x=111111111
 f()

def foo():
     x=11111111111
     f()
 foo()

闭包函数

1，  定义在函数内部的函数

2，  并且该函数包含对外部函数作用域中的名字的引用，该函数就称为闭包函数

def outter():
     name='egon'
     def inner():
         print('my name is %s' %name)
     return inner
 f=outter()

了解

为函数体传值的方式

方式1：将值以参数的形式的传入
import  requests

def get(url):
     response=requests.get(url)
     if requests.status_code==200:
         print(requests.text)

 get('https'://www.baiducom)

#方式2：import requests
import  time

def outter(url):
     def get():
         response=requests.get(url)
         if response.status_code==200:
             print(response.text)
     return  get
 baidu=outter('https://www.baidu.com')
 python=outter('https://www.python.org')
 baidu()

def outter(x):
     def foo():
         print(x)
     return  foo
 f_10=outter(10)
 f_10()

 f_100=outter(100)
 f_100()