面向对象之反射和内置方法

1 class Student:
 2     f = open('student', encoding='utf-8')
 3     def __init__(self):
 4         pass
 5     @classmethod #类方法 ：有个默认参数cls，并且可以直接使用类名去
 6                  #调用，还可以与类属性交互（也就是可以使用类属性）
 7     def show_student_info_class(cls):
 8         # f = open('student', encoding='utf-8')
 9         for line in cls.f:
10             name,sex = line.strip().split(',')
11             print(name,sex)
12     @staticmethod  #静态方法:可以直接使用类名去调用，就像正常的函数调用一样
13     def show_student_info_static(): #不用传self
14         f = open('student',encoding='utf-8')
15         for line in f:
16             name,sex = line.strip().split(',')
17             print(name,sex)
18 # egon = Student()
19 # egon.show_student_info_static()  #也可以这样调，但是还是推荐用类名去调
20 # egon.show_student_info_class()
21 
22 Student.show_student_info_class()#类名.方法名()
23 print('-------------------')
24 Student.show_student_info_static()#类名.方法名()

 1 class Foo:
 2     pass
 3 class Son(Foo):
 4     pass
 5 s = Son()
 6 print(isinstance(s,Son))  #判断s是不是Son的对象
 7 print(type(s) is Son)
 8 print(isinstance(s,Foo))  #判断s是不是Foo的对象  不精准
 9 print(type(s) is Foo)  #type比较精准
10 
11 print(issubclass(Son,Foo)) #判断Son是不是Foo的子类
12 print(issubclass(Son,object))
13 print(issubclass(Foo,object))
14 print(issubclass(int,object))

1 class Foo:
 2     def __init__(self):
 3         self.name = 'egon'
 4         self.age = 51
 5     def func(self):
 6         print('hello')
 7 egg = Foo()
 8 setattr(egg,'sex','男')
 9 print(egg.sex)
10 # 2.
11 def show_name(self):
12     print(self.name+'sb')
13 setattr(egg,'sh_name',show_name)
14 egg.sh_name(egg)
15 show_name(egg)

1 delattr(egg,'name')
2 print(egg.name)

1 class Foo:
 2     def __init__(self):
 3         self.name = 'egon'
 4         self.age = 51
 5     def func(self):
 6         print('hello')
 7 egg = Foo()
 8 print(hasattr(egg,'name'))  #先判断name在egg里面存在不存在
 9 print(getattr(egg,'name')) #如果为True它才去得到
10 print(hasattr(egg,'func'))
11 print(getattr(egg,'func'))  #得到的是地址
12 # getattr(egg,'func')()  #在这里加括号才能得到，因为func是方法
13 if hasattr(egg,'func'):
14     getattr(egg,'func')()
15 else:
16     print('没找到')

1 class Foo:
 2     f = 123
 3     @classmethod
 4     def class_method_dome(cls):
 5         print('class_method_dome')
 6 
 7     @staticmethod
 8     def static_method_dome():
 9         print('static_method_dome')
10 print(hasattr(Foo,'class_method_dome'))
11 method = getattr(Foo,'class_method_dome')
12 method()
13 print('------------')
14 print(hasattr(Foo,'static_method_dome'))
15 method1 = getattr(Foo,'static_method_dome')
16 method1()

1 # 1.导入其他模块引用
2 import mymodule
3 print(hasattr(mymodule,'test'))
4 getattr(mymodule,'test')()
5 
6 # # 这里的getattr(mymodule,'test')()这一句相当于
7 # p = getattr(mymodule,'test')
8 # p()

1 # 2.在本模块中应用反射
2 def demo1():
3     print('wwww')
4 import sys
5 # print(sys.modules)
6 module_obj = sys.modules[__name__]  #相当于'__main__'
7 print(module_obj)
8 print(hasattr(module_obj,'demo1'))
9 getattr(module_obj,'demo1')()

 1 # 举例
 2 def 注册():
 3     print('regiester')
 4 def 登录():
 5     print('login')
 6 def 购物():
 7     pass
 8 print('注册，登录，购物')
 9 ret = input('请输入你要做的操作：')
10 import sys
11 my_module = sys.modules[__name__]  #利用sys模块导入一个自己的模块
12 if hasattr(my_module,ret):
13     getattr(my_module,ret)()

 1 class Foo:
 2     def __init__(self,name):
 3         self.name = name
 4     def __repr__(self):
 5         return 'obj in str'  #这里只能是return
 6     # def __str__(self):
 7     #     return '%s obj in str'%self.name
 8 f = Foo('egon')
 9 print(f)  #优先执行__str__里面的内容
10 # 那么你是不是据地__repr__没用呢？
11 # print('%s'%f)  #执行的是__str__里面的返回值
12 # print('%r'%f)  #执行的是__repr__里面的返回值
13 print('==============')
14 print(str(f))  #当执行str(f)时，会去找__str__这个方法，如果找不到的时候，__repr__这个方法就给替补了
15 print(repr(f))
16 #1.当打印一个对象的时候，如果实现了__str__方法，打印__str__中的返回值
17 # 2.当__str__没有被实现的时候，就会调用__repr__方法
18 # 3.但是当你用字符串格式化的时候，%s和%r会分别调用__str__和__repr__方法
19 # 4.不管是在字符串格式化的时候还是在打印对象的时候，
20 # __repr__方法都可以作为__str__方法的替补，但反之则不行
21 # 5.用于友好的表示对象。如果__str__和__repr__方法你只能实现一个：先实现__repr__

 1 class Foo:
 2     def __init__(self):
 3         self.name = 'egon'
 4         self.age = 73
 5         self.l=[1,2,3]
 6     def __getitem__(self, item):  #得到
 7         # return  self.l[item]
 8         # return self.__dict__[item]
 9         # print(Foo.__dict__)
10         return 123
11     def __setitem__(self, key, value):  #修改
12         print(key,value)
13         self.__dict__[key] = value
14     def __delitem__(self, key):  #删除
15         del self.__dict__[key]
16 f = Foo()
17 print(f['qqq'])  #不管里面放的啥值，它都会得到返回值的内容，调用的是__getitem__方法
18 f['name']='alex' #修改egon的值为alex，调用 __setitem__方法
19 # del f['name'] #删除name，就会报错了，说明在调用__delitem__方法调用成功了，就已经删了，就会报错了
20 print(f.name) 
21 f1 = Foo()
22 print(f == f1)
23 # print(f.name)
24 # print(f[0])  #一开始不能这样取值，但是提供了一个__getitem__方法，这样就可以用了
25 # print(f[1])
26 # print(f[2])

1 # 4.__new__方法
 2 # 单例模式：是一种设计模式
 3 class Singleton:
 4     def __new__(cls, *args, **kw):
 5         if not hasattr(cls, '_instance'):
 6             orig = super(Singleton, cls)
 7             cls._instance = orig.__new__(cls, *args, **kw)
 8         return cls._instance
 9 
10 one = Singleton()
11 two = Singleton()
12 print(one,two)   #他们两个的地址一样
13 
14 one.name = 'alex'
15 print(two.name) 

1 # class A:
 2 #     def __init__(self):  #有一个方法在帮你创造self
 3 #         print('in init function')
 4 #         self.x = 1
 5 #
 6 #     def __new__(cls, *args, **kwargs):
 7 #         print('in new function')
 8 #         return object.__new__(A, *args, **kwargs)
 9 # a = A()
10 # b = A()
11 # c = A()
12 # d = A()
13 # print(a,b,c,d)

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