Python系列10-Python类介绍

本是古典何须时尚 2022-11-14 11:59 203阅读 0赞

### 文章目录 ###

*  一.Python类介绍
 *   *  1.1 创建和使用类
     *   *  1.1.2 根据类创建实例
     *  1.2 使用类和实例
     *   *  1.2.1 创建一个database类
         *  1.2.2 给属性指定默认值
         *  1.2.3 修改属性的值
     *  1.3 继承
     *   *  1.3.1 子类的方法\_\_init\_\_()
         *  1.3.2 给子类定义属性和方法
         *  1.3.3 重写父类的方法
         *  1.3.4 将实例用作属性
     *  1.4 导入类
     *   *  1.4.1 导入单个类
         *  1.4.2 在一个模块中存储多个类
         *  1.4.3 从一个模块中导入多个类
         *  1.4.4 导入整个模块
         *  1.4.5 导入模块中的所有类
         *  1.4.6 在一个模块中导入另一个模块
     *  1.5 Python标准库
     *  1.6 类编码风格
 *  参考:

# 一.Python类介绍 #

面向对象编程 是最有效的软件编写方法之一。在面向对象编程中，你编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。编写类时，你定义一大类对象都有的通用行为。基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。使用面向对象编程可模拟现实情景，其逼真程度达到了令你惊讶的地步。

根据类来创建对象被称为实例化 ，这让你能够使用类的实例。在本章中，你将编写一些类并创建其实例。你将指定可在实例中存储什么信息，定义可对这些实例执行哪些操作。你还将编写一些类来扩展既有类的功能，让相似的类能够高效地共享代码。你将把自己编写的类存储在模块中，并在自己的程序文件中导入其他程序员编写的类。

理解面向对象编程有助于你像程序员那样看世界，还可以帮助你真正明白自己编写的代码：不仅是各行代码的作用，还有代码背后更宏大的概念。了解类背后的概念可培养逻辑思维，让你能够通过编写程序来解决遇到的几乎任何问题。

随着面临的挑战日益严峻，类还能让你以及与你合作的其他程序员的生活更轻松。如果你与其他程序员基于同样的逻辑来编写代码，你们就能明白对方所做的工作；你编写的程序将能被众多合作者所理解，每个人都能事半功倍。

## 1.1 创建和使用类 ##

使用类几乎可以模拟任何东西。下面来编写一个表示数据库的简单类Database ——它表示的不是特定的数据库，而是任何数据库。对于大多数数据库，都有数据库名称、创建年份、是否开源，我们还知道数据库有排名以及市场份额。

代码:

方法\_\_init\_\_()类中的函数称为方法 ；你前面学到的有关函数的一切都适用于方法，就目前而言，唯一重要的差别是调用方法的方式。方法\_\_init\_\_() 是一个特殊的方法，每当你根据Database 类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。

我们将方法\_\_init\_\_() 定义成了包含三个形参：self 、name 和creat\_year 。在这个方法的定义中，形参self 必不可少，还必须位于其他形参的前面。为何必须在方法定义中包含形参self 呢？因为Python调用这个\_\_init\_\_() 方法来创建Database 实例时，将自动传入实参self 。每个与类相关联的方法调用都自动传递实参self ，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。我们创建Database 实例时，Python将调用Database 类的方法\_\_init\_\_() 。我们将通过实参向Dog() 传递名字和创建年份；self 会自动传递，因此我们不需要传递它。每当我们根据Dog 类创建实例时，都只需给最后两个形参（name 和create\_year ）提供值。

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

Database 类还定义了另外两个方法：welcome\_db() 和study\_db() 。由于这些方法不需要额外的信息，如名字或创建年份，因此它们只有一个形参self 。我们后面将创建的实例能够访问这些方法。当前，welcome\_db() 和study\_db() 所做的有限，它们只是打印一条消息。

### 1.1.2 根据类创建实例 ###

可将类视为有关如何创建实例的说明。Database 类是一系列说明，让Python知道如何创建表示特定数据库的实例。

代码:

class Database():
        """一次模拟数据库的简单测试"""
    
        def __init__(self, name, create_year):
            """初始化属性create_year和is_open"""
            self.name = name
            self.create_year = create_year
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print(self.name + " is a very good database.")
    
        def study_db(self):
            """模拟我在学习数据库"""
            print("I'm studying " + self.name + "." )
    
    # 创建实例
    my_db1 = Database('Oracle', '1977')
    
    # 访问属性
    print(my_db1.name)
    print(my_db1.create_year)
    
    # 访问方法
    my_db1.welcome_db()
    my_db1.study_db()
    
    # 创建多个实例
    my_db2 = Database('MySQL', '1996')
    my_db3 = Database('PostgreSQL', '1987')
    
    print("\n")
    my_db2.welcome_db()
    my_db2.study_db()
    
    print("\n")
    my_db3.welcome_db()
    my_db3.study_db()

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/database.py
    Oracle
    1977
    Oracle is a very good database.
    I'm studying Oracle.
    
    
    MySQL is a very good database.
    I'm studying MySQL.
    
    
    PostgreSQL is a very good database.
    I'm studying PostgreSQL.
    
    Process finished with exit code 0

## 1.2 使用类和实例 ##

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

### 1.2.1 创建一个database类 ###

代码:

class Database():
        """一次模拟数据库的简单测试"""
    
        def __init__(self, name, create_year):
            self.name = name
            self.create_year = create_year
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print(self.name + " is a very good database.")
    
        def study_db(self):
            """模拟我在学习数据库"""
            print("I'm studying " + self.name + "." )

### 1.2.2 给属性指定默认值 ###

类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。在有些情况下，如设置默认值时，在方法\_\_init\_\_() 内指定这种初始值是可行的；如果你对某个属性这样做了，就无需包含为它提供初始值的形参。  
下面来添加一个名为 db\_type 的属性，其初始值总是为Relation。

代码:

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/database.py
    Oracle
    1977
    Relation
    
    Process finished with exit code 0

### 1.2.3 修改属性的值 ###

可以以三种不同的方式修改属性的值：直接通过实例进行修改；通过方法进行设置；通过方法进行递增（增加特定的值）。下面依次介绍这些方法。

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

代码:

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/database.py
    Oracle
    1977
    关系型数据库
    
    Process finished with exit code 0

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

代码:

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/database.py
    Oracle
    1977
    关系型数据库
    
    Process finished with exit code 0

**3.通过方法对属性的值进行递增**  
有时候需要将属性值递增特定的量，而不是将其设置为全新的值。

代码:

class Database():
        """一次模拟数据库的简单测试"""
    
        def __init__(self, name, create_year):
            """初始化属性create_year和name"""
            self.name = name
            self.create_year = create_year
            self.db_type = 'Relation'
            self.study_person = 100
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print(self.name + " is a very good database.")
    
        def study_db(self):
            """模拟我在学习数据库"""
            print("I'm studying " + self.name + "." )
    
    
        def update_value(self, increase_person):
            """更改学习数据库的人数"""
            self.study_person += increase_person
    
    
    
    # 创建实例,并修改属性
    my_db1 = Database('Oracle', '1977')
    
    # 访问属性
    print(my_db1.name)
    print(my_db1.create_year)
    
    print("\n")
    print(my_db1.study_person)
    my_db1.update_value(5)
    print(my_db1.study_person)
    
    print("\n")
    my_db1.update_value(8)
    print(my_db1.study_person)

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/database.py
    Oracle
    1977
    
    
    100
    105
    
    
    113
    
    Process finished with exit code 0

## 1.3 继承 ##

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

### 1.3.1 子类的方法\_\_init\_\_() ###

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

代码:

class Database():
        """一次模拟数据库的简单测试"""
    
        def __init__(self, name, create_year):
            """初始化属性create_year和name"""
            self.name = name
            self.create_year = create_year
            self.db_type = 'Relation'
            self.study_person = 100
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print(self.name + " is a very good database.")
    
        def study_db(self):
            """模拟我在学习数据库"""
            print("I'm studying " + self.name + "." )
    
    
        def update_value(self, increase_person):
            """更改学习数据库的人数"""
            self.study_person += increase_person
    
    
    class Relation_Database(Database):
        """关系型数据库的独特之处"""
    
        def __init__(self, name, create_year):
            """初始化父类的属性"""
            super().__init__(name, create_year)
    
    
    my_db1 = Relation_Database('Oracle', 1977)
    
    # 访问属性
    print(my_db1.name)
    print(my_db1.create_year)
    print(my_db1.db_type)

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/database.py
    Oracle
    1977
    Relation
    
    Process finished with exit code 0

首先是Database类，。创建子类时，父类必须包含在当前文件中，且位于子类前面。  
创建Relation\_Database子类的时候，必须在括号内指定父类的名称。方法\_\_init\_\_() 接受创建Database 实例所需的信息

super() 是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用Relation\_Database 的父类的方法\_\_init\_\_() ，让Relation\_Database 实例包含父类的所有属性。父类也称为超类 （superclass），名称super因此而得名。

### 1.3.2 给子类定义属性和方法 ###

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

下面来添加一个关系型数据库的独特之处，事务的隔离级别，并编写一个方法将其打印。

代码:

class Database():
        """一次模拟数据库的简单测试"""
    
        def __init__(self, name, create_year):
            """初始化属性create_year和name"""
            self.name = name
            self.create_year = create_year
            self.db_type = 'Relation'
            self.study_person = 100
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print(self.name + " is a very good database.")
    
        def study_db(self):
            """模拟我在学习数据库"""
            print("I'm studying " + self.name + "." )
    
    
        def update_value(self, increase_person):
            """更改学习数据库的人数"""
            self.study_person += increase_person
    
    
    class Relation_Database(Database):
        """关系型数据库的独特之处"""
    
        def __init__(self, name, create_year):
            """初始化父类的属性"""
            super().__init__(name, create_year)
            self.isolation_level = 'Read Commited'
    
    
        def describe_isolation(self):
            """打印数据库的事务隔离级别"""
            print("Database " + self.name + " isolation_level is " + self.isolation_level + ";")
    
    
    my_db1 = Relation_Database('Oracle', 1977)
    my_db1.describe_isolation()

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/database.py
    Database Oracle isolation_level is Read Commited;
    
    Process finished with exit code 0

### 1.3.3 重写父类的方法 ###

对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。

Database父类有一个welcomdb()的方法，针对关系型数据库，我想增加输出 “welcome Relation Database.”

代码:

class Database():
        """一次模拟数据库的简单测试"""
    
        def __init__(self, name, create_year):
            """初始化属性create_year和name"""
            self.name = name
            self.create_year = create_year
            self.db_type = 'Relation'
            self.study_person = 100
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print(self.name + " is a very good database.")
    
        def study_db(self):
            """模拟我在学习数据库"""
            print("I'm studying " + self.name + "." )
    
    
        def update_value(self, increase_person):
            """更改学习数据库的人数"""
            self.study_person += increase_person
    
    
    class Relation_Database(Database):
        """关系型数据库的独特之处"""
    
        def __init__(self, name, create_year):
            """初始化父类的属性"""
            super().__init__(name, create_year)
            self.isolation_level = 'Read Commited'
    
    
        def describe_isolation(self):
            """打印数据库的事务隔离级别"""
            print("Database " + self.name + " isolation_level is " + self.isolation_level + ";")
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print("\nwelcome Relation Database.")
            print(self.name + " is a very good Relation Database.")
    
    
    
    my_db1 = Relation_Database('Oracle', 1977)
    my_db1.welcome_db()

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/database.py
    
    welcome Relation Database.
    Oracle is a very good Relation Database.
    
    Process finished with exit code 0

### 1.3.4 将实例用作属性 ###

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

## 1.4 导入类 ##

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

### 1.4.1 导入单个类 ###

下面来创建一个只包含Database 类的模块。代码存储在Database.py文件中。

代码:  
database.py

class Database():
        """一次模拟数据库的简单测试"""
    
        def __init__(self, name, create_year):
            """初始化属性create_year和name"""
            self.name = name
            self.create_year = create_year
            self.db_type = 'Relation'
            self.study_person = 100
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print(self.name + " is a very good database.")
    
        def study_db(self):
            """模拟我在学习数据库"""
            print("I'm studying " + self.name + "." )
    
    
        def update_value(self, increase_person):
            """更改学习数据库的人数"""
            self.study_person += increase_person
    
    
    class Relation_Database(Database):
        """关系型数据库的独特之处"""
    
        def __init__(self, name, create_year):
            """初始化父类的属性"""
            super().__init__(name, create_year)
            self.isolation_level = 'Read Commited'
    
    
        def describe_isolation(self):
            """打印数据库的事务隔离级别"""
            print("Database " + self.name + " isolation_level is " + self.isolation_level + ";")
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print("\nwelcome Relation Database.")
            print(self.name + " is a very good Relation Database.")

my\_database.py

from database import Relation_Database
    
    my_db1 = Relation_Database('Oracle', 1977)
    my_db1.welcome_db()

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/my_database.py
    
    welcome Relation Database.
    Oracle is a very good Relation Database.
    
    Process finished with exit code 0

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

### 1.4.2 在一个模块中存储多个类 ###

一个模块中可以有多个类，例如Database.py 这个文件可以定义多个class，每个class负责完成不同的功能。

### 1.4.3 从一个模块中导入多个类 ###

可根据需要在程序文件中导入任意数量的类。

**代码:**  
database.py

class Database():
        """一次模拟数据库的简单测试"""
    
        def __init__(self, name, create_year):
            """初始化属性create_year和name"""
            self.name = name
            self.create_year = create_year
            self.db_type = 'Relation'
            self.study_person = 100
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print(self.name + " is a very good database.")
    
        def study_db(self):
            """模拟我在学习数据库"""
            print("I'm studying " + self.name + "." )
    
    
        def update_value(self, increase_person):
            """更改学习数据库的人数"""
            self.study_person += increase_person
    
    
    class Relation_Database(Database):
        """关系型数据库的独特之处"""
    
        def __init__(self, name, create_year):
            """初始化父类的属性"""
            super().__init__(name, create_year)
            self.isolation_level = 'Read Commited'
    
    
        def describe_isolation(self):
            """打印数据库的事务隔离级别"""
            print("Database " + self.name + " isolation_level is " + self.isolation_level + ";")
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print("\nwelcome Relation Database.")
            print(self.name + " is a very good Relation Database.")

my\_database.py

from database import Database,Relation_Database
    
    my_db1 = Database('Oracle', 1977)
    my_db1.welcome_db()
    
    print("\n")
    
    my_db1 = Relation_Database('Oracle', 1977)
    my_db1.welcome_db()

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/my_database.py
    Oracle is a very good database.
    
    
    
    welcome Relation Database.
    Oracle is a very good Relation Database.
    
    Process finished with exit code 0

### 1.4.4 导入整个模块 ###

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

代码:  
database.py

class Database():
        """一次模拟数据库的简单测试"""
    
        def __init__(self, name, create_year):
            """初始化属性create_year和name"""
            self.name = name
            self.create_year = create_year
            self.db_type = 'Relation'
            self.study_person = 100
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print(self.name + " is a very good database.")
    
        def study_db(self):
            """模拟我在学习数据库"""
            print("I'm studying " + self.name + "." )
    
    
        def update_value(self, increase_person):
            """更改学习数据库的人数"""
            self.study_person += increase_person
    
    
    class Relation_Database(Database):
        """关系型数据库的独特之处"""
    
        def __init__(self, name, create_year):
            """初始化父类的属性"""
            super().__init__(name, create_year)
            self.isolation_level = 'Read Commited'
    
    
        def describe_isolation(self):
            """打印数据库的事务隔离级别"""
            print("Database " + self.name + " isolation_level is " + self.isolation_level + ";")
    
        def welcome_db(self):
            """模拟说数据库是非常好的数据库"""
            print("\nwelcome Relation Database.")
            print(self.name + " is a very good Relation Database.")

my\_database.py

import database
    
    my_db1 = database.Database('Oracle', 1977)
    my_db1.welcome_db()
    
    print("\n")
    
    my_db1 = database.Relation_Database('Oracle', 1977)
    my_db1.welcome_db()

测试记录:

### 1.4.5 导入模块中的所有类 ###

要导入模块中的每个类，可使用下面的语法：

from module_name import *

不推荐使用这种导入方式，其原因有二。首先，如果只要看一下文件开头的import 语句，就能清楚地知道程序使用了哪些类，将大有裨益；但这种导入方式没有明确地指出你使用了模块中的哪些类。这种导入方式还可能引发名称方面的困惑。如果你不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。这里之所以介绍这种导入方式，是因为虽然不推荐使用这种方式，但你可能会在别人编写的代码中见到它。

需要从一个模块中导入很多类时，最好导入整个模块，并使用 module\_name.class\_name 语法来访问类。这样做时，虽然文件开头并没有列出用到的所有类，但你清楚地知道在程序的哪些地方使用了导入的模块；你还避免了导入模块中的每个类可能引发的名称冲突。

### 1.4.6 在一个模块中导入另一个模块 ###

有时候，需要将类分散到多个模块中，以免模块太大，或在同一个模块中存储不相关的类。将类存储在多个模块中时，你可能会发现一个模块中的类依赖于另一个模块中的类。  
在这种情况下，可在前一个模块中导入必要的类。

## 1.5 Python标准库 ##

Python标准库 是一组模块，安装的Python都包含它。你现在对类的工作原理已有大致的了解，可以开始使用其他程序员编写好的模块了。可使用标准库中的任何函数和类，为此只需在程序开头包含一条简单的import 语句。

下面来看模块collections 中的一个类——OrderedDict 。  
字典让你能够将信息关联起来，但它们不记录你添加键—值对的顺序。要创建字典并记录其中的键—值对的添加顺序，可使用模块collections 中的OrderedDict类。OrderedDict 实例的行为几乎与字典相同，区别只在于记录了键—值对的添加顺序。

我们再来看一看favorite\_languages.py示例，但这次将记录被调查者参与调查的顺序：  
favorite\_languages.py

from collections import OrderedDict
    
    favorite_languages = OrderedDict()
    
    favorite_languages['jen'] = 'python'
    favorite_languages['sarah'] = 'c'
    favorite_languages['edward'] = 'ruby'
    favorite_languages['phil'] = 'python'
    
    for name, language in favorite_languages.items():
        print(name.title() + "'s favorite language is " + language.title() + ".")

测试记录:

E:\python\learn_python1\venv\Scripts\python.exe E:/python/learn_python1/favorite_languages.py
    Jen's favorite language is Python.
    Sarah's favorite language is C.
    Edward's favorite language is Ruby.
    Phil's favorite language is Python.
    
    Process finished with exit code 0

## 1.6 类编码风格 ##

你必须熟悉有些与类相关的编码风格问题，在你编写的程序较复杂时尤其如此。

类名应采用驼峰命名法 ，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。

对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。

可使用空行来组织代码，但不要滥用。在类中，可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。

需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import 语句，再添加一个空行，然后编写导入你自己编写的模块的import 语句。在包含多条import 语句的程序中，这种做法让人更容易明白程序使用的各个模块都来自何方。

# 参考: #

1.Python编程:从入门到实践