学习:自定义类

转自:http://www.byhy.net/tut/py/basic/18/

什么是类

Python 中的一切对象都有各自的类型,比如

整数对象   的类型是   int
字符串对象 的类型是   str
列表对象   的类型是   list
元组对象   的类型是   tuple
字典对象   的类型是   dict

Python 的内置函数type可以查看对象的类型

>>> type(12)
    # 整数类型
>>> type('12')
    # 字符类型
>>> type([1,2])
   # 列表类型
>>> type((1,2))
  # 元组类型
>>> type({1:2})
   # 字典类型

我们掌握了这些内置的数据类型,通常就可以开发Python程序了。

但是当我们要开发的软件系统 更加复杂的时候,尤其是系统里面的对象 和现实世界的对象 存在对应关系的时候,如果只能用这些内置类型,就会感觉很不方便了。

比如,我们的程序要表示一个 奔驰汽车 这样的对象类型,属性有:品牌,国家,价格。

如果只用Python的内置类型,大家想想怎么表示 。

当然,我们可以定义一个字典类型的对象,比如

benzCar = {
    'brand'   : '奔驰',
    'country' : '德国',
    'price'   : 300000
}

如果这个汽车对象还需要有自己特定的行为,比如 按喇叭会发出嘟嘟的声音。那又该怎么定义呢?

有人说,可以定义一个函数对象作为它的属性,像这样

def  pressHorn():
    print('嘟嘟~~~~~~')

benzCar = {
    'brand'   : '奔驰',
    'country' : '德国',
    'price'   : 300000,
    'pressHorn' : pressHorn # 字典对象的值可以是一个函数对象
}

# 我可以这样执行它的行为
benzCar['pressHorn']()

似乎也可以。

但是这里 benzCar 更像是一个具体的对象,并不是一种 对象类型

而且 这个 benzCar 汽车的 行为的定义 ,要在外面定义一个函数, 然后benzCar字典的内部去引用它,这样也比较麻烦。


为了解决这样的普遍问题,Python语言可以让我们 自己定义对象类型

Python中自定义对象类型,就是 定义一个类 就是 类型 的意思。

比如 : 奔驰汽车, 可以这样定义

class BenzCar:    
    brand   = '奔驰'  # 品牌属性
    country = '德国'  # 产地属性

    @staticmethod
    def pressHorn(): 
        print('嘟嘟~~~~~~')

定义一个类 用关键字 class 后面加 类的名称。

类名的规范 和 变量命名规范一样。 通常我们会把类名 首字母大写, 这里定义的类名就是 BenzCar

下面定义的 brand, country 都是 BenzCar 类的 属性

这种属性被称为类属性

如果我们要得到属性的值可以这样用 类名.属性名 的方式,如下

print(BenzCar.brand) 

而 pressHorn 则是该类型的一个 方法。 请注意上面的 @staticmethod 的修饰, 说明这是该类的一个 静态方法

要调用执行该类的静态方法,像这样就可以了

BenzCar.pressHorn()

大家可以拷贝如下代码到一个文件中,执行一下看看

class BenzCar:    
    brand   = '奔驰'  
    country = '德国'  

    @staticmethod
    def pressHorn(): 
        print('嘟嘟~~~~~~')

BenzCar.pressHorn()

类的实例

点击这里,边看视频讲解,边学习以下内容

类和实例的关系

Python中 类 是 某种对象的类型。

比如 int 是 整数对象的类型, str是字符串对象的类型, list是 列表对象的类型。

我们把一个个具体的 对象称为 该类型的 实例

比如,我们可以说

数字对象 3 是 int 类型的的实例,具有int类型的特征

字符串对象 ‘abc’ 是 str 类型的实例,具有str类型的特性(比如可以执行str的所有方法,比如 find, split等)

列表对象 [1,2,3] 是 list 类型的的实例,具有list类型的特性(比如可以执行list的所有方法,比如 reverse,append等)

同样的,我们自定义的类,也可以产生该类的实例对象。 每个实例对象就是该类的一个实例,具有该类的一切特征。

要产生一个类的实例对象,只需要 在类名后面加上括号,就可以了,就会返回一个该类的实例对象。

比如

car1 = BenzCar()

car1 变量就对应了一个 BenzCar 类型 的实例对象,具有 BenzCar 类的一切属性和方法。大家可以执行下面的代码试试。

class BenzCar:    
    brand   = '奔驰'  
    country = '德国'  

    @staticmethod
    def pressHorn(): 
        print('嘟嘟~~~~~~')

car1 = BenzCar()       
print(car1.brand) 
car1.pressHorn()

同样,我们也可以用 type 函数查看 car1 这个实例的类型,如下所示

>>> type(car1)


说明 car1 是 __main__ 模块里面定义的 BenzCar 类型。

大家一定要搞清楚 类 和 实例 的关系。

比如 :

人 就是 一个 类, 而 关羽、张飞 就是 人 这个类的 具体实例。

狗 也是 一个 类, 而 你们家的阿黄 和 隔壁家的旺财 就是狗 这个类的 具体实例。。

Python中 定义一个类型 就是描述 这些类型的实例的 公共特征 。后面根据这个类创建的实例 都具有这个类的 特征,就是 具体什么 属性、方法。

实例属性和实例方法

点击这里,边看视频讲解,边学习以下内容

刚才我们定义的类里面的属性都是 类属性 ,里面的方法都是类的 静态方法

所有BenzCar类的实例对象,其 品牌名 brand ,对应的类属性应该是相同的。

就是说下面这样的两个实例

car1 = BenzCar()     
car2 = BenzCar()

car1 和 car2 的 brand属性 都是一样的 值, 都是字符串 ‘奔驰’

很好理解,因为品牌这样的属性 对于所有的 奔驰车都是一样的,都是 ‘奔驰’。

类属性 是类的共同特征属性。

但是有些属性,比如颜色、发动机编号 是每一辆奔驰车 都不同的。

所以,在我们定义的 类BenzCar 里面, 颜色、发动机编号 是 不应该 作为类属性的。

每个实例独有的属性,称之为 类的实例属性

实例属性通常是在类的 初始化方法 __init__ 里面定义的。

比如:

class BenzCar:    
    brand   = '奔驰'  
    country = '德国'  

    @staticmethod
    def pressHorn(): 
        print('嘟嘟~~~~~~')

    # 初始化方法, 注意前后各有两个下划线
    def __init__(self):
        self.color  =  'red'        # 颜色
        self.engineSN = '837873398' # 发动机编号

上面的初始化方法 __init__ ,就创建了两个实例属性 color 和 engineSN。

为什么 __init__ 方法 叫初始化方法呢?

解释器在执行 像下面这样的 实例化类对象 的代码时,

car1 = BenzCar()     

首先,解释器会 在内存中 创建一个该类 的 实例对象;

然后,解释器会查看这个类是否有 __init__方法,如果有,就会去调用它。

__init__ 是 创建好实例后 立即就要 执行 的方法,所以称之为初始化方法。

通常我们会在__init__方法里面 执行一些初始化的动作,主要就是创建该实例的 实例属性。

__init__ 方法的第一个参数是 self, 它 是干什么用的呢?

刚才说了, 解释器执行实例化代码,会先在内存中创建该类实例对象,然后调用类 的__init__方法。

调用 __init__方法时,就将实例对象 传递给 self参数。

self 参数变量 指向的 就是 实例对象 本身, 所以下面的代码就是创建该实例的属性color 和 engineSN 了

        self.color  =  'red'         # 颜色
        self.engineSN = '8378738398' # 发动机编号


类的静态方法要在方法定义 上面加上 @staticmethod 的修饰。

而 类的 实例方法 不需要任何修饰。

通常类的实例方法,都是要 访问类的实例属性的。 包括: 创建、修改、删除 类的实例属性。

因为 实例方法 就是要操作 实例独有的属性,否则不操作任何实例属性的话,就应该定义为 类方法。

比如 __init__ 初始化方法,就是一个实例方法,它通常要创建一些实例属性。

pressHorn 方法是类的静态方法, 静态方法是不能访问实例属性的


有时候,实例属性的取值,不是固定写在初始化方法的代码里面。

比如这里,每辆车的颜色、发动机号都是不同的,我们应该作为参数传进去。

所以修改代码为这样

class BenzCar:    
    brand   = '奔驰'  
    country = '德国'  

    @staticmethod
    def pressHorn(): 
        print('嘟嘟~~~~~~')

    def __init__(self,color,engineSN):
        self.color  =  color     # 颜色
        self.engineSN = engineSN # 发动机编号

这样我们在创建实例的时候,就可以根据需要指定不同的实例属性了,比如

car1 = BenzCar('白色','24503425527866')
car2 = BenzCar('黑色','34598423586877')
print(car1.color)
print(car2.color)
print(car1.engineSN)
print(car2.engineSN)

虽然定义的时候, __init__ 方法 有3个参数 : self,color,engineSN

但是我们这样调用 BenzCar() 实例化的时候, 只需要传入后面两个参数即可。

因为self 参数 需要传入实例对象本身,解释器会自动帮我们传入。

其它的 实例方法也是这样, 比如我们定义一个 修改车身颜色的方法 changeColor

class BenzCar:     
    brand   = '奔驰'  
    country = '德国'  

    @staticmethod
    def pressHorn(): 
        print('嘟嘟~~~~~~')

    def __init__(self,color,engineSN):
        self.color  =  color     # 颜色
        self.engineSN = engineSN # 发动机编号

    def changeColor(self,newColor):
        self.color = newColor

car1 = BenzCar('白色','24503425527866')       
car1.changeColor('黑色')

print (car1.color)

调用 changeColor方法的时候,只需要传入参数 newColor 对应新的颜色即可。

不需要我们传入self参数,self 参数是实例对象本身,解释器会自动帮我们传入。

注意: 如果你的实例属性名称 和 静态属性 重复了 ,通过类实例访问该属性,访问的是实例属性。通过类名访问该属性,访问的是类属性。

比如

class Car:
    brand = '奔驰'
    name = 'Car'

    def __init__(self):
        # 可以通过实例访问到类属性
        print(self.brand)

        # 定义实例属性和类属性重名
        self.name = 'benz car'

c1 = Car()

print(f'通过实例名访问name:{c1.name}')
print(f'通过类名  访问name:{Car.name}')

一旦创建了 和类属性同名的 实例属性,通过实例访问的就是实例属性了

参考 https://stackoverflow.com/questions/12949064/python-what-happens-when-class-attribute-instance-attribute-and-method-all-ha

类之间的关系

继承关系

点击这里,边看视频讲解,边学习以下内容

真实世界中,类型之间 可能存在 范围 包含关系。

比如: 这个类型 和 亚洲人 这个类型。

是包括了 亚洲人 的。 如果 某人 是一个 亚洲人,那么它必定是一个

这种关系,编程语言中称之为 继承关系

比如上面的例子, 亚洲人 这个类 就 继承 这个类。

通常我们把被继承的类称之为 父类 或者叫 基类

把继承类称之为 子类 或者 派生类

同样的,以车为例, 上面我们定义了奔驰车 这个类, 我们还可以定义两个 子类: 奔驰2016奔驰2018 对应两种不同款的奔驰车。

如下所示:

class BenzCar:    
    brand   = '奔驰'  
    country = '德国'  

    @staticmethod
    def pressHorn(): 
        print('嘟嘟~~~~~~')

    def __init__(self,color,engineSN):
        self.color  =  color  # 颜色
        self.engineSN = engineSN # 发动机编号

    def changeColor(self,newColor):
        self.color = newColor

class Benz2016(BenzCar):
    price   = 580000
    model   = 'Benz2016'   

class Benz2018(BenzCar):
    price   = 880000
    model   = 'Benz2018'    

大家可以发现定义子类的时候,必须指定它的父类是什么。

指定的方法就是在类名的后面的括号里写上父类的名字。

大家注意: 子类会自动拥有父类的一切属性和方法

为什么? 因为一个子类的实例对象 ,必定也是一个父类的实例对象。 当然需要拥有父类的一切属性和方法。

就像 一个亚洲人 当然 拥有一个 所应该具有的一切特性。

比如,执行下面的代码

car1 = Benz2016('red','234234545622')    
car2 = Benz2018('blue','111135545988')   

print (car1.brand)
print (car1.country)
car1.changeColor('black')

print (car2.brand)
print (car2.country)
car2.pressHorn()

输出结果如下

奔驰
德国
奔驰
德国
嘟嘟~~~~~~


一个子类在继承父类的一切特性的基础上,可以有自己的属性和方法。 比如:


class Benz2018(BenzCar):
    price   = 880000
    model   = 'Benz2018'     

    def __init__(self,color,engineSN,weight):
        # 先调用父类的初始化方法
        BenzCar.__init__(self,color,engineSN)
        self.weight = weight # 车的重量
        self.oilweight = 0  # 油的重量

    # 加油
    def fillOil(self, oilAdded):
        self.oilweight +=  oilAdded 
        self.weight    +=  oilAdded

这里 子类 Benz2018 ,新增了两个 类属性

价格: price 
型号: model

新增了两个实例属性

整车重量:weight 
油的重量:oilweight

新增了一个实例方法 fillOil , 对应 加油这个行为。

这个行为会导致 实例属性 weight 和 oilweight 变化,所以必须是 实例方法。

这样定义好了以后, 就可以创建该类的实例,并访问其新的方法和属性了。

car2 = Benz2018('blue','111135545988',1500)   
print (car2.oilweight)
print (car2.weight)
car2.fillOil(50) 
print (car2.oilweight)
print (car2.weight)

要特别注意的是, 子类的初始化方法里面,如果有一部分的初始化代码和父类的初始化相同(通常都是这样),需要显式的 调用父类的初始化方法 __init__

而且要传入相应的参数, 像上面那样,然后可以加上自己的特有的初始化代码。如下所示

def __init__(self,color,engineSN,weight):
    # 先调用父类的初始化方法
    BenzCar.__init__(self,color,engineSN)
    self.weight = weight 
    self.oilweight = 0  

如果子类 没有 自己的初始化方法,实例化子类对象时,解释器会自动调用父类初始化方法,如下

class Rect:
    def __init__(self):
        print('初始化 rect')

class Squre(Rect):
    pass

s = Squre()

运行结果,会打印出 初始化 rect

但是,如果子类 有自己 的初始化方法,实例化子类对象时,解释器就不会自动化调用父类的初始化方法,如下

class Rect:
    def __init__(self):
        print('初始化 rect')

class Square(Rect):
    def __init__(self):
        print('初始化 square')

s = Squre()

运行结果只会打印 初始化 square

调用父类的方法,除了直接用父类的名字 BenzCar, 还可以使用 函数 super()

像这样

def __init__(self,color,engineSN,weight):
    # 同样是调用父类的初始化方法
    super().__init__(color, engineSN)
    self.weight = weight 
    self.oilweight = 0  

这样使用的时候,方法参数中 不需要加上 self 参数。

使用super的好处之一就是:子类中调用父类的方法,不需要 显式指定 父类的名字。 代码的可维护性更好。

想象一下,如果BenzCar有很多子类,如果那一天BenzCar类改了名字,采用super这样的写法,就不需要修改子类的代码了。

另外一个更重要的好处是,在多重继承的情况,super能有效的保证继承链上的方法被正确调用到,感兴趣的朋友可以参考stack overflow上的阐述 , 和 这里的官方文档

注意 super不仅仅可以调用父类的初始化方法,也可以调用父类的其他方法。

一个子类,同时还可以是另一个类的父类。

比如 亚洲人 可以是 的子类, 同时可以是 中国人 的父类。

因为一个中国人,一定是一个亚洲人, 当然也一定是一个 人 。

同样的,上面的车的例子, 我们还可以定义 奔驰2018混合动力 作为 奔驰2018 的 子类。

定义的语法还是一样的

class Benz2018Hybrid(Benz2018):
    model = 'Benz2018Hybrid' 
    price = 980000

    def __init__(self,color,engineSN,weight):
        Benz2018.__init__(self,color,engineSN,weight)

同样,类 Benz2018Hybrid 也会拥有其父类 Benz2018 的一切属性和方法,自然也包括 父类的父类 BenzCar 的一切属性和方法

car2 = Benz2018Hybrid('blue','111135545988',1500)   
print (car2.oilweight)
print (car2.weight)
car2.fillOil(50) 
print (car2.oilweight)
print (car2.weight)

类的组合关系

点击这里,边看视频讲解,边学习以下内容

除了上面的继承关系, 类之间还有一种常见的组合关系。

所谓组合关系,就是一个类实例的属性里面包含另外一个类实例。

比如

class BenzCar:    
    brand   = '奔驰'  
    country = '德国'  

    def __init__(self,color,engineSN):
        self.color  =  color     # 颜色
        self.engineSN = engineSN # 发动机编号

这样的定义,类 BenzCar 中

brand 属性就是一个字符串对象 奔驰

country 属性就是一个字符串对象 德国

而该类的实例对象中,就包含了 两个属性 color 和 engineSN, 都是字符串对象

我们可以说 该类由 一些字符串对象 组合 而成。

甚至还可以包含 我们自己定义的类的实例,比如:

# 轮胎
class Tire:    
    def __init__(self,size,createDate):
        self.size  =  size  # 尺寸
        self.createDate = createDate # 出厂日期

class BenzCar:    
    brand   = '奔驰'  
    country = '德国'  

    def __init__(self,color,engineSN,tires):
        self.color  =  color  # 颜色
        self.engineSN = engineSN # 发动机编号
        self.tires   =  tires

# 创建4个轮胎实例对象
tires = [Tire(20,'20160808')  for i in range(4)]
car = BenzCar('red','234342342342566',tires)

上面的例子里,奔驰汽车对象就 包含 了4个轮胎 Tire 对象。

我们可以说奔驰汽车对象是由 4个轮胎对象 组合 而成,形成了对象的组合关系。

对象的 属性 变量 保存了 组合它的那些对象。

组合关系,可以通过上层对象的属性一步的访问到内部对象的属性

比如,我们可以通过 BenzCar 对象 访问其内部的轮胎对象

print(car.tires[0].size)

Python解释器对这个表达式 car.tires[0].size 是从左到右依次执行的,如下所示

car.tires   # BenzCar实例的tires属性,得到一个列表,里面是四个 Tire 实例对象

car.tires[0]   # 得到BenzCar实例的tires属性列表里面的第1个Tire 实例对象

car.tires[0].size  # 得到BenzCar实例的tires属性列表里面的第1个Tire 实例对象的size属性

十万分感谢白月黑羽平台

你可能感兴趣的:(学习:自定义类)