python_day24_面向对象进阶1_内置方法详解编程语言

__len__  len(obj) 
obj对应的类中含有__len__方法,len(obj)才能正常执行。 
__hash__ hash(obj)  是object类自带的 
只有实现了__hash__方法，has(obj)才能正常执行。 
题外话2: 列表和字典 
需要循环遍历去寻找的用列表比字典好一点，例如遍历文件中保存的用户名和密码。 
而需要快速由一个key找到一个值的，用字典好，比如用户登录状态。 
__str__内置方法 和__repr__内置方法 
print() # 向文件中写 print替你将数据类型转换成字符串打印出来。 
print(obj) 的结果是obj.__str__()的结果。 
str(obj) 的结果也是obj.__str__()的结果  (str是一个类名)。 
'%s' % obj 的结果是也是obj.__str__()的结果。 
repr(obj) 的结果和obj.__repr__()是一样的。 
'%r' % obj 的结果和obj.__repr__()是一样的。 
所有的输出本质上都是往文本上写。 
print(lis)  ---> lis.__str__() 
object类中的__str__就是默认返回一个数据的内存地址。 
自己新建的类重写一下自己类中的__str__内置方法就可以人性化的输出。 
重写内置方法为的是调用内置函数时输出的是自己想要的结果。 
reps(1) 和 reps('1') 打印的结果不一样， 
是因为class int 和class str 中的 __repr__方法不一样。 
默认设计是让你区分不同。 
当需要使用__str__的场景时，找不到__str__就找__repr__， 
当需要使用__repr__的场景时，找不到__repr__的时候就找父类的repr。 
双下repr是双下str的备胎。 
len() obj.__len__()  返回值是一致的 
不如这样说：len() 的结果是依赖 obj.__len__() 
同理 hash()的结果是依赖 obj.__has__() 
str() 的结果是依赖 obj.__str__() 
print(obj) 的结果是依赖 obj.__str__() 
%s 的结果是依赖 obj.__str__() 
repr 的结果是依赖 obj.__repr__() 
%r 的结果是依赖 obj.__repr__() 
repr是str的备胎。 
题外话3: 语法糖很甜 
凡是不以函数调用方式出现的给予你便利的语法方式，都可以称为语法糖。 
表面上语法只是很简单的方式，实际上后台都会落实到具体的方法上。 
__format__方法 
当你自己去实现双下format的时候，需要带有format_spec参数。 
format_spec参数 ：格式化的标准（规则），format内置函数规定的。 
format_spec 在外部定义一个标准，为了让用户更灵活定制。 
def format(*args, **kwargs): # real signature unknown 
""" 
    Return value.__format__(format_spec) 
     
    format_spec defaults to the empty string 
    """ 
pass 
例： 
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')) 
题外话4：为什么要归一化设计呢？ 
1）更接近面向函数编程 
2）简单且节省代码 
__call__内置方法： 
class Teacher(): 
def __call__(self): 
print(123) 
t = Teacher() 
t() 
对像名加(),相当于调用类内置的__call__ 
callable 检测对象能否被调用，返回布尔值。 
一个对象是否可调用，取决于这个对象对应的类是否实现了__call__。 
如果对象拥有内置双下call方法，就可以被调用了。 
对象后面加括号，触发执行。 
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ； 
而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()() 
__eq__内置方法： 
判断 == 这件事是由__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() 
b = A() 
print(a == b) 
__del__ 析构方法 
所有面向对象语言都有的; 
在删除一个对象的时候做一些收尾工作，比如说关闭一些打开的文件，断开一些网络链接等。 
析构方法，当对象在内存中被释放时，自动触发执行。 
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放， 
因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。 
class A: 
def __init__(self): 
self.f = open('File','w') 
del __del__(self): 
self.f.close 
print('执行我啦') 
a = A() 
del a 
print('666') 
运行完一个程序之后，python解释器会执行回收内存，自动运行双下del。 
__new__ 构造方法 
实例化的时候，init初始化之前，有一个创造对象的过程， 
创造对象过程就是用内置的双下new方法， 
先把小孩生下来才能给他穿衣服，先有对象再有初始化。 
设计模式---单例模式(考到了双下new方法） 
单例模式就是一个类只能有一个实例。 
可以被多次实例化，但最终只会有一个实例存在。 
# 使用双下new实现单例模式如下： 
class Teacher(): 
__instance = None 
def __init__(self, name, age): 
self.name = name 
self.age = age 
def __new__(cls, *args, **kwargs): 
if cls.__instance is None: 
obj = object.__new__(cls) 
cls.__instance = obj 
return cls.__instance 
a = B('alex', 80) 
b = B('egon', 20) 
print(a) 
print(b) 
print(a.name) 
print(b.name) 
item 系列 对象使用中括号的形式去操作(属性） 
__getitem__/__setitem__/__delitem__ 
[]中括号的形式，字典的通过key找值的方式，通过双下getitem实现 
__getitem__ 查询  对象名[属性名] 等同对象名.属性名 
__setitem__ 设置  对象名[属性名]= 值  赋值和修改，新增 
__delitem__ 删除  del 对象名[属性名］ 等同del 对象名.属性 
也相当于执行了__delattr__ 
例：扑克牌游戏 
class FranchDeck: 
ranks = [str(n) for n in range(2, 11)] + list('JQKA') 
# 直接拼接两个列表生成13张扑克牌，并且里面的元素同时转为字符串 
suits = ['红心', '方块', '梅花', '黑桃'] 
def __init__(self): 
self.cards = [(rank, suit) for rank in FranchDeck.ranks 
for suit in FranchDeck.suits] 
# 元组中的点数和花色分别推导循环得出 
# [('2', '红心'), ('2', '方块'), ('2', '梅花'), ('2', '黑桃'), ('3', '红心')……] 
def __len__(self): 
return len(self.cards) 
# 统计扑克牌一共52张 
def __getitem__(self, item): 
return self.cards[item] 
# 等同于列表切片，取出当中的元素 
def __setitem__(self, key, value): 
self.cards[key] = value 
deck = FranchDeck() # 实例化 
# 对列表对象切片取值，下面两行是相同的 
print(deck[0]) 
print(deck.__getitem__(0)) 
print(deck.ranks) 
print(deck.cards) 
# 对列表统计元素，下面两行也是相同结果 
print(len(deck)) 
print(deck.__len__()) 
# 随机选择扑克牌 
from random import choice 
print(choice(deck)) 
print(choice(deck)) 
# 设置对应索引位置为什么值 
deck.__setitem__(0, ('3', '黑桃')) 
deck[1] = ('3', '梅花') 
print(deck[0]) # 取到的值不是红心2了，变成了黑桃3 
print(deck[1]) # 取到的值不是方块2了，变成了梅花3 
# shuffle = 洗牌,但每一次都要重新洗牌，不洗的话取出的是同一组 
from random import shuffle 
shuffle(deck) 
print(deck[:5]) 
shuffle(deck) 
print(deck[:13]) 
shuffle(deck) # 洗牌，然后切片发牌，将52张按序切完就可以玩扑克啦 
print(deck[:13]) 
print(deck[13:26]) 
print(deck[26:39]) 
print(deck[39:52]) 
# [('7', '黑桃'), ('A', '方块'), ('Q', '梅花'), ('3', '梅花'), ('10', '方块'), ('K', '红心'), ('8', '黑桃'), ('J', '方块'), ('2', '黑桃'), ('5', '方块'), ('Q', '方块'), ('5', '红心'), ('9', '红心')] 
# [('J', '梅花'), ('Q', '红心'), ('3', '红心'), ('4', '梅花'), ('10', '黑桃'), ('10', '梅花'), ('K', '黑桃'), ('7', '红心'), ('2', '梅花'), ('A', '梅花'), ('J', '黑桃'), ('2', '方块'), ('3', '黑桃')] 
# [('7', '梅花'), ('K', '方块'), ('6', '红心'), ('J', '红心'), ('A', '红心'), ('4', '方块'), ('8', '方块'), ('4', '黑桃'), ('5', '梅花'), ('9', '黑桃'), ('3', '方块'), ('Q', '黑桃'), ('8', '红心')] 
# [('4', '红心'), ('9', '梅花'), ('9', '方块'), ('6', '方块'), ('A', '黑桃'), ('6', '梅花'), ('10', '红心'), ('6', '黑桃'), ('K', '梅花'), ('5', '黑桃'), ('7', '方块'), ('2', '红心'), ('8', '梅花')] 
面试题: 
100个同一个类的对象， 
Person 对象有同名，同性别，但不同年龄，进行去重。 
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))