24 Python 对象进阶

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

 class Foo(object):
      pass

 obj = Foo()

 isinstance(obj, Foo)

issubclass(sub, super)检查sub类是否是 super 类的派生类

 class Foo(object):
     pass

 class Bar(Foo):
     pass

 issubclass(Bar, Foo)

反射

1 什么是反射

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

2 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

四个可以实现自省的函数

下列方法适用于类和对象（一切皆对象，类本身也是一个对象）

 class Foo:
     f = '类的静态变量'
     def __init__(self,name,age):
         self.name=name
         self.age=age

     def say_hi(self):
         print('hi,%s'%self.name)

 obj=Foo('egon',73)

 #检测是否含有某属性
 print(hasattr(obj,'name'))
 print(hasattr(obj,'say_hi'))

 #获取属性
 n=getattr(obj,'name')
 print(n)
 func=getattr(obj,'say_hi')
 func()

 print(getattr(obj,'aaaaaaaa','不存在啊')) #报错

 #设置属性
 setattr(obj,'sb',True)
 setattr(obj,'show_name',lambda self:self.name+'sb')
 print(obj.__dict__)
 print(obj.show_name(obj))

 #删除属性
 delattr(obj,'age')
 delattr(obj,'show_name')
 delattr(obj,'show_name111')#不存在,则报错

 print(obj.__dict__)

 class Foo(object):

     staticField = "old boy"

     def __init__(self):
         self.name = 'wupeiqi'

     def func(self):
         return 'func'

     @staticmethod
     def bar():
         return 'bar'

 print getattr(Foo, 'staticField')
 print getattr(Foo, 'func')
 print getattr(Foo, 'bar')

 import sys

 def s1():
     print 's1'

 def s2():
     print 's2'

 this_module = sys.modules[__name__]

 hasattr(this_module, 's1')
 getattr(this_module, 's2')

导入其他模块，利用反射查找该模块是否存在某个方法

__str__和__repr__

改变对象的字符串显示__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__没有被定义,那么就会使用__repr__来代替输出
 注意:这俩方法的返回值必须是字符串,否则抛出异常
 '''
 print(format(s1,'nat'))
 print(format(s1,'tna'))
 print(format(s1,'tan'))
 print(format(s1,'asfdasdffd'))

__format__

 class B:

      def __str__(self):
          return 'str : class B'

      def __repr__(self):
          return 'repr : class B'

 b=B()
 print('%s'%b)
 print('%r'%b)

%r和%s

__del__

析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

 class Foo:

     def __del__(self):
         print('执行我啦')

 f1=Foo()
 del f1
 print('------->')

__del__（析构方法）

item系列

 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')
 f1['age']=18
 f1['age1']=19
 del f1.age1
 del f1['age']
 f1['name']='alex'
 print(f1.__dict__)

__getitem__/__setitem__/__delitem__

__new__

 class Foo:
     def __init__(self):
         self.x = 1
         print('in init function')

     def __new__(cls, *args, **kwargs):
         print('in new function')
         return object.__new__(cls, *args, **kwargs)

__new__

__call__

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

 class Foo:

     def __init__(self):
         pass

     def __call__(self, *args, **kwargs):

         print('__call__')

 obj = Foo() # 执行 __init__
 obj()       # 执行 __call__

__call__

__len__

 class Foo:
     def __init__(self):
         self.a = 1
         self.b = 2

     def __len__(self):
         return len(self.__dict__)

 f = Foo()
 print(len(f))

__len__

__hash__

 class Foo:
     def __init__(self):
         self.a = 1234
         self.b = 5678

     def __hash__(self):
         return hash(str(self.a) + str(self.b))

 f = Foo()
 print(hash(f))

__hash__

__eq__

 class Foo:
     def __init__(self):
         self.a = 1
         self.b = 2

     def __eq__(self, other):
         if self.a == other.a and self.b == other.b:
             return True

 a = Foo()
 b = Foo()
 print(a == b)

 from collections import namedtuple
 Card = namedtuple('Card', ['rank', 'suit'])
 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]

 deck = FranchDeck()
 print(deck[0])
 from random import choice
 print(choice(deck))
 print(choice(deck))

纸牌游戏1

 from collections import namedtuple
 Card = namedtuple('Card', ['rank', 'suit'])
 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[:52])
 print(deck[:5])

纸牌游戏2

 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 or 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))

对象去重