函数进阶（一）

1.命名空间

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

命名空间的分类：可以分为三类

（1）全局命名空间（变量）

（2）局部命名空间（变量）

（3）内置命名空间 （变量）->python解释器自带，拿过来就可以用的方法。

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

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

取值：

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

在局部使用变量取值的方法如下：

a=1
def f(a)
      print(a)

print(10)

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

ps:在全局引用变量x

x=1
def func(x):
      print(x)

f(10)
print(x)

print(max)

2.作用域

 定义:作用域就是作用范围，分为全局作用域(locals)和局部作用域(global)。

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

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

补充：

#小范围的可以用大范围的，但是大范围的不能用小范围的

#范围从大到小

#在小范围内，如果要用一个变量，是当前这个小范围有的，就用自己的；如果在小范围内没有，就用上一级的，如果上一级没有，就用上上级的，如果都没有，则报错。

3.函数嵌套

函数嵌套（支持多层嵌套、多层并行）：
(1)格式：def 外部函数名（）：
def 内部函数名1（）：
def 内部函数名2（）：
return 内部函数名1
return 内部函数名2

函数嵌套调用

例一：
name='alex'

def foo():
    name='lhf'
    def bar():
        print(name)
    return bar

func=foo()
func()


例二：
name='alex'

def foo():
    name='lhf'
    def bar():
        name='wupeiqi'
        def tt():
            print(name)
        return tt
    return bar

func=foo()
func()()

(2)调用：在函数内部，可以调用其他函数。如果在调用一个函数的过程中直接或间接调用自身本身
  定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

函数的嵌套定义

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

    f2()
f1()

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

闭包函数（可以有多级包）：
基础：闭包函数基于嵌套函数（闭包函数属于嵌套函数的一种）
产生条件：
a.必须为内部函数
b.对外部作用域的引用（外部作用域不包括全局作用域，只限于在本层函数之外最外层函数之内的作用空间）
特点：
a.延迟计算（惰性计算，不调用不计算）
b.自带作用域（作用域范围：本层函数之外全局作用域之内）

ps:
print（闭包函数的引用.__closure__）
访问闭包函数的元素（闭包函数的引用.__closure__[0].cell_contents）

def func():
    name = 'eva'
    def inner():
        print(name)

def func():
    name = 'eva'
    def inner():
        print(name)
    return inner

f = func()
f()

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

f = func()
f()

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

f2 = func2()
f2()

两个关键字：
用法：关键字（global nonlocal） 变量名
变量名 = 新的变量值
global 全局声明，可以在函数内部将全局变量进行修改
nonlocal 函数内部声明，可以在函数内部对局部变量进行修改（只能是内层函数对本层函数之外最外层函数之内的作用域变量进行修改）

nonlocal关键字

# 1.外部必须有这个变量
# 2.在内部函数声明nonlocal变量之前不能再出现同名变量
# 3.内部修改这个变量如果想在外部有这个变量的第一层函数中生效

补充
三目运算符：
res = if成立时的结果 if 条件 else else成立时的结果

练习题

1、整理今天的知识点、继续整合思维导图

2、写函数，，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作

import os
def file_1(demo,i,j):
    with open(demo,'r',encoding='utf-8') as read_f,
          open('demo1.py','w',encoding='utf-8') as write_f:
        for line in read_f:
            write_f.write(line.replace(i,j))
    return read_f,write_f
file_11,file_l2=file_1('demo.py','def','haha')
os.remove(file_1.name)
os.rename(file_l2.name,file_11.name)

3、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。

def func1(s):
    for i in s:
        if i.isspace():
            return False
        else:
            return True
s='hello world'
print(func1(s))

4、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表

#方法一
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def length(s):
    a=[]
    for i in dic:
        if len(dic[i])>2:
         a.append({i:dic[i][0:2]})
    return a
print(length(dic))
#方法二
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def func1(dic):
    for i in dic:
        if len(dic[i])>2:
            dic[i]=dic[i][0:2]
    return dic
print(func1(dic))