day 22

目录

• classmethod
• staticmethod
• isinstance与issubclass
• 反射
• 魔法方法
• 单例模式

classmethod

翻译：一个类方法

classmethod是一个装饰器，可以装饰给类内部的方法，使该方法绑定给类来使用

​ — 对象的绑定方法特殊之处

​ 由对象来调用，会将对象当作第一个参数传给该方法

​ — 类的绑定方法特殊之处

​ 由类来调用，会将类当作第一个参数传给该方法

staticmethod

staticmethod是一个装饰器，可以装饰给类内部的方法，使该方法即不绑定给对象，也不绑定给类

import hashlib
import uuid
import settings

class Teacher:
    def __init__(self,user,pwd):
		self.user = user
        self.pwd = pwd
        
    # 主页
    def index(self):
        if self.user =='tank' and self.pwd == '123':
            print('验证通过，显示主页...')
    
    @classmethod
    def login_auth_from_settings(cls):
        obj = cls(settings.USER, settings.PWD)
        return obj	# Teacher() --> return = obj
    
    @ staticmethod
    def create_id():
        # 生成一个唯一的id字符串
        uuid_obj = uuid.uuid4()
        md5 = hashlib.md5()
        md5.update(str(uuid_obj)).encode('utf-8')
        return md5.hexdigest()

isinstance与issubclass

__class__: 对象的属性，获取该对象当前的类

— isinstance(参数1，参数2)

​ python内置的函数，可以传入两个参数，用于判断参数1是否是参数2的一个实例

​ *** 判断一个对象是否是一个类的实例

— issubclass(参数1，参数2)

​ python内置的函数，可以传入两个函数，用于判断参数1是否是参数2的子类

​ ** 判断一个类是否是另一个类的子类

class Foo:
    pass

clss Goo(Foo):
    pass

foo_obj = Foo()
print(isinstance(foo_obj,Foo))
print(isinstance(foo_obj,Goo))
print(issubclass(Goo,Foo)

反射

指的是通过“字符串”对,对象或类的属性进行操作

​ — hasattr：通过字符串，判断改字符串或类的属性

​ — getattr:： 通过字符串，获取对象或类的属性

​ — setattr：通过字符串，设置对象或类的属性

​ — delattr：通过字符串，删除对象或类的属性

'''
反射小练习
'''

class Movie:
    def input_cmd(self):
        while True:
            cmd = input('请输入执行的方法名：').strip()
            
            # 若用户输入的cmd命令是当前对象的属性
            if hasattr(self, cmd):
                method = getattr(self, cmd)
                method()
            else:
                print('命令错误，请重新输入！')
    
    def upload(self):
        print('电影开始上传...')
    
    def download(self):
        print('电影开始下载...')
        
       
movie_obj = Movie()
movie_obj.input_cmd()

魔法方法

凡是在类内部定义，以“__开头__结尾”的方法都称之为魔法方法，又称“类的内置方法”

魔法方法会在某些条件成立时触发

__init__：在调用类时触发

__str__：会在打印对象时触发

__del__：对象被销毁前执行该方法，该方法会在最后执行

__getattr__：会在对象.属性是，“属性没有”的情况下才会触发

__setattr__：会在“对象.属性 = 属性值” 时触发

__call__：会在对象被调用时触发

__new__：会在__init__执行前触发

class Foo(object):
    
    def __new__(cls, *args, **kwrags):
        print(cls)
        return object.__new__(cls) # 真正产生一个空对象
    
    # 若当前类的__new__没有return一个空对象时，则不会触发
    def __init__(self):
        print('在调用时触发...')
        
    def __str__(self):
        print('会在打印时触发...')
        # 必须要有一个返回值，该返回值必须是字符串类型
        return '[1,2,3]'
    
    def __del__(self):
        print('对象被销毁前执行该方法...')
        
    def __getattr__(self,itrm):
        print('会在对象.属性时，"属性没有"的情况下才会触发...')
        print(item)
        # 默认返回None， 若想打印属性的结果，必须return一个值
        return 123
    
     # 注意：执行该方法时外部“对象 . 属性 = 属性值”时无效
     def __setattr__(self,key,value):
        print('会在 “对象 . 属性 = 属性值”时触发...')
        print('key,value')
        print(type(self))
        print(self,123)
        self.__dict__[key] = value
        
     def __call__(self, *args, **kwargs):
        print(self)
        print('调用对象时触发该方法...')
               

class MyFile(object):
    def __init__(self, file_name, mode='r',encoding='utf_8'):
        self.file_name = file_name
        self.mode = mode
        self.encoding = encoding
     
    def file_open(self):
        self.f = open(self.file_name,self.mode,encoding=self.encoding)
        
    def file_read(self):
        res = self.f.read()
        print(f'''
        当前文件名称：{self.file_name}
        当前文件数据：{res}
        ''')
        
       
    def __del__(self):
        self.f.close()
        print('文件关闭成功！')

单例模式

从配置文件中获取相同的文件名

class File:
    
    __instance = None
    
    # 单例方式1:
    @classmethod
    def singleton(cls,file_name):
        if not cls.__instance:
            obj = cls(file_name)
            cls.__instance = obj
            return cls.__instance
     
    # 单例方式2：
    def __new__(cls, *args, **kwargs):
        # cls.__new__(cls, *args, **kwargs)
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
            return cls.__instance
       
    def __init__(self,file_name, mode='r', encoding='utf-8'):
        self.file_name = file_name
        self.mode = mode
        self.encoding = encoding
       
    def open(self):
        self.f = open(self.file_name, self.mode, encoding=self.encoding)
       
    def read(self):
        res = self.f.read()
        print(res)
       
    def close(self):
        self.f.close()