python的class类

一.简介

　　类(Class)：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

　　对象(instance/object)：包括两个数据成员（类变量和实例变量）和方法，对象就是方法或者类的具体示例

　　　　类变量是所有对象共有，其中一个对象的值改变，其他对象得到的是改变后的效果，是定义在类中的属性，可使用全大写来命名

 　　　   实例变量则属于对象私有，每个实例单独拥有的变量，某个对象的值发生改变，不影响其他对象

　　方法：类中定义的函数，第一个参数必须是self,这个参数代表实例对象本身，不接受传入值。

　　局部变量：定义在方法中的变量，只作用于当前实例的类

　　类的属性：类中定义的变量和方法都是类的属性

　　实例化(对象):通过类产生对象的过程为实例化，格式为：对象名=类名()；对象调用属性和方法的格式为对象名.属性和对象名.方法；可以将一个类实例化成多个对象，这些对象间的属性和方法时相互独立，互不干扰的。

二.封装

　　封装：将内容封装到某个地方，需要使用的时候再去调用封装在某处的内容

　　实例化：实例化就是创建一个该类的对象，在类对象名称后面加一个括号就调用类的实例化方法，完成实例化。实例化后会自动调用__init__方法

　　__init__方法的作用是对示例进行初始化，当创建了这个类的实例时就会自动调用该方法；

　　这个方法的第一个形式参数必须留给self，其他参数随意；self就是指代摸一个实例自身

　　该方法不能有返回值只能返回return None

　　类实例化后，得到一个实例对象，通过instance.class_name()方式进行调用，实例对象就会被绑定到方法上

　　__init__中所定义的变量，是保存在实例上的，并不是类上，所以称为实例变量，实例变量是每个实例自己的变量，是实例独有的

　　类变量是类的变量，是所有实例共享的属性和方法

示例1：

封装：

class MyClass():   #class为关键字，表示开始创建类；MyClass是类名

    "my class"      #'类的帮助信息'类文档字符串，可通过ClassName._doc_查看
    print('in my class')
    xx="abc"                    #一个类变量，它的值可在这个类的所有示例之间共享，可在类内和类外通过ClassName.xx访问
    def __init__(self,x,y):     #self代表类的实例，self在定义类的方法时是必须的，但调用时不必传入相应的参数
　　　　print('in my class init')       
　　　　self.x=x        
　　　　self.y= y        
　　　　print(x+y)    
　　def foo(self):     #foo  类的属性
　　　　print('in foo')
　　　　return "my class re"

调用：print(myabs.xx)  #执行成功，类变量是共用的
　　　print(myabs.x)   #执行成功，实例变量是实例独有的
　　  print(MyClass.xx)  #执行成功，类变量是共用的
　　  print(MyClass.x)   #执行失败，实例变量不能共享

返回：in my class   #每次调用均会执行
　　  abc   #调用类变量xx
调用：print(MyClass.foo)
返回：in my class
　　  <function MyClass.foo at 0x00000140993099D0>
调用：print(MyClass.__doc__)  #输出类的帮助文档
返回：in my class
　　  my class
调用：myabs=MyClass(2,3)   #调用myclass类创建对象myabs
返回：in my class
　　　in my class init  #调用类则需执行init方法
　　  5　　　            #输出init的结论
调用：myabs=MyClass(2,3)   #调用类创建对象myabs
　　  print(myabs.foo())  #调用具体的foo方法
返回：in my class         #调用类输出
　　　in my class init    #调用类时，执行init的输出
　　　5                   #调用类时，执行init的输出
　　　in foo              #调用方法foo的输出
     my class re         #调用方法foo的返回结论
调用：print(MyClass.foo(myabs))

返回：in my class         #调用类输出
　　　in my class init    #调用类时，执行init的输出
　　　5                   #调用类时，执行init的输出
　　　in foo              #调用方法foo的输出
     my class re         #调用方法foo的返回结论

示例2：

封装：

class MyClass():
    "my class"      #'类的帮助信息'类文档字符串，可通过ClassName._doc_查看
    print('in my class')   #
    xx="abc"                    #一个类变量，它的值可在这个类的所有示例之间共享，可在类内和类外通过ClassName.xx访问
    def __init__(self,x,y):     #self代表类的实例，self在定义类的方法时是必须的，但调用时不必传入相应的参数
　　　　self.x=x          #初始化实例属性
　　　　self.y= y          #初始化实例属性
　　　　print(x+y)    
　　def foo(self,c):     #有单独的变量
　　　　print(c)
　　　　return "my class re"

调用：myabs1=MyClass(2,3) #调用类创建对象myabs1，传入初始化实例所需要的参数值，将2和3分别封装在myabs1/self的x和y属性中

　　　myabs2=MyClass(4,5) #调用类创建对象myabs1，将4和5分别封装到myabs2/self的x和y属性中，每个对象都有x和y属性

　　  myabs1.foo(99)   #执行成功，传入方法需要的参数，执行具体的方法，返回99
　　  MyClass.foo(99)  #执行失败，foo缺少参数
返回：99    
　　  my class re
三.调用封装
1.通过对象直接调用被封装的内容

class MyClass():
    "my class"      
    print('in my class')   
    xx="abc"                   
    def __init__(self,x,y):
　　　　self.x=x          
　　　　self.y= y
myabs1=MyClass(4,5)  #生成对象myabs1

print(myabs1.x)  #直接调用myabs1对象的x属性，打印4
print(myabs1.y)  #直接调用myabs1对象的y属性，打印5

myabs2=MyClass(99,100)  #生成对象myabs2
print(myabs2.x)  #直接调用myabs1对象的x属性，打印99
print(myabs2.y)  #直接调用myabs1对象的y属性，打印100
2.通过self间接调用被封装的内容

class MyClass():
    "my class"      
    print('in my class')   
    xx="abc"                   
    def __init__(self,x,y):
　　　　self.x=x          
　　　　self.y= y
　　　def abs(self):
　　　　 print(self.x)
　　　　 print(self.y)
myabs1=MyClass(4,5)  #生成对象myabs1
myabs1.abs() #打印4和5；默认将myabs1传给self参数，即myabs1.abs(myabs1)，此时方法内部self=myabs1，self.x为4，self.y为5

print(myabs1.x)  #直接调用myabs1对象的x属性，打印4
print(myabs1.y)  #直接调用myabs1对象的y属性，打印5

myabs2=MyClass(99,100)  #生成对象myabs2
print(myabs2.x)  #直接调用myabs1对象的x属性，打印99
print(myabs2.y)  #直接调用myabs1对象的y属性，打印100

四.对象属性
属性即变量，python中的函数、类、类的实例都是对象，每个不同的对象都有不同的属性
1.属性的类型

• __dict__ : 类的属性（包含一个字典，由类的数据属性组成），类的属性保存在类的__dict__中，类的属性所有实例都可以访问，实例的属性保存在实例的　　                __dict__中，实例的属性是自己的，类或其他实例都不可以访问
• __doc__ :类的文档字符串
• __name__: 类名
• __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
• __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

　2.属性的访问

实例.__dict__[变量名] 和 实例.变量名 都可以访问到实例自己的属性（但两种访问是有本质区别的）
3.属性操作

emp1.age = 7  # 添加一个 'age' 属性
emp1.age = 8  # 修改 'age' 属性
del emp1.age  # 删除 'age' 属性

五.继承
1.简介
将多个类共有的方法提取到父类中，子类仅需要继承父类而不必一一实现每个方法。
当新建的类不用继承其他类时，类名后面可以不加().
语法：

class 派生类名(基类名)
    ...
2.父类的调用
在调用父类的方法时，需要加上父类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：
class SubClassName (ParentClass1[, ParentClass2, ...]):
    ...

示例1：封装

class Parent:  # 定义父类
    parentAttr = 100
    def __init__(self):  #父类初始化
        print("调用父类构造函数")
    def parentMethod(self):   #父类方法
        print('调用父类方法')
    def setAttr(self, attr):
        Parent.parentAttr = attr
    def getAttr(self):
        print("父类属性 :", Parent.parentAttr)
class Child(Parent):  # 定义子类
    def __init__(self):
        print("调用子类构造方法")
    def childMethod(self):
        print('调用子类方法')
c = Child()  # 实例化子类，返回：调用子类构造方法
c.childMethod()  # 调用子类的方法，返回：调用子类构造方法
c.parentMethod()  # 调用父类方法，返回：调用父类方法
c.setAttr(200)  # 再次调用父类的方法 - 设置属性值
c.getAttr()  #再次调用父类的方法 - 获取属性值，返回：父类属性 : 200