一.类的存储与实例对象的存储
类定义好后会为类开辟一块空间。
实例化一个类后会将初始化的数据和对象名一并传入类中，并在类的外面开辟一块空间用于存数据。
注意：初始化时会将对象当形参（self）传入类
实例对象不会将类中共同的方法或变量的存下来，而是通过self进行访问。
二.变量的分类
实例属性（静态属性）只对该实例对象有作用域
实例方法（动态属性）只对该实例对象有作用域
类变量 对所有的实例对象都有作用域，只存放在类里面
注意：当类变量与实例变量矛盾时，实例变量有效，通过实例改类变量时，是将类变量复制一份到该实例对象中 ，将复制后的进行修改。但list不一样，通过实例改类变量的list时就是在类中修改。
二.构造函数
class Dog: def __init__(self,name,age,salary)： self.name = name self.age = age self.salary = salary#等号的左右的名称可以不同，左边是属性名，右边是形参名 def bulk(self,voice) print('%s is bulking,,,,%s' %s(self.name,voice)) def __del__(): print('我是析构函数') taidi = Dog(taidi,3,2300) taidi.bulk()
作用：实例化类时，进行初始化，并开辟一块空间。但不会将类中的方法都复制一边
实例化类时构造函数会自动执行
三.析构函数
但不能有参数，实例释放和销毁时自动执行，进行扫尾工作，如关闭数据库链接。
四.私有属性，私有方法
私有属性或方法名前加 __（双下划线）外部不能访问，但可以通过类中其他的方法访问。
五.继承
在构造一个类时将要继承的父类当做参数传入。
class school_member(object): #父类，object是基类，是新式类的写法 def __init__(self,name,age,id): self.name=name self.age=age self.id=id def enroll(self): #注册函数 print('welcom to %s"%self.name) class student(school_member): def __init__(self,name,age,id,money): #school_member.__init__(self,name,age,id) super(sudent,self).__init__(name,age,id) self.money=money
六.多继承
多继承的顺序，分为广度优先和深度优先
Python3中新式类和经典类都是广度优先
Python2中 新式类是广度优先 经典类是深度优先
class A(object): def __init__(self): print('A') class B(A): def __init__(self): print('B') class C(A): def __init__(self): print('C') class D(B,C): def __init__(self): print('D')
说明：B,C继承了A,而D继承B,C
广度优先：先在B中找有没有构造函数，没有再在C中找，最后在A中找
深度优先：在B中找没有再再A中找，后面依次类推。
多继承的顺序是按参数从左向右。并依次寻找是否有构造函数，有了就不执行后面的构造函数，前面构造的属性，可以在另一个父类中调用。
class School(object): def __init__(self,name,addr): self.name=name self.addr=addr self.students=[] self.teachers=[] self.couses=[] self.greens=[] def encoll(self,stu_obj): self.students.append(stu_obj) print("欢迎%s来到%s"%(stu_obj.name,self.name)) def hair(self,teacher_obj): self.teachers.append(teacher_obj) def couse(self,cou_obj): self.couses.append(cou_obj) def green(self,gren_obj): self.greens.append(gren_obj) class Sch_member(object): def __init__(self,name,sex,age): self.name=name self.sex=sex self.age = age class Teacher(Sch_member): def __init__(self,name,sex,age,salary,couse_obj,green_obj,id,sch_obj): super(Teacher, self).__init__(name.sex,age) self.salary=salary self.couse=couse self.green=green self.id=id self.school=sch_obj def teach(self): print("%s teaching the class %s of %s"%s(self.name,self.green,self.couse)) class Student(Sch_member): def __init__(self,name,sex,age,id,green_obj,sch_obj): # type: (object, object, object, object, object, object) -> object super(Student,self).__init__(name,sex,age) self.id=id self.green=green_obj self.school=sch_obj def choose_couse(self,name,addr,name1,teacher_obj,time,priser,green_obj): print("请选择课程") self.couses.append(Couse(name,addr,name1,teacher_obj,time,priser,green_obj)) class green(School): def __init__(self,name,addr,name1,teacher_obj,couse_obj): super(green, self).__init__(name,addr) self.teacher=teacher_obj self.couse=couse_obj class Couse(School): def __init__(self,name,addr,name1,teacher_obj,time,priser,green_obj): self.name=name1 super(Couse, self).__init__(name,addr) self.teacher=teacher_obj self.time=time self.priser=priser self.green=green_obj B_sch=School("Beijing universtry","beijing") S_sch=School("fudan universtry","shanghai") g_01=green("Beijing universtry","beijing","苹果班",teacher1,c_language) B_sch.green(g_01) g_02=green("fudan universtry","shanghai","仙女班",teacher2,python) S_sch.green(g_01) c_language=Couse("Beijing universtry","beijing","c",teacher1,"8:00-12:00",12000,g_01) B_sch.green(c) python=Couse("fudan universtry","shanghai","Python",teacher2,"8:00-12:00",12000,g_02) S_sch.green(python) teacher1=Teacher("alex","男",22,21000,c_language,g_01,1001,B_sch) B_sch.hair(teacher1) teacher2=Teacher("oldboy","男",32,41000,python,g_02,10002,S_sch) S_sch.hair(teacher2) '''stu1 = Student("xiaoling","男",23,0001,g_01,B_sch) B_sch.encoll(stu1) stu2 = Student("hanshangyan","女",23,0002,g_02,S_sch) S_sch.encoll(stu2)'''
七.多态
一个接口，多个实现，即通过一个接口的调用实现多个功能
class animal(object): def __init__(self,name,age) self.name = name self.age = age def eat(self): print("%s is eating %s"%(self.name,sself.food)) '''多态的实现''' @staiticmethod def animal_food(obj): obj.eat() class Dog(animal): def __init__(self,name,age,food) super(Dog,self).__init__(name,age) self.food = food d1=Dog(taidi,2,bone) d2 = Dog(bianmu,3,chiken) animal.eat(d1) animal.eat(d2)
八.静态方法，类方法，属性方法
1.静态方法 @staticmethod
名义上是类的方法，但与类没有什么联系，除了必须要通过类的实例调用，但该方法不能调用类或实例中的任何属性，同时它可以没有参数，正常的方法必须至少有一个self参数
2.类方法 @classmethod
只能访问类的变量，不能访问实例属性
3.属性方法 @porperty
将一个方法函数变成属性，同时可以通过@方法名.setter进行设置 用@方法名.deltter进行删除属性，（设置属性的本质是在类属性一开始写好，但不传参，通过该方法进行传参），
class perpol(object): n= "i am class var" def __init__(self,name): self.name = name self.__food @staticmethod def test1(): print("in the static") @porperty def eat(self): print("%s is eating %s"%(self.name,self.__food)) @eat.setter def eat(self,food): print("set porperty done") self.__food = food @eat.deltter def eat(self): del self.__food p1 =perpol("alex",23) p1.test1() p1.eat p1.eat = "包子"#进行属性设置时自动调用 del p1.eat#进行删除操作时自动执行上面的函数
九.各种内置方法
1.__dict__
返回所有的方法与属性，当是类名时返回类中的属性与方法，若是实例时返回值实例的 属性
2.__module__/__class__
__module__ 返回导入该类对应的模块
__class__ 返回模块和类名（路径）
3.__setitem__/getitem__/__delitem__
给类添加字典的功能，
class Foo(object): def __init__(self,name): self.name=name self.date={} def __setitem__(self,key,value): print(have set done) self.date[key]= value def __getitem__(self,key): print(self.date[key]) def __delitem__(self,key): del self.date[key] f=Foo('alex') f[age]=23#自动调用__setitem__ print(f[age])#调用__getitem__
4.__doc__
打印类名时会打印出注释语句
5.__str__
打印实例名时会打印改函数的返回值，用于了解实例对象
6.__call__
class Foo(object): def __call__(self): print(in the call) f=Foo() f()#在实名后加括号调用call函数
在类后面加括号自动执行__init__，在实例名后加括号自动执行__call__
类的类是type
通过type方法来定义一个类，将没有关系的函数通过type联系起来了
def __init__(self,name,age): self.name=name self.age=age def information(self): print('the name is',name) Foo=type('Foo',(object,),{'__init__':__init__, 'fanc':information}) f=Foo('高佳雪',20) f.information（）
7.__metaclass__ 类中的一个属性__metaclass__表示该类由谁实例化创建，因此可以为__metaclass__设置一个type类的派生类
class MyType(type): def __init__(self,what,bases=None,dict=None): surper(MyType,self).__init__(what,bases,dict) def __call__(self,*args,**kwargs): obj=self.__new__(self,*args,**kwargs) self.__init__(obj) class Foo(object): __metaclass__ = MyType def __init__(self,name): self.name=name def __new__(cls,*args,**kwargs):#cls是MyType中的obj return object.__new__(cls,*agrs,**kwargs) obj = Foo()
类的实例实际是通过__new__方法创建的self就是__new__函数的返回值，即为实例开辟的一块空间
十.反射
通过字符串映射或修改程序运行时的状态，属性，方法
1.getattr( object, name, default=none ) 根据字符串获取obj对象里对应的方法的内存地址
2.hasattr( object, name_str ) 判断一个对象object里是否有对应的name_str字符串对应的属性或方法
3.setattr(x ,y ,v) x是实例对象，y是字符串名，v是方法或属性
4.delattr(x, y ) x，y同上
class Foo(object): def __init__(self,name): self.name=name f = Foo('alex') def bulk(self): print('%s is bulking',%self.name) choice = input("输入方法或属性").strip() if hasatter(f,choice): getatter(f,choice)#如果是方法可以改为 choice = getatter(f,choice) choice(f) else: setatter(f,choice,bulk)#f.choice=bulk func = getatter(f,choice) func(f)
