python学习日记8 python基本语法（函数的本质&闭包&函数作用域）

一、函数的本质

函数本质是一个变量，函数名其实就是一个变量名

num = 10   # 10 <class 'int'>
print(num,type(num))

def func1():
    pass
print(func1,type(func1))  # <function func1 at 0x102818f70> <class 'function'>

一个函数可以作为另一个函数的参数或返回值使用,只需要传递或返回函数名即可

# 注意：xx()：表示函数的调用
# a.作为参数
def show1(num1,num2,f):
    print(f)
    print(f(num1) + f(num2))
show1(34,-10,abs)  # 44

# b.作为返回值
def show2():
    return abs
r2 = show2()  # 这个位置r2相当于函数名abs  通过r2（num）相当于调用函数abs（num）
print(r2)
print(r2(-34))  # 34

二、函数进阶

1.闭包

​ 函数只是一段可执行代码，编译后就“固化”了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了。函数还可以嵌套定义，即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题。

# 1.需求：在func2中访问func1中的变量num1
# 方式一：设置返回值，在func2中调用func1
def func1():
    num1 = 234
    return num1
def func2():
    print(func1() + 10)
func2()

# 方式二：进行函数的嵌套定义
def func1():
    num1 = 234
    def func2():  # 因为func2（）未调用所以最后不会执行func2内的语句
       print(num1 + 10)
func1()

# 2.嵌套定义的函数的调用方式    ******
# 注意：一个函数，无论以什么样的形式，书写在哪个位置，定义之后都需要手动调用才能执行
# 方式一：在func1中调用func2
def func1():
    print('111111')
    num1 = 234
    def func2():
        print('22222')
        print(num1 + 10)
    func2()
func1()

# 方式二：将func2作为func1的返回值,常用于装饰器中
def func1():
    print('111111')
    num1 = 234
    def func2():
        print('22222')
        print(num1 + 10)
    return func2
f1 = func1()  # 调用外部函数
print(f1)   # <function func1.<locals>.func2 at 0x106440790>
f1()   # 相当于调用func2()

# 3.闭包
"""
概念：两个函数嵌套定义，如果在内部函数中访问了外部函数中的变量，则会形成一个闭包
"""
# a.
def outter1():
    num = 10
    def inner1():
        print(num)
    return inner1
f1 = outter1()
f1()    # 10

# b.
def outter2(a):
    num = 10
    def inner2():
        print(a,num)
    return inner2
f2 = outter2(34)
f2()   #  34 10

# c.
def outter3(a):
    num = 10
    def inner3(b):
        print(a,num,b)
    return inner3
f3 = outter3(34)
f3(18)  #  34 10 18

# d.
def outter4(a):
    num = 10
    def inner4(b):
        print(a,num,b)
        return 'abc'
    return inner4
f4 = outter4(34)  
r4 = f4(18)  #  34 10 18
print(r4)  # abc
"""
说明：
    a.闭包本质还是一个函数，只要遵循闭包的概念，可以设置默认参数，关键字参数，不定长参数和返回值
    b.闭包的使用场景：变量的作用域和装饰器
"""

2.变量的作用域

2.1 作用域的分类

变量的作用域指的是变量可以使用的范围

程序的变量并不是在任意位置都可以访问，访问权限取决于这个变量是在哪里赋值的

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。

Python的作用域一共有4种，分别是

​ L:Local,局部作用域，特指内部函数

​ E:Enclosing,函数作用域【内部函数外的函数中】

​ G:Global,全局作用域

​ B:Built-in,内建作用域【内置作用域】 num = int(“244”)

查找方式：以L—>E—>G—>B,在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找

# 1.变量定义在不同的位置，访问的权限和位置也不同
num1 = 10        # G:Global,全局作用域:可以在当前py文件的任意位置访问
def outter():
    num2 = 20    # E:Enclosing,函数作用域:只能在outter中访问
    def inner():
        num3 = 30    # L:Local,局部作用域:只能在inner中访问
        print('inner:',num1,num2,num3)
    print("outter:",num1,num2)
    return inner
f = outter()
f()
print("global:",num1)

# 2.不同作用域内的变量重名，变量被访问的原则：就近原则
num = 10
def outter():
    num = 20
    def inner():
        num = 30
        print('inner:',num)   # 10 20 30-----》 30
    print("outter:",num)   # 10 20 ----》20
    return inner
f = outter()
f()
print("global:",num)   # 10

# 3.什么样的情况下回涉及到变量的作用域问题
"""
a.在Python中，只有函数，类，模块会引入新的作用域
b.其他的代码块，如：if，while，for，try-except，with等都不会引入新的作用域
"""

2.2 局部变量和全局变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中

"""
注意：全局变量和局部变量是一个相对的概念
全局变量：可以在当前文件的任意位置被访问的变量
局部变量：只能在指定的范围内被访问的变量
"""
num1 = 34    # 全局变量
def func1():
    num2  = 35   # 局部变量【函数作用域】
    def func2():
        num3= 24   # 局部变量【局部作用域】

2.3 global和nonlocal

两者的功能不同
global关键字修饰变量后标识该变量是全局变量，对该变量进行修改就是修改全局变量，而nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）。

两者使用的范围不同
global关键字可以用在任何地方，包括最上层函数中和嵌套函数中，即使之前未定义该变量，global修饰后也可以直接使用，而nonlocal关键字只能用于嵌套函数中，并且外层函数中定义了相应的局部变量，否则会发生错误。

# global关键字
# 当函数内部只是调用全局变量使用而不对全局变量进行修改可以直接使用全局变量
num = 10       
def outter():
    num1 = num + 20    
    def inner():
        num2 = num + 30   
        print('inner:',num,num1,num2)  # inner: 10 30 40
    print("outter:",num,num1)  # outter: 10 30
    return inner
f = outter()
f()
print("global:",num)  # global: 10

# 当函数内部需要对全局变量进行修改时，就需要在局部用global声明该全局变量
num = 10
def outter():
    global num
    num += 20
    def inner():
        global  num  # 内部函数要使用必须再一次声明
        num += 30
        print('inner:',num)  # inner: 60
    print("outter:",num)  # outter: 30
    return inner
f = outter()
f()
print("global:",num)  # global: 60

# nonlocal关键字
# 当函数内部只是调用局部变量使用而不对局部变量进行修改可以直接使用局部变量  和全局相同
# 当函数内部需要对局部变量进行修改时，就需要在内部用nonlocal声明该局部变量
num = 10
def outter():
    num = 20
    def inner():
        nonlocal  num  # num = 20
        num += 30
        print('inner:',num)  # inner: 50
    print("outter:",num)  # outter: 20
    return inner
f = outter()
f()
print("global:",num)  # global: 10

三、生成器

生成器概念的由来

问题：
列表：一次性将所有的元素全部定义出来,如果只需要访问其中的前几个元素，大量的内存空间会被浪费
解决方案：
使用第n个元素，则只需要生成前n元素，在Python中，将这种一边使用，一般计算的机制被称为生成器(generator)

生成器的定义方式有两种：
a.将列表推导式中的[]改为()

# 列表推导式
list1 = [i for i in range(10000)]
print(type(list1))  #<class 'list'>
print(list1)  # [0,1,2……]  所有数据都生成出来了
# 生成器
ge1 = (i for i in range(10000))
print(type(ge1))  # <class 'generator'>
print(ge1)  # <generator object <genexpr> at 0x000001F0B957F350>  输出的是生成器对象

# 访问生成器中的元素
# a.next(生成器)获取生成器中的下一个元素
ge1 = (i for i in range(5))
print(next(ge1))
# 注意：定义一个生成器，通过next()获取生成器中的下一个元素，当所有元素全部生成获取完毕，再次next(),则报错StopIteration

# b.for循环
for n in ge1:
    print(n)

​ b.函数结合yield，定义函数生成器

# 只要在函数内部出现yield关键字，则该函数就是一个函数生成器，yield关键字后面的数据将是生成器中的元素
def test1():
    yield 10
r1 = test1()
print(r1,type(r1))  # <generator object test1 at 0x0000021523610570> <class 'generator'>
# print(next(r1))
for n in r1:
    print(n)  # 10

# c.
def test2():
    yield 10
    yield 20
    yield 30
r2 = test2()
for n in r2:
    print(n)  # 10 20 30

# d.
# 获取一个生成器中的3个元素
def test3(n):
    for i in range(n):
        yield  i ** 2
r3 = test3(5)
print(next(r3))  # 0
print(next(r3))  # 1
print(next(r3))  # 4

# 分别获取三个生成器中的第0个元素
def test3(n):
    for i in range(n):
        yield  i ** 2
print(next(test3(5)))
print(next(test3(5)))
print(next(test3(5)))

# 注意：在函数生成器中，只要函数调用一次，则表示生成一个新的生成器

四、可迭代对象和迭代器

可迭代对象和迭代器之间的区别和联系
区别：
可迭代对象：Iterable,可以直接作用于for循环的对象【可以使用for循环遍历其中元素的对象】，
如：list,tuple,dict,set，str,range(),generator等
迭代器: Iterator,可以直接作用于for循环,或者可以通过next()获取下一个元素的对象，
如：generator
联系：
迭代器一定是可迭代对象，可迭代对象不一定是迭代器
但是，可以通过系统功能iter()将不是迭代器的可迭代对象转换为迭代器