py---------函数进阶

本章大纲

楔子

名空间和作用域

函数嵌套及作用域链

函数名的本质

闭包

本章小结

---

 

一、楔子

假如有个函数，实现返回两个数中的较大值:

def my_max(x,y):
    m = x if x > y else y
    return m
bigger = my_max(10,20)
print(bigger)

之前是不是我告诉你们要把结果return回来你们就照做了？可是你们有没有想过，我们为什么要把结果返回？如果我们不返回m，直接在程序中打印，行不行？

看结果宝贝们:

>>> def my_max(x,y):
...     m = x if x>y else y
... 
>>> my_max(10,20)
>>> print(m)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'm' is not defined

或

def func1():
    m = 1
    print(m)

print(m)  #这行报的错


报错了：
NameError: name 'm' is not defined

 

报错了！错误是“name 'm' is not defined”。变量m没有被定义。。。为啥？我明明定义了呀！

在这里我们首先回忆一下python代码运行的时候遇到函数是怎么做的。

从python解释器开始执行之后，就在内存中开辟了一个空间

每当遇到一个变量的时候，就把变量名和值之间的对应关系记录下来。

但是当遇到函数定义的时候解释器只是象征性的将函数名读入内存，表示知道这个函数的存在了，至于函数内部的变量和逻辑解释器根本不关心。

等执行到函数调用的时候，python解释器会再开辟一块内存来存储这个函数里的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量会存储在新开辟出来的内存中。函数中的变量只能在函数的内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。

我们给这个“存放名字与值的关系”的空间起了一个名字——叫做命名空间

代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间，在函数的运行中开辟的临时的空间叫做局部命名空间。

 

二、命名空间和作用域

命名空间的本质：存放名字与值的绑定关系

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

python之禅

在python之禅中提到过：命名空间是一种绝妙的理念，让我们尽情的使用发挥吧！

 

命名空间一共分为三种：

　　内置命名空间

　　全局命名空间

　　局部命名空间

*内置命名空间中存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法。

三种命名空间之间的加载与取值顺序：

加载顺序：内置命名空间(程序运行前加载)--->全局命名空间(程序运行中：从上到下加载)---->局部命名空间(程序运行中：调用时才加载)

取值顺序：

在局部调用：局部命名空间---->全局命名空间---->内置命名空间         

综上所述，在找寻变量时，从小范围，一层一层到大范围去找寻。

x = 1
def f(x):
    print(x)
print(10)

　　在全局调用：全局命名空间->内置命名空间

x = 1
def f(x):
    print(x)
    
f(10)
print(x)

print(max)

作用域：   作用的范围

作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。

全局作用域：包含，在整个文件的任意位置都能被引用、全局有效。

局部作用域：局部名称空间，只能在局部范围内生效。

globals和locals方法

print(globals())
print(locals())

def func():
    a = 12
    b = 99
    print(locals())
    print(globals())
func()

global关键字，nonlocal关键字。(全局and局部变量)

global：

1、声明一全局变量

2、在局部作用域想要对全局作用域的全局变量进行修改时，需要用到global（限于字符串，数字）。

a = 1
def func():
    a =  3 #在全局外调用不生效
func()
print(a) #全局外调用结果为1

a = 1
def func():
    global a  #声明a为全局变量     
    a = 3
func()
print(a)     #结果3

 ps：对可变数据类型（list，dict，set）本身可以直接引用不用通过global，就是不用global也是全局生效的。

对于可变类型应用举例

li = [1,2,3]
dic = {'a':'1'}

def change():
    li.append('a')
    dic['c'] = '9'
    print(li)      #局部调用
    print(dic)     #

change()
print(li)      #全局调用依然生效，结果局部一样
print(dic)     #全局调用依然生效

nonlocal:

1、不能修改全局变量

2、声明的变量事先存在，非全局

3、在局部作用域中，对父级作用域或者更外层的变量进行引用和修改，引用到哪层，哪层一下此变量全部发生改变。

ps:在局部，声明后儿子级全部是生效。

def func1(arg1):
    n = arg1
    print(n)         #结果为10
    def func2():
        nonlocal n  #声明n,下面定义n=100
        n = 100     #如不指定n=100，则继承nonlocal声明之前的数n=10，子级都n=10
        n += 5  #n = 100 +5
    func2()
    print(n)       #声明后结果105

func1(10)

#结果
10
105

#本例重要思想随机应变

def add_b():
    b = 42
    def do_global():
        b = 10
        print(b)           #结果b = 10
        def dd_nonlocal():
            nonlocal b       #现在b=10，声明后子级都b = 10
            b = b + 20
            print(b)         #结果30
        dd_nonlocal()
        print(b)       #结果30
    do_global()   #
    print(b)    #结果42，在nonlocal声明之外，b读取add_b()函数的b = 42

add_b()

三、函数的嵌套和作用域链
函数的嵌套调用：　　在调用一个函数的过程中，又调用了其他函数

def max2(x,y):
    m = x if x>y else y
    return m

def max4(a,b,c,d):
    res1 = max2(a,b)   #对比之后得 23
    res2 = max2(res1,c)   #23 与 c 对比 得c 31 
    res3 = max2(res2,d)   #31 与 d 对比得 31   #结果为31
    return res2

ret =max4(23,-7,31,11)
print(ret)

函数的嵌套定义：　　在一个函数的内部，又定义另外一个函数

def f1():
    print("in f1")
    def f2():
        print("in f2")

    f2()
f1()

def f1():   #1 成对看，一层一层看，不乱， f1()函数里面执行啥，再f2()函数执行啥，以此类推
    def f2(): #2 f2里面执行啥    
        def f3():   #3 f3 没有做函数调用所以不执行
            print("in f3")
        print("in f2")      
    print("in f1")
    f2()    #2 f2函数调用
f1()      #1 f1函数调用  执行顺序从外往内计算执行的

#结果
in f1
in f2

函数的作用域链：小范围作用域可以使用大范围的变量，但是反之不行，他是单向的。

def f1():
    a = 1
    def f2():
        print(a)
    f2()

f1()

def f1():
    a = 1
    def f2():
        def f3():
            print(a)
        f3()
    f2()

f1()

def f1():
    a = 1
    def f2():
        a = 2
    f2()
    print('a in f1 : ',a)

f1()


a in f1: 1    #获取第一个f1外层值(大范围)，内存不生效

四，函数名的本质。（函数对象）

函数名本质上就是函数的内存地址。

1、可以被引用，可以当做参数传入

def func():
    print('in func')

f = func()   #可以把函数名赋值给另一个参数，调用f效果等同于func()
print(f)

2、可以被当做容器类型元素

def f1():
    print('f1 值')

def f2():
    print('f2 值')

def f3():
    print('f3 值')

l = [f1,f2,f3]
d = {'f11':f1,'f22':f2,'f33':f3}

l[0]()   #列表方式调用f1()函数
d['f22']()  #字典方式调用f2()函数

3、可以当做函数的参数和返回值

def f1():
    print('f1')

def func1(argv): #2
    argv()
    return argv   #3把参数返回

f = func1(f1)   #1把第一个定义的函数f1 当做参数传入第二个func1()  f接收return返回值
f()

def select(sql):
    '''select function'''
    print('select----->',sql)
    #sql=['select', '*', 'from', 'mysql.user;']   #输入示例


def insert(sql):
    '''insert function'''
    print('insert---->',sql)

def update(sql):
    '''update function'''
    print('update----->',sql)

def delete(sql):
    '''delete function'''
    print('delete---->',sql)

def alter(sql):
    print('alter===>',sql)

cmd_dic = {
    'insert': insert,
    'update': update,
    'delete': delete,
    'select': select,

    'alter':alter,   #以后加功能可以直接字典里添加就可以了
}



#select  * from mysql.user;
def main():
    while True:
        sql=input('>>: ').strip()   #去除两边空格
        if not sql:continue  # 输入空继续输
        cmd_info=sql.split()  #指定切片分隔
        cmd=cmd_info[0]   #input输入后切片分割第1位

        if cmd in cmd_dic:    #如果input输入在 cmd_dic字典里
            cmd_dic[cmd](cmd_info)  #cmd_dic[cmd] 对应字典一个value 加(cmd_info)把用户输入信息传进入
        else:
            print('cmd not exists')

main()

第一类对象概念:指的是函数可以被当做数据传递

第一类对象（first-class object）指
1、可以在运行期创建
2、可用作函数参数或返回值
3、可存入变量的实体

*不明白？那就记住一句话，就当普通变量用

五，闭包

def func():
    name = "zhishu"
    def inner():　　　　#内部函数，闭包函数
　　 　　print(name)

闭包函数：

1、内部函数包含对外部作用域变量的引用，该内部函数称为 闭包函数。

2、函数内部定义的函数称为内部函数。

 

由于有了作用域的关系，我们就不能拿到函数内部的变量和函数了，如果我们就像拿怎么办？返回就可以。

我们都知道函数内的变量我们要想在函数外部用，可以直接返回这个变量，那么如果我们想在函数外部调用函数内部的函数呢？

是不是直接就把这个函数的名字返回就好了？

这才是闭包函数最常用的用法：

#例1
#假如 定义一个函数，要用这个参数，就得wrapper(123243434534) 传个参数进去
def wrapper(x):
    print(x)

wrapper(123243434534)


#学完闭包函可以给一个函数捆绑一个值
def deco():
    x = 121212134
    def wrapper():
        print(x)
    return wrapper   #拿到闭包函数，打破层级

func = deco() #运行deco函数

func()         #在任何地方用只需要调用func()这个函数就可以了


#例2 和例子1一样 只不过换个参数
def func():
    name = "sunwukong"
    def inner():
        print(name)
    return inner

f = func()
f()

判断闭包函数的方法__closure__

#输出的__closure__有cell元素 ：是闭包函数
def func():
    name = "wukong"
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f = func()
f()

#输出的__closure__为None ：不是闭包函数
name = 'bajie'
def func2():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner
f2 = func2()
f2()

def warpper():
    money = 1000
    def func():
        name = 'wukong'
        def inner():
            print(name,money)
        return inner
    return func

f = warpper()
i = f()
i()

from urllib.request import urlopen

def index():
    url = "http://www.yxcfu.com"
    def get():
        return urlopen(url).read()
    return get

xiaohua = index()
content = xiaohua()

print(content)

例
import requests

def get(url):
    return requests.get(url).text

print(get('http://www.xiaohua.com'))
#每次都得传url，url改变传太频繁



#闭包函数解决
import requests
def index(url):
    #url = "http://www.xiaohua.com"
    def get():
        print(requests.get(url).text)
    return get

xiaohua_web = index('http://www.xiaohua.com')
baidu_web = index('http://www.baidu.com')


#若今天让你爬校花，明天让你爬百度，切换下就可以了
#爬校花   
xh_web =xiaohua_web()
print(xh_web)

#爬百度
bd_web= baidu_web()
print(bd_web)