classmethod
翻译：一个类方法
classmethod是一个装饰器，可以装饰给类内部的方法，使该方法绑定给类使用
对象的绑定方法特殊之处
由对象来调用，会将对象当作第一个参数传给该方法
类的绑定方法特殊之处
由类来调用，会将类当作第一个参数传给该方法
class People:
def __init__(self,name,age):
self.name=name
self.age=age
@classmethod
def tell_info(cls):#cls=People
print(cls)
print('此处是类方法')
p=People('tank',18)
p.tell_info()
'''
<class '__main__.People'>
此处是类方法'''
People.tell_info()
'''
<class '__main__.People'>
此处是类方法'''
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():
uuid_obj=uuid.uuid4()
md5=hashlib.md5()
md5.update(str(uuid_obj).encode('utf-8'))
return md5.hexdigest()
obj=Teacher.login_auth_from_settings()
obj.index()#验证通过，显示主页
tea1=Teacher('tank','123')
tea1.index()#验证通过，显示主页
#import uuid #是一个加密模块，uuid4通过时间戳生成一个世界上唯一的字符串。
print(uuid.uuid4())#617e8e86-ea4b-4004-bc67-03984dd0d0e0
print(type(uuid.uuid4()))#<class 'uuid.UUID'>
print(Teacher.create_id())#9f9cb0402a68270ad629af2060656457
print(tea1.create_id())#f0973188d6964cb4f7259259b74b2c2c
isinstance
__class__:对象的属性，获取该对象当前类
isinstance(参数1，参数2)：
python内置的函数，可以传入两个参数，用于判断参数1是不是参数2的一个实例。
判断一个对象是否是一个类的实例。
issubclass
issubclass(参数1，参数2)：
python内置的函数，可以传入两个参数，用于判断参数1是否是参数2的子类。
判断一个类是否是另一个类的子类
class Foo:
pass
class Goo(Foo):
pass
foo_obj=Foo()
print(isinstance(foo_obj,Foo))#True
print(issubclass(Goo,Foo))#True
反射
反射：指的是通过“字符串”对 对象或类的属性进行操作
hasattr:通过对字符串，判断该字符串是否是对象或类的属性
getattr:通过字符串，获取对象或类的属性
setattr:通过字符串，设置对象或类的属性
delattr:通过字符串，删除对象或类的属性
class People:
country='China'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
#hasattr
p=People('tank',18,'male')
print(hasattr(p,'name'))#True
print(hasattr(People,'country'))#True
#getattr
print(getattr(p,'name','nick'))#tank
print(getattr(p,'name1','nick'))#nick
print(getattr(People,'country','China'))#China
#setattr
setattr(p,'sal','3.0')
print(hasattr(p,'sal'))#Ture
print(p.sal)#3.0
setattr(People,'Sal','3.0')
print(hasattr(People,'Sal'))#Ture
print(People.Sal)#3.0
#delattr
delattr(p,'sal')
print(hasattr(p,'sal'))#False
delattr(People,'Sal')
print(hasattr(People,'Sal'))#False
class Movie:
def input_cmd(self):
print('输入命令：')
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()
'''输入命令：
请输入执行的方法名upload
电影开始上传。。。
请输入执行的方法名download
电影开始下载。。。
请输入执行的方法名'''
魔法方法（类的内置方法）
凡是在类内部定义，以__开头__结尾的方法都称为魔法方法，又称类的内置方法。
__init__:在调用类时触发
__str__:会在打印对像时触发
__del__:对象被销毁前执行该方法，该方法会在最后执行
__getattr__:会在对象.属性时，“属性没有”的情况下才会触发。
__setattr__:会在“对象.属性=属性值”时书法
__call__:会在对象被调用时触发
__new__:会在__init__之前前触发
class Foo(object):
def __new__(cls, *args, **kwargs):
print(cls)
return object.__new__(cls)#真正产生一个空对象
#若当前类的__new__没有return一个空对象时,__init__不会触发
def __init__(self):
print('__init__在调用类时触发')
def __str__(self):
print('__str__会在打印对象时触发')
#必须要有一个返回值，该返回值必须是字符串类型
return '__str__必须要有一个返回值，该返回值必须是字符串类型'
def __del__(self):
print('__del__对象被注销前执行该方法')
def __getattr__(self, item):
print('__getattr__会在对象.属性时，"属性没有"的情况下才会触发')
print(item)
#默认返回None，若想打印属性的结果，必须return一个值
return 111
#注意：执行该方法时，外部“对象.属性=属性值”是无效的
def __setattr__(self, key, value):
print('__setattr__会在“对象.属性=属性值”时触发')
print(key,value)
def __call__(self, *args, **kwargs):
print('__call__调用对象时触发该文件')
foo_obj=Foo()
print(foo_obj)
foo_obj.x
foo_obj.y=10
foo_obj()
'''<class '__main__.Foo'>
__init__在调用类时触发
__str__会在打印对象时触发
__str__必须要有一个返回值，该返回值必须是字符串类型
__getattr__会在对象.属性时，"属性没有"的情况下才会触发
x
__setattr__会在“对象.属性=属性值”时触发
y 10
__call__调用对象时触发该文件
__del__对象被注销前执行该方法'''
单例模式
单例模式指的是单个实例，实例指的是调用类产生的对象
实例化多个对象会产生不同的内存地址，单例可以让所有调用者在调用类产生对象的情况下都指向一份内存地址。
目的：
为了减少内存的占用
class File:
__instance=None
# @classmethod
# def singleton(cls,file_name):
# if not cls.__instance:
# obj=cls(file_name)
# cls.__instance=obj
# return cls.__instance
def __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()
# obj1=File.singleton('mofa.py')
# obj2=File.singleton('mofa.py')
# print(obj1)
# print(obj2)
obj1=File('mofa.py')
obj2=File('mofa.py')
print(obj1)
print(obj2)