题外话1： 学习方法【wwwh】
what where why how
是什么，用在哪里，为什么，怎么用
学习到一个新知识点的时候，多问问上面的四个问题，并了解和实践透彻。
什么是反射？
先不说枯燥的概念，你可以自己总结出来，对于python中的反射，什么时候会用到？
需要使用字符串数据类型的变量名来使用变量的时候用到反射。
（通过字符串的形式操作对象相关的属性和方法。）
关键词：字符串
使用到字符串的场景多在：
1）文件中存储的是字符串，
2）网络上能传递的也最接近字符串，
3）用户输入的（用的不多，因为毕竟有安全隐患）
今天来学习内置方法的用处
（重写内置方法应用于个别需求）
__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))end
2018-4-19
原文地址：https://www.cnblogs.com/tielemao/p/8886258.html
时间： 2024-11-07 18:43:29