python中的类


面向对象编程是最有效的软件编写方法之一:

  • 理解面向对象编程有助于你像程序员那样看世界,还可以帮助你真正明白自己编写的代码。
  • 不仅是各行代码的作用,还有代码背后更宏大的概念。
  • 了解背后的概念可培养逻辑思维,让你能够通过编写程序来解决遇到的几乎任何问题。
  • 随着面临的挑战日益严峻,类还能让你与合作的其他程序员更轻松。

1.创建和使用类

使用类几乎可以模拟任何东西。根据约定,在python中,首字母大写的名称指的是类。这个类定义中的括号是空的,因为我们要从空白创建这个类。像这样可以通过实例访问的变量称为属性。

例:

class Dog( ):
    """一次模拟小狗的简单尝试"""
    def _init_(self,name,age):
        """"初始化属性name和age"""
        self.name = name
        self.name = age
    def sit(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + " is now sitting.")
    def roll_over(self):
        """模拟小狗被命令时打滚"""
        print(self.name.title() + "rolled over!")

_init_()是一个特殊的方法,每当你根据Dog类创建新实例时,python都会自动运行它。在这个方法中,开头和末尾各有两个下划线,这是一种约定,旨在避免python默认方法与普通方法发生名称冲突。_init_()包含三个形参:self、name和age。在这个方法的定义中,形参self必不可少,还必须位于其他形参前面。

为何必须在方法中包含形参self呢?

因为python调用这个,_init_()方法来创建Dog()时,将自动传入实参self。每个与类相关联的方法调用都自动传递实参self,它是一个指向实例本身的引用,让实例能够访问类中的属性和方法。我们创建Dog实例时,python将调用Dog类的方法_init_()。我们将通过实参向Dog()传递名字和年龄;self会自动传递,因此我们不需要传递它。每当我们根据类创建实例时,都只需给最后两个形参(name和age)提供值。

接下来定义两个变量都有前缀self。以self为前缀的变量都可供类中的所有方法使用,我们还可以通过类的任何实例类访问这些变量。self.name = name获取存储在形参中的值,并将其存储到变量name中,然后该变量被关联到当前创建的实例。self.age = age的作用与此类似。像这样可通过实例访问的变量称为属性。

在Python2.7 中创建类时,需要做的修改为------在括号内包含单词object。Class ClassName( object ):这让Python2.7类的行为更像Python 3类,从而简化了你的工作。在Python 2.7中定义Dog类时,代码类似于下面这样:Class Dog(object )。


2.根据类创建实例

可将类视为有关如何创建实例的说明。我们通常可以认为首字母大写的名称( 如 Dog )指的是类,而小写字母的名称(my - dog)指的是类创建的实例。你可以按需求根据一个类创建任意数量的实例,条件是将每个实例都存储在不同的变量中,或占用列表或字典的不同位置。

class Dog( ):
    -- snip --

my_dog = Dog('willie',6);

print("My dog's name is" + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old. ")

首先使用python创建一条名字为'willie'年龄为6的小狗。遇到这行代码时,python使用实参'willie'和6调用Dog类中的方法_init_()。方法_init_()创建一个表示特定小狗的示例,并使用我们提供的值来设置属性name和age。方法_init_()并未显式地包含return语句,但python自动返回一个表示这条小狗的实例。我们将这个实例存储在变量my_dog中。

就算我们给第二条小狗指定同样的名字和年龄,python依然会根据Dog创建另一个实例。你可按需求根据一个类创建任意数量的实例,条件是将每个实例都存储在不同的变量中,或占用列表或字典的不同位置。


3.使用类和实例:

你可以使用类来模拟现实世界中的很多情景。类编写好后,你的大部分时间都将花在使用根据类创建的实例上。你需要执行的一个重要任务是修改实例的属性。你可以直接修改实例的属性,也可以编写方法以特定的方式进行修改。   

(1)给属性指定默认值:

类中的每个属性都必须有初始值,哪怕这个值是0或者空字符串。在有些情况下,如果设置默认值时,在方法_init_()内指定这种初始值是可行的;如果你对某个属性这么做了,就无需包含为它提供初始值的形参。

下面来添加一个名为odometer_reading的属性,其初始值总是为0。我们还添加了一个名为read_odometer()的方法,用于读取汽车的里程表:

class Car( ):
    
    def _init_(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        --snip--

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

    my_new_car = Car('audi', 'ad', 2016)
    print(my_new_car.get_descriptive_name())
    my_new_car.read_odometer()

现在,当python调用方法_init_()来创建实例时,将像前一个示例一样以属性的方法存储制造商、型号和生产年份。接下来,python将创建一个名为odometer_reading的属性,并将其初始值设置为0。接下来,我们还定义了一个名为read_odometer()的方法,它让你能够轻松地获悉汽车的里程。

(2)修改属性的值:

可以以三种不同的方法修改属性的值:

  • 直接通过实例进行修改
  • 通过方法进行设置
  • 通过方法进行递增(增加特定的值)

直接修改属性的值:要修改属性的值,最简单的方法是通过实例直接访问它。下面的代码直接将里程表读数设置为23:

class Car( ):
   --snip--

my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.reading_odometer()

通过方法修改属性的值:如果有替你更新属性的方法,将大有裨益。这样你就无需直接访问属性。而可将值传递给一个方法,由它在内部进行更新。

class Car( ):
   --snip--
   def update_odometer(self, mileage):
      """将里程表读数设置为指定的值"""
      self.odometer_reading = mileage
   
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())

my_new_car.update_odometer(23)
my_new_car.reading_odometer()

添加方法update_odometer()。这个方法接受一个里程值,并将其存储到self.odometer_reading中。接下来,调用update_odometer(),并向它提供了实参23。(该实参对应于方法定义中的形参mileage)。它将里程表读数设置为23;

通过方法对属性的值进行递增:

有时候需要将属性值递增,而不是将其设置为全新的值。

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

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

可以使用类似上面的方法来控制用户修改属性值(如:里程表读取)的方式。但能够访问程序的人都可以通过直接访问属性来将里程表修改为任何值。要确保安全,除了进行类似前面的基本检查外,还需特别注意细节。


4.继承:

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

(1)子类的方法 _init_( ):

 创建子类的实例时,python首先需要完成的任务是给父类的所有属性赋值。为此,子类的方法_init_( )需要父类施以援手。

例:

class Car( ):
    """一次模拟汽车的简单尝试"""
    
    def _init_(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    
    def get_descriptive_name(self):
        long.name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()
    
    def read_odometer(self):
        print("This car has" + str(self,odometer_reading) + "miles on it.")
    
    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading
             self.odometer_reading = mileage
        else:
             print("You can't roll back an odometer!")
    
    def increment_odmeter(self, miles)
        self.odometer_reading += miles

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

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())

创建子类时,父类必须包含在当前文件中,并且于子类前面。接下来定义了子类ElectricCar。定义子类时,必须在括号内指定父类的名称。方法_init_()接受创建Car实例所需的信息。定义子类时,必须在括号内指定父类的名称。方法_init_()接受创建Car实例所需的信息。

super( )是一个特殊函数,帮助python将子类和父类关联起来。这行代码让python调用ElectricCar的父类的方法_init_(),让ElectricCar实例包含父类所有属性。父类也称为超类(superclass),名称super因此而得名。

(2)子类添加和重写属性

下面来添加一个电动汽车特有的属性(电瓶),以及一个描述属性的方法。

class Car( )
    --snip--

class ElectricCar(Car):
    """Represent aspect of a car, specific to electric vehicles."""
    
    def _init_(self, make, model, year):
        """
        电动汽车的独特之处
        初始化父类的属性,再初始化电动汽车特有的属性
        """
        super()._init_(make, model, year)
        self.battery_size = 70
    
    def descriptive_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + " -kWh battery.")

my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

添加了新属性self.battery_size,并设置其初始值。根据ElectricCar类创建的所有实例都将包含这个属性,但所有Car实例都不包含它。接下来还添加了一个名为describe_battery( )的方法,它打印有关电瓶的信息。

对于父类的方法,只要它不符合子类模拟的实物的行为,都可对其进行重写。为此,可在子类中定义一个这样的方法。即它与要重写的父类方法同名。这样,python将不会考虑这个父类方法,而只关注你在子类中定义的相应方法。假设Car类有一个名为fill_gas_tank()的方法,它对全电动汽车来说是毫无意义,因此你可能想重写它,例如:

class Electric(Car):
    --snip--
    
    def fill_gas_tank(self):
        """电动汽车没有油箱"""
        print("This car doesn't need a gas tank!")

(3)将实例用作属性:

使用代码模拟实物时,你可能发现自己给类添加的细节越来越多:属性和方法清单以及文件都越来越长。在这种情况下,可能需要将类的一部分作为一个独立的类提取出来。你可以将大型类拆分成多个协同工作的小类。例如可以专门定义一个Battery类来存放ElectricCar中的不断增加的关于电池属性的类。

class Car( ):
    --snip--
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()._init_(make, model, year)
    self.battery = Battery()

my_tesla = ElectricCar('tesla', 'model s', 2016)
my_tesla.battery.describe_battery()

开始定义了一个Battery的新类,在ElectricCar类中,添加了一个名为self.battery的属性。这行代码让python创建一个新的Battery实例,并将该实例存储在属性self.battery中。每当方法_init_()被调用时,都将执行该操作;因此现在在每个ElectricCar实例中都包含一个自动创建的的Battary实例。

3.导入类:

随着你不断地给类添加功能,文件可能变得很长,即使你妥善地使用了继承,亦如此。为遵循Python的总体理念,应让文件尽可能整洁。为这方面提供帮助,Python允许你将类存储在模块中,然后在主程序中导入所需的模块。

(1)导入单个类:

导入类是一种有效的编程方式。通过将这个类移到一个模块中,并导入该模块,你依然可以使用期所有的功能,但主程序文件变得整洁而易于阅读了。这还能让你将大部分逻辑存储在独立的文件中;确定类像你希望的那样工作后,你就可以不管这些文件,而专注于主程序的高级逻辑了。

在car.py中先定义一个类,

"""一个可用于表示汽车的类"""

class Car( ):
    """一次模拟汽车的简单尝试"""
    
    def _init_(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    
    def get_descriptive_name(self):
        long.name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()
    
    def read_odometer(self):
        print("This car has" + str(self,odometer_reading) + "miles on it.")
    
    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading
             self.odometer_reading = mileage
        else:
             print("You can't roll back an odometer!")
    
    def increment_odmeter(self, miles)
        self.odometer_reading += miles

开始包含了一个模块级文档字符串,对该模块的内容做了简单的描述。你应为自己创建的每个模块都编写字符文档。下面创建一个文件------my_car.py,在其中导入Car类并创建其示例:

from car import Car

my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name( ))

my_new_car.odomater_reading = 23
my_new_car.read_odometer( )

import语句让python打开模块car,并导入其中的Car类。这样我们就可以使用Car类了,就像它是在这个文件中定义的一样。导入类是一种有效的编程方式。如果在这个文件中包含了整个Car类,程序变得非常长。通过将这个类移到一个模块中,并导入该模块,你依然可以使用其所有功能,但主程序文件变得整洁而易于阅读了。这还能让你将大部分逻辑存储在独立的文件中;确定类像你希望的那样工作后,你就可以不管这些文件,而专注于主程序的高级逻辑了。

(2)在一个模块中存储多个类:

可根据需要在一个模块中存储任意数量的类,例 car.py:

"""一组用于表示燃油汽车和电动汽车的类"""
class Car():
    --snip--

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.")
    
    def get_range(self):
        """打印一条描述电瓶续航里程的消息"""
        if self.battery_size = 70:
            range = 240
        elif self.battery_size == 85:
            range = 270
        
        message = "This car can go approximately " + str(range)
        message += " miles on a full change."
        print(message)

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

现在,可以创建一个名为my_electric_car.py的文件,导入ElectricCar类,并创建一辆电动汽车了:

my_electric_car.py

from car import ElectricCar

my_tesla = ElectricCar('tesla', 'model s', 2016)

print(my_tesla.get_descriptive_name( ))
my_tesla.battery.describe_battery( )
my_tesla.battery.get_range( )

(3)从一个模块中导入多类:

可根据需要在程序文件中导入任意数量的类。,用逗号分开多个类,my_cars.py

from car import Car, ElectricCar

my_beetle = Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name( ))

my_tesla = ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name( ))

(4)导入整个模块:

你还可以导入整个模块,再使用句点表示法访问需要的类。这种导入的方法很简单,代码也易于阅读。由于创建类实例的代码都包含模块名,因此也不会与当前的文件使用的任何名称发生冲突,开始就导入整个car模块。

例,my_cars.py

import car

my_beetle = car.Car('volkwagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name( ))

my_tesla = car.ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name( ))

(5)在一个模块中导入另一个模块

有时候,需要将类分散到多个模块中,以免模块太大,或在同意模块中存储不相关的类。将类存储在多个模块中时,你可能会发现一个模块中的类依赖于另一个模块中的类。在这种情况下,可在前一个模块中导入必要的类。例如,下面将Car类存储在一个模块中,并将ELectricCar和Battery类存储在另一个模块中。我们将第二个模块命名为electric_car.py(这将覆盖前面创建的文件electric_car.py),并将Battery和ElectricCar类复制到这个模块中。

electric_car.py

"""一组可用于表示电动汽车的类"""

from car import Car

class Battery( ):
    --snip--

class ElectricCar( ):
    --snip--

ElectricCar类需要访问其父类Car,因此在开始,直接将Car类导入该模块中。如果我们忘记了这行代码,python将在我们试图创建ElectricCar实例时引发错误。我们还需要重新更新模块car,使其包含Car类:

car.py

"""一个可用于表示汽车的类"""

class Car( ):
    --snip--

   现在可以分别从每个模块中导入类,以根据需要创建任何类型的汽车了:

my_cars.py

from car import Car
from eletric_car import ElectricCar

my_beetle = Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name( ))

my_tesla = ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name( ))

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券