标签：__ obj name self 魔法元类面向对象 print def

今日内容回顾

今日内容回顾

面向对象的魔法方法

魔法方法：类定义的上下方法都称为魔法方法不需要人为调用在特定的条件下会自动触发运行
eg: __init__创建空对象之后自动触发给对象添加独有的数据

__init__对象添加独有数据的时候自动触发

class C1(object):
	def __init__(self, name, age):  # 类名加括号 给对象添加独有数据时自动触发
        self.name = name
        self.age = age
        print('__init__')
        
obj = C1('jason', 18)
print(obj)  # <__main__.C1 object at 0x00000226035B5A30>

__str__对象被执行打印操作的时候自动触发

class C1(object):
    def __init(self, name, age):
        self.name = name
        self.age = age
        print('__init__')
    def __str__(self):  # 对象在被执行打印操作的时候自动触发 该方法返回什么打印的结果就是什么
        return '啊哈哈'  # 返回的值必须是字符串类型
      # return f'{self}说:哈哈哈哈'  # 不能再返回对象本身 对象一打印就执行__str__
        
obj = C1('jason', 18)
print(obj)  # 啊哈哈

__call__对象加括号调用的时候自动触发

class C1(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('__init__')
    def __str__(self):
        return f'{self.name}说:哈哈哈哈'
    def __call__(self, *args, **kwargs):  # 对象加括号的时候自动触发 该方法返回什么对象调用之后的返回值就是什么
        print('我可是很热爱学习的哟')
        print(args, kwargs)
        return 123

obj = C1('jason', 18)
res = obj('大宝贝', name= 'jason')
print(res)

__getattr__对象不存在的名字的时候自动触发

class C1(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        # print('__init__')
    def __str__(self):
        return f'{self.name}说:哈哈哈哈'
    def __call__(self, *args, **kwargs):
        print('我可是很热爱学习的哟')
        print(args, kwargs)
        return 123
    def __getattr__(self, item):  # 对象在查找无法使用的名字时自动触发
        print('爱吃苦')
        print(item)
        
obj = C1('jason', 18)
obj.pwd  # 爱吃苦 pwd

__getattribute__对象点名字就会自动触发有他的存在就不会执行上面的双下getattr

class C1(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
      # print('__init__')
    def __str__(self):
        return f'{self.name}说:哈哈哈哈'
    def __call__(self, *args, **kwargs):
        print('我可是很热爱学习的哟')
        print(args, kwargs)
        return 123
    def __getattr__(self, item):
        # print('爱吃苦')
          print(item)
        return f'抱歉你找的名字{item}不存在'
    def __getattribute__(self, item):  # 对象在查找的时候不管名字存不存在都会触发
        print('呵呵呵')

obj = C1('jason', 18)
obj.name

__setattr__给对象添加或者修改数据的时候触发对象.名字 = 值

class C1(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __setattr__(self, key, value):
        print('嘿嘿嘿')
        print(key, value)
        
obj = C1('jason', 18)
obj.pwd = 123

__enter__当对象被当做with上下文管理操作的开始自动触发并且该方法返回什么 as后面的变量名就会就收到什么
双下exit with上下文管理运行完毕之后自动触发(子代码结束)

class C1(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
  # def __setattr__(self, key, value):
      # print('嘿嘿嘿')
      # print(key, value)
    def __enter__(self):
        return 123
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
     
obj = C1('jason', 18)
with obj as f:
    print(f)  # 123

魔法方法笔试题

补全下列代码使得运行不会报错即可

题：
class Context:
    pass
with Context() as f
    f.do_something()
分析： 
with 后面跟着的是类名加括号即对象  
f即enter触发返回什么as后面变量名f就会接收什么 
然后f去点的一个名字加括号调用方法
答：
class Context:
    def do_somethings(self):
        pass
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

with Context() as f:
    f.do_somethings()

自定义字典类型并让字典能够通过句点符的方式操作键值对

class MyDict(dict):
    def __setattr__(self, key, value):
        self[key] = value

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

obj = MyDict()
# 对象点一个东西触发一个东西>>>__setattr__
obj.name = 'jason'
print(obj)
obj.age = 18
# 点的方式取值 对象点一个不存在的名字触发>>>__getattr__
print(obj.name)
print(obj.age)
注意区分字典对象拥有存储数据的能力 而classs类是名称空间存储数据的

元类简介

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

创键类的两种方式

方式1：使用关键字class

classs Teacher:
    school_name = '老baby'
    def func1(self):pass
print(Teacher)  # <class '__main__.Teacher'>
print(Teafcher.__dict__)  # {'__module__': '__main__', 'school_name': '老baby', 'fucn1': <function Teacher.fucn1 at 0x00000212C70E9A60>, '__dict__': <attribute '__dict__' of 'Teacher' objects>, '__weakref__': <attribute '__weakref__' of 'Teacher' objects>, '__doc__': None}

方式2：利用元类

cls = type('Student', (object, ), {'name': 'jason'})
print(cls)  # <class '__main__.Student'>
print(cls.__dict__)  # {'name': 'jason', '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}

了解知识：名称空间的产生
1.手动写键值对
	针对绑定方法不好定义
2.内置方法exec
	能够运行字符串类型的代码并产生名称空间

元类定制类的产生行为

# 推导
	对象是由类名加括号产生的	__init__
    类是有元类加括号产生的		__init__
'''所有的类必须首字母大写 否则无法产生'''
# 1.自定义元类：继承type的类也称之为元类
class MyMetaClass(type):
    def __init__(self, what, bases=None, dict=None):  # 在元类里面如果要干涉类的创建过程 可以考虑写一个元类 然后再元类中的的__init__方法里面对类的名字、类的父类、类的名称空间都可以做一些干预
        # print('what', what)
        if not what.istitle():
            raise TypeError('类名首字母要大写啊')
        super().__init__(what, bases, dict)


# 2.指定类的元类：利用关键字mateclass指定类的元类
# 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):
    #   print(args)  # ('jason', 18, 'male')
    #   print(kwargs) # {}
        if args:
            raise TypeError('你咋回事 现在要求你对象的独有数据必须按照关键字传参')
        return super().__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')  类加括号在实例化对象的时候创建的独有数据数'jason', 18, 'male'先交给了元类里面的双下call的然后再给双下init
obj = Student(name='jason', age=18, gender= 'male')
print(obj.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male'}

魔法方法之双下new

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

标签：__,obj,name,self,魔法,元类,面向对象,print,def
From： https://www.cnblogs.com/xiao-fu-zi/p/16871010.html

面向对象的魔法方法、元类定制类与对象的产生行为