# 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
