一、isinstance(obj,cls)和issubclass(sub,super)
1.isinstance(obj,cls)
判断obj是不是由cls产生的类
2.issubclass(sub,super)
判断sub是否是super的子类
3.代码
class Foo:
def __init__(self,name):
self.name = name
class Son(Foo):
# pass
def __init__(self,name):
self.name = name
f1 =Foo("dazui")
f2 = Son("zuizui")
print(isinstance(f1,Foo))#True,判断对象是否由类实例化而来的
print(isinstance(f2,Foo))#True
print(isinstance(f2,Son))#True
print(issubclass(Son,Foo))#True
print(issubclass(Foo,Son))#False
print(type(f1),type(f2))#<class '__main__.Foo'> <class '__main__.Son'>
二、反射
1.定义
通过字符串的形式操作对象相关的属性。
2.四个函数
class Intermedia:
def __init__(self,name,addr):
self.name = name
self.addr = addr
def rent_house(self):
print("%s正在租房子"%(self.name))
i1 = Intermedia("自如","翠屏山")
#hasattr:判断对象是否包含指定的数据属性,也可以判断类是否包含指定的函数属性
print(hasattr(i1,"name"))#True
print(hasattr(Intermedia,"rent_house"))#True
#getattr:传入三个参数,如果数据属性存在,则返回该数据属性的值,不存在则返回指定的内容
print(getattr(i1,"name","自定义的内容"))#i1没有nam22e这个属性,打印“自定义内容”
#setattr:设置数据属性和函数属性
setattr(i1,"price",1600)
print(i1.__dict__)#{'price': 1600, 'name': '自如', 'addr': '翠屏山'}
#删除属性
delattr(i1,"price")
print(i1.__dict__)#{'name': '自如', 'addr': '翠屏山'}
delattr(Intermedia,"rent_house")
3.优点
(1)实现可插拔机制
class FtpClient:
"Ftp客户端,但具体功能还没实现"
def __init__(self,addr):
self.addr = addr
def put(self):
print("正在上传文件")
from ftp_client import FtpClient
f1 = FtpClient("1.1.1.1")
if hasattr(f1,"put"):
func_get = getattr(f1,"put")
func_get()
else:
print("执行其他功能")
(2)动态导入模块
import importlib
module_t = importlib.import_module("m1.test")
print(module_t)#<module 'm1.test' from 'D:\\python_s3\\day27\\m1\\test.py'>
module_t.test1()
module_t._test2()
from m1 import test
test.test1()
test._test2()
module_t = __import__("m1.test")
print(module_t)#<module 'm1' from 'D:\\python_s3\\day27\\m1\\__init__.py'>
module_t.test.test1()
module_t.test._test2()
from m1.test import *
test1()
_test2()#用*的方式导入找不到_test2()
from m1.test import test1,_test2
test1()
_test2()
三、__setattr__、__delattr__和__getattr__
class Foo:
y = 24
def __init__(self,x):
self.x = x
def __getattr__(self, item):
print("执行__getattr__")
def __delattr__(self, item):
print("执行__delattr__")
def __setattr__(self, key, value):
print("执行__setattr__")
self.__dict__[key] = value
f1 = Foo(8)
#__getattr__,当要找的属性不存在时,执行__getattr__
getattr(f1,"不存在")#执行__getattr__
#__delattr__:当实例删除属性时,执行
del f1.y#执行__delattr__
del Foo.y#不执行__delattr__
#设置属性时执行__setattr__
f1 = Foo(8)#执行__setattr__
f1.z = 6#执行__setattr__
四、二次加工标准类型
1.包装
利用继承和派生知识,基于标准的数据类型来定制需求的数据类型,新增或改写方法。包装一个类型通常是对已存在的类型的一些定制,可以新建、修改或删除原有功能,其他保持不变
class List(list):
def append(self, p_object):
if type(p_object)==str:
# list.append(self,p_object)
super().append(p_object)
else:
print("输入的不是字符串类型")
def show_middle(self):
return self[int(len(self)/2)]
l = List("hello world!")
print(l)
l.append(123)#输入的不是字符串类型
2.授权
授权是包装的一个特性,授权的过程是所以更新的功能都由新类的某部分来处理,已存在的功能设为对象的默认属性
import time
class Open:
def __init__(self,filename,mode,encoding="utf-8"):
# self.filename = filename
self.file = open(filename,mode,encoding=encoding)
self.mode = mode
self.encoding = encoding
def write(self,line):
t = time.strftime("%Y-%m-%D %X")
self.file.write("%s %s" %(t,line))
def __getattr__(self, item):
return getattr(self.file,item)
f1 = Open("a.txt","w")
f1.write("111111\n")
f1.write("222222\n")
五、__getattribute__
class Foo:
def __init__(self,name):
self.name = name
def __getattr__(self, item):
print("执行getattr")
def __getattribute__(self, item):#无论能否找到都执行__getattribute__,只有抛出AttributeError时会执行__getattr__ print("执行getattribute")
raise AttributeError("抛出异常")#会去执行__getattr__
# raise TabError("抛出异常")#不会去执行__getattr__
f1 = Foo("大嘴")
f1.age
六、__setitem__、__getitem__和__delitem__
class Foo:
def __init__(self,name):
self.name = name
def __getitem__(self, item):
print("执行__getitem__")
return self.__dict__[item]
def __setitem__(self, key, value):
print("执行__setitem__")
def __delitem__(self, key):
print("执行__delitem__")
f1 = Foo("dazui")
print(f1["name"])#执行__getitem__
f1["age"]=18#执行__setitem__
del f1["name"]#执行__delitem__
七、__str__、__repr__和__format__
1.利用__str__或__repr__改变对象的字符串显示
class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return "这是str的返回结果 name:%s age: %s" %(self.name,self.age)
def __repr__(self):
return "这是repr的返回结果 name:%s age: %s" %(self.name,self.age)
f1 = Foo("大嘴",80)
print(f1)#<__main__.Foo object at 0x001D5F30>默认显示,\
# 定义__str__时,显示str的返回值;没有__str__,定义了__repr__,显示repr的返回值
2.利用__format__定制格式化字符串
format_dic={
"ymd":"{0.y} {0.m} {0.d}",
"y:m:d":"{0.y}:{0.m}:{0.d}",
"d-m-y":"{0.d}-{0.m}-{0.y}"
}
class Data:
def __init__(self,y,m,d):
self.y = y
self.m = m
self.d = d
def __format__(self, format_spec):
print("执行__format__")
print(format_spec)
if not format_spec or format_spec not in format_dic:
format_spec = "ymd"
fm = format_dic[format_spec]
return fm.format(self)
d1 = Data(2018,5,18)
print(format(d1,"yaaaaaaaaa"))
八、__slots__
# 节省内存,对象不能新建数据属性
class Foo:
__slots__ = ["name","age"]
f1=Foo()
print(Foo.__slots__)
print(f1.__slots__)
f1.name = "dazui"
f1.age = 80
print(f1.name,f1.age)
f1.gender = "female"#'Foo' object has no attribute 'gender'
九、__next__和__iter__实现迭代器协议
1.代码
class Foo:
def __init__(self,x):
self.x = x
def __iter__(self):
return self
def __next__(self):
if self.x == 15:
raise StopIteration("迭代器中止")
self.x += 1
return self.x
f1 = Foo(10)
print(f1.__next__())
print(next(f1))
for i in f1:#从13开始循环
print(i)
2.实现菲波那切数列
class Fib:
def __init__(self,a,b):
self._a = a
self._b = b
def __iter__(self):
return self
def __next__(self):
if self._a>200:
raise StopIteration
self._a,self._b = self._b,self._a+self._b
return self._a
f1 = Fib(1,2)
print(next(f1))
print(f1.__next__)
print("<><><><><><><><><><><><><><><><>")
for i in f1:
print(i)
十、__doc__
#描述信息不会被继承
class Foo:
"Foo的描述信息"
pass
class Son(Foo):
pass
print(Foo.__doc__)#Foo的描述信息
print(Son.__doc__)#None
十一、__module__和__class__
__module__表示当前操作对象在哪个模块
__class__表示当前操作对象的类
from test.test1 import Foo
f1 = Foo("dazui")
print(f1.__module__)#test.test1
print(f1.__class__)#<class 'test.test1.Foo'>
十二、__del__
析构方法,当对象在内存中被释放时,自动触发执行
class Foo:
def __init__(self,name):
self.name = name
def __del__(self):
print("执行析构函数")
f1 = Foo("dazui")#执行析构函数
# del f1.name
# print("<><>")#先打印"<><>",然后执行构析函数释放内存
#<><>
# 执行析构函数
del f1#先执行构析函数释放内存,然后打印"<><>"
print("<><>")
#执行析构函数
# <><>
十三、__call__
#对象后面加(),触发执行
class Foo:
def __call__(self, *args, **kwargs):
print("执行__call__")
f1 = Foo()
f1()#执行__call__
十四、__enter和__exit__
1.with语句
又称上下文管理协议,为了让一个对象兼容with语句,必须在这个对象的类中声明__enter__和__exit__方法
2.优点
(1)使用with语句的目的就是把代码块放入with中执行,with结束后,自动完成清理工作,无须手动干预
(2)在需要管理一些资源比如文件,网络连接和锁的编程环境中,可以在__exit__中定制自动释放资源的机制。
3.代码
class Foo:
def __init__(self,name):
self.name = name
def __enter__(self):
print("执行__enter__")#出现with语句,执行,返回值赋给as声明的变量
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("执行__exit__")
print(exc_type)#异常类
print(exc_val)#异常值
print(exc_tb)#追踪信息
return True#异常被清空,with后面的语句正常执行,如不返回,会抛出异常,,程序停止执行
with Foo("a.txt") as f :
print(f)
print(大嘴)
print("<><><><><><><><><><><>")
十五、metaclass
元类是类的类,元类创建类正如类创建对象,当一个类没有声明自己的元类,它的默认元类就是type,,除了使用元类type,用户也可通过继承type来自定义元类
1.另一种定义类的方式
def __init__(self,name,age):
self.name = name
self.age = age
def test(self):
print("test")
Foo = type("Foo",(object,),{"x":1,"__init__":__init__,"test":test})
f1 = Foo("dazui",18)
print(f1.name)
f1.test()
2.自定义元类
class MyType(type): def __init__(self,a,b,c): print(self,a,b,c) print("元类的构造函数执行") def __call__(self, *args, **kwargs): print(self,*args,**kwargs) obj = object.__new__(self) self.__init__(obj,*args,**kwargs) return obj class Foo(metaclass=MyType): def __init__(self,name): self.name = name f1 = Foo("alex")
十六、property
一个静态属性property本质就是实现了get、set、delete三种方法
class Goods: def __init__(self): self.original_price = 100 self.discount = 0.8 @property def new_price(self): new_price = self.original_price*self.discount return new_price @new_price.setter def price(self,value): self.original_price = value @new_price.deleter def del_price(self): del self.original_price g1 = Goods() print(g1.new_price) g1.price = 200 print(g1.original_price) del g1.original_price
class Foo: def get_AAA(self): print("get的时候运行") def set_AAA(self,value): print("get的时候运行") def del_AAA(self): print("del的时候运行") AAA = property(get_AAA,set_AAA,del_AAA) f1 = Foo() f1.AAA = "aaa" del f1.AAA
十七、 描述符
1.描述符定义
描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__()和__delete__()中的一个
__get__():调用一个属性时触发
__set__():设置一个属性时触发
__get__():调用一个属性时触发
2.作用
描述符是用来代理另外一个类的属性,必须把描述符定义为这个类的类属性,不能定义到构造函数中
3.分类
(1)数据描述符:至少实现了__get__()和__set__()
(2)非数据描述符:没有实现__set__()
4.优先级
从高到低类属性>s数据描述符>实例属性>非数据描述符>找不到属性触发__getattr__()
5.描述符的应用
class Nametype: def __init__(self,key,expected_type): self.key = key self.expected_type = expected_type def __get__(self, instance, owner): print("__get__方法") return instance.__dict__[self.key] def __set__(self, instance, value): print("__set__方法") if not isinstance(value,self.expected_type): raise TypeError("%s输入类型错误,不是%s" %(self.key,self.expected_type)) instance.__dict__[self.key] =value def __delete__(self, instance): instance.__dict__.pop(self.key) class People: name = Nametype("name",str) age = Nametype("age",int) def __init__(self,name,age,salary): self.name = name self.age = age self.salary = salary p1 = People("dazui","18",19999)
6.类的装饰器
def deco(obj): print(obj) obj.x = 1 obj.y = 2 obj.z = 3 return obj @deco#Foo = deco(Foo) class Foo: pass print(Foo.__dict__)
def Typed(**kwargs): def deco(obj): for key,val in kwargs.items(): setattr(obj,key,val) return obj return deco @Typed(x = 1,y = 2,z= 3) class Foo: pass print(Foo.__dict__) @Typed(name = "dazui") class Bar: pass print(Bar.__dict__)
7.类的装饰器应用
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
class Nametype: def __init__(self,key,expected_type): self.key = key self.expected_type = expected_type def __get__(self, instance, owner): return instance.__dict__[self.key] def __set__(self, instance, value): if not isinstance(value,self.expected_type): raise TypeError("%s输入类型错误,不是%s" %(self.key,self.expected_type)) instance.__dict__[self.key] =value def __delete__(self, instance): instance.__dict__.pop(self.key) def deco(**kwargs): def wrapper(obj): for key,val in kwargs.items(): setattr(obj,key,Nametype(key,val)) return obj return wrapper @deco(name = str,age = int) class People: def __init__(self,name,age,salary): self.name = name self.age = age self.salary = salary p1 = People("dazui","18",1000) print(p1.__dict__)