python进阶_浅谈面向对象进阶

 class Foo: pass class Son(Foo): pass s = Son() #判断一个对象是不是这个类的对象,传两个参数（对象，类） print(isinstance(s,Son)) print(isinstance(s,Foo)) #type更精准 print(type(s) is Son) print(type(s) is Foo) #判断一个类是不是另一类的子类，传两个参数(子类，父类) print(issubclass(Son,Foo)) print(issubclass(Son,object)) print(issubclass(Foo,object)) print(issubclass(int,object))

 class Foo: def __init__(self): self.name = 'egon' self.age = 73 def func(self): print(123) egg = Foo() #常用： #hasattr #getattr # print(hasattr(egg,'name')) print(getattr(egg,'name')) if hasattr(egg,'func'): #返回bool Foo_func = getattr(egg,'func') #如果存在这个方法或者属性，就返回属性值或者方法的内存地址 #如果不存在，报错，因此要配合hasattr使用 Foo_func() #不常用： #setattr # setattr(egg,'sex','属性值') # print(egg.sex) # def show_name(self): #  print(self.name + ' sb') # setattr(egg,'sh_name',show_name) # egg.sh_name(egg) # show_name(egg) # egg.sh_name() #delattr # delattr(egg,'name') # print(egg.name) # print(egg.name) # egg.func() # print(egg.__dict__) #反射 #可以用字符串的方式去访问对象的属性、调用对象的方法 反射举例1

 class Foo: f = 123 #类变量 @classmethod def class_method_demo(cls): print('class_method_demo') @staticmethod def static_method_demo(): print('static_method_demo') # if hasattr(Foo,'f'): #  print(getattr(Foo,'f')) print(hasattr(Foo,'class_method_demo')) method = getattr(Foo,'class_method_demo') method() print(hasattr(Foo,'static_method_demo')) method2 = getattr(Foo,'static_method_demo') method2() #类也是对象 

 import my_module # print(hasattr(my_module,'test')) # # func_test = getattr(my_module,'test') # # func_test() # getattr(my_module,'test')() #import其他模块应用反射 from my_module import test def demo1(): print('demo1') import sys print(__name__) #'__main__' print(sys.modules) #'__main__':  module_obj =sys.modules[__name__] #sys.modules['__main__'] # module_obj :  print(module_obj) print(hasattr(module_obj,'demo1')) getattr(module_obj,'demo1')() #在本模块中应用反射 反射举例3

 #对象 #类 #模块 ： 本模块和导入的模块 def register(): print('register') def login(): pass def show_shoppinglst(): pass # print('注册，登录') ret = input('欢迎，请输入您要做的操作： ') import sys print(sys.modules) # my_module = sys.modules[__name__] # if hasattr(my_module,ret): #  getattr(my_module,ret)() if ret == '注册': register() elif ret == '登录': login() elif ret == 'shopping': show_shoppinglst() 反射举例4

 def test(): print('test')

 class Foo: def __init__(self,name): self.name = name def __str__(self): return '%s obj info in str'%self.name def __repr__(self): return 'obj info in repr' f = Foo('egon') # print(f) print('%s'%f) print('%r'%f) print(repr(f)) # f.__repr__() print(str(f)) #当打印一个对象的时候，如果实现了str，打印中的返回值 #当str没有被实现的时候，就会调用repr方法 #但是当你用字符串格式化的时候 %s和%r会分别去调用__str__和__repr__ #不管是在字符串格式化的时候还是在打印对象的时候，repr方法都可以作为str方法的替补 #但反之不行 #用于友好的表示对象。如果str和repr方法你只能实现一个：先实现repr

 class Foo: def __del__(self): print('执行我啦') f = Foo() print(123) print(123) print(123) #析构方法，当对象在内存中被释放时，自动触发执行。 #注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。 

 class Foo: def __init__(self): self.name = 'egon' self.age = 73 def __getitem__(self, item): return self.__dict__[item] def __setitem__(self, key, value): # print(key,value) self.__dict__[key] = value def __delitem__(self, key): del self.__dict__[key] f = Foo() print(f['name']) print(f['age']) f['name'] = 'alex' # del f['name'] print(f.name) f1 = Foo() print(f == f1)

 # class A: #  def __init__(self): #有一个方法在帮你创造self #   print('in init function') #   self.x = 1 # #  def __new__(cls, *args, **kwargs): #   print('in new function') #   return object.__new__(A, *args, **kwargs) # a = A() # b = A() # c = A() # d = A() # print(a,b,c,d) #单例模式 class Singleton: def __new__(cls, *args, **kw): if not hasattr(cls, '_instance'): cls._instance = object.__new__(cls, *args, **kw) return cls._instance one = Singleton() two = Singleton() three = Singleton() go = Singleton() print(one,two) one.name = 'alex' print(two.name)

 class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print('__call__') obj = Foo() # 执行 __init__ obj() # 执行 __call__ Foo()() # 执行 __init__和执行 __call__ #构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

 class Foo: def __len__(self): return len(self.__dict__) def __hash__(self): print('my hash func') return hash(self.name) f = Foo() print(len(f)) f.name = 'egon' print(len(f)) print(hash(f))

 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() b = A() print(a == b) #__eq__控制着==的结果

 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)) 纸牌游戏

 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]) 纸牌游戏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 and other.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)) #只要姓名和年龄相同就默认为一人去重 去重