def __new__(cls, identity):
"""
假设相同的学号只会有1个学生
:param identity:
:return:
"""
obj = cls.pool.get(identity, None)
if not obj:
obj = object.__new__(cls)
print(f'实例化 学号为 {identity} 的学生')
cls.pool[identity] = obj
return obj
def main():
sample_queue = Queue()
sample_queue.put('yam')
with QueueObject(sample_queue) as obj:
print('Inside with: {}'.format(obj))
print('Outside with: {}'.format(sample_queue.get()))
sample_queue.put('sam')
queue_object = QueueObject(sample_queue, True)
print('内部 func: {}'.format(queue_object.object))
print('外部 func: {}'.format(sample_queue.get()))
if not sample_queue.empty():
print(sample_queue.get())
def __cached_function_result_for_a_time(*args, **kwargs):
# print(cls.func_result_dict)
# if len(cls.func_result_dict) > 1024:
if sys.getsizeof(cls.func_result_dict) > 100 * 1000 * 1000:
cls.func_result_dict.clear()
key = cls._make_arguments_to_key(args, kwargs)
if (fun, key) in cls.func_result_dict and time.time(
) - cls.func_result_dict[(fun, key)][1] < cache_time:
return cls.func_result_dict[(fun, key)][0]
else:
print('函数 [{}] 此次不能使用缓存'.format(fun.__name__))
result = fun(*args, **kwargs)
cls.func_result_dict[(fun, key)] = (result, time.time())
return result
def build(self, build_type):
if build_type == "House":
director = Director()
builder = HouseBuilder()
director.builder = builder
director.construct_building()
building = director.get_building()
print(building)
else:
director = Director()
builder = FlatBuilder()
director.builder = builder
director.construct_building()
building = director.get_building()
print(building)
def __new__(cls, identity):
"""
假设相同的学号只会有1个学生
:param identity:
:return:
这个是享元模式，有人一看到重写 __new__就条件反射神经过敏，但凡是重写了__new__的代码他都认为是单例模式。
主要是没有掌握类的一些概念的本质，死记硬背形式造成的错误认知。
最起码要知道__new__是干啥，__init__是干啥，不知道的话就会死记硬背单例模式的形式。
"""
obj = cls.pool.get(identity, None)
if not obj:
obj = object.__new__(cls)
print(f'实例化 学号为 {identity} 的学生')
cls.pool[identity] = obj
return obj
def operation1(self):
print("My Concrete Operation1")
def operation3(self):
print('操作3')
def process(self):
print("fault")
def __init__(self, a, b):
print(f'初始化 {a},{b}')
def show(self):
print('显示 Home 页面')
def f1(self):
print("before run f1")
self._decoratee.f1()
print("after run f1")
def f2(self):
print("original f2")
def f1(self):
print("original f1")
def display(self, depth):
print('-' * depth + self.name)
def line_of_duty(self): # 履行职责
print('%s\t员工招聘培训管理' % self.name)
def display(self, depth):
print('-' * depth + self.name)
for component in self.childrenCompany:
component.display(depth + 2)
def print_data(self):
for data in self.compositeEntity.get_data():
print(f'Data: {data}')
def show(self):
print('显示 Student 页面')
def send_msg(self):
print(f'用 {self.phone_name} 发短信')
def is_authentic_user(self):
print("用户鉴权成功")
return True
obj = object.__new__(cls)
print(f'实例化 学号为 {identity} 的学生')
cls.pool[identity] = obj
return obj
def __init__(self, identity):
self.identity = identity
def eat(self):
print(f'{self.identity} 吃饭')
if __name__ == '__main__':
A('001').eat()
A('001').eat()
A('002').eat()
# 下面是关于这个享元模式被人说成是单例模式的反驳。如果是单例模式print(id(A('001')) == id(A('002'))) 结果会是True
print(id(A('001')) == id(A('002'))) # False
print(id(A('001')) == id(A('001'))) # True
"""
不会多次生成 001学号的同学这个对象。
"D:/coding2/python36patterns/创建型模式-享元模式.py:30" 11:46:53 实例化 学号为 001 的学生
"D:/coding2/python36patterns/创建型模式-享元模式.py:38" 11:46:53 001 吃饭
"D:/coding2/python36patterns/创建型模式-享元模式.py:38" 11:46:53 001 吃饭
"D:/coding2/python36patterns/创建型模式-享元模式.py:30" 11:46:53 实例化 学号为 002 的学生
"D:/coding2/python36patterns/创建型模式-享元模式.py:38" 11:46:53 002 吃饭
"D:/coding2/python36patterns/创建型模式-享元模式.py:45" 11:46:53 False
"D:/coding2/python36patterns/创建型模式-享元模式.py:46" 11:46:53 True
"""
def track_request(self, request):
print("被请求页面: " + request)
def eat(self):
print(f'{self.identity} 吃饭')
print("Student: RollNo " + str(student.get_roll_no())
+ ", updated in the database")
def delete_student(self, student: Student):
self.students.pop(student.get_roll_no())
print("Student: Roll No " + str(student.get_roll_no())
+ ", deleted from database")
if __name__ == '__main__':
student_dao = StudentDao()
# // 输出所有的学生
for student in student_dao.get_all_students():
print("Student: [RollNo : " + str(student.get_roll_no()) + ", Name : " + student.get_name() + " ]")
# // 更新学生
student = student_dao.get_all_students()[0]
student.set_name("Michael")
student_dao.update_student(student)
# // 获取学生
student_dao.get_student(0)
print("Student: [RollNo : "
+ str(student.get_roll_no()) + ", Name : " + student.get_name() + " ]")
"""
"D:/coding2/python36patterns/j2ee模式-数据访问对象模式.py:84" 17:38:06 Student: [RollNo : 0, Name : 小明 ]
"D:/coding2/python36patterns/j2ee模式-数据访问对象模式.py:84" 17:38:06 Student: [RollNo : 1, Name : 小黄 ]
"D:/coding2/python36patterns/j2ee模式-数据访问对象模式.py:70" 17:38:06 Student: RollNo 0, updated in the database
def process(self):
print("normal")
def update_student(self, student: Student):
# print(student.get_roll_no())
# print(student.get_name())
self.students[student.get_roll_no()].set_name(student.get_name())
print("Student: RollNo " + str(student.get_roll_no())
+ ", updated in the database")
def template_method(self):
print("Defining the Algorithm.Operation1 follows Operation2")
self.operation2()
self.operation1()
self.operation3()
def delete_student(self, student: Student):
self.students.pop(student.get_roll_no())
print("Student: Roll No " + str(student.get_roll_no())
+ ", deleted from database")
def operation2(self):
print("Operation 2 remains same")
def __get__(self, obj, cls):
print(obj, cls)
if obj is None:
return self
value = obj.__dict__[self.func.__name__] = self.func(obj)
return value
