Python 类

最新推荐文章于 2022-01-20 00:01:23 发布

Fe_cow丿

最新推荐文章于 2022-01-20 00:01:23 发布

阅读量207

点赞数 1

分类专栏： Python

本文链接：https://blog.csdn.net/Fe_cow/article/details/84980207

版权

Python 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

Python 类

面向对象编程是最有效的软件编写方法之一。
基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。
根据类来创建对象被称为实例化
实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

1、创建和使用类：

使用类几乎可以模拟任何东西，下面举个小狗的简单类：

class Dog():   # 定义了一个名为Dog的类，再python中首字母大写的名称指类
    """一次模拟小狗的简单类"""
    def __init__(self, name, age):
        """初始化属性/名字和年龄"""
        self.name = name
        self.age = age

    def __str__(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + ' is now sitting.')

    def roll_over(self):
        """模拟小狗再地上打滚"""
        print(self.name.title() + 'roll over.')

1):方法 init ():

类中的函数称为方法
__ init __ ()是一个特殊方法，每当你根据Dog类创建新实例时，Python都会自动运行它.
这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突
在这个方法的定义中，形参self 必不可少，还必须位于其他形参的前面。
为何必须在方法定义中包含形参self 呢?
- 因为Python调用这个__init__() 方法来创建Dog 实例时，将自动传入实参self。
- 每个与类相关联的方法调用都自动传递实参self ，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
- 我们创建Dog 实例时，Python将调用Dog 类的方法__init__() 。
以self 为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。
- self.name = name 获取存储在形参name 中的值，并将其存储到变量name 中，然后该变量被关联到当前创建的实例
- self.age = age 的作用与此类似.
- 像这样可通过实例访问的变量称为属性。

2):再python2.7中创建类：

在Python 2.7中创建类时，需要做细微的修改——在括号内包含单词object ：

class Dog(object):  # 这让Python 2.7类的行为更像Python 3类，从而简化了你的工作。

1.2、根据类创建实例：

可将类视为有关如何创建实例的说明

class Dog():   # 定义了一个名为Dog的类，再python中首字母大写的名称指类
    """一次模拟小狗的简单类"""
    def __init__(self, name, age):
        """初始化属性/名字和年龄"""
        self.name = name
        self.age = age

    def __str__(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + ' is now sitting.')

    def roll_over(self):
        """模拟小狗再地上打滚"""
        print(self.name.title() + 'roll over.')


my_dog = Dog('fe_cow', 16)
print('My dog name is ' + my_dog.name.title() + '.')
print('My dog is ' + str(my_dog.age) + ' years old.')

# 输出结果如下：
My dog name is Fe_Cow.
My dog is 16 years old.

我们让python创建一条名字为’fe_cow’，年龄’16’的小狗，遇到这行代码时，python使用实参'fe_cow'和16调用Dog()类中的方法__ init __(), 方法__ init __() 创建一个表示特定小狗的实例，并使用我们提供的值来设置属性name 和age
- 方法__ init __() 并未显式地包含return 语句，但Python自动返回一个表示这条小狗的实例
- 我们将这个实例存储在变量my_dog 中
命名约定很有用：我们通常可以认为首字母大写的名称（如Dog ）指的是类，而小写的名称（如my_dog ）指的是根据类创建的实例

1):访问属性：

要访问实例的属性，可使用句点表示法
```
my_dog.name
my_dog.age
```
- Python先找到实例my_dog ，再查找与这个实例相关联的属性name 。
- 在Dog 类中引用这个属性时，使用的是self.name 。

2):调用方法：

根据Dog 类创建实例后，就可以使用句点表示法来调用Dog 类中定义的任何方法。
```
my_dog = Dog('fe_cow', 16)
my_dog.sit()
my_dog.roll_over()
```
- 要调用方法，可指定实例的名称（这里是my_dog ）和要调用的方法，并用句点分隔它们

3):创建多个实例:

可按需求根据类创建任意数量的实例

class Dog(object):
    """一次模拟小狗的简单类"""
    def __init__(self, name, age):
        """初始化属性/名字和年龄"""
        self.name = name
        self.age = age

    def __str__(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + ' is now sitting.')

    def roll_over(self):
        """模拟小狗再地上打滚"""
        print(self.name.title() + 'roll over.')

my_dog = Dog('fe_cow', 16)
print('My dog name is ' + my_dog.name.title() + '.')
print('My dog is ' + str(my_dog.age) + ' years old.')
my_dog.roll_over()

your_dog = Dog('cu_cow', 18)
print('\nMy dog name is ' + my_dog.name.title() + '.')
print('My dog is ' + str(my_dog.age) + ' years old.')
your_dog.roll_over()

# 输出结果如下：
My dog name is Fe_Cow.
My dog is 16 years old.
Fe_Cowroll over.

My dog name is Fe_Cow.
My dog is 16 years old.
Cu_Cowroll over.

2、使用类和实例：

2.1、创建一个类：

下面来编写一个表示汽车的类，它存储了有关汽车的信息，还有一个汇总这些信息的方法
```
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):  
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year

    def get_descriptive_name(self):   #
        """返回描述信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name


my_new_car = Car('fe_cow', 'a6', 2018)
car_descrpitive = my_new_car.get_descriptive_name()
print(car_descrpitive)
# 输出结果：
2018 fe_cow a6
```
- 我们定义了__ init __方法，这个方法第一个形参是self,还包含了另外三个形参, make, model year,接收这些参数并将他们存储这个类创建的实例属性中
- 我们又定义了一个名为为get_descriptive_name() 的方法，它使用属性year,make,model创建一个对汽车进行描述的字符串，再这个方法中访问属性的值，使用了self.name, self.model, self.year。
- 根据Car类创建了一个实例，并将其存储到变量my_new_car中，我们再调用方法get_descriptive_name() ，就指出我们拥有一辆什么的汽车。

2.2、给属性指定默认值：

类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。

在有些情况下，如设置默认值时，在方法__ init __() 内指定这种初始值是可行的；如果你对某个属性这样做了，就无需包含为它提供初始值的形参。

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 100

    def get_descriptive_name(self):
        """返回描述信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name

    def read_odometer(self):
        """打印一条指出汽车历程的消息"""
        print('This car has ' +  str(self.odometer_reading) + ' miles on it.')


my_car = Car('fe_cow', 'a6', '2018')
my_car.read_odometer()
# 输出结果如下：
This car has 100 miles on it.

2.3、修改属性的值:

可以以三种不同的方式修改属性的值：
- 1：直接通过实例进行修改；
- 2：通过方法进行设置；
- 3：通过方法进行递增（增加特定的值)；

1.直接修改属性的值:

要修改属性的值，最简单的方式是通过实例直接访问它。

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 100

    def get_descriptive_name(self):
        """返回描述信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name

    def read_odometer(self):
        """打印一条指出汽车历程的消息"""
        print('This car has ' +  str(self.odometer_reading) + ' miles on it.')


my_car = Car('fe_cow', 'a6', '2018')
my_car.odometer_reading = 1000  # 直接通过实例调用该属性来修改
my_car.read_odometer()
# 输出结果：This car has 1000 miles on it.

2.通过方法修改属性的值：

如果有替你更新属性的方法，你就无需直接访问属性，而可将值传递给一个方法，由它在内部进行更新

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 100

    def get_descriptive_name(self):
        """返回描述信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name

    def read_odometer(self):
        """打印一条指出汽车历程的消息"""
        print('This car has ' +  str(self.odometer_reading) + ' miles on it.')

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        self.odometer_reading = mileage

my_car = Car('fe_cow', 'a6', 2018)
my_car.read_odometer()

my_car.update_odometer(6666)
my_car.read_odometer()
# 输出结果如下：
This car has 100 miles on it.
This car has 6666 miles on it.

Car类所作的唯一修改是添加了update_odometer()，这个方法里接收一个里程值，并将其存储到self.odometer_reading中，通过调用update_odometer()并向他提供了实参6666，它将里程值设置为了6666，而方法read_odometer()打印读数。

3.通过方法对属性的值进行递增：

有时候需要将属性值递增特定的量，而不是将其设置为全新的值

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 100

    def get_descriptive_name(self):
        """返回描述信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name

    def read_odometer(self):
        """打印一条指出汽车历程的消息"""
        print('This car has ' +  str(self.odometer_reading) + ' miles on it.')

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        self.odometer_reading = mileage

    def increment_odometer(self, miles):  # 新添加了递增的方法
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles


my_car = Car('fe_cow', 'a6', 2018)
my_car_info = my_car.get_descriptive_name()
print(my_car_info)

my_car.update_odometer(235000)
my_car.read_odometer()

my_car.increment_odometer(100)
my_car.read_odometer()

# 输出结果如下：
2018 fe_cow a6

This car has 235000 miles on it.

This car has 235100 miles on it.

新增的方法increment_odometer() 接受一个单位为英里的数字，并将其加入到self.odometer_reading 属性中。

3、继承：

编写类时，并非总是要从空白开始。
如果你要编写的类是另一个现成类的特殊版本，可使用**继承 **。
一个类继承另一个类时，它将自动获得另一个类的所有属性和方法。
- **原有的类称为父类，而新类称为子类 **。
- 子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

3.1、子类的方法 init ():

创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法__ init __() 需要父类施以援手，以下是Python3中的继承

class Car(object):
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 100

    def get_descriptive_name(self):
        """返回描述信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name

    def read_odometer(self):
        """打印一条指出汽车历程的消息"""
        print('This car has ' +  str(self.odometer_reading) + ' miles on it.')

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        self.odometer_reading = mileage

    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles


class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super().__init__(make, model, year)  # 这行代码让Python调用ElectricCar 的父类的方法__init__() ，让ElectricCar 实例包含父类的所有属性。


my_tesla = ElectricCar('fe_cow', 'aima', 2018)
print(my_tesla.get_descriptive_name())
# 输出结果：2018 fe_cow aima

首先是Car 类的代码。创建子类时，父类必须包含在当前文件中，且位于子类前面
定义子类时，必须在括号内指定父类的名称。 class ElectricCar(Car):
方法__ init __() 接受创建Car 实例所需的信息
super() 是一个特殊函数，帮助Python将父类和子类关联起来
- 父类也称为超类（superclass），名称super因此而得名。

3.2、Python2.7中的继承：

在Python 2.7中，继承语法稍有不同，ElectricCar 类的定义类似于下面这样：

class Car(object):
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
..........................................

class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super(ElectricCar, self).__init__(make, model, year)

函数super() 需要两个实参：子类名和对象self 。为帮助Python将父类和子类关联起来，这些实参必不可少。另外，在Python 2.7中使用继承时，务必在定义父类时在括号内指定object 。

3.3、给子类定义属性和方法：

让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法。

class Car(object):
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
..........................................

class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super(ElectricCar, self).__init__(make, model, year)
        self.battery_size = 70  # 给子类定义一个显示电瓶容量的属性

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print('This car has a '+ str(self.battery_size) + '-kWh battery.')


my_tesla = ElectricCar('fe_cow', 'aima', 2018)
my_tesla.describe_battery()
# 输入结果如下：
This car has a 70-kWh battery.

我们添加了新属性self.battery_size ，并设置其初始值（如70 ）
根据ElectricCar 类创建的所有实例都将包含这个属性，但所有Car 实例都不包含它
我们还添加了一个名为describe_battery() 的方法，它打印有关电瓶的信息。我们调用这个方法时，将看到一条电动汽车特有的描述
如果一个属性或方法是任何汽车都有的，而不是电动汽车特有的，就应将其加入到Car 类而不ElectricCar 类中。这样，使用Car 类的人将获得相应的功能，而ElectricCar 类只包含处理电动汽车特有属性和行为的代码。

3.4、重写父类的方法：

对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写

即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。

class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super(ElectricCar, self).__init__(make, model, year)
        self.battery_size = 70

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print('This car has a '+ str(self.battery_size) + '-kWh battery.')

    def fill_gas_tank(self):
        """电动汽车没有油箱"""
        print('This car doesn need gas tank!')


my_tesla = ElectricCar('fe_cow', 'aima', 2018)
my_tesla.fill_gas_tank()
# 输出结果如下：
This car doesn need gas tank!

如果只有子类要用的这个方法，父类不需要的话，可以再子类中重新定义fill_gas_tank()方法

3.5、将实例用作属性：

使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：
属性和方法清单以及文件都越来越长。
在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。

你可以将大型类拆分成多个协同工作的小类。

class Car(object):
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
..........................................


class Battery():
    """一次模拟电动汽车电瓶"""

    def __init__(self, battery_size=70):
        self.battery_size = battery_size

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print('This car has a '+ str(self.battery_size) + '-kWh battery.')


class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super(ElectricCar, self).__init__(make, model, year)
        self.battery = Battery()  

    def fill_gas_tank(self):
        """电动汽车没有油箱"""
        print('This car doesn need gas tank!')


my_tesla = ElectricCar('fe_cow', 'aima', 2018)
my_tesla.battery.describe_battery()  # 这行代码让Python在实例my_tesla 中查找属性battery ，并对存储在该属性中的Battery 实例调用方法describe_battery() 。

# 输出结果如下：This car has a 70-kWh battery.

定义了一个名为Battery 的新类，它没有继承任何类
Battery()类的法__ init __() 除self 外，还有另一个形参battery_size，这个形参是可选的，如果没有给提供值，电瓶容量将被设置为70。方法describe_battery() 也移到了这个类中
在ElectricCar 类中，我们添加了一个名为self.battery 的属性，这行代码让Python创建一个新的Battery 实例（由于没有指定尺寸，因此为默认值70 ），并将该实例存储在属性self.battery 中。
每当方法__ init __() 被调用时，都将执行该操作；因此现在每个ElectricCar 实例都包含一个自动创建的Battery 实例

Fe_cow丿

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Python 类

Python 类面向对象编程是最有效的软件编写方法之一。基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。根据类来创建对象被称为实例化实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。1、创建和使用类：使用类几乎可以模拟任何东西，下面举个小狗的简单类：class Dog(): # 定义了一个...
复制链接

扫一扫