带你一起学Python-3-Python面向对象编程

今天要分享的内容就是Python中的面向对象编程，面向对象的思想不是Python特有的，在C++/Java语言中都有面向对象的思想。

面向对象中最重要的两个概念就是类(class)和实例(Instance)。类（class）是一种抽象的概念，比如我们定义了一个人的类-Person，它指的是人这种概念。而实例指的就是某一个具体的人，比如说张三。面向对象中三个重要的特点就是：封装、继承、多态。（这三个概念在后面会讲到）

1、如何定义一个类

类中主要包括两个部分的内容：属性和行为。

结合Person类这个具体的例子可能更好理解面向对象的概念：

1）作为一个表示人的类Person，它应该具有哪些基本的属性：名字、性别、年龄。每个人都具有上面这三个属性。属性都是用变量来表示。

2）作为一个表示人的类Person，哪些行为是它共有的呢：呼吸、吃饭。我们用函数来表示类共有的行为。

我们可以用下面这段代码来表示上面定义的Person类：

class Person(object):
 def __init__(self, name, sex, age):
 self.name = name 
 self.sex = sex 
 self.age = age
 def breathe(self):
 print("我要呼吸")
 def eat(self):
 print("我要吃饭")

对上面代码的解释：

1）在Python中所有的类最终都继承了object，所以如果一个类如果没有显式的继承关系的话，定义方式如下：

class ClassName(object):
	#类的内容
	pass

2）__init__方法的第一个参数永远都是self，表示创建实例本身，在__init__方法内部，可以把各种属性绑定到self，因为self指向创建的实例本身。

3）在类中定义的函数可以称为类的成员函数，成员函数和普通的函数的不同就是"类的成员的函数的第一个参数永远是self，用来表示这个类的实例本身"

2、如何创建类的实例以及调用成员函数

直接看代码更加的直接：

#coding:utf-8
class Person(object):
 def __init__(self, name, sex, age):
 self.name = name 
 self.sex = sex 
 self.age = age
 def print_self(self):
 print("我的名字是：" + str(self.name))
 print("我是一个" + str(self.sex) + "生")
 print("我今年" + str(self.age) + "岁")
 def breathe(self):
 print("我要呼吸")
 def eat(self):
 print("我要吃饭")
#创建Person的一个实例
person1 = Person("liulinfeng", "男", 23)
#调用成员函数
person1.print_self()
person1.breathe()
person1.eat()

运行结果如下：

对上面代码的一些解释：

1）可以看到，类的每一个成员函数都有相同的一个参数self，并且都是作为第一个参数，在调用成员函数的时候，self是自动传入的，不需要我们显式的传递参数。

2）类的每一个实例，都自动具有类定义的所有的属性和方法。所以，我们可以认为类其实就是我们定义的一个模板。

面向对象编程的一个重要的特点就是数据封装。

先来看一下下面的分析：上例中的Person类有三个属性name、sex、age，然后在类外要访问这几个属性的话，可以直接按照下面的方式来进行访问：

#创建Person的一个实例
person1 = Person("liulinfeng", "男", 23)
#类外访问实例的属性
age = person1.age
print("person1的年龄是" + str(age) + "岁")
person1.age = 500
age = person1.age
print("person1的年龄是" + str(age) + "岁")

运行结果：

这会造成一个问题：可以随意的修改实例的属性，即使是让属性的值为一个不符合实际的值。这在实际的系统中是很不安全的。

下面就是改进的方法：

1. 我们可以使得在类外不能访问其属性，也就是给这些属性设定访问限制（这可以联想到C++/Java中private关键字的作用），设定方法是在属性名称的前面加上两个下划线。
2. 给属性加上访问限制后，如果在类外必须要访问这些属性怎么办呢？比如说随着时间的流逝，年龄必须是要更新的。我们可以定义两个函数，通过这两个函数可以访问到类的属性。

下面是代码的改进：

#coding:utf-8
class Person(object):
 def __init__(self, name, sex, age):
 self.__name = name 
 self.__sex = sex 
 self.__age = age
 '''
 属性age的set和get方法
 '''
 def get_age(self):
 return self.__age
 def set_age(self, age):
 if age > 150:
 return False
 else:
 self.age = age
#创建Person的一个实例
person1 = Person("liulinfeng", "男", 23)
#类外访问实例的属性
age = person1.get_age()
print("person1的年龄是" + str(age) + "岁")
res = person1.set_age(200)
if res == True:
 age = person1.get_age()
 print("person1的新年龄是" + str(age) + "岁")
else:
 print("age不符合规则")

运行结果：

这样做的好处就是：在类的外部想要访问类的属性必须通过提供给外部的setter、getter方法来进行访问，我们可以在方法内做出各种限定，防止因为错误访问出现数据错误。

这就是类的一大特点之一：类的数据封装。

2、类的继承

什么是类的继承？在面向对象程序设计中，我们定义一个类的时候，它可以继承已有的类。这个时候，已有的类称为父类（或者基类、超类）；新的类称为子类。一个类继承了已有的类之后，它将自动具有它的父类的所有的属性和方法。

下面看一个例子：

现在有三种动物：狗、猫、羊。它们都具有属性：雌雄、年龄、主人为它取的名字。请为上面的这个场景建模。

思路：我们可以定义基类Animal，表示动物，具有属性雌雄、年龄、名字。然后可以分别定义三个类（用来表示狗类、猫类、羊类）并且继承Animal类。

代码实现如下：

class Animal(object):
 '''
 1. __init__()方法用于绑定类的属性
 2. 所有的属性都设定访问限制
 '''
 def __init__(self, sex, age, name):
 self.__sex = sex 
 self.__age = age 
 self.__name = name
 def print_self(self):
 print("我的名字是" + self.__name)
 print("我的性别是" + self.__sex)
 print("我的年龄是" + str(self.__age))
 print()
#Dog类
class Dog(Animal):
 def print_dog(self):
 print("我是一条狗")
 super().print_self()
#猫类
class Cat(Animal):
 def print_cat(self):
 print("我是一只猫")
 super().print_self()
#羊类
class Sheep(Animal):
 def print_sheep(self):
 print("我是一只羊")
 super().print_self()
#测试
dog = Dog("m", 2, "dog")
dog.print_dog()
cat = Cat("m", 2, "cat")
cat.print_cat()
sheep = Sheep("m", 2, "sheep")
sheep.print_sheep()

运行结果：

子类中调用父类中的方法用super().method()；也可以直接使用类名.method()。

通过上面的例子可以体会到继承有一个很好的作用就是代码复用，如果不用继承的话，那么狗类、猫类、羊类都需要定义三个属性+函数print_self，显然代码会大大的冗余。

3、什么是多态？

多态往往和继承联系在一起。多态指的是当子类中有一个和父类同名的函数时，Python会调用子类的函数，这就是多态的意思。（在子类中定义一个和父类中的函数同名的函数称为重写父类的函数）

下面先看一个例子：

class Animal(object):
 '''
 1. __init__()方法用于绑定类的属性
 2. 所有的属性都设定访问限制
 '''
 def __init__(self, sex, age, name):
 self.__sex = sex 
 self.__age = age 
 self.__name = name
 def print_self(self):
 print("Animal running")
#Dog类
class Dog(Animal):
 def print_self(self):
 print("Dog running")
#测试
dog = Animal("m", 2, "dog")
dog.print_self()
dog2 = Dog("m", 2, "dog2")
dog2.print_self()

运行结果：

多态的好处就是，当我们需要传入更多的子类，例如新增 Cat类、Sheep类 等时，我们只需要继承 Animal 类型就可以了，而 print_self() 方法既可以不重写（即使用 Animal 的），也可以重写一个特有的。这就是多态的意思。

调用方只管调用，不管细节，而当我们新增一种 Animal 的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：

对扩展开放（Open for extension）：允许子类重写父类函数
对修改封闭（Closed for modification）：不重写，直接继承父类方法函数

以上就是今天要分享的内容了。

下一篇文章分享的内容: Python模块化操作，同时介绍几个Python中常用的模块。