首页 > 其他分享 >面向对象4魔法方法及元类

面向对象4魔法方法及元类

时间:2022-11-08 16:56:24浏览次数:33  
标签:__ obj self 魔法 及元类 面向对象 print type def

目录

面向对象的魔法方法

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

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

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

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

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

5. __getattribute__
    对象点名字就会自动触发 有它的存在就不会执行上面的__gatattr__

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

7. __enter__ 
    当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么

8. __exit__
    with上下文管理语法运行完毕之后自动触发(子代码结束)
	
	
class Student:
    name = 'winter'
    print('__init__')  # 对象添加独有数据的时候自动触发

    def spark(self):
        print('hehe')

    def __str__(self):
        return '哈哈'

    def __call__(self, *args, **kwargs):
        print('__call__')

    def __getattr__(self, item):
        return f'抱歉 你所要的名字{item}不存在'

    # def __getattribute__(self, item):
    #     return 'getattribute'
    # 当这个存在,上面__getattr__会失效

    def __setattr__(self, key, value):
        print(key,value)

    def __enter__(self):
        return 123

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('结束with子代码')

obj = Student()  # __init__
print(obj)  # 哈哈
obj()  # __call__
print(obj.name1)  # 抱歉 你所要的名字name1不存在
obj.age = 18  # age 18

with obj as f:
    print(f)

魔法方法笔试题

# 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)  # {'name': 'jason', 'pwd': 18, 'hobby': 'read'}
print(obj.name) # jason
print(obj.pwd)  # 18
print(obj.hobby)  # read
print(obj.__dict__)  # {}
print(type(obj))  # <class '__main__.MyDict'>

元类简介

"""推导步骤1:如何查看数据的数据类型"""
s1 = 'hello world'
l1 = [11 ,22 ,33 ,44]
d1 = {'name': 'jason', 'pwd': 123}
t1 = (11, 22, 33, 44)
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'>
class A:pass
class B:pass
print(type(A), type(B))  # <class 'type'> <class 'type'>

"""结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)"""

创建类的两种方式

方式1:使用关键字class
class Teather:
    school_name = '老女儿'
    def func1(self):pass
print(Teather)  # <class '__main__.Teather'>
print(Teather.__dict__)  # {'__module__': '__main__', 'school_name': '老女儿',
# 'func1': <function Teather.func1 at 0x000002BEF81EE310>, '__dict__':
# <attribute '__dict__' of 'Teather' objects>, '__weakref__':
# <attribute '__weakref__' of 'Teather' objects>, '__doc__': None}

方式2:利用元类type  type(类名,类的父类,类的名称空间)
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__(cls,what,bases=None, dict= None):
        # print('what',what)
        # print('bases',bases)
        # print('dict',dict)
        if not what.istitle():
            raise TypeError('类首字母大写')
        super().__init__(what,bases,dict)

# 2. 指定类的元类:利用关键字metaclass指定类的元类
# class myclass(metaclass=MyMetaClass):
#     desc = '元类其实很有趣 就是有点绕'

class Student(metaclass=MyMetaClass):
    info = '我是学生 我很听话'
print(Student)  # <class '__main__.Student'>
print(Student.__dict__)

元类定制对象的产生行为

"""
推导
    对象加括号会执行产生该对象类里面的   __call__
    类加括号会执行产生该类的类里面的    __call__
"""
"""给对象添加独有数据的时候 必须采用关键字参数传参"""
class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError("必须按照关键字参数传参")
        return super().__call__(*args, **kwargs)

class Student(metaclass=MyMetaClass):
    def __init__(self, name, age, gender):
        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__)  # {'name': 'jason', 'age': 18, 'gender': 'male'}

魔法方法之双下new

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

标签:__,obj,self,魔法,及元类,面向对象,print,type,def
From: https://www.cnblogs.com/winter-yu1989/p/16870238.html

相关文章

  • 14.面向对象编程
    1.初识面向对象想要通过面向对象去实现某个或某些功能时需要2步:定义类,在类中定义方法,在方法中去实现具体的功能。实例化类一个对象,通过对象去调用并执行方法。c......
  • 面向对象的魔法方法
    面向对象的魔法方法(格式都是双下)方法作用init对象添加独有数据的时候自动触发str对象被执行打印操作的时候自动处罚call对象加括号调用的时候自动触发......
  • 面向对象之元类
    元类简介"""推导步骤1:如何查看数据的数据类型"""s1='helloword'l1=[11,22,33,44,55]d1={'name':'jason'}t1=(11,22,33,44)p......
  • python第三十课---面向对象的魔法方法,元类相关知识
    昨日内容回顾派生方法实战案例1.继承某个类2.重写被继承类里面的某个方法3.在方法内添加一些额外的操作4.最后利用super重新调用被继承类里面的方法"""super:子类......
  • 面向对象
    面向对象派生方法实战演练importjsonimportdatetimed={'t1':datetime.date.today't2':datetime.datetime.today(),'t3':'jason'}#res......
  • 面向对象(部分讲解)
    派生方法什么是派生:​ 指的的子类继承父类的属性方法,并且派生 出自己独有的属性与方法​ 通过super来指向父类的属性(super()是一 个特殊的类,调用super得到一个对象,......
  • 面向对象三大特性之封装、伪装、三大特性之多态、面向对象之反射
    派生方法实战演练importjsonimportdatetimed={'t1':datetime.date.today(),'t2':datetime.datetime.today(),'t3':'jason'}#res=json.dum......
  • PYthon基础之面向对象:反射方法实战—增删改查
    classUser_cls_info(object):def__init__(self,name,age,gender,hobby,):self.__name=nameself.__age=ageself.__gander=ge......
  • 面向对象(二)——派生方法、封装、多态、反射
    一、派生方法:子类基于父类某个方法做了扩展classPerson:def__init__(self,name,age,gender):self.name=nameself.age=agesel......
  • 面向对象之封装、多态 反射
    目录派生方法实战演练面向对象三大特征之封装封装之隐藏封装之伪装面向对象三大特征之多态面向对象之反射反射实战案例派生方法实战演练importjsonimportdatetimed1......