isinstance 和 issubclass
isinstance(obj,b) 检查是否obj是否是类b的对象
class A(object):pass
class B(A):pass
b=B()
print(isinstance(b,B)) #如果b是B的对象 就返回True,反之False
print(isinstance(b,A)) #如果b是A的对象 就返回True,反之False
issubclass(A,B) 检测B是否继承A
class A(object):pass
class B(A):pass
print(issubclass(B,A)) #如果B继承A 就返回True,反之Fasle
类的内置方法
1)改变对象的字符串显示 __str__,__repr__
自定制格式化字符串 __format__
format_dict={
'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
}
class School:
def __init__(self,name,addr,type):
self.name=name
self.addr=addr
self.type=type
def __repr__(self):
return 'School(%s,%s)' %(self.name,self.addr)
def __str__(self):
return '(%s,%s)' %(self.name,self.addr)
def __format__(self, format_spec):
# if format_spec
if not format_spec or format_spec not in format_dict:
format_spec='nat'
fmt=format_dict[format_spec]
return fmt.format(obj=self)
s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1))
print('from str: ',str(s1))
print(s1)
'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__() <--#__str__的备胎
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))
class B:
def __str__(self):
return 'str : class B' ------%s
def __repr__(self):
return 'repr : class B'------%r
b=B()
print('%s'%b)
print('%r'%b)
%s和%r
2)__del__
析构方法,当对象在内存中被释放,自动触发执行.
注意:此方法一般无需定义,因为python是一门高级语言.
class Foo:
def __del__(self):
print('执行我了')
f=Foo()
del f
print('---->')
#输出结果
执行我了
---->
3)item系列
__getitem__\__setitem__\__delitem__
class Foo:
def __init__(self,name):
self.name=name def __getitem__(self, item):
print(self.__dict__[item]) #直接生成字典 def __setitem__(self, key, value):
self.__dict__[key]=value
def __delitem__(self, key):
print('del obj[key]时,我执行')
self.__dict__.pop(key)
def __delattr__(self, item):
print('del obj.key时,我执行')
self.__dict__.pop(item) f1=Foo('sb')
print(f1.name)
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)
4)__new__ \ __init__(实例化 构造方法(单例模式))/ 初始化方法
class A:
def __init__(self):
self.x = 1
print('in init function')
def __new__(cls, *args, **kwargs):
print('in new function')
return object.__new__(A, *args, **kwargs)------提供了一个类实例化的时候提供的一个所需要的内存空间 a = A()
print(a.x)
5)__call__ (对象后面加括号,触发执行)
注意:构造方法的执行是由创建对象触发的,即:对象 = 类名():而对于__call__方法的执行是由对象后加括号触发的 ,即:对象() 或者 类()
class Student():
def __init__(self,name,age):
self.name = name
self.age = age
# def call(self):pass
def __call__(self, *args, **kwargs):
print('调用我啦')
alex = Student('alex',83)-----执行__init__
alex() ----执行__call__
6)__len__ (len(对象))
class A:
def __init__(self):
self.a = 1
self.b = 2
self.c = 1 def __len__(self):
return len(self.__dict__)------查的长度
a = A()
print(len(a))
7)__hash__ (每次执行__hash__都会改变,在一次执行的过程中对同一个值的hash结果总是不变的)
class A:
def __init__(self):
self.a = 1
self.b = 2 def __hash__(self):
return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))
8)__eq__( 判断)
class A:
def __init__(self):
self.a = 1
self.b = 2 def __eq__(self,obj):
if self.a == obj.a and self.b == obj.b:
return True
a = A()
print(a)
b = A()
print(b)
print(a == b)
9)__iter__和__next__(这两个方法用于将一个对象模拟成序列)
class Num:
def __init__(self, max_num):
self.max_num = max_num
self.count = 0 def __iter__(self):
return self def __next__(self):
if self.count < self.max_num:
self.count += 1
return self.count
else:
raise StopIteration('已经到达临界') num = Num(10)
for i in num:
print(i) # 循环打印1---10
10)__getattr__\__setattr__\__delattr__(访问,设置和删除)
class Student:
def __getattr__(self, item):
print('访问一个不存在的属性时候触发')
return '不存在' def __setattr__(self, key, value):
print('设置一个属性值的时候触发')
# self.key = value # 这样会无限循环
self.__dict__[key] = value def __delattr__(self, item):
print('删除一个属性的时候触发')
if self.__dict__.get(item, None):
del self.__dict__[item] stu = Student()
stu.name = 'zlw' # 设置一个属性值的时候触发
print(stu.noexit) # 访问一个不存在的属性时候触发 , 返回'不存在'
del stu.name # 删除一个属性的时候触发
11)__getattribute__(属性访问截断器)
属性查找顺序:
实例的 getattribute-->实例对象字典--.实例所在类字典--->实例所在类的父类(MRO顺序)字典-->实例所在类的getattr--->报错
class People:
a = 200 class Student(People):
a = 100 def __init__(self, a):
self.a = a def __getattr__(self, item):
print('没有找到:', item) def __getattribute__(self, item):
print('属性访问截断器')
if item == 'a':
return 1
return super().__getattribute__(item) stu = Student(1)
print(stu.a) #
12)__enter__和__exit__
class MySQL:
def connect(self):
print('启动数据库连接，申请系统资源') def execute(self):
print('执行sql命令，操作数据') def finish(self):
print('数据库连接关闭，清理系统资源') def __enter__(self): # with的时候触发，并赋给as变量
self.connect()
return self def __exit__(self, exc_type, exc_val, exc_tb): # 离开with语句块时触发
self.finish() with MySQL() as mysql:
mysql.execute() # 结果:
# 启动数据库连接，申请系统资源
# 执行sql命令，操作数据
# 数据库连接关闭，清理系统资源
13)__doc__ (类的描述信息)
class Foo:
""" 描述类信息，这是用于看片的神奇 """ def func(self):
pass print Foo.__doc__
#输出：类的描述信息
14)__module__ 和__class__( 当前操作的对象在那个模块\当前操作的对象的类是什么)
from lib.aa import C obj = C()
print obj.__module__ # 输出 lib.aa，即：输出模块
print obj.__class__ # 输出 lib.aa.C，即：输出类
class FranchDeck:
ranks = [str(n) for n in range(2,11)] + list('JQKA')
suits = ['红心','方板','梅花','黑桃'] def __init__(self):
self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
for suit in FranchDeck.suits] def __len__(self):
return len(self._cards) def __getitem__(self, item):
return self._cards[item] def __setitem__(self, key, value):
self._cards[key] = value deck = FranchDeck()
print(deck[0])
from random import choice
print(choice(deck))
print(choice(deck)) from random import shuffle
shuffle(deck)
print(deck[:5])
纸牌游戏
class Person:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex def __hash__(self):
return hash(self.name+self.sex) def __eq__(self, other):
if self.name == other.name and self.sex == other.sex:return True p_lst = []
for i in range(84):
p_lst.append(Person('egon',i,'male')) print(p_lst)
print(set(p_lst))
面试题
希望大家多多关注,多多评论!!!