day23 特殊方法 面向对象的总结

总结 请看下面代码

# class A:
#     name = 'alex'
#
#     def func(self,age):
#         # print('in func')
#         print(self,age)
#
# # print(A.__dict__)
# # print(A.name)
# # A.func('alex',12)
# a1 = A()


# class B:
#     name = 'alex'
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#     def func(self):
#         print(self)
#
# a1 = B('alex', 1000)

# 空间以及查询顺序

# class C:
#     name = 'oldboy'
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#     def func(self):
#         print(self)
#
# a1 = C('alex', 1000)
# print(a1.name)
# 继承
# class A:
#     name = 'oldboy1'
#     def func(self,area,school):
#         print(area,school)
# # A.func(111,'深圳','oldboy')
# class C(A):
#     age = 1000
#     def __init__(self,age):
#         self.age = age
#
#     def func(self,area1,school1):
#         # A.func(self,area1,school1)
#         # super().func(area1,school1)
#         print(666)
#
# c1 = C(1000)
# # print(c1.name)
# c1.func('上海','老男孩')



# 新式类:
# class A:
#     def func(self):
#         print('A')
#
# class B(A):
#
#     def func(self):
#         print('B')
#
# class C(A):
#     def func(self):
#         print('C')
#
# class E(C):
#     def func(self):
#         print('E')
#
# class D(B,E):
#     def func(self):
#         print('D')
#
# class F(D,E):
#     def func(self):
#         print('F')
#
# d = F()
# d.func()
# print(F.mro())


# class A :
#     def __init__(self,name):
#         self.name = name
#     def func(self,obj):
#         self.obj = obj
#
# a1 = A('alex')
# a1.func(a1)
# print(a1.obj.name)

er python的特殊方法

 class F:
#     pass
# class A(F):
#     pass
# class B(A):
#     pass
# class C:
#     pass
# obj1 = B()
# print(isinstance(obj1,B))
# print(isinstance(obj1,A))
# print(isinstance(obj1,F))
# isinstance 这个对象是本类实例化的,或者是此类的派生类实例化出来的.
# print(isinstance(obj1,C))

# class F:
#     pass
#
#
# class A(F):
#     pass
#
#
# class B(A):
#     pass
#
#
# class C:
#     pass

# print(issubclass(C,B))
# issubclass:判断一个类是否是另一个类的派生类.
# print(issubclass(B,A))
# print(issubclass(B,F))

# __len__, __hash__ __str__ __repr__
# print(dir(list))
# print(dir(str))

# l1 = list([1, 1, 2, 3])  # 是list类实例化的一个对象
# print(len(l1))  # 对一个对象len(),则他会执行这个对象从属于的类 的__len__方法

# class A:
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#
# a1 = A('oldboy',1000)
# print(len(a1))

# class A:
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#
#     def __len__(self):
#         return len(self.__dict__)
#
# a1 = A('oldboy',1000)
# print(len(a1))
# 如果对一个对象进行len()操作,
# 他会找到对象从属于的类中的__len__方法,并且此方法中必须要有数字的返回值.
# __hash__

# class A:
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#
#     # def __len__(self):
#     #     return len(self.__dict__)
#     def __hash__(self):
#         return 100
# a1 = A('oldboy',1000)
# print(hash(a1))

#  __str__    __repr__
# class A:
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#
#     def __str__(self):
#         return 'alex'
# a1 = A('oldboy',1000)
# # print(a1)  # <__main__.A object at 0x000000000237E908>
# print(str(a1),type(str(a1)))  # '<__main__.A object at 0x000000000237E908>'
# class A:
#
#     def __init__(self):
#         pass
#     def __str__(self):
#         print(666)
#         return '太白'
# a = A()
# print(a)  # 打印对象,就会触发类中__str__方法
# str(a) # str(a),就会触发类中__str__方法
# print('打印此类对象:%s' % a)  # 格式化输出 '%s'a

# class A:
#     def __init__(self):
#         pass
#     def __repr__(self):
#         return '太白'
# a = A()
# print(repr(a))
# print('%r'%a)

# msg = '飞哥说他是%s,他真%r,%s,%s'  % ('sb','NB',666,6.66)
# print(msg)

# *** __call__
# class A:
#     def __init__(self):
#         pass
#     def func(self):
#         print(111)
#
#     def __call__(self, *args, **kwargs):
#         '''各种代码'''
#         # print(666)
#         print(args)
#         return 'wusir'
# a1 = A()
# print(a1(1,2,3))  # 对象() 自动执行类中的__call__方法

# __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
# a1 = A()
# b1 = A()
# print(a1 == b1)  # 对一个类实例化的两个对象进行比较运算的时候,他会自动触发类中的__eq__
# a = 1
# b = 2
# c = 3
# def func():
#     print(a)
# func()
# __del__  析构方法

# python垃圾回收机制
# :文件中你创建的所有的变量,类等等.执行完毕之后,
# 一段时间内如果没有用到, 他会自动在内存中去除.
# 深入研究: 他会将你的所有变量,类等等做个标记,在一段时间之内,没有被调用,则就会自动回收.

# __del__  析构方法

# class A:
#     def __init__(self):
#         pass
#     def __del__(self):
#         print(666)
# a1 = A()

# *** __new__ : object产生并返回一个对象空间.
# 自己定义的__new__ 第一个参数自动接收类空间.

# 执行顺序:先执行__new__方法,然后在执行__init__方法
# class A:
#     def __init__(self):
#         self.x = 1
#         print('in init function ')
#
#     def __new__(cls, *args, **kwargs):
#         print(cls)  # <class '__main__.A'>
#         print('in new function ')
#         # return object.__new__(cls)  # 调用object类中的__new__方法,产生一个真正的对象空间
#         return super().__new__(cls)  # 返回给 A()
# object
# a1 = A()
# print(a1)
# print(a1)
# 类名() 自动执行类中__new__ 类中没有,则找到object
# 找到__new__ 这个方法是产生一个对象空间,自动执行类中的__init__,给这对象空间封装一些属性,
# 最后返回给A() 然后给 变量a1
# print(a1.x)

# class A1:
#     def __new__(cls, *args, **kwargs):
#         '产生对象空间'
#         pass
#
# class B(A1):
#     def __init__(self):
#         self.x = 1
#     def __new__(cls, *args, **kwargs):
#         print('B1')
# b1 = B()
# print(b1)
# 最详细版本:
'''
1,类名() 执行 __new__方法,先从自己的类中寻找,
如果没有找到,则从父类(直到object类)寻找,然后从object的__new__产生一个对象空间,返回给类名().
2,对象空间一旦产生并返回.则自动执行__init__方法,给这个对象空间封装属性.
3,最终你得到是封装好属性的对象空间.

'''

# 设计模式: 单例模式. 最简单的设计模式. 面试必考,默写.
# 单例模式: 对一个类是能实例化一个对象.
# class A:
# #     pass
# # a1 = A()
# # b1 = A()
# # c1 = A()
# # d1 = A()
# # print(a1,b1)

# class A:
#     __instance = None
#     def __new__(cls, *args, **kwargs):
#         if A.__instance is None: # 第一次进入,满足这个条件
#             obj = object.__new__(cls)  # 利用object 创建一个对象空间 给了obj
#             A.__instance = obj  # 我将类的私有静态字段 __instance 重新赋值了 对象空间obj
#         return A.__instance
# a1 = A()
# b1 = A()
# c1 = A()
# print(a1,b1,c1)

# *** item
# class Foo:
#     def __init__(self, name, age, sex):
#         self.name = name
#         self.age = age
#         self.sex = sex

    # def __getitem__(self, item):
    #     # print(self.__dict__[item])
    #     # if hasattr(self,item):
    #     #     return getattr(self,item)
    #     # else:
    #     #     return '没有此属性'
    #     return getattr(self, item, '没有此属性')
    # #
    # def __setitem__(self, key, value):
    #     print(key,value)
    #
    # #
    # def __delitem__(self, key):
    #     print(key)

#     def __delattr__(self, item):
#         print(item)
#         print('del obj.key时,我执行')
#
#
#
# f1 = Foo('alex', 12, '男')
# print(f1['name'])  # 对一个对象使用f1['name1']这种方法,自动触发__getitem__这个方法,将'oldboy123' 传到这个方法中.
# print(f1['age1'])
# f1['name1'] = 'wusir666'
# del f1['fkjdslfjdslafj']
#  如果你对对象进行相似的字典的操作,就会主动触发类中__getitem__ __setitem__ delitem__

# del f1.name
# del f1.aaaaaa
#