Python基础30

今日内容概要

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

今日内容详细

面向对象之魔法方法

	魔法方法:类中定义的双下方法都称之为魔法方法 不需要人为调用 在特定条件下会自动触发运行
如:__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 My_Dict(dict):
    def __setattr__(self, key, value):
        self[key] = value

    def __getattr__(self, item):
        return self.get(item)


d1 = My_Dict()
d1.name = 'jason'
print(d1)
print(d1.name)

元类简介

'''推导步骤1: 如何查看数据的数据类型'''
s1 = 'hello'
l1 = [11, 22, 33]
d1 = {'name':'jason', 'age':18}
t1 = (11, 22, 33)
print(type(s1))  # <class 'str'>
print(type(l1))  # <class '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__.Student'>
print(type(Student))  # <class 'type'>
'''结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)'''

创建类的两种方式

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

元类定制类的产生行为

'''
推导
	对象是由类名加括号产生的
	类是由元类加括号产生的
'''
'''小练习
所有的类必须首字母大写 否则无法产生'''
1.自定义元类:继承type的类也称之为元类
class MyMetaClass(type):
    def __init__(self, what, bases=None, dict=None):
        # print('what', what)  # 查看得知what是生成的类名
        # print('bases', 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 Myclass(metaclass=MyMetaClass):
    info = '我很乖'
    
print(Myclass)
print(Myclass.__dict__)

元类定制对象的产生行为

'''
推导
	对象加括号户执行产生该对象类里面的__call__
	类加括号会执行产生该类的类里面的__call__
'''
'''给对象添加独有数据的时候 必须采用关键字参数传参'''
class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        print(args) 
        print(kwargs)
        if args:
            raise TypeError('都说了必须采用关键字传参')
        return super().__call__(*args, **kwargs)
    
class Student(metaclass=MyMetaClass):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
obj = Student(name='jason', age=18)
print(obj.__dict__)

魔法方法之双下new

class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        # 1.产生一个空对象(骨架)
        obj = self.__new__(self)
        # 2.调用__init__给对象添加独有的数据(血肉)
        self.__init__(obj, *args, **kwargs)
        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.单例模式
	类加括号无论执行多少次永远只会产生一个对象
	目的:
		当类中有很多非常强大的方法 我们在程序中很多地方都需要使用
      如果不做单例 会产生很多无用的对象浪费存储空间
      我们想着使用单例模式 整个程序就用一个对象