俺老师让发的作业，９.１０号

name="sanzhang"

def fun1():
    pass
print(type(name))
print(type(fun1))
#函数的本质是一个变量，
# 函数名就是一个函数名
fun1=12
name=[1,2,3,323,2424]
print(type(name))
print(type(fun1))
#需求在fun2中访问fun1中的变量num1,求num2和num1
#1,设置返回值
def fun1():
    num1=92
    return num1
def fun2():
    num2=100
    ss= fun1()+num2
    print(ss)
fun2()
#2,函数的嵌套定义
def ppp():
    mu1=12
    print("99999999999")
    def hu():
        nu2=22
        total=mu1 + nu2
        print(total)
        return total
    print("000000000")# 在内部函数调用的上面先执行
    hu()  # 调用内部函数hu()，
    # 内部函数在调用时才有用
    # 根据从上到下的顺序，严格遵守内外函数运行
    #同级别函数在上面的先运行
    return hu() ,111
#python运行从上到下运行
#注意，mu1,和hu()相当于是ppp()的局部变量
# ，只能在ppp()内部被访问
mm=ppp()#mm调用了函数，又获取了函数的返回值
print(mm)
#以上运行顺序是26,27,32,33,27-31,37,27,37,41

#闭包，如果两个函数嵌套定义，
# 如果在内部函数中访问了外部函数的变量则构成闭包
def b1(a,b,c):
    numn=79
    def b2(d,e,f):
        total=numn+1#如果在内部函数中访问了外部函数的变量则构成闭包
        print(total,a,b,c,d,e,f)
        return "99999"
    return b2
a1=b1(1,2,2)
ss=a1(1,2,333)#只调用了函数，没有获得返回值
print(ss)#调用函数同时，函数结束获得函数返回值

#变量的作用域
#变量的作用域指的是变量可以使用的范围
#１L，local,局部作用域，特指内部函数
#2,E,Enclosing,函数的作用域[外部函数中]
#3,G,Golal全局作用域
#4,B,Built-in,内部函数[内置作用域]

k1=20#G,Golal全局作用域,哪里都能用，通用！　
def k3(a,b):
    num1=100#E,Enclosing,函数的作用域[外部函数中]
    def k4(c,d):#内部函数在外部函数中
        num2=200#B,Built-in,内部函数[内置作用域]
        s=num2+1
        def k5(e,f):
            k3(23,98)
            ppps=1
            return e,f
        k3(12,23)#在内部函数中访问外部函数
        print(num1,s)#ppps无法被访问，这里已经在k5外部
        return k5
    return k4
#注意，如果不同作用域变量重名，就近访问！谁更近访问谁
#注意，不同作用域中的变量重名，但是互相之间没有关系
hhh=k3(1,23)
mqm=hhh(2,87)
nhnh=mqm(12,87)
print(nhnh)

e=10
def m(a,c):
    global e#globalx 声明x变量来自全局变量
    e+=202
    return e
kwa=m(3,4)
print(kwa)

def q(c,d):
    name="ba123"
    def pq(k,p):
        nonlocal name
        #声明nonlocal.x声明ｘ变量来自函数作用域
        name+="ba456"
        print(name)
        return name
    return pq
jjj=q(1,21)
qqq=jjj(2,978)
print(qqq)

#生成器
#问题：列表；一次性将所有元素定义出来
# ，如果只需要访问前几个元素大量的内存空间就会被浪费
#解决方案；
#使用第几个元素，就只需要生成前几个元素，在python中，将这种一边
#使用一边计算的机制称之为生成器
#方式有两种，在还没使用时不占用空间
#1，将列表推导式中的[]改为()

list2=(x  for x in range(0,5))
print(type(list2))
#2,函数结合yield定义函数生成器
def m():
    for x in range(1,10):
        #执行几次就是放里面放几个元素
        yield x**2
r1=m()
print(r1)
#方式二转换成列表
r1=list(r1)
print(r1)
#方式二遍历

#生成器获取完了，接着获取会报错

# for kk in r1:
#     print(kk)
#方式三打印next(x)
# print(next(r1))