关键词：
迭代器模式和观察值模式
"""
行为模式：是对不同的对象之间划分责任和算法的抽象方式。重点在于类和类之间相互作用。
# 迭代器模式
# 观察者模式
"""
1. 迭代器模式
# Iterable: iter方法: return Iterator
# Iterator：next iter方法
# 用于访问 集合对象的时候按照顺访问，不需要集合对象的底层表示。
# 迭代器的抽象类
class Iterator:
def __init__(self,aggregate):
self.aggregate=aggregate
self.curr=0
def First(self):
return self.aggregate[0]
def Next(self):
self.curr+=1
if self.curr<len(self.aggregate):
result=self.aggregate[self.curr]
return result
def CurrIterm(self):
return self.aggregate[self.curr]
def Isdone(self):
# if self.curr+1>=len(self.aggregate):
# return True
# else:
# return False
return True if self.curr+1>=len(self.aggregate) else False
# 抽象的被迭代元素对象
class Aggregate:
def __init__(self):
self.ilist = []
def createIterator(self):
return Iterator(self.ilist)
a=Aggregate()
a.ilist.append(1)
a.ilist.append(2)
a.ilist.append(3)
# 获得自己的迭代器
iter=a.createIterator()
print(iter.First())
print(iter.Next())
print(iter.CurrIterm())
while not iter.Isdone():
print(iter.Next())
"""
适用场景：需要为可迭代的类型提供多种遍历方式。
当遍历可迭代对象时，不希望在内部暴露迭代的细节（first内部，next内容）
优点：对迭代对象进行遍历，进行获取元素。可以自定义获取的方式
缺点：当出现不同的迭代对象时，需要不同的迭代器，需要新增迭代器。
"""
2. 观察者模式：定义对象之间一对多的依赖关系。需要使用观察者模式，当一个对象状态发生
改变，所有依赖于它的对象都会得到通知从而发生改变。
# 学生上课玩手机，班主任看见了，需要批评。
# 学生作为观察者，观察“侦探”，当“侦探”发出通知，学生能够采取对应的措施。多个学生，一个侦探。
# 第一个版本
# 观察者
class Classmates:
def __init__(self,name,detective):
self.name=name
self.detective=detective
def KingGame(self):
return "王者荣耀"
# 为了保证能够接到侦探通知，同时还能够采取行动
def update(self):
# 1. 得到通知 2采取行动
self.detective.discoverTeacher()
print("不玩游戏了，开始假装学习".format(self.name))
# 侦探
class Detactive:
def __init__(self):
self.classmates=[]
def discoverTeacher(self):
print("老师来了")
def nofify(self):
for i in self.classmates:
print("，别，快学习！".format(i.name,i.KingGame()))
i.update()
# d=Detactive()
# c1=Classmates("张三",d)
# c2=Classmates("李四",d)
# d.classmates=[c1,c2]
# d.nofify()
# 第二个版本：针对不同的同学可能做不同的事情，所以需要有基类，有扩展类。
class Classmates:
def __init__(self,name,detective):
self.name=name
self.detective=detective
def update(self):
pass
class ClassmatesKing(Classmates):
def noStudy(self):
return "王者荣耀"
# 为了保证能够接到侦探通知，同时还能够采取行动
def update(self):
# 1. 得到通知 2采取行动
self.detective.discoverTeacher()
print("不玩游戏了，开始假装学习".format(self.name))
class ClassmatesNBA(Classmates):
def noStudy(self):
return "正在看NBA"
# 为了保证能够接到侦探通知，同时还能够采取行动
def update(self):
# 1. 得到通知 2采取行动
self.detective.discoverTeacher()
print("不看视频了，开始假装学习".format(self.name))
# 侦探
class Detactive:
def __init__(self):
self.classmates=[]
def discoverTeacher(self):
print("老师来了")
def nofify(self):
for i in self.classmates:
print("，别，快学习！".format(i.name,i.noStudy()))
i.update()
# d=Detactive()
# c1=ClassmatesKing("张三",d)
# c2=ClassmatesKing("李四",d)
# c3=ClassmatesNBA("王五",d)
# d.classmates=[c1,c2,c3]
# d.nofify()
# 第三版：侦探可以不是一个 ：解决侦探可以扩充子类。
class Classmates:
def __init__(self,name,detective):
self.name=name
self.detective=detective
def update(self):
pass
class ClassmatesKing(Classmates):
def noStudy(self):
return "王者荣耀"
# 为了保证能够接到侦探通知，同时还能够采取行动
def update(self):
# 1. 得到通知 2采取行动
self.detective.discoverTeacher()
print("不玩游戏了，开始假装学习".format(self.name))
class ClassmatesNBA(Classmates):
def noStudy(self):
return "正在看NBA"
# 为了保证能够接到侦探通知，同时还能够采取行动
def update(self):
# 1. 得到通知 2采取行动
self.detective.discoverTeacher()
print("不看视频了，开始假装学习".format(self.name))
# 侦探
class Detactive:
def __init__(self):
self.classmates = []
def discoverTeacher(self):
print("老师来了")
def nofify(self):
for i in self.classmates:
print("，别，快学习！".format(i.name, i.noStudy()))
i.update()
class DetactiveA(Detactive):
def discoverTeacher(self):
print("A大吼一声老师来了")
class DetactiveB(Detactive):
def discoverTeacher(self):
print("B悄悄的说一声老师来了")
# da=DetactiveA()
# db=DetactiveB()
# c1=ClassmatesKing("张三",da)
# c2=ClassmatesKing("李四",da)
# c3=ClassmatesNBA("王五",db)
# da.classmates=[c1,c2]
# db.classmates=[c3]
# da.nofify()
# db.nofify()
#第四版：侦探对于同学可以添加好友，还可以踢出好友
class Classmates:
def __init__(self, name, detective):
self.name = name
self.detective = detective
def update(self):
pass
class ClassmatesKing(Classmates):
def noStudy(self):
return "王者荣耀"
# 为了保证能够接到侦探通知，同时还能够采取行动
def update(self):
# 1. 得到通知 2采取行动
self.detective.discoverTeacher()
print("不玩游戏了，开始假装学习".format(self.name))
class ClassmatesNBA(Classmates):
def noStudy(self):
return "正在看NBA"
# 为了保证能够接到侦探通知，同时还能够采取行动
def update(self):
# 1. 得到通知 2采取行动
self.detective.discoverTeacher()
print("不看视频了，开始假装学习".format(self.name))
# 侦探
class Detactive:
def __init__(self):
self.classmates = []
def add(self,c):
self.classmates.append(c)
def remove(self,c):
self.classmates.remove(c)
def discoverTeacher(self):
print("老师来了")
def nofify(self):
for i in self.classmates:
print("，别，快学习！".format(i.name, i.noStudy()))
i.update()
class DetactiveA(Detactive):
def discoverTeacher(self):
print("A大吼一声老师来了")
class DetactiveB(Detactive):
def discoverTeacher(self):
print("B悄悄的说一声老师来了")
da = DetactiveA()
db = DetactiveB()
c1 = ClassmatesKing("张三", da)
c2 = ClassmatesKing("李四", da)
c3 = ClassmatesNBA("王五", db)
da.add(c1)
da.add(c2)
db.add(c3)
da.remove(c1)
da.nofify()
db.nofify()
"""
观察者：观察者（同学）可以把自己注册到被观察对象中，
观察对象都存放在被观察者（侦探）的容器中。
被观察者：被观察者发生了变化（notify），
会从容器中获得所有注册过的观察者，把通知通知给观察者（update）
被观察者（侦探）可以撤销和注册被观察者（add,remove）
优点：被观察者和观察者是抽象耦合的，使用抽象尽量降低耦合度；
建立一套触发机制，只要notify，所有的观察者都会执行update
缺点：如果一个被观察者对象有很多的观察者，因为会通知到所有的观察者，会浪费时间。如果
观察者的数目过大，可能会造成死机。
"""
元类
"""
元编程：使用元类进行编程
元类----类------对象
"""
"""
一、元类
类可以被赋值、可以作为参数传递、可以打印输出。
"""
def fun():
pass
f = fun
f()
# 可以对类进行赋值。
class A:
pass
p = A
k = p()
print(k)
print(type(k))
# 类作为返回值
def fun():
return A
print(fun())
# 类也可以被当成参数传入
def fun(param):
return param()
print(fun(A))
类也是对象。谁创建的类？---元类
最原始的元类：type，元类还是 由元类自己创建的。
print(type(list()))
print(type(list))
print(type(A))
print(type(type))
二、type
"""
type有两种用法：
1. 使用type返回当前对象（如果是实例，那么返回的是类，如果是类，那么返回的就是元类）的类型
就是返回谁创建的对象。
2. 用type创建一个类（没有指定其他的元类，默认使用type创建）
"""
# 第二种用法type内部是三个参数
# 1. 类的名字（字符串）:
# 指的是当使用type(A)显示类是由谁创建时的名字<class ‘__main__.Person1‘>
# 2.所有继承的父类（元组）
# 3.类所关联的属性和方法的名称（字典类型）
def init(self, name):
self.name = name
@classmethod
def copy(cls, person):
copyperson = cls(person.name)
return copyperson
Person = type("Person1", (), "desc": "人类", "__init__": init, "copy": copy)
p = Person("bill")
print(p.name)
pcopy = Person.copy(p)
print(pcopy.name)
print(Person.__name__)
三、自定义元类
"""
1.继承type，创建元类
2.创建好自定义的元类之后，需要使用metaclass关键字指定用哪一个类创建其他的类
"""
class ModelMetaclass(type):
def __new__(cls, name, bases, attrs):
print("我是新的元类!!!", bases)
return type.__new__(cls, name, bases, attrs)
class A(metaclass=ModelMetaclass):
pass
# a=A()
# print(type(A))
class D:
pass
class B(A):
pass
class C(B, D):
pass
四、三个特殊的函数 魔法方法__init__ __new__ __call__
"""
1.__new__：创建对象的时候执行方法，创建一个对象。是一个静态方法
2.__init__: 初始化实例，执行完__new__，再去执行__init__，实例方法。
3.__call__: 使得类当函数调用 a()====a.__call__()
"""
class ModelMetaclass(type):
def __new__(cls, *args, **kwargs):
print("元类的new方法执行")
return super().__new__(cls, *args, **kwargs)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
print("元类的init执行")
def __call__(self, *args, **kwargs):
print("执行元类的call方法")
return super().__call__(*args, **kwargs)
class A(metaclass=ModelMetaclass):
def __new__(cls, *args, **kwargs):
print("A的new方法执行")
return super().__new__(cls, *args, **kwargs)
def __init__(self, *args, **kwargs):
print("A的init执行")
super().__init__(*args, **kwargs)
def __call__(self, *args, **kwargs):
print("A的call方法执行")
# 没有return super().call方法
def fun(self):
pass
"""
1.定义了元类之后，只要定义了类使用了这个元类来创建，就会调用元类的new和init方法
无论是否已经有类的对象了，都会执行
2. 当使用这个类创建了实例时，会先调用它的元类下的call方法，然后再去调用这个的new
和init方法。
3. 当仅调用实例时（在实例后面加()），会调用类下面的call
4. 当调用实例的其他方法时，不会调用类的call方法
"""
a = A()
# print(type(A))
a()
a("11")
a("11", "22")
a.fun()
五、元类的应用：元类一般都是自己写一个元类，用来改变类的创建方式。
from datetime import datetime
class ModelMetaclass(type):
def __new__(cls, name, bases, attrs):
print("我是新的元类")
attrs["create_time"] = datetime.now()
for k, v in attrs.items():
print(k, v)
return type.__new__(cls, name, bases, attrs)
class A(metaclass=ModelMetaclass):
pass
a = A()
print(type(A))
print(A.create_time)
1. 创建元类，使得使用这个元类创建的类不能被实例化对象（抽象类abstract）
class AbstarctMeta(type):
def __call__(self, *args, **kwargs):
raise TypeError("不能使用当前类创建对象")
class Card(metaclass=AbstarctMeta):
# 静态方法和类方法、类属性
pass
class Ccard():
pass
class Xcard():
pass
# c=Card()
cc = Ccard()
2.创建一个元类，使得使用这个元类创建的类不能被继承。（终级类final ）
# type :name bases attrs
class final(type):
def __init__(self, name, bases, attrs):
super().__init__(name, bases, attrs)
for i in bases:
if isinstance(i, final):
raise TypeError("所继承的父类是终级类，不能有子类")
class A(metaclass=final):
pass
class C:
pass
class B(C):
pass
3.使用元编程完成单例模式
class Singleton(type):
def __new__(cls, *args, **kwargs):
print("元类的new")
return super().__new__(cls, *args, **kwargs)
def __init__(self, *args, **kwargs):
print("元类的init")
super().__init__(*args, **kwargs)
self.instance = None
def __call__(self, *args, **kwargs):
print("元类的call")
if not self.instance:
self.instance = super().__call__(*args, **kwargs)
return self.instance
class A(metaclass=Singleton):
pass
数据结构学习第二十三天
13:50:24 2019-09-14继续把未看完的看完 排序算法定理:任意$N$个不同元素组成的序列平均具有$N(N-1)/4$个逆序对定理:任何仅以交换相邻两元素来排序的算法，其平均时间复杂度为$Ω(N^2)$这样子冒泡排序插入排序的最坏情况... 查看详情
华为实习日记——第二十三天
最近几天的天气比较凉爽，早晨走在路上吹着清凉清凉的风，感觉很舒服。 上午没任务，就把cinder-volume的创建卷的过程过了一遍，记了下笔记。 下午的时候很无聊，师父要开一天会，没人给我任务。就一边刷刷知... 查看详情
mysql基础第二十三天,更新和删除数据(代码片段)
更新数据updatecustmerssetcust_city=replace(cust_city,'市','city')wherecust_id>1000;updatecustomersetcust_adderess='新福路12号',cust_city='厦门市'wherecust_id=1;u 查看详情
学习python的第二十三天(re模块)(代码片段)
6.13自我总结1.re模块1.re.findall()1.基本用法re.findall(正则匹配的格式,匹配的对象)2.正则匹配常用格式1.^只匹配开头在多行模式中匹配每一行的开头类似字符串内置方法里面的startswithimportres='''aaaa,123213123,____,杨aaaaa''&#... 查看详情
python之第二十三天的努力--函数总结(代码片段)
01函数总结#仅限关键字参数#deffunc(a,b,*args,c):#print(a,b)#print(c)##func(1,2,3,4,c=666)#*#a,b=(1,2)#a,b,*c=(1,2,3,4,5,6)#print(a,b,c)#12[3,4,5,6]#a,*b,c=[11,22,33,44,55,66,77]#print(a,b,c)#11[22,33,44,55,66]77# 查看详情
java基础第二十三天——解析xml文件和dtd约束(代码片段)
反射注意点：当我们利用反射获取src下的.properties文件时，我们利用IO流获取文件的路径时可以这样写：InputStreamstream=Demo1.class.getClassLoader().getResourceAsStream("person.properties");开发中，要把所有配置文件写入sr 查看详情
学java第二十三天，list类型和set类型(代码片段)
数组，是我们最常用的，但是有时候，我们要用数组，但是又不知道数组的类的长度的时候，我们java就有一个很好用的工具Collection，这都是java的爸爸的用心良苦，Collection中包含List和Set和Map，但是今天老师讲了List和Set。List是... 查看详情
爱创课堂每日一题第二十三天-expires和cache-control？
Expires要求客户端和服务端的时钟严格同步。HTTP1.1引入Cache-Control来克服Expires头的限制。如果max-age和Expires同时出现，则max-age有更高的优先级。 Cache-Control:no-cache,private,max-age=0 ETag:abcde &nb 查看详情
第二十三天泛型(代码片段)
1.概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传... 查看详情
每日算法&面试题，大厂特训二十八天——第二十三天（树）(代码片段)
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法... 查看详情
10.27开课一个月零二十三天（设计模式）
<?php//面向对象的三大特性//封装：//目的：为了让类更安全//做法：将成员变量变为私有，做一个方法来间接操作成员变量，在方法里面加限制条件//继承：//子类可以继承父类的一切//特点：单继承，一个子类只能有一个父类//... 查看详情
第二十三课
第二十三课第一单元语法部分Vておく<提前>：预先…… 口语形式：～とく 说明： A、表示为后面要做的事情事先做好某种准备。 B、表示采取某种行为，并使其结果的状态持续下去。&nb... 查看详情
蓝桥杯刷题第二十三天
第一题：长草题目描述小明有一块空地，他将这块空地划分为n行m列的小块，每行和每列的长度都为1。小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。这些草长得很快，每个月，... 查看详情
重学java基础第二十三课:java基础注释
第二十三篇densenet——论文翻译
文章目录摘要1引言2相关工作3DenseNets4实验4.1数据集4.2训练4.3CIFAR和SVHN的分类结果4.4.ImageNet上的分类结果5讨论 查看详情
java练习题java程序的输出|第二十三套（继承）
第二十三篇责任与义务
第二十三篇 责任与义务 我们来到这个世界，本身就有自身的责任与义务。如果没有责任与义务，我们就失去了生活的意义，因为一个人必须活出价值才有意义；没有价值地活着，那就成为了宇宙的累赘。以这样的方式来... 查看详情
第二十三课模块独立编译的支持(代码片段)
1.PHONY:allcompilelinkcleanrebuild$(MODULES)23DIR_PROJECT:=$(realpath.)4DIR_BUILD_SUB:=$(addprefix$(DIR_BUILD)/,$(MODULES))5MODULE_LIB 查看详情