python中类有什么用 python中的类有哪些

文章目录

• 一.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 ——它表示的不是特定的数据库，而是任何数据库。对于大多数数据库，都有数据库名称、创建年份、是否开源，我们还知道数据库有排名以及市场份额。

代码:

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 + "." )

方法__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。

代码:

class Database():
    """一次模拟数据库的简单测试"""

    def __init__(self, name, create_year):
        """初始化属性create_year和name"""
        self.name = name
        self.create_year = create_year
        self.db_type = 'Relation'

    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)
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

1.2.3 修改属性的值

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

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

代码:

class Database():
    """一次模拟数据库的简单测试"""

    def __init__(self, name, create_year):
        """初始化属性create_year和name"""
        self.name = name
        self.create_year = create_year
        self.db_type = 'Relation'

    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')
my_db1.db_type = '关系型数据库'

# 访问属性
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
关系型数据库

Process finished with exit code 0

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

代码:

class Database():
    """一次模拟数据库的简单测试"""

    def __init__(self, name, create_year):
        """初始化属性create_year和name"""
        self.name = name
        self.create_year = create_year
        self.db_type = 'Relation'

    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, new_db_type):
        """更改属性的值"""
        self.db_type = new_db_type



# 创建实例,并修改属性
my_db1 = Database('Oracle', '1977')
my_db1.update_value('关系型数据库')

# 访问属性
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
关系型数据库

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()

测试记录:

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.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编程:从入门到实践