【python进阶3】super，迭代器，装饰器

super函数

• super函数可以调用父类的方法
• super().函数方法 使用子类调用父类已经被覆盖的方法
• super(Child,obj).f()使用子类对象调用父类被覆盖的方法

class Parent:
    def say(self):
        print('parent ')
        
class Child(Parent):
    def say(self):
        print('Child')
        super().say()  # 子类调用父类已经覆盖的方法

c = Child()
c.say()
super(Child,c).say() # 子类对象调用父类已经覆盖的方法

python迭代器和生成器

迭代器

[迭代器](内置类型 — Python 3.12.4 文档)

python中的迭代器是访问迭代对象的工具

iter() 返回迭代器对象

next() 对迭代器对象进行迭代，每次迭代的不同，只能向后进行

li = [1,2,3]
li = iter(li)
print(next(li)) #1
print(next(li))# 2
print(next(li))# 3

生成器

使用关键字yield的函数

可以迭代过程逐步产生值

生成器函数可以生成一个迭代对象

def f(n):
    for i in range(n):
        yield str(i)

it1 = f(10)
li = [i for i in it1]
print(li)
it2 = f(5)
print(next(it2))
print(next(it2))
print(next(it2))

迭代类

class my_iter:
    def __init__(self,a):
        self.a = a
    def __iter__(self):
        return self
    
    def __next__(self):
        self.a -= 1
        return self.a

it = my_iter(3)
print(next(it))  # __next__的返回值
print(next(it))
print(next(it))
x = iter(it)  # __iter__的返回值

• 迭代器表达式
  • (表达式 for 变量 in 可迭代对象 [if 条件])

python 函数式编程

• 将函数作为参数传递

def cb():
	print('cb函数执行')
def f(fun):
    fun()
f(cb)


def cb(x):
    x *= x
    return x
def f(x,cb):
    a = cb(x)
    return a
print(f(12,cb))
# 闭包 把函数作为另一个函数的参数传入
# 内部函数调用外部函数的变量
# 绑定两个函数的执行环境

• 函数作为返回值

def f(z):
    print(z,'  f函数执行')
    def m(x):
        print(x,'   m running')
    return m
fun = f(1)
fun(2)

内置高阶函数

map将迭代对象的每一个元素作为传入函数的参数，返回值成为新的迭代对象

filter 迭代对象满足条件的组成新的迭代对象

print([i for i in filter(lambda x:x>3,(i for i in range(6)))])
[4, 5]

max() 迭代对象最大值

min() 迭代对象最小值

sorted() 返回对迭代对象排序的结果

装饰器

• 基本装饰

'''
装饰器函数接收函数作为参数传入
装饰器内对传入的函数进行一些逻辑的增加
对传入的函数调用
装饰器返回一个函数，在调用被装饰的函数时会调用这个函数

在装饰函数时，装饰器里的代码块会执行
'''
# def mydeco(fn):
#     fn()
#     print('装饰器被调用，返回fx')
#     def fx():
#         print('fx被调用')
#     return fx
# @mydeco
# def m():
#     print('m函数执行')    
# m()

• 带参数的装饰器

'''
可以在使用装饰器时传入一个参数
'''

def wr(n):
    def dec(f):
        def m():
            for _ in range(n):
                f()
        return m
    return dec

@wr(4)
def fn():
    print('被装饰的函数')
fn()

• 装饰器链

def dec1(f):
    def m():
        print('装饰器1')
        return '装饰器1 的m' + f()
    return m

def dec2(f):
    def m():
        print('装饰器2')
        return '装饰器2 的m' +f()
    return m

@dec1
@dec2
def f():
    return '!'

print(f())

• 类装饰器
  • 类装饰器接收函数在call方法中执行额外操作

class Person1:
    def __init__(self,fun):
        self.fun = fun
    def __call__(self):
        def m():
            print('类装饰器里的m函数执行')
            self.fun()
        return m
   
@Person1
def f():
    print('f函数执行')
# f()()

'''
装饰器里的函数接收的参数就是传入函数调用时接收的参数
'''
class Person2:
    def __init__(self,fun):
        self.fun = fun
    def __call__(self,x):

        print('类装饰器里的m函数执行')
        self.fun(x)

   
@Person2
def f(x):
    print(x)
    print('f函数执行')
f(12)

参考——装饰器