05类的续集

一、yield关键字

# 在一个函数里面 一旦遇到yield关键 调用函数的时候 不会执行函数体代码
# 会返回一个生成器 生成器就是一个自定义的迭代器
def func():
    print(111)
    yield '第一次'
    print(222)
    yield '第二次'


# g = func()
# print(g.__next__())
# print(g.__next__())
#
# [].__iter__()
# 可迭代对象  内置了有 __iter__方法的对象
# 可迭代对象.__iter__()  得到就是迭代器对象
# 迭代器对象 __iter__   __next__

# print([].__next__)

"""
1. 给序列和非序列提供了一种统一取值的方式
2. 在同一时刻内存里面只有一个值 可以只在你使用 __next__这个方法的时候 那到1一个值
迭代器里面可以存无限大的数据
"""


def my_range(start, stop, step=1):
    while start < stop:  # 2 < 5
        yield start  # 2
        start += step  # start=2


for i in my_range(1, 101):
    print(i)

二、类的装饰器

# class ClassMethod:
#     def __init__(self, func):
#         self.func = func
#
#     def __get__(self, instance, owner):
#         def inner():
#             self.func(owner)
#         return inner
#
#
#
# class People:
#     country = '中国人'
#
#     # say_hai = ClassMethod(say_hai)
#     @ClassMethod
#     def say_hai(cls):
#         print('牛逼的' + cls.country)
#
#
# # print(People.__dict__)
# People.say_hai()
# # p1 = People()
# # p1.say_hai()
#
#
#
#


class StaticMethod:
    def __init__(self, func):
        self.func = func

    def __get__(self, instance, owner):
        def inner(*args, **kwargs):
            self.func(*args, **kwargs)

        return inner


class People:
    country = '中国人'

    # say_hai = ClassMethod(say_hai)
    @StaticMethod
    def say_hai(a, b):
        print(a, b)


# print(People.__dict__)
People.say_hai(1, 2)
# p1 = People()
# p1.say_hai()

元类

python当中一切皆对象 你定义的函数 导入的模块 数据类型产生的值 都是对象

类本身也是一个对象 对象是一个类的实例

# 我们可以使用type来看一个对象的类
print(type([1, 2, 3]))  # <class "list">

class Foo:
    pass


# foo = Foo()
# print(type(foo))
#
# print(type([1, 2, 3]))
print(type(Foo))  # <class 'type'>

产生类的类我们叫元类 默认所有用class关键字创建的类 他们的元类是type

# class Chinese:
#     country = 'China'
#
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#     def talk(self):
#         print(f'{self.name}在说话')

#
# obj = Chinese('久违', 18)
# print(obj.name, obj.age)

# 创建一个类的三大要素
# 类名 父类 名称空间

class_name = 'Chinese'
class_bases = (object, )
class_body = """
country = 'China'

def __init__(self, name, age):
    self.name = name
    self.age = age

def talk(self):
    print(f'{self.name}在说话')

"""
class_dic = {}
exec(class_body, globals(), class_dic)

Chinese1 = type(class_name, class_bases, class_dic)
obj = Chinese1('久违', 18)
print(obj.name, obj.age)

# class Foo:
#     pass
#
#
# # foo = Foo()
# # print(type(foo))
# #
# # print(type([1, 2, 3]))
# print(type(Foo))  # <class 'type'>

# type 创建一个类
# class 创建一个类

# class Chinese:
#     country = 'China'
#
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#     def talk(self):
#         print(f'{self.name}在说话')

#
# obj = Chinese('久违', 18)
# print(obj.name, obj.age)

# 创建一个类的三大要素
# 类名 父类 名称空间

# class_name = 'Chinese'
# class_bases = (object, )
# class_body = """
# country = 'China'
#
# def __init__(self, name, age):
#     self.name = name
#     self.age = age
#
# def talk(self):
#     print(f'{self.name}在说话')
#
# """
# class_dic = {}
# exec(class_body, globals(), class_dic)
#
# Chinese1 = type(class_name, class_bases, class_dic)
# obj = Chinese1('久违', 18)
# print(obj.name, obj.age)


class MyClass(type):
    def __init__(self, class_name, class_bases, class_dic):
        if not class_name.istitle():
            raise TypeError('类名首字母必须要大写')

        if '__doc__' not in class_dic or not class_dic['__doc__'].strip():
            raise TypeError('必须写注释')

        super().__init__(class_name, class_bases, class_dic)


class Chinese(object, metaclass=MyClass):
    """

    """
    country = 'China'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        print(f'{self.name}在说话')

三大特征

封装: 在我们那到一个需求的时候 我们要一个需求分解成多个类
将同一类方法封装到一个类里面 将数据封装到一个对象里面

代码可读性更好 高内聚 低耦合 可扩展好

继承:重用现有类的功能和概念并在此基础上做扩展

隔离变化点 统一管理 : 约束子类行为

多态:父类的同一种行为在不同子类上有不同的实现 增加程序的扩展性 体现 开闭原则