函数嵌套，函数对象

上节课复习

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

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