# staticmethod和classmethod
class Student:f = open('student', encoding='utf-8')def __init__(self):pass@classmethod #类方法 ：有个默认参数cls，并且可以直接使用类名去#调用，还可以与类属性交互（也就是可以使用类属性）def show_student_info_class(cls):# f = open('student', encoding='utf-8')for line in cls.f:name,sex = line.strip().split(',')print(name,sex)@staticmethod  #静态方法:可以直接使用类名去调用，就像正常的函数调用一样def show_student_info_static(): #不用传selff = open('student',encoding='utf-8')for line in f:name,sex = line.strip().split(',')print(name,sex)
# egon = Student()
# egon.show_student_info_static()  #也可以这样调，但是还是推荐用类名去调
# egon.show_student_info_class()Student.show_student_info_class()#类名.方法名()
print('-------------------')
Student.show_student_info_static()#类名.方法名()

class Foo:pass
class Son(Foo):pass
s = Son()
print(isinstance(s,Son))  #判断s是不是Son的对象
print(type(s) is Son)
print(isinstance(s,Foo))  #判断s是不是Foo的对象  不精准
print(type(s) is Foo)  #type比较精准print(issubclass(Son,Foo)) #判断Son是不是Foo的子类
print(issubclass(Son,object))
print(issubclass(Foo,object))
print(issubclass(int,object))

# setattr
class Foo:def __init__(self):self.name = 'egon'self.age = 51def func(self):print('hello')
egg = Foo()
setattr(egg,'sex','男')
print(egg.sex)
# 2.
def show_name(self):print(self.name+'sb')
setattr(egg,'sh_name',show_name)
egg.sh_name(egg)
show_name(egg)

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

# 对象应用反射
class Foo:def __init__(self):self.name = 'egon'self.age = 51def func(self):print('hello')
egg = Foo()
print(hasattr(egg,'name'))  #先判断name在egg里面存在不存在
print(getattr(egg,'name')) #如果为True它才去得到
print(hasattr(egg,'func'))
print(getattr(egg,'func'))  #得到的是地址
# getattr(egg,'func')()  #在这里加括号才能得到，因为func是方法
if hasattr(egg,'func'):getattr(egg,'func')()
else:print('没找到')

# 类应用反射
class Foo:f = 123@classmethoddef class_method_dome(cls):print('class_method_dome')@staticmethoddef static_method_dome():print('static_method_dome')
print(hasattr(Foo,'class_method_dome'))
method = getattr(Foo,'class_method_dome')
method()
print('------------')
print(hasattr(Foo,'static_method_dome'))
method1 = getattr(Foo,'static_method_dome')
method1()

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

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

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

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

class Foo:def __del__(self):print('执行我啦')f= Foo()
print(123)
print(123)
print(123)
print(123)

class Foo:def __init__(self):self.name = 'egon'self.age = 73self.l=[1,2,3]def __getitem__(self, item):  #得到# return  self.l[item]# return self.__dict__[item]# print(Foo.__dict__)return 123def __setitem__(self, key, value):  #修改print(key,value)self.__dict__[key] = valuedef __delitem__(self, key):  #删除del self.__dict__[key]
f = Foo()
print(f['qqq'])  #不管里面放的啥值，它都会得到返回值的内容，调用的是__getitem__方法
f['name']='alex' #修改egon的值为alex，调用 __setitem__方法
# del f['name'] #删除name，就会报错了，说明在调用__delitem__方法调用成功了，就已经删了，就会报错了
print(f.name)
f1 = Foo()
print(f == f1)
# print(f.name)
# print(f[0])  #一开始不能这样取值，但是提供了一个__getitem__方法，这样就可以用了
# print(f[1])
# print(f[2])

# 单例模式
# 4.__new__方法
# 单例模式：是一种设计模式
class Singleton:def __new__(cls, *args, **kw):if not hasattr(cls, '_instance'):orig = super(Singleton, cls)cls._instance = orig.__new__(cls, *args, **kw)return cls._instanceone = Singleton()
two = Singleton()
print(one,two)   #他们两个的地址一样one.name = 'alex'
print(two.name)

#__new__# 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 Foo:def __call__(self, *args, **kwargs):print(123)
# f = Foo()
# f() #如果不写上面的__call__方法，就不会调用。如果加上，就正确了
Foo()() #也可以这样表示

class Foo:
def __hash__(self):
print('aaaaaaaaaa')
return hash(self.name)
# print('aaas')
f = Foo()
f.name = 'egon'
print(hash(f)) #hash方法是可以重写的

class A:
def __eq__(self, other):
return True
a = A()
b = A()
print(a==b) #不加方法的时候返回的是False，加了个__eq__方法就返回了个True
# '=='内部就调用了__eq__方法
print(a is b)

# 纸牌游戏
from collections import namedtuple
Card = namedtuple('Card',['rank','suit'])  #两个属性：一个是数，一个是花色（每一个card的对象就是一张纸牌）
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] = valuedeck = FranchDeck()
# print(deck[0])
# print(deck[0])
# print(deck[0])
# print(deck[0])
from random import choice
print(choice(deck))
print(choice(deck))from random import shuffle
shuffle(deck)
print(deck[:5])