面向对象

目录

• 面向对象的没法方法
• 基于魔法方法笔试题
• 元组简介
• 创建类的两种方式
• 元类定制类的产生行为
• 元类定制对象的产生行为
• 魔法方法之双下new方法
• 设计模式简介

目录概要

面向对象的魔法方法

• 魔法方法：类中定义的双侠方法都称为魔法方法
• 其一不需要人为调用 其二特点的条件自动触发运转
  eg：__init__创建空对象之后自动触发给对象添加独有的数据

1. __init__
对象添加独有数据的时候自动触发
2. __str__
对象被执行打印操作的是很好自动触发
3. __call__
对象加括号调用的时候自动触发
4. __getattr__
对象点不存在名字的时候自动触发
5. __getattribute__
对象点名字就会自动触发 有它的存在就不会运行上面的__getattr__
6. __setattr__
给对象添加或者修改数据的时候自动触发  对象.名字 = 值
7. __enter__
当对象被当做with上下文文件管理操作的开始自动触发 并且该方法返回 as后面的变量名就会接收到什么
8. __exit__
with上下文管理语法运行完毕之后自动触发（子代码结束）

魔法方法笔试题

1. 补全下列代码使得运行不报错即可
	class Context:
		pass
	with Context() as f:
		f.do_something()

class Context:
	def do_something(self):
		pass
	def__enter__(self):
		return self
	def__exit__(self, exc_type, exc_val, exc_tb):
		pass
with Context() as f:
	f.do_something()

2. 自定义自动类型并让字典能够通过据点符的方式操作键值对
	class MyDict(dict):
		def__setattr__(self, key, value):
			self[key] = value
		def__getattr__(self, item):
			return self.get(item)
		obj = MyDict()
		obj.name = 'jason'
		obj.pwd = 18
		obj.hobby = 'read'
		# print(obj)
		print(obj.name)
		pring(obj.pwd)
		print(obj.hobby)
		# print(obj)
		# print(obj)  # 字典存储的数据  {}
		# print(obj.__dict__)  # 字典对象名称空间  {'name' : 'jason'}
		print(type(obj))

元类简介

"""推到步骤1：如何查看数据的数据类型"""
# s1 = 'hello word'  # str()
# l1 = [11, 22, 33]  # list()
# d1 = {'name' : 'jason', 'pwd' : 123}  # dict()
# t1 = (11, 22, 33)  # tuple()
# print(type(s1))  # <class 'str'>
# print(type(l1))  # <calss 'list'>
# print(type(d1))  # <class 'dict'>
# print(type(t1))  # <class 'tuple'>
"""推导步骤2：其实type方法是用来查看产生对象的类名"""
# class STudent:
# 		pass
# obj = Student()
# print(type(obj))  # <class '__main__.Student'>
"""推到步骤3：python中一切皆对象 我们好奇type查看类名显示的是什么"""
class Student:
	pass
obj = Student()
print(type(obj))  # <class '__main__.Stuent'>
print(type(Student))  # <class 'type'>
class A:pass
class B:pass
print(type(A), type(B))
"""结论：我们定义的类其实都是type类产生的>>>:元类(产生类的类)"""

创建类的两种方式

# 方式①：使用关键字class
class Teacher:
	school_name = '老闺女'
	def func1(self):pass
print(Teacher)
print(Teacher.__dict__)
# 方式②：利用元类type type(类名，类的父类，类的名称空间)
cls = type('Student', (object,), {'name':'jason'})
print(cls)
print(cls.__dict__)
"""
知识了解：名称空间的产生
1. 手动写键值对
	针对绑定方法不好定义
2. 内置放啊exec
	能够运行字符串类型的代码并产生名称空间
"""

元类定制类的产生行为

"""
推导
	对象是由类名加括号产生的  __init__
	类是由元类加括号产生的  __init__
"""
"""所有的类首字母必须大小写 否则无法产生"""
# 1.自定义元类：继承type的类也称为元类
class MyMetaClass(type):
	def__init__(self, what, bases=None, dict=None):
		# pringt('what', what)
		# print('bases', bases)
		# print('dict', dict)
		if not what.istitle():
			raise TypeError('你是不是python程序员  类名首字母必须是大写啊')
		super().__init__(what, bases, dict)
# 2.指定类的元素：利用关键字metaclass指定类的元素
class myclass(metaclass=MyMetaClass):
	desc = '元类其实很有趣 就是有点绕绕的'
class Student(metaclass=MyMetaClass):
	info = '我还是孩子 我好乖的哦'
print(Student)
print(Student.__dict__)

元类定制对象的产生行为

"""
推导
	对象加括号会执行产生该对象里面的  __call__
	类加括号会执行产生该类的类里面  __call__
"""
"""给对象添加独有数据的时候 必须用关键字参数传参"""
class MyMetaClass(type):
	def__call__(self, *args, **kwargs):
		1.产生一个空对象(骨架)
		2.调用__init__给对象添加独有的数据(血肉)
		3.返回创建好的对象
		# print(args)  # ('json', 18, 'male')
		# print(kwargs)  # {}
		if args:
			raise TypeError("你咋回事 Jason要求对象独有数据必须按照官架子参数传参")
		return supper().__call__(*args, **kwargs)
class Student(metaclass=MyMetaClass):
	def__init__(self, name, age, gender):
		# print('__init__')
		self.name = name
		self.age = age
		self.gender = gender
# obj = Student('jason', 18, 'male')
obj = Student(name='jason', age = 18, gender = 'male')
print(obj.__dict__)

魔法方法之双下new

class MyMetaClass(type):
	def__call__(self, *args, **kwargs):
		# 1.产生一个空对象(骨架)
		obj = self.__new__(self)
		#2.调用__init__(obj, *args, **kwargs)
		self.__init__(obj, *args, **kwargs)
		3.返回创建好的对象
		return obj
class Student(metaclass=MyMetaClass):
	def__init__(self, name):
		self.name = name
obj = Student('jason')
print(obj.name)
"""
__new__可以产生空对象
"""

设计模式简介

1.设计模式
	前人通过大量的验证创建出来解决一些问题的固定高效方法
2.IT行业
	23种
        创建型
        结构型
        行为型
"""
创建型模式：工厂方法模式、抽象工厂模式、创建者模式、原型模式、单例模式。隐藏底层模块的逻辑，关注怎么创建对象。

结构型模式：适配器模式、桥模式、组合模式、装饰模式、外观模式、享元模式、代理模式。类之间如何协同工作，应该组成什么结构。

行为型模式：解释器模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式、模板方法模式。关注行为，也就是方法，应该怎样某些行为。

"""
3.单例模式
	类加括号无论执行多少次永远只会产生一个对象
	目的:
        当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
        如果不做单例 会产生很多无用的对象浪费存储空间
        我们想着使用单例模式 整个程序就用一个对象