文章目录
前言
本文的主要内容是Python中类的介绍及使用，具体包括面向对象与面向过程的介绍、类的创建和使用、使用类和实例、继承、类的导入和Python标准库的使用，文中附有代码以及相应的运行结果辅助理解。
一、面向对象与面向过程
面向过程（procedure-oriented）：注重过程，在解决一个问题的时候，面向过程会把事情拆分成 一个个函数和数据，然后按照一定的顺序，依次执行这些方法，等方法执行完了，问题就解决了。
面向对象（object-oriented）：注重对象，在解决一个问题的时候，面向对象会把事物抽象成若干个对象，然后再给对象赋一些属性和方法，让每个对象去执行自己的方法，问题得到解决。
举一个例子：洗衣机洗衣服。
面向过程：
1.把衣服放进洗衣机；
2.往洗衣机中注水；
3.加入洗衣液；
4.启动洗衣机；
5.洗衣机清洗；
6.洗衣机烘干。
面向过程洗衣服就是按照顺序按部就班的执行一个个的“函数”。
面向对象：
先抽象出两个对象：“人”和“洗衣机”。
对“人”加一些属性和方法：“把衣服放进洗衣机”、“往洗衣机中注水”、“加入洗衣液”、“启动洗衣机”。
对“洗衣机”加一些属性和方法：“洗衣机清洗”、“洗衣机烘干”。
执行：人——“把衣服放进洗衣机”；人——“往洗衣机中注水”；人——“加入洗衣液”；人——“启动洗衣机”；洗衣机——洗衣机清洗；洗衣机——洗衣机烘干。
面向对象洗衣服就是先抽象出类，然后各个类再分别调用“方法”。
二、类的创建和使用
面向对象编程是最有效的软件编写方法之一，在面向对象编程中，你编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。编写类时，你定义一大类对象都有的通用行为，基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。根据类来创建对象被称为实例化，这让你能够使用类的实例。
根据约定，在Python中，首字母大写的名称指的是类，类中的函数称为方法，通过实例访问的变量称为属性。
方法__init__()是一个特殊的方法，每当你给类创建新的实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。在这个方法的定义中，形参self是必不可少的，还必须位于其他形参的前面，因为Python调用__init__()方法来创建实例时，将自动传入实参self，因此我们不需要传递它，只需要给self后面的参数传递实参即可。每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
下面是一个类的创建和使用的例子。
class User():
"""定义用户的类"""
def __init__(self, first_name, last_name, gender, age):
"""初始化属性"""
self.name = first_name.title() + ' ' + last_name.title()
#获取存储在形参first_name和last_name中的值，并将其存储到变量name中
self.gender = gender
self.age = age
#这里的name，gender和age都是属性
def describe_user(self):
"""描述用户的方法"""
if self.gender == 'male':
print("This user's name is " + self.name + ", and his age is " + str(self.age) + ".")
elif self.gender == 'female':
print("This user's name is " + self.name + ", and her age is " + str(self.age) + ".")
def greet_user(self):
"""问候用户的方法"""
print("Hello, " + self.name + "!")
#这里的describe_user()和greet_user()都是方法
user_1 = User('lebron', 'james', 'male', 37) #根据类创建实例，Python遇到这行代码会调用方法__init__()来提供属性
print('name : ' + user_1.name) #用句点表示法访问实例的属性
print('gender : ' + user_1.gender)
print('age : ' + str(user_1.age))
user_1.describe_user() #用句点表示法调用方法
user_1.greet_user()
print()
user_2 = User('rachel', 'green', 'female', 24) #创建多个实例
print('name : ' + user_2.name) #用句点表示法访问实例的属性
print('gender : ' + user_2.gender)
print('age : ' + str(user_2.age))
user_2.describe_user()
user_2.greet_user()
运行结果如下图所示。
由运行结果可知，对于类中的属性可以用句点表示法访问实例的属性，也可以直接调用类中的方法。
三、使用类和实例
可以使用类来模拟现实世界中的很多情景，类编写好以后，大部分时间都将花在使用根据类创建的实例上，还要执行的一个重要任务是修改实例的属性，可以直接修改实例的属性，也可以编写方法以特定的方式进行修改。
1.给属性指定默认值
类中的每个属性都必须有初始值，即使这个值是0或空字符串。在有些情况下，如设置默认值时，如果在方法__init__()内指定了初始值，那么在后面的括号中就无需包含其形参。
下面是给属性指定默认值的例子。
class User():
"""定义用户的类"""
def __init__(self, first_name, last_name, gender, age): #不用给login_attempts传递形参
"""初始化属性"""
self.name = first_name.title() + ' ' + last_name.title()
#获取存储在形参first_name和last_name中的值，并将其存储到变量name中
self.gender = gender
self.age = age
self.login_attempts = 0 #给属性指定默认值后不用再传递形参
def print_login_attempts(self):
"""打印属性login_attempts"""
print('login_attempts in function: ' + str(self.login_attempts))
user = User('lebron', 'james', 'male', 37) #不用给login_attempts传递实参
print('name : ' + user.name) #用句点表示法访问实例的属性
print('gender : ' + user.gender)
print('age : ' + str(user.age))
print('login_attempts : ' + str(user.login_attempts)) #直接访问实例属性
user.print_login_attempts() #调用方法打印属性login_attempts
运行结果如下图所示。
由运行结果可知，我们给属性指定默认值之后，可以直接访问实例的该默认属性，也可以通过方法来访问，其结果都是一样的。
2.修改属性的值
修改属性的值可以用三种不同的方式：直接通过实例进行修改；通过方法进行修改；通过方法进行递增。
下面是修改属性值的例子，里面包含了上面提到的三种方法。
class User():
"""定义用户的类"""
def __init__(self, first_name, last_name, gender, age): #不用给login_attempts传递形参
"""初始化属性"""
self.name = first_name.title() + ' ' + last_name.title()
#获取存储在形参first_name和last_name中的值，并将其存储到变量name中
self.gender = gender
self.age = age
self.login_attempts = 0 #给属性指定默认值后不用再传递形参
def print_login_attempts(self):
"""打印属性login_attempts"""
print('print_login_attempts login_attempts : ' + str(self.login_attempts))
def update_login_attempts(self, value):
"""修改属性login_attempts的值"""
self.login_attempts = value
print('update_login_attempts login_attempts : ' + str(self.login_attempts))
def increment_login_attempts(self, value):
"""修改属性login_attempts的值"""
self.login_attempts += value
print('increment_login_attempts login_attempts : ' + str(self.login_attempts))
user = User('lebron', 'james', 'male', 37) #不用给login_attempts传递实参
print('name : ' + user.name) #用句点表示法访问实例的属性
print('gender : ' + user.gender)
print('age : ' + str(user.age))
print('original login_attempts : ' + str(user.login_attempts)) #直接访问实例属性
user.login_attempts = 10 #直接通过实例进行修改默认属性值
user.print_login_attempts() #调用方法打印属性login_attempts
user.update_login_attempts(20) #调用方法修改默认属性的值
user.increment_login_attempts(10) #调用方法对默认属性值递增
运行结果如下图所示。
由上面运行结果可知，原始的login_attempts值为0；直接通过实例进行修改其值后为10；通过方法修改其值时会覆盖掉原来的10，修改为20；再调用方法对属性值递增，递增时不会覆盖掉已有的login_attempts值20，而是在其基础上递增10，结果即为30。
四、继承
并非所有类的编写总是从空白开始，如果你要编写的类是另一个现成类的特殊版本，可使用继承。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法，原有的类称为父类(超类)，而新类称为子类，子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。
创建子类时，父类必须包含在当前文件中，且位于子类前面。
定义子类时，必须在括号内指定父类的名称。
1.子类的方法__init__()
创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值，而子类的方法__init__()需要父类施以援手。
super()是一个特殊函数，帮助Python将父类和子类关联起来。
下面是子类的方法__init__()编写的例子。
class User():
"""定义用户的类"""
def __init__(self, first_name, last_name, gender, age):
"""初始化属性"""
self.name = first_name.title() + ' ' + last_name.title()
self.gender = gender
self.age = age
def describe_user(self):
"""描述用户的方法"""
if self.gender == 'male':
print("This user's name is " + self.name + ", and his age is " + str(self.age) + ".")
elif self.gender == 'female':
print("This user's name is " + self.name + ", and her age is " + str(self.age) + ".")
def greet_user(self):
"""问候用户的方法"""
print("Hello, " + self.name + "!")
class Administrator(User):
"""定义子类Administrator继承父类User"""
def __init__(self, first_name, last_name, gender, age):
"""初始化父类的属性"""
super().__init__(first_name, last_name, gender, age)
admin = Administrator('lebron', 'james', 'male', 37)
admin.greet_user()
运行结果如下图所示。
通过上面的例子可以看到，子类Administrator继承了父类User的属性和方法，在子类的__init__()方法中需要用到super()来初始化父类的属性。子类继承父类后，就可以用父类中的属性和方法了。
2.给子类定义属性和方法
让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法。
下面是给子类定义属性和方法的例子。
class User():
"""定义用户的类"""
def __init__(self, first_name, last_name, gender, age):
"""初始化属性"""
self.name = first_name.title() + ' ' + last_name.title()
self.gender = gender
self.age = age
def describe_user(self):
"""描述用户的方法"""
if self.gender == 'male':
print("This user's name is " + self.name + ", and his age is " + str(self.age) + ".")
elif self.gender == 'female':
print("This user's name is " + self.name + ", and her age is " + str(self.age) + ".")
def greet_user(self):
"""问候用户的方法"""
print("Hello, " + self.name + "!")
class Administrator(User):
"""定义子类Administrator继承父类User"""
def __init__(self, first_name, last_name, gender, age):
"""初始化父类的属性"""
super().__init__(first_name, last_name, gender, age)
self.identity = 'administrator' # 添加子类的特有属性
def greet_admin(self): # 添加子类的特有方法
"""问候管理员的方法"""
print("Dear " + self.identity + ":")
print("Welcome to login, " + self.name + "!")
admin = Administrator('lebron', 'james', 'male', 37)
admin.greet_user() #调用子类继承父类的方法
admin.greet_admin() # 调用子类特有的方法
运行结果如下图所示。
可以看到，子类除了有父类的属性和方法，还可以添加新的属性和方法。
3.重写父类的方法
对于父类的方法，只要它不符合子类的要求，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。
下面是重写父类方法的例子。
class User():
"""定义用户的类"""
def __init__(self, first_name, last_name, gender, age):
"""初始化属性"""
self.name = first_name.title() + ' ' + last_name.title()
self.gender = gender
self.age = age
def describe_user(self):
"""描述用户的方法"""
if self.gender == 'male':
print("This user's name is " + self.name + ", and his age is " + str(self.age) + ".")
elif self.gender == 'female':
print("This user's name is " + self.name + ", and her age is " + str(self.age) + ".")
def greet_user(self):
"""问候用户的方法"""
print("Hello, " + self.name + "!")
class Administrator(User):
"""定义子类Administrator继承父类User"""
def __init__(self, first_name, last_name, gender, age):
"""初始化父类的属性"""
super().__init__(first_name, last_name, gender, age)
self.identity = 'administrator' # 添加子类的特有属性
def greet_admin(self): # 添加子类的特有方法
"""问候管理员的方法"""
print("Dear " + self.identity + ":")
print("Welcome to login, " + self.name + "!")
def describe_user(self):
"""重写父类的方法describe_user()"""
if self.gender == 'male':
print("This admin's name is " + self.name + ", and his age is " + str(self.age) + ".")
elif self.gender == 'female':
print("This admin's name is " + self.name + ", and her age is " + str(self.age) + ".")
user = User('lebron', 'james', 'male', 37)
user.describe_user() # 调用父类方法
admin = Administrator('emma', 'green', 'female', 24)
admin.describe_user() # 调用子类重写的父类方法
运行结果如下图所示。
通过上面运行结果的对比就可以知道，子类成功重写了父类的方法。
4.将实例用作属性
使用代码模拟实物时，你可能会发现给类添加的细节越来越多，属性和方法清单以及文件都越来越长，在这种情况下，可能需要将类的一部分作为一个独立的类提取出来，将大型类拆分成多个协同工作的小类。
下面是将实例用作属性的例子。
class User():
"""定义用户的类"""
def __init__(self, first_name, last_name):
"""初始化属性"""
self.name = first_name.title() + ' ' + last_name.title()
def print_name(self):
"""打印姓名"""
print("name : " + self.name)
class Attribute():
"""定义一个属性类"""
def __init__(self, gender, age):
"""初始化属性"""
self.gender = gender
self.age = age
def describe_attribute(self):
"""描述属性的方法"""
print("gender : " + self.gender)
print("age : " + str(self.age))
class Administrator(User):
"""定义子类Administrator继承父类User"""
def __init__(self, first_name, last_name):
"""初始化父类的属性"""
super().__init__(first_name, last_name)
self.attribute = Attribute('female', 24) # 将类用作属性
admin = Administrator('emma', 'green')
admin.print_name()
admin.attribute.describe_attribute() # 调用属性中的方法
运行结果如下图所示。
通过上面的例子可知，一个类可以作为另一个类的属性，这样一来，我们在完成一个复杂的问题时就可以将其拆解为多个小问题，每个小问题对应着一个小类，最后将它们合在一个大类中，大的问题就比较容易的解决了。
五、类的导入
如果不断地给类添加新的功能，文件可能变得很长，即便妥善地使用了继承也是如此，因此，可以将类存储在模块中，然后在主程序中导入所需的模块。
可以在一个模块里只存储一个类，比如在模块user.py中存储着名为User的这一个类，在主程序代码模块中导入该类时使用如下代码。
from user import User
也可以在一个模块中存储多个类，比如在模块user.py中存储着名为User、Admin等多个类，在主程序代码模块中要导入其中的几个类时使用如下代码。
from user import User, Admin
还可以使用如下代码导入user.py整个模块，再使用句点表示法访问需要的类。
import user
导入user.py模块中的所有类使用如下代码。
from user import *
下面是导入类的例子。
模块user.py中的代码如下。
class User():
"""定义用户的类"""
def __init__(self, first_name, last_name):
"""初始化属性"""
self.name = first_name.title() + ' ' + last_name.title()
def print_name(self):
"""打印姓名"""
print("name : " + self.name)
class Attribute():
"""定义一个属性类"""
def __init__(self, gender, age):
"""初始化属性"""
self.gender = gender
self.age = age
def describe_attribute(self):
"""描述属性的方法"""
print("gender : " + self.gender)
print("age : " + str(self.age))
class Administrator(User):
"""定义子类Administrator继承父类User"""
def __init__(self, first_name, last_name):
"""初始化父类的属性"""
super().__init__(first_name, last_name)
self.attribute = Attribute('female', 24) # 将类用作属性
主程序中的代码如下。
1.导入user.py整个模块。
import user
admin = user.Administrator('emma', 'green')
admin.print_name()
admin.attribute.describe_attribute() # 调用属性中的方法
2.从模块user.py中导入类。
from user import Administrator
# from user import *
# from user import User, Attribute, Administrator
# 对于本例，以上三条导入语法的运行结果一致
admin = Administrator('emma', 'green')
admin.print_name()
admin.attribute.describe_attribute()
对于本例而言，上面主程序中的代码不管是导入user.py整个模块还是从模块user.py中导入类，其运行结果都一样，如下图所示。
合理的导入类对于代码的可读性和维护性都有很大的好处。
六、Python标准库
Python标准库是一组模块，安装的Python都包含它，这是其他程序员编写好的模块，有时候我们需要用到它们，在程序开头包含一条import语句即可导入这些模块。
下面是Python标准库应用的例子。
from random import randint
class Dice():
"""掷骰子"""
def __init__(self):
self.sides = 6 #默认是6面的骰子
def roll_dice(self):
"""打印骰子点数"""
print(randint(1, self.sides))
def change_side(self,side):
"""改变骰子面数"""
self.sides = side
dice = Dice()
dice.roll_dice() # 点数在1-6之间
dice.change_side(10)
dice.roll_dice() # 点数在1-10之间
dice.change_side(20)
dice.roll_dice() # 点数在1-20之间
运行结果如下图所示。
本例用到的是random模块中的randint函数，这是Python自带的库，不用我们自己写，使用起来非常方便，使用Python标准库可以极大的方便我们编程。
总结
以上就是Python中类的介绍及使用的所有内容了，类的创建和使用是最基础也是最重要的；在继承中，子类既保留了父类的属性方法，还可以自己创建独有的属性和方法，将实例用作属性也是非常高效的编程手段；类的导入和Python标准库都是为了方便我们更好的编程，应当熟练运用。
本文参考书目：Python 编程 ：从入门到实践 / (美) 埃里克•马瑟斯(Eric Matthes)著；袁国忠译
参考博文：
面向对象与面向过程的本质的区别
https://zhuanlan.zhihu.com/p/75265007
文章出处登录后可见！
