python类class语句和实例属性

1 python类class语句和实例属性

点号运算进行属性继承搜索，小括号运算产生实例对象，或调用类方法。

1.1 python类class语句

用法

class 类名(超类1,...,超类n):
    #等号赋值语句
    var = 'value'
    #def 赋值语句
    def classmethod(self[,var1,...,varn]):
        self.name = var1
        pass

描述

（1）模块导入或执行时，执行class语句生成类对象，并且赋值给class的头部类变量名。

（2）类内顶层赋值语句的变量成为类对象属性，称为类成员变量。

（3）通过“类名.属性名”访问类的成员属性。

（4）类方法第1个参数，通常为self。

文件

E**😗*\documents\F盘\testclass.py

class MyClass:
    s = '梯阅线条'
    def setData(self,value):
        self.data = value
        
    def display(self):
        print(self.data)
        
if __name__ == '__main__':
    print('MyClass={}'.format(MyClass))
    print('MyClass.s={}'.format(MyClass.s))
    print('MyClass.setData={}'.format(MyClass.setData))
    print('MyClass.display={}'.format(MyClass.display))

示例

# 打开cmd，执行下面示例
E:\documents\F盘>python testclass.py
MyClass=<class '__main__.MyClass'>
MyClass.s=梯阅线条
MyClass.setData=<function MyClass.setData at 0x01B3C780>
MyClass.display=<function MyClass.display at 0x01B3C810>

1.2 python实例对象和属性

描述

（1）小括号运算：小括号()调用类对象即：类名()，产生实例对象。

（2）点运算：实例对象继承类对象，通过“实例名.类属性”访问类对象属性。

（3）self：实例调用类方法，第一个参数self自动接收实例对象，为当前调用的主体。

（4）self：类调用方法，需显式给self传递参数值。

（5）self：类可以产生多个实例，类方法通过self区别当前调用的实例。

（6）属性设置：类外通过实例名设置属性，类内通过self设置属性。

（7）类数据属性：不可变对象，各自维护互不影响；可变对象，全部实例共用，一改全改。

（8）实例数据属性：相互独立，其他实例不可访问。

文件

E**😗*\documents\F盘\testclass.py

class MyClass:
    s = '梯阅线条'
    y = [1,2,3]
    def setData(self,value):
        self.data = value
        
    def display(self):
        #类通过self指向当前调用的实例
        print('display.self.data={}={}'.format(self.data,self))
        
if __name__ == '__main__':
    #类产生多个不同实例
    c1=MyClass() 
    c2=MyClass()
    print('c1={}'.format(c1))
    print('c2={}'.format(c2))
    
    c1.setData('c1')
    c2.setData('c2')#类内通过self设置属性
    c1.display()
    c2.display()
    c2.data='1'#类外通过实例名设置属性
    #通过实例名调用类方法，自动将当前实例传给self
    c2.display()
    #通过类名调用类方法，需要显式给self传参数
    MyClass.display(c2)
    
    #类数据为不可变对象,初始相同
    print('c1.s={}'.format(c1.s))
    print('c2.s={}'.format(c2.s))
    print('MyClass.s={}'.format(MyClass.s))
    
    #类数据为不可变对象,修改后互不影响
    c1.s = 'c1s'
    c2.s = 'c2s'
    MyClass.s = 'MyClass'
    print('c1.s={}'.format(c1.s))
    print('c2.s={}'.format(c2.s))
    print('MyClass.s={}'.format(MyClass.s))
    
    #类数据为可变对象,初始相同
    print('c1.y={}'.format(c1.y))
    print('c2.y={}'.format(c2.y))
    print('MyClass.y={}'.format(MyClass.y))
    
    #类数据为可变对象,修改后相互影响，指向同一个值
    c1.y[0] = 'c1y'
    c2.y[0] = 'c2y'
    MyClass.y[0] = 'MyClassy'
    print('c1.y={}'.format(c1.y))
    print('c2.y={}'.format(c2.y))
    print('MyClass.y={}'.format(MyClass.y))
    
    #类对象新增属性，类和实例都可以访问，因为继承搜索
    MyClass.MC='b'
    print('c1.MC={}'.format(c1.MC))
    print('c2.MC={}'.format(c2.MC))
    print('MyClass.MC={}'.format(MyClass.MC))

    #实例新增属性只属于当前实例,其他实例和类对象无法访问
    c1.x='a'
    print('c1.x={}'.format(c1.x))
    try:
        print('c2.x={}'.format(c2.x))
    except Exception as e:
        print('c2.x={}'.format(e))
    try:
        print('MyClass.x={}'.format(MyClass.x))
    except Exception as e:
        print('MyClass.x={}'.format(e))

示例

# 打开cmd，执行下面示例
E:\documents\F盘>python testclass.py
c1=<__main__.MyClass object at 0x0208ADD0>
c2=<__main__.MyClass object at 0x0208AD50>
display.self.data=c1=<__main__.MyClass object at 0x0208ADD0>
display.self.data=c2=<__main__.MyClass object at 0x0208AD50>
display.self.data=1=<__main__.MyClass object at 0x0208AD50>
display.self.data=1=<__main__.MyClass object at 0x0208AD50>
c1.s=梯阅线条
c2.s=梯阅线条
MyClass.s=梯阅线条
c1.s=c1s
c2.s=c2s
MyClass.s=MyClass
c1.y=[1, 2, 3]
c2.y=[1, 2, 3]
MyClass.y=[1, 2, 3]
c1.y=['MyClassy', 2, 3]
c2.y=['MyClassy', 2, 3]
MyClass.y=['MyClassy', 2, 3]
c1.MC=b
c2.MC=b
MyClass.MC=b
c1.x=a
c2.x='MyClass' object has no attribute 'x'
MyClass.x=type object 'MyClass' has no attribute 'x'