python中面向对象的三大特性（高级编程之面向对象）

科班出身的同学应该学过C语言、C 或者Java，编程语言一般分为两种设计方式：面向过程编程、面向对象编程，早期的编程语言多数是面向过程的，像C语言就是面向过程编程，面向过程由多个过程组合在一起，也可以理解为函数编程，而python在设计的时候就是一种面向对象编程的语言，其实python把面向对象简化了很多，如果学过java的同学再来学习python面向对象就会感觉非常简单。所以本篇文章就让我带着大家来学习一下什么是面向对象编程。

python环境和基础部分讲解可以参考我以下几篇文章：

• Python 介绍和环境准备
• Python 基础语法介绍（一）
• Python 基础语法介绍（二）

• 类(Class)——用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类方法——类中定义的函数。
• 类属性——属性就是类变量。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 实例变量——在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承——即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化——创建一个类的实例，类的具体对象。
• 对象——通过类定义的数据结构实例。对象包括两个数据成员：属性和方法。

对象可以分为两个部分：一部分称为属性（变量），一部分称为行为（方法）。

1）类定义

语法格式如下：

class ClassName: <statement-1> . . . <statement-N>

示例如下：

#!/usr/bin/python3 class MyClass: """一个简单的类实例""" i = 12345 def f(self): return 'hello world' # 实例化类 x = MyClass() # 访问类的属性和方法 print("MyClass 类的属性 i 为：", x.i) print("MyClass 类的方法 f 输出为：", x.f())

2）类属性

python类属性分为：私有属性和公开属性，python是没有什么修饰符的，像java就分的更细致，通过private(私有级)、protected(受保护级)、无前缀(默认级)、public(公开级)控制权限。

• 私有属性（__private_attrs）：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
• 公开属性（private_attrs）：不带两个下划线开头，可以在类外访问，通过实例名访问，也可以在类中访问。

示例如下：

#!/usr/bin/python3 class JustCounter: __secretCount = 0 # 私有变量 publicCount = 0 # 公开变量 def count(self): self.__secretCount = 1 self.publicCount = 1 print (self.__secretCount) counter = JustCounter() counter.count() counter.count() print (counter.publicCount) print (counter.__secretCount) # 报错，实例不能访问私有变量

3）类方法

类方法也是分为：私有方法和公开方法，但是私有变量属性一把通过set/get公开方法操作。示例如下：

class Parents(object): __name = "test" __age = 35 # 设置姓名 def set_name(self, name): self.__name = name # 获取姓名 def get_name(self): return self.__name # 设置年龄 def set_age(self, age): self.__age = age # 获取年龄 def get_age(self): return self.__age if __name__ == "__main__": # 实例化 p = Parents() # 调用公有方法去设置属性 p.set_age(30) # 获取私有属性 print(p.get_age()) # 调用公有方法去设置属性 p.set_name("zhangsan") # 获取私有属性 print(p.get_name())

【温馨提示】self 的名字并不是固定的，也可以使用 this，但是最好还是按照约定使用 self。

4）构造方法（init）

init : 构造函数，在生成对象时调用。

示例如下：

class Parents(object): __name = "test" __age = 35 def __init__(self, name, age): self.__name = name self.__age = age # 设置姓名 def set_name(self, name): self.__name = name # 获取姓名 def get_name(self): return self.__name # 设置年龄 def set_age(self, age): self.__age = age # 获取年龄 def get_age(self): return self.__age if __name__ == "__main__": # 实例化 p = Parents(25, "lisi") # 获取私有属性 print(p.get_age()) # 获取私有属性 print(p.get_name())

不单单有构建函数，还有其它专有的函数，都是自动去调用的：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用
• repr : 打印，转换
• setitem : 按照索引赋值
• getitem: 按照索引获取值
• len: 获得长度
• cmp: 比较运算
• call: 函数调用
• add: 加运算
• sub: 减运算
• mul: 乘运算
• truediv: 除运算
• mod: 求余运算
• pow: 乘方

三、面向对象封装、继承和多态

面向对象编程有三大特点：封装、继承和多态。

1）封装

就是将一个类的属性、方法全部包装到了一个类中。一般设置属性为私有的，通过方法去调用，当然有些方法只需要在类内部使用也是可以设置成私有的方法的，通过公开的方法来供外部间接调用这些“封装”好的属性和方法，这就是封装。

其实上面的示例就是很好的证明，内部定义私有属性，外部通过公开的方法访问。

class Parents(object): __name = "test" __age = 35 def __init__(self, name, age): self.__name = name self.__age = age # 设置姓名 def set_name(self, name): self.__name = name # 获取姓名 def get_name(self): return self.__name # 设置年龄 def set_age(self, age): self.__age = age # 获取年龄 def get_age(self): return self.__age if __name__ == "__main__": # 实例化 p = Parents(25, "lisi") # 获取私有属性 print(p.get_age()) # 获取私有属性 print(p.get_name())

2）继承

继承就非常好理解了，其实通过字面意思理解就行了，一个类是另一个类的子类，那么这个类就可以拥有和父类一样的属性、方法。这就好比是现实当中，儿子继承父母的遗产一样。但是需要注意的是私有属性和私有方法是无法继承的，其它语言也是一样的。

在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

示例如下：

class Animal(object): # 无法给继续子类 __name = "" # 可以继承给子类 color = "" def __init__(self, name, color): self.__name = name self.color = color # 可以继承给子类 def set_name(self, name): self.__name = name def get_name(self): return self.__name def set_color(self, color): self.color = color # 无法给继续子类 def __get_color(self): return self.color class Cat(Animal): def __init__(self, name, color): self.name = name self.color = color # 调用父类构造函数 super(Cat, self).__init__(name, color) # Animal.__init__(name, color) # 重写父类方法 def set_name(self, name): self.name = name # 重写父类方法 def get_name(self): return self.name if __name__ == "__main__": c = Cat("小猫", "黑色") # 获取父类公开属性 print(c.color) # 调用子类方法重写的方法 c.set_name("大猫")

多继承：所谓多继承意思就是一个类同时继承了多个父类

示例如下：

#类定义 class people: #定义基本属性 name = '' age = 0 #定义私有属性,私有属性在类外部无法直接进行访问 __weight = 0 #定义构造方法 def __init__(self,n,a,w): self.name = n self.age = a self.__weight = w def speak(self): print("%s 说: 我 %d 岁。" %(self.name,self.age)) #单继承示例 class student(people): grade = '' def __init__(self,n,a,w,g): #调用父类的构函 people.__init__(self,n,a,w) self.grade = g #覆写父类的方法 def speak(self): print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade)) #另一个类，多重继承之前的准备 class speaker(): topic = '' name = '' def __init__(self,n,t): self.name = n self.topic = t def speak(self): print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic)) #多重继承 class sample(speaker,student): a ='' def __init__(self,n,a,w,g,t): student.__init__(self,n,a,w,g) speaker.__init__(self,n,t) test = sample("Tim",25,80,4,"Python") test.speak() #方法名同，默认调用的是在括号中参数位置排前父类的方法

3）子类重新方法和super()调用父类方法

class Parent: # 定义父类 def myMethod(self): print ('调用父类方法') class Child(Parent): # 定义子类 # 重新父类方法 def myMethod(self): print ('调用子类方法') c = Child() # 子类实例 c.myMethod() # 子类调用重写方法 super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

4）多态

多态首先是建立在继承的基础上的，先有继承才能有多态。多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式。多态成立的另一个条件是在创建子类时候必须使用父类new子类的方式。

示例如下：

#!/usr/bin/env python3 # -*- coding:utf-8 -*- class Person: def __init__(self, name, age): self.name = name self.age = age def print_age(self): print("%s's age is %s" % (self.name, self.age)) class Man(Person): def print_age(self): print("Mr. %s's age is %s" %(self.name, self.age)) class Woman(Person): def print_age(self): print("Ms. %s's age is %s" %(self.name, self.age)) def person_age(person): person.print_age() if __name__ == "__main__": person = Person("kevin", 23) man = Man("Bob", 33) woman = Woman("Lily", 28) person_age(person) person_age(man) person_age(woman)

【总结】其实多态也很好理解，就是将不同的对象传到相同的函数，表现不同的形态，这就是多态。

其实python的面向对象还是非常简单的，因为相比其它语言的面向对象简化了很多，python的面向对象讲解就先到这里了，有疑问的小伙伴欢迎给我留言哦，也可以关注我的公众号【大数据与云原生技术交流】深入技术交流~

,