# 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))

# 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__

# 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

day__23（特殊方法）