day 24 内置函数（补充）

一。 内置函数 
1.__len__ 与 len()


# class A:
#     def __init__(self,name,age,sex,cls):
#         self.name = name
#         self.age = age
#         self.sex = sex
#         self.cls = cls
#     def __len__(self):
#         return len(self.__dict__)
#
# # 有一个内置函数 和内置方法len()是唯一对应的关系
# a1 = A('alex',81,'不详',2)
# a1.hobby = '烫头'
# a2 = A('egon',20,'不详',3)
# a3 = A('yuan',21,'不详',4)
# print(len(a1))
# print(len(a2))
# print(len(a3))



2.字典的存储

# hash

class A:
    def __init__(self,name,age,sex,cls):
        self.name = name
        self.age = age
        self.sex = sex
        self.cls = cls
    def __hash__(self):
        return 0
a1 = A('alex',81,'不详',2)
print(hash(a1))
每一次的哈希值都不同，为什么可以直接哈希，因为object类里有__hash__方法

二。__str__ 与 __repr__ 与 print()

ps: 总结：

　　1.print() 想文件中写，print() 替你将数据类型转化成字符串打印出来

　　2.__str__ : object 类中的__str__ 就是返回一个数据类型的内存地址

l = [1,2,3,4]
print(l)   # 向文件中写   print替你将数据类型转化成字符串打印出来

class List:
    def __init__(self,*args): 5
        self.l = list(args)
    def __str__(self):
        return '[%s]'%(','.join([str(i) for i in self.l]))
l = List(1,2,3,4,5)
print(l)   #--> l.__str__()   # object类中的__str__就是返回一个数据的内存地址
print(l)
print(str(l))
print('%s'%l)
print(obj)   的结果 是 obj.__str__()的结果
str(obj)   的结果 也是 obj.__str__()的结果
'%s'%obj   的结果 也是 obj.__str__()的结果

class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    # def __str__(self):
    #     return "Teacher's object is %s" %self.name
    def __repr__(self):
        return "repr %s" %self.name
a = Teacher('alex',18)
b = Teacher('wusir',18)

print(a)
print(repr(b))

# repr(obj)的结果和obj.__repr__()是一样的
# '%r'%(obj)的结果和obj.__repr__()是一样的

总结：

　　1.实际上上述三种结果都是__str__的返回值

　　2.当然：如果我们不手动改写object中的上下划线str或者repr，就会默认调用object类中的方法，默认返回的是内存地址

思考：why? repr(1) 与 repr('1'):的打印结果不同？

因为：在整形中定义的repr方法，与在str中定义的repr方法定义的函数方法的返回值不同。　　即在class int 与 class str 中的 __repr__ 方法的返回值不同

class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return "Teacher's object %s"%self.name
    def __repr__(self):
        return 'repr function %s'%self.name
a = Teacher('alex',80)
b = Teacher('egon',80)
print(a)
print(b)

PS：总结：

　　1.到需要使用__str__的方法时，找不到__str__方法时，就会找__repr__方法。

　　2.当需要使用__repr__的方法时，找不到__repr__的方法时，就会找父类的或object的__repr__方法，这是默认返回的时内存地址

　　3.repr()方法是 str()方法的备胎。嘿嘿嘿（偷笑）

　　3.实际上：len()和 repr() 方法的返回值都是依赖__len__和__repr__方法来返回值的

三。__len__方法与 __hash__方法

# class A:
#     def __init__(self):pass
#     def __len__(self):pass
# def len(obj):
#     obj.__len__()
# a = A()
# a.__len__()
# len()   # 为什么要归一化设计呢？
# 更接近面向函数编程，简单且节省代码

# len()  obj.__len__()  返回值是一致的
# len() 的结果是依赖 obj.__len__()
# hash() 的结果是依赖 obj.__hash__()

# str() 的结果是依赖 obj.__str__()
# print(obj) 的结果是依赖 obj.__str__()
# %s 的结果是依赖 obj.__str__()    # 语法糖
#
# repr() 的结果是依赖 obj.__repr__()
# %r 的结果是依赖 obj.__repr__()
# repr是str的备胎

思考：如果str与repr 我只能实现一个，那选哪个？# __str__

# __repr__   一定是选择repr


什么是语法糖？语法糖的定义？
　　
　　答：语法糖就是可以让数据结构变得更加简单，就像吃了糖一样甜。这就是语法糖。

四。__format__方法？

class Format:
    def __init__(self,name,age,hobby):
        self.name = name
        self.age = age
        self.hobby = hobby

    def __format__(self,format_spec):
        return format_spec.format(obj = self)

person = Format('alex',18,'女')
format_spec = '{obj.name}-{obj.age}-{obj.hobby}'
print(format(person,format_spec))

五：__call__?

class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __call__(self):
        print(123)


t = Teacher('wusir',18)
t()

靠？方法加（），什么鬼？

对象名（）相当于调用了类内置的__call__方法

print(callable(类名))：是否可调用的

如果一个对象是否可调用，取决于这个对象对应的类是否有__call__方法


2.__eq__?

class A:pass
a = A()
b = A()
print(a == b)

返回False
因为连个对象的内存地址是不一样的，

# class A:
#     def __eq__(self, other):
#         # if self.__dict__ == other.__dict__:
#             return True
# # __eq__()
# a = A()
# a.name = 'alex'
# b = A()
# b.name = 'egon'
# print(a)
# print(b)
# print(a == b)

# == 是由__eq__的返回值来决定的

# == 是由__eq__的返回值来决定的

3.__del__ 析构方法？

在删除一个对象的时候做一些收尾工作。

class A:
    def __init__(self):
        self.f = open('文件','w')

a = A()
print('aaa')

把a对象删除不用了

这是文件并没有关闭，文件没有关闭会占内存。

应该在删除对象是进行一个析构方法，用操作系统将文件关闭在删除文件

class A:
    def __init__(self):
        pass
        self.f = open('文件','w')
    def __del__(self):
        self.f.close()
        print('执行我了')

a = A()
del a
print(a)
print('aaa')

4.__new__?

__new__ 构造方法

实例化对象的时候

创建对象的过程

init 初始化

　　 设计模式 —— 单例模式

 单例模式 就是 一个类 只能有一个实例
# class A:pass
# a = A()
# b = A()
# print(a)
# print(b)

# class B:
#     __instance = None
#     def __new__(cls, *args, **kwargs):
#         if cls.__instance is None:
#             obj = object.__new__(cls)
#             cls.__instance = obj
#         return cls.__instance
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#     def func(self):
#         print(self.name)
# a = B('alex',80)
# b = B('egon',20)
# print(a)
# print(b)
# print(a.name)
# print(b.name)




5.__item__系列

# item
# dic = {'k':'v'}
# print(dic['k'])


# class Foo:
#     def __init__(self,name):
#         self.name=name
#
#     def __getitem__(self,item):
#         return  self.__dict__[item]
#
#     def __setitem__(self, key, value):
#         self.__dict__[key]=value
#
#     def __delitem__(self, key):
#         print('del obj[key]时,我执行')
#         self.__dict__.pop(key)

# f = Foo('alex')
# # f.name = ...
# print(f['name'])    # f.__getitem__('name')
# f['age']  = 18      # 赋值
# print(f.age)         # 自带的语法
# print(f['age'])     # 修改
# f['age']  = 80
# print(f['age'])     # 通过实现__getitem__得到的
# del f['age']
# print(f.age)         # 删除

# class Foo:
#     def __init__(self,name):
#         self.name=name
#     def __delattr__(self, item):
#         print('del obj.key时,我执行')
#         self.__dict__.pop(item)
# f = Foo('alex')
# del f.name     #相当于执行了__delattr__
# # delattr(f,'name')

面试题：　　

# 写一个类 定义100个对象
# 拥有三个属性 name age sex
# 如果两个对象的name 和 sex完全相同
# 我们就认为这是一个对象
# 忽略age属性
# 做这100个对象的去重工作
class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __hash__(self):
        # hash算法本身就存在了 且直接在python中就能调用
        # 姓名相同 性别相同的对象的hash值应该相等才行
        # 姓名性别都是字符串
        return hash(self.name+self.sex)
    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:
            return True
# python2.7
# 去重 set
# hash方法
# set([obj,obj])   unhashable
# hash算法  一个值 进行一系列的计算得出一个数字在一次程序执行中总是不变
            #来让每一个不同的值计算出的数字都不相等
obj_lst = []
obj_lst.append(Person('alex',80,'male'))
obj_lst.append(Person('alex',70,'male'))
obj_lst.append(Person('alex',60,'male'))
obj_lst.append(Person('boss_jin',50,'male'))
obj_lst.append(Person('boss_jin',40,'male'))
obj_lst.append(Person('boss_jin',30,'male'))
obj_lst.append(Person('nezha',20,'male'))
obj_lst.append(Person('nezha',10,'male'))
obj_lst = set(obj_lst)
for obj in obj_lst:print(obj.name)
# set对一个对象序列的去重 依赖于这个对象的两个方法 hash eq


# 可hash顺带着写的
# eq来做判断

# key hash 数字 --》 内存地址 --》 value
# set hash 数字 --》 内存地址 --》 set中的元素
# 'aaa' hash

# java
# set去重 一个容器中 有相同值的内容  __eq__
# 当你这个容器中有10000个元素的时候 我判断第10000个元素
# hash算法
    # 'abc'
    # 'bca'
# set对一个对象序列的去重 如何判断这两个值是否相等
# 值a进行hash --> 存值
# 值b进行hash --> 判断值是否相等 -相等-> 说明是一样的
                                #-不相等-> 在开辟一个空间 来存放b