isinstance(obj,cls)和issubclass(sub,super)
class Person(object):
def __init__(self, name, age, sex, nationality):
self.name = name
self.age = age
self.sex = sex
self.nationality = nationality def say(self):
print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality)) def __getattr__(self, item):
print("当实例获取属性不存在的时候会执行__getattr__方法") def __getattribute__(self, item):
print("实例获取属性，不管实例dict属性字典里又没有都会执行__getattribute__方法") class Chinese(Person):
pass if __name__ == "__main__":
p1 = Person("里斯", 78, '男', "美国")
# p1 实例是否是Person类的一个实例
print(isinstance(p1, Person))
# issubclass(sub, super)检查sub类是否是 super 类的派生类
print(issubclass(Chinese, Person))
isinstance(obj,cls)检查是否obj是否是类 cls 的对象
issubclass(sub, super)检查sub类是否是 super 类的派生类
反射
python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
hasattr(obj,"属性"):# obj.属性是否存在
getattr(obj,"属性"):# 获取 obj.属性 如果不存在就报错
getattr(obj,"属性","默认值"):# 获取 obj.属性 如果不存在不会报错，并且返回默认的
setattr(obj,"属性"):# 设置属性
delattr(obj,"属性"):# 删除属性
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 class Person(object):
name = "hah" def __init__(self, name, age, sex, nationality):
self.name = name
self.age = age
self._sex = sex
self.__nationality = nationality def say(self):
print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s" % (self.name, self.age, self._sex, self.__nationality)) class Chinese(Person):
pass if __name__ == "__main__":
print("\r\n ==============对象的反射============ \r\n")
p1 = Person("张三", 18, '男', "中国")
p1.say()
# 获取 p1 对象里name的值
print(getattr(p1, "name")) # 判断p1对象里又没有addr属性
print(hasattr(p1, "addr")) # 设置p1 对象addrs属性并且赋值
setattr(p1, "addrs", "四川达州")
print(getattr(p1, "addrs")) # 删除p1对象addrs属性
delattr(p1, "addrs")
print(hasattr(p1, "addrs")) print("\r\n ==============类的反射（类本质上也是对象）============ \r\n")
print(hasattr(Person, "addrs"))
print(getattr(Person, "name", "没有这个属性"))
setattr(Person, "addrs", "类地址")
print(getattr(Person, "addrs"))
delattr(Person, "name")
print(hasattr(Person, "name"))
importlib---动态导入模块
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 from Python基础.myImport import chufa
import importlib if __name__ == "__main__":
# 第一种导入调用
# print(chufa(1000,50)) # 第二种：动态导入模块
# m1 = __import__("myImport")
# print(m1)
# # 调用模块里的方法
# print(m1.chufa(10,2)) # # 第三中：动态导入模块
# m2 = importlib.import_module("myImport")
# print(m2)
# print(m2.chufa(4,2))
m3 = importlib.import_module("modular.sendMsg")
print(m3)
print(m3.SendMsage())
__setattr__,__delattr__,__getattr__
__getattr__:不存在的时候出发
__setattr__:设置属性的值的时候出发
__delattr__:删除属性的时候出发
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 """
__getattr__:不存在的时候出发
__setattr__:设置属性的值的时候出发
__delattr__:删除属性的时候出发 """ class Person(object):
def __init__(self, name, age, sex, nationality):
self.name = name
self.age = age
self.sex = sex
self.nationality = nationality def say(self):
print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality)) def __getattr__(self, item):
print("执行了__getattr__") def __setattr__(self, key, value):
print("执行了__setattr__")
# 实际上就是操作属性字典
self.__dict__[key] = value def __delattr__(self, item):
print("执行了__delattr__")
self.__dict__.pop(item) class Chinese(Person):
pass class American(Person):
pass class Korean(Person):
pass class Japanese(Person):
pass if __name__ == "__main__":
pass
# # 因为在类中重写了设置属性的方法，然而代码里并没有正在设置上，所以调用say会报错
# p1 = Person("张三",18,'男',"中国")
# p1.say() # 修改后在执行
p1 = Person("张三", 18, '男', "中国")
p1.say()
del p1.name
print(hasattr(p1, "name"))
__getattr__例子：
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 import time class FileHelper(object):
def __init__(self, filepath, model="r", encoding='utf-8'):
self.file = open(filepath, mode=model, encoding=encoding) def __getattr__(self, item):
# item 是字符串类型
# 通过getattr()获取 self.file 中的方法
return getattr(self.file, item) def write(self, line):
# 在每次写入的内容前面加上时间
t = time.strftime("%Y-%m-%d %X")
self.file.write('%s %s' % (t, line + "\r\n")) if __name__ == "__main__":
f1 = FileHelper("../files/Log/logger.log", 'w', encoding='utf-8')
f1.write("锄禾日当午")
f1.write("汗滴禾下土")
f1.write("谁知盘中餐")
f1.write("粒粒皆辛苦") f1 = FileHelper("../files/Log/logger.log", 'r', encoding='utf-8')
# f1.read() 首先在f1实例中的__dict__数据字典中去找read方法，如果没有就去FileHelper类中的__dict__数据字典中找，如果还是没有
# 就报错，如果在FileHelper中重写的__getattr__方法，就执行该方法。所以在该方法中通过self.file属性中去找，self.file就是系统的open对象。
content = f1.read()
print(content)
__setitem__,__getitem,__delitem__
class Chinese(Person):
def __getitem__(self, item):
print("执行了__getitem__")
def __setitem__(self, key, value):
print("执行了__setitem__")
def __delitem__(self, key):
print("执行了__delitem__")
c1 = Chinese("李四",14,"女","中国")
c1["addrs"] = "四川成都"
c1['addrs']
del c1["addrs"]
__getattribute__
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 class Person(object):
def __init__(self, name, age, sex, nationality):
self.name = name
self.age = age
self.sex = sex
self.nationality = nationality def say(self):
print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality)) def __getattr__(self, item):
print("当实例获取属性不存在的时候会执行__getattr__方法") def __getattribute__(self, item):
print("实例获取属性，不管实例dict属性字典里又没有都会执行__getattribute__方法") if __name__ == "__main__":
p1 = Person("里斯", 78, '男', "美国")
# p1 实例是否是Person类的一个实例
print(isinstance(p1, Person))
# issubclass(sub, super)检查sub类是否是 super 类的派生类
print(issubclass(Chinese, Person)) # getattribute方法
# addrs不存在与p1的dict属性字典里，所以会执行getattr方法
p1.addrs
p1.name
"""
当实例中同时具有__getattr__和__getattribute__方法时候，都只会执行__getattribute__方法，如果__getattribute__方法里有
抛出AttributeError异常，就会出发 __getattr__方法。 """
总结
obj点的方式操作属性时候出发
__getattr__:不存在的时候出发
__setattr__:设置属性的值的时候出发
__delattr__:删除属性的时候出发 obj['属性']的的方式操作属性的时候出发
__getitem__:不存在的时候出发
__setitem__:设置属性的值的时候出发
__delitem__:删除属性的时候出发
def __get__():
pass
def __set__():
pass
def __del__():
pass 描述的就是一个新式类，这个类至少实现上述三个方法中的一个
改变对象的字符串显示__str__,__repr__
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 # 改变对象的字符串显示__str__,__repr__ class Person(object):
def __init__(self, name, age, sex, nationality):
self.name = name
self.age = age
self.sex = sex
self.nationality = nationality def say(self):
print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality)) def __str__(self):
return '重写str方法，默认就返回我啦！！！' def __repr__(self):
return '通过解释器执行后返回的' if __name__ == "__main__":
# 实例中没有__str__函数，打印实例 地址，加了之后，打印重写后返回的内容。
p1 = Person("小村伊朗", 78, '妖', '小岛')
print(p1)
__next__和__iter__实现迭代器协议
高效的求斐波拉契数列方法
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 class FeiBoLa(object):
def __init__(self):
self.__a = 1
self.__b = 1 def __iter__(self):
return self def __next__(self):
self.__a, self.__b = self.__b, self.__a + self.__b
return self.__a if __name__ == "__main__":
f = FeiBoLa()
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
__enter__和__exit__组成with语法
with MyOpen('a.txt') as f:
print(f)
print('执行代码块')
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8
""" 案例：
with MyOpen('a.txt','r',encoding='utf-8') as f:
pass __enter__(): MyOpen('a.txt','r',encoding='utf-8') 会触发 MyOpen类中的__enter__方法
__exit__():执行完代码块中的代码后出发 __exit__方法。 """ class MyOpen(object):
def __init__(self, path, model='r', encoding='utf-8'):
self.path = path
self.model = model
self.encoding = encoding def __enter__(self):
print('执行了enter方法.....') def __exit__(self, exc_type, exc_val, exc_tb):
# 如果发生异常 对应三个值的说明
# exc_type：异常类, exc_val：异常值, exc_tb：异常追踪信息
print('执行了exit方法......')
print(exc_type)
print(exc_val)
print(exc_tb)
return False if __name__ == "__main__":
with MyOpen('a.txt') as f:
print(f)
print('执行代码块')
案例：
描述符类装饰器给类动态添加属性
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 # 类属性描述
class AttrDesc: def __init__(self, attr_name, attr_type):
self.attr_name = attr_name
self.attr_type = attr_type def __get__(self, instance, owner):
return instance.__dict__[self.attr_name] def __set__(self, instance, value):
if not isinstance(value, self.attr_type):
raise TypeError("%s值的类型不是:%s" % (self.attr_name, self.attr_type))
instance.__dict__[self.attr_name] = value def __delete__(self, instance):
return instance.__dict__.pop(self.attr_name) # 限制类属性类型装饰器
def add_attr(**kwargs):
def add(obj):
for key, val in kwargs.items():
setattr(obj, key, AttrDesc(key, val)) return obj return add @add_attr(height=float, weigt=float, name=str)
class Person(object):
def __init__(self, name, age, sex, nationality):
self.name = name
self.age = age
self.sex = sex
self.nationality = nationality def say(self):
print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality)) if __name__ == "__main__":
p1 = Person('小明', 12, '男', '中国')
p1.height = 2.19
print(Person.__dict__)
案例：自定义property
可以让一个方法 看起来像一个属性，使用的时候对象点出来即可
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 class LazyPropery:
def __init__(self, func):
self.func = func def __get__(self, instance, owner):
print(instance)
print(owner)
if instance is None:
return self
return self.func(instance) class Person(object):
def __init__(self, name, age, sex, nationality):
self.name = name
self.age = age
self.sex = sex
self.nationality = nationality # 标记上@property 变为静态属性，这样就可以通过实例名点方法名调用。
@property
def say(self):
print("大家好我叫：%s 今年%d岁了，我是一名%s生来自%s。" % (self.name, self.age, self.sex, self.nationality)) class Chinese(Person): @LazyPropery
def run(self):
print('run')
return '我是%s' % self.name if __name__ == "__main__":
print("\r\n======系统内置property=====\r\n")
p1 = Person('王二小', 12, '女', '中国')
p1.say
print("\r\n======自定义的property=====\r\n")
c1 = Chinese('王二', 15, '女', '中国')
print(c1.run)
工厂模式案例：
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8
'''
在父类中定义，在子类中实现 ========工厂模式
''' # 店铺类
class Store(object):
def select_car(self):
pass def Order(self, car_type):
return self.select_car(car_type) # 宝马4S店
class BMStore(Store):
def select_car(self, car_type):
return BMFactory().select_car_by_type(car_type) # 桑塔纳4S店
class STNStore(Store):
def select_car(self, car_type):
return STNFactory().select_car_by_type(car_type) # 雪佛兰4S店
class XFLStore(Store):
def select_car(self, car_type):
return XFLFactory().select_car_by_type(car_type) # 宝马工厂
class BMFactory(object):
def select_car_by_type(self, car_type):
if car_type == "宝马X": return BaoMaX()
if car_type == "宝马XX": return BaoMaXX()
if car_type == "宝马XXX": return BaoMaXXX() # 桑塔纳工厂
class STNFactory(object):
def select_car_by_type(self, car_type):
if car_type == "桑塔纳Q": return SangTaNaQ()
if car_type == "桑塔纳QQ": return SangTaNaQQ() # 雪佛兰工厂
class XFLFactory(object):
def select_car_by_type(self, car_type):
if car_type == "雪佛兰T": return XueFuLanT()
if car_type == "雪佛兰TT": return XueFuLanTT() # 整个车类
class Car(object):
def move(self):
print("车在移动......") def music(self):
print("车里再放音乐....") def stop(self):
print("车停下了.......") # 宝马车类
class BaoMa(Car):
pass class BaoMaX(BaoMa):
pass class BaoMaXX(BaoMa):
pass class BaoMaXXX(BaoMa):
pass # 桑塔纳车类
class SangTaNa(Car):
pass class SangTaNaQ(SangTaNa):
pass class SangTaNaQQ(SangTaNa):
pass # 雪佛兰车类
class XueFuLan(Car):
pass class XueFuLanT(XueFuLan):
pass class XueFuLanTT(XueFuLan):
pass stor = BMStore()
s = stor.Order("宝马XX")
s.move()
s.music()
s.stop()
简单工厂模式案例：
# -*- coding: utf-8 -*- # 声明字符编码
# coding:utf-8 #<region 简单工厂模式> # 店铺类
class CarStore(object):
def __init__(self):
self.factory = Factory()
def Order(self,car_type):
return self.factory.select_car_by_type(car_type) # # 店铺类
# class CarStore(object):
# def Order(self,car_type):
# return select_car_by_type(car_type) class Factory(object):
def select_car_by_type(self,car_type):
if car_type =="宝马":return BaoMa()
if car_type == "桑塔纳":return SangTaNa()
if car_type == "雪佛兰":return XueFuLan() # # 函数（达到了解耦性）
# def select_car_by_type(car_type):
# if car_type =="宝马":return BaoMa()
# if car_type == "桑塔纳":return SangTaNa()
# if car_type == "雪佛兰":return XueFuLan() # 整个车类
class Car(object):
def move(self):
print("车在移动......")
def music(self):
print("车里再放音乐....")
def stop(self):
print("车停下了.......") # 宝马车类
class BaoMa(Car):
pass
# 桑塔纳车类
class SangTaNa(Car):
pass
# 雪佛兰车类
class XueFuLan(Car):
pass stor = CarStore()
s = stor.Order("宝马")
s.move()
s.music()
s.stop() #<endregion>