实例属性：和具体的某个实例对象有关系

并且一个实例对象和另外一个实例对象是不共享属性的

类属性：类属性所属于类对象

并且多个实例对象之间共享同一个类属性，在类定义的时候只定义一次

#encoding=utf-8
#多继承的特点
class Base(object):
	def test(self):
		print("----base")
class A(Base):
	def test(self):
		print("-----A")
class B(Base):
	def test(self):
		print("----B")
class C(Base):
	def test(self):
		pass
class D(A,B):
	def test(self):
		print("----D")
class E(A,C):
	def test(self):
		pass 
e=E()
e.test()
print(E.__mro__)
#类名.__mro__:根据C3算法计算到的，显示继承的顺序E-A-C-Base,决定了调用一个方法时，搜索父类的顺序
#如果在某个类中找到了方法，那么久停止搜索

#多态的概念：定义时的类型和运行的类型不一样，此时就成了多态
#python语言是动态的
#是弱类型语言，定义变量的时候不需要定义变量的类型
class Attribute:
	num=0  #这里定义了一个类的属性，类属性
	def __init__(self,new_name):#实例方法
		self.name=new_name #这里一个定义了一个属性，直接赋值，实例属性
		Attribute.num+=1 #对类属性进行操作
	@classmethod
	def add_num(cls):#定义一个类方法 cls表示类，代表类，可以换个名字
		cls.num=100  #改变类属性 	
	@staticmethod
	def printSome():
		print("can print something")	

a1=Attribute('property')
a1.add_num() #可以通过类的名字调用此方法，也可以通过类创建的对象调用此方法
Attribute.add_num()
#调用静态方法，可以完成一个类方法和实例方法之外的简单工作
Attribute.printSome() #通过类名调用此方法
a1.printSome() #通过类对象调用此方法，都可行

#这里有个特点，实例方法参数写（self），类方法写@classmethod,参数(cls)
#x写@staticmethod,可以没有任何参数

#Attribute是一个类对象，创建的话会创建一个实例对象
#实例属性：和具体的某个实例对象有关系
#并且一个实例对象和另外一个实例对象是不共享属性的
#类属性：类属性所属于类对象
#并且多个实例对象之间共享同一个类属性，在类定义的时候只定义一次

#实例方法、类方法、静态方法

__new__()方法：完成了创建，__init__（）完成了初始化

#encoding=utf-8
#工厂方法模式
#__new__方法：__new__至少有一个参数cls，代表要实例化的类，此参数在实例化时由python解释器自动提供
#__new__方法必须有返回值，返回实例化出来的实例
#__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些
#其他初始化的动作，__init__不需要返回值
#可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节
#复习一下学过的__开头的方法
class Teacher(object):
	"""docstring for Teacher"""
	def __init__(self):
		self.arg = 1
	def __del__(self):
		print("将对象删除后执行的操作")
	def __str__(self):
		print("打印对象时执行的操作")
	def __new__(cls):#这里有参数,把类当作参数传输
		print("执行new方法")
	

tea=Teacher() #这时候调用了一个方法，__new__
#运行结果：执行new方法
#1 创建一个对象；2 调用__init__()方法 3返回对象的引用
#之前在没有写new方法是时候，自动调用父类的object类的__new__()方法，现在上面例子是重写了__new__()方法，只是完成了打印功能，并没有实现创建对象
#
class Student(object):
	"""docstring for Student"""
	def __init__(self):
		self.arg = 1
	def __del__(self):
		print("将对象删除后执行的操作")
	def __str__(self):
		print("打印对象时执行的操作")
	def __new__(cls):#这里有参数,把类当作参数传输
		print("执行new方法")
		object.__new__(cls)#仍然调用父类的__new__方法，这里的cls是要创建的对象的类
		print("调用父类执行new方法")
 
stu=Student()#1 调用__new__方法来创建对象 2 调用__init__,刚创建的对象是参数self 3 返回对象的引用
#像C++中的构造函数：完成了创建和初始化，在python中分成了两个方法，分别完成创建__new__和初始化__init__
'''显示的内容：
执行new方法
将对象删除后执行的操作
调用父类执行new方法
'''

创建单例模式

#encoding=utf-8
#创建一个单例模式，即，始终打开的都是一个，若已创建则不再创建
class StudentA(object):
	__instance=None#私有属性，此类内部可以访问
	def __new__(cls):
		if cls.__instance==None:
			cls.__instance=object.__new__(cls)
			return cls.__instance
		else:
			return cls.__instance

stu=StudentA()

只能初始化一次

#encoding=utf-8
#创建一个单例模式，即，始终打开的都是一个，若已创建则不再创建
class StudentA(object):
	__instance=None#私有属性，此类内部可以访问
	def __new__(cls,name):#因为__init__有参数，所以这里也需要给定参数
		if cls.__instance==None:
			cls.__instance=object.__new__(cls)
			return cls.__instance
		else:
			return cls.__instance
	def __init__(self,name):
		self.name=name

stu=StudentA("hummy")#这种方法在__new__方法中进行了限定，只开一个单例模式，但是初始化的时候则会每次创建都会初始化
print(id(stu))
print(stu.name)
stud=StudentA("bohy")
print(id(stud))
print(stud.name)
'''显示结果
18468592
hummy
18468592
bohy
'''
class StudentB(object):
	__instance=None#私有属性，此类内部可以访问
	__initFlag=False
	def __new__(cls,name):#因为__init__有参数，所以这里也需要给定参数
		if cls.__instance==None:
			cls.__instance=object.__new__(cls)
			return cls.__instance
		else:
			return cls.__instance
	def __init__(self,name):
		if StudentB.__initFlag==False:
			StudentB.__initFlag=True
			self.name=name
stu=StudentB("hummy")#这种方法在__new__方法中进行了限定，只开一个单例模式，但是初始化的时候则会每次创建都会初始化
print(id(stu))
print(stu.name)
stud=StudentB("bohy")
print(id(stud))
print(stud.name)
'''显示的结果
18477128
hummy
18477128
hummy
'''