Python-面向对象编程（超详细易懂）

本文主要是介绍Python-面向对象编程（超详细易懂），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

面向对象编程（oop）

面向对象是Python最重要的特性，在Python中一切数据类型都是面向对象的。

面向对象的编程思想：按照真实世界客观事物的自然规律进行分析，客观世界中存在什么样的实体，构建的软件系统就存在什么样的实体。

例如：在学校里，有学生实体，学生是抽象的描述，称为“类”；而张同学、李同学等具体的学生个体称为“对象”，也称为“实例”；学生有学号、姓名、班级等属性，还有吃饭、走路等操作。

面向对象三大特性：封装性、继承性、多态性

封装性：使外部访问者不能随意存取对象的内部数据，隐藏了对象的内部细节，只保留有限的对外接口。外部访问者不用关心对象的内部细节，操作对象变得简单。

继承性：特殊类继承一般类，拥有一般类的全部数据和操作。一般类称为“父类”或“超类”，特殊类称为“子类”或“派生类”。

多态性：在父类中成员被子类继承后，可以具有不同的状态或表现行为。

类和对象

Python中的数据类型都是类，类是组成Python程序的基本要素，它封装了一个类对象的数据和操作。

定义类

Python语言中一个类的实现包括类定义和类体。语法格式如下：

class 类名[(父类)]:类体

输入下面代码

class Animal:pass
print(id(Animal))
print(type(Animal))

代码运行结果

2519404222224
<class 'type'>

注意：object类是所有类的根类，在Python中任何一个类都直接或间接的继承object；代码的pass语句表示什么操作都不执行，用来维持程序结构的完整。

创建、使用和销毁对象

一个对象的生命周期包括创建、使用和销毁。类实例化可生成对象，所以对象也称为“实例”。

创建对象就是在类对象的后面加上一对小括号，表示调用类对象的构造方法，这就创建了一个对象，示例代码如下

class Animal:pass
'''
Animal()表达式创建了一个对象，并把创建的对象赋给animal变量
animal是指向对象的一个引用。通过animal可以使用刚刚创建的对象
'''
animal = Animal()
# print函数实际上是调用了对象的__str__()方法（__str__()是object类的一个方法，
# 用于返回有关该对象的描述信息）输出字符串信息
print(animal)

代码运行结果

<__main__.Animal object at 0x000001A74F1F1970>

销毁对象

Python会实现自动的垃圾回收：当对象没有被引用时（引用计数为0），由垃圾回收器调用__del__()（析构函数），__del__()被称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象占用的资源（例如：打开的文档资源、网络连接等）。我们也可以通过del语句删除对象，系统会自动调用__del__()方法，一般不需要自定义析构方法。

示例代码如下

class Person:def __del__(self):print("销毁对象：{0}".format(self))
p1 = Person()
p2 = Person()
del p2
'''
当 p2 的引用被 del 语句删除时
p2 的 __del__ 方法会被调用
但是，p1 的 __del__ 方法可能在程序结束前不会被调用
因为它的引用仍然存在于变量 p1 中
'''
print("程序结束")

代码运行结果

销毁对象：<__main__.Person object at 0x000001B649C01AF0>
程序结束
销毁对象：<__main__.Person object at 0x000001B649C01AC0>

实例变量

“实例变量”就是某个实例（或对象）个体特有的数据

示例代码如下

class Animal(object):def __init__(self,name,age,weight,gender):self.name = name # 定义姓名实例变量self.age= age # 定义年龄实例变量self.weight = weight # 定义体重实例变量self.gender =gender   # 定义性别实例变量
animal = Animal('Tom',18,66,1)
animal1 = Animal('Mary',18,50,0)print("姓名：{0}，年龄：{1}，体重：{2}".format(animal.name,animal.age,animal.weight))
print("男性" if animal.gender==1 else '女性')
print("姓名：{0}，年龄：{1}，体重：{2}".format(animal1.name,animal1.age,animal1.weight))
print("男性" if animal1.gender==1 else '女性')

代码运行结果

姓名：Tom，年龄：18，体重：66
男性
姓名：Mary，年龄：18，体重：50
女性

类变量

“类变量”是所有实例（或对象）共有的变量，需要在方法外定义，访问实例变量通过“实例名.实例变量名”的形式，而访问类变量“类名.类变量名”的形式访问。

示例代码如下

class Account:interest_rate = 0.068 # 类变量
# 重写构造方法def __init__(self,owner,amount):self.owner =  ownerself.amount = amount
account = Account('Tony',1_800_000.0)
# 查看实例变量
print('account实例所有变量：{0}'.format(account.__dict__))
# 为account.interest_rate变量赋值，此时无论类中是否有同名变量都会创建一个新的实例变量
account.interest_rate = 0.01
account.interest_rate2 = 0.01
print('账户名：{0}'.format(account.owner))
print('账号金额：{0}'.format(account.amount))
print('利率：{0}'.format(Account.interest_rate))
# 查看实例变量
print('account实例所有变量：{0}'.format(account.__dict__))

代码运行结果

account实例所有变量：{'owner': 'Tony', 'amount': 1800000.0}
账户名：Tony
账号金额：1800000.0
利率：0.068
account实例所有变量：{'owner': 'Tony', 'amount': 1800000.0, 'interest_rate': 0.01, 'interest_rate2': 0.01}

注意：不要通过实例存取类变量数据。当通过实例读取变量时，Python解释器会先在实例中找这个变量，如果没有再到类中去找；当通过实例为变量赋值时，无论类中是否有该同名变量，Python解释器都会创建一个同名实例变量。

构造方法

__init_()方法是构造方法，用来创建和初始化实例变量，定义时它的第一个参数应该是self，其后的参数才是用来初始化实例变量的；其中参数可以有默认值。调用构造方法时不需要传入self。如果未定义构造方法，则会自动调用默认的构造方法；一旦定义了构造方法，则不会调用默认的构造方法。

输入下面代码

class Animal(object):# 构造方法def __init__(self,name='mark',age=20,weight=120,gender=120):self.name = name # 定义姓名实例变量self.age= age # 定义年龄实例变量self.weight = weight # 定义体重实例变量self.gender =gender   # 定义性别实例变量
animal0 = Animal() # 此时没有传入参数，参数为默认值
animal = Animal('Tom',18,66,1)
animal1 = Animal('Mary',18,50,0)print("姓名：{0}，年龄：{1}，体重：{2}".format(animal0.name,animal0.age,animal0.weight))
print("姓名：{0}，年龄：{1}，体重：{2}".format(animal.name,animal.age,animal.weight))
print("姓名：{0}，年龄：{1}，体重：{2}".format(animal1.name,animal1.age,animal1.weight))

代码运行结果

姓名：mark，年龄：20，体重：120
姓名：Tom，年龄：18，体重：66
姓名：Mary，年龄：18，体重：50

实例方法

实例方法与实例变量一样都是某个实例个体特有的。定义实例方法时它的第一个参数应该是self，这个过程是将当前实例与该方法绑定起来，使该方法成为实例方法。

示例代码如下

class Animal:def __init__(self,age,sex=1,weight=0.0):self.age = ageself.sex = sexself.weight = weightdef eat(self):self.weight += 0.05print("eat...")def run(self):self.weight -= 0.01print("run...")
a1 = Animal(2,0,10.0)
print('a1体重：{0:0.2f}'.format(a1.weight))
a1.eat()
print('a1体重：{0:0.2f}'.format(a1.weight))
a1.run()
print('a1体重：{0:0.2f}'.format(a1.weight))

代码运行结果

a1体重：10.00
eat...
a1体重：10.05
run...
a1体重：10.04

类方法

类方法不需要与实例绑定，但需要与类绑定，定义时它的第一个参数是类的type实例。type是描述Python数据类型的类，Python中所有数据类型都是type的一个实例。类方法可以访问类变量和其他类方法，但不能访问其他实例方法和实例变量。

定义类方法：方法第一个参数cls是type类型的一个实例；方法使用装饰器@classmethod声明该方法是类方法。

示例代码如下

class Account:interest_rate = 0.0668 # 类变量
# 重写构造方法def __init__(self,owner,amount):self.owner =  ownerself.amount = amount# 类方法@classmethoddef interest_by(cls,amt):return cls.interest_rate * amtinterest = Account.interest_by(12_000.0)
print('计算利息：{0:.4f}'.format(interest))

代码运行结果

计算利息：801.6000

静态方法

如果定义的方法既不想与实例绑定，也不想与类绑定，只是想把类作为它的命名空间，那么可以定义静态方法。定义时使用@staticmethod装饰器，声明方法是静态方法，方法参数不指定self 和 cls。

示例代码如下

class Account:interest_rate = 0.0668 # 类变量
# 重写构造方法def __init__(self,owner,amount):self.owner =  ownerself.amount = amount# 类方法@classmethoddef interest_by(cls,amt):return cls.interest_rate * amt@staticmethoddef interst_with(amt):return Account.interest_by(amt)
interest1 = Account.interest_by(12_000.0)
print('计算利息：{0:.4f}'.format(interest1))
interest2 = Account.interest_by(12_000.0)
print('计算利息：{0:.4f}'.format(interest2))

代码运行结果

计算利息：801.6000
计算利息：801.6000

封装性

私有变量

默认情况下，Python中的变量是公有的，可以在类的外部访问他们。如果想让他们成为私有变量，可以在变量前加上双下划线“__”

示例代码如下

class Animal:def __init__(self,age,sex=1,weight=0.0):self.age = ageself.sex = sexself.__wight = weightdef eat(self):self.__wight += 0.05print("eat...")def run(self):self.__wight -= 0.01print("run...")a1 = Animal(2,0,10.0) # 该段代码发生错误，因为weight是私有变量，无法在类的外部访问
print('a1体重：{0:0.2f}'.format(a1.weight))
a1.eat()
a1.run()

代码运行结果

Python语言并不像Java，私有变量只是形式上私有，并非严格意义上的私有；如果想要访问私有变量，可以通过 _类名__变量名来访问，但是一般不推荐这么做，因为这违反了封装的原则，使代码的维护变得困难。（可见Python的封装性靠的是程序员的自律，而非强制性的语法）

输入下面代码

class Animal:def __init__(self,age,sex=1,weight=0.0):self.age = ageself.sex = sexself.__weight = weight #定义私有变量def eat(self):self.__weight += 0.05print("eat...")def run(self):self.__weight -= 0.01print("run...")a1 = Animal(2,0,10.0)
print('a1体重：{0:0.2f}'.format(a1._Animal__weight))
a1.eat()
a1.run()

代码运行结果

a1体重：10.00
eat...
run...

推荐的做法是定义一个公共方法来访问

示例代码如下

class Animal:def __init__(self,age,sex=1,weight=0.0):self.age = ageself.sex = sexself.__weight = weight #定义私有变量def eat(self):self.__weight += 0.05print("eat...")def run(self):self.__weight -= 0.01print("run...")def get_weight(self): # 添加一个公共方法来获取私有变量的值return self.__weighta1 = Animal(2,0,10.0)
print('a1体重：{0:0.2f}'.format(a1.get_weight()))
a1.eat()
a1.run()
print('a1体重：{0:0.2f}'.format(a1.get_weight()))

代码运行结果

a1体重：10.00
eat...
run...
a1体重：10.04

私有方法

私有方法与私有变量是类似的，只要在方法前加上双下划线“__”就是私有方法，在类外面强制使用也是“_变量名__方法名”（不推荐）。

示例代码如下

class Animal:def __init__(self,age,sex=1,weight=0.0):self.age = ageself.sex = sexself.__weight = weight #定义私有变量def eat(self):self.__weight += 0.05print("eat...")def __run(self):self.__weight -= 0.01print("run...")def get_weight(self): # 添加一个公共方法来获取私有变量的值return self.__weighta1 = Animal(2,0,10.0)
print('a1体重：{0:0.2f}'.format(a1.get_weight()))
a1.eat()
a1._Animal__run() #强制访问,不推荐这样做
print('a1体重：{0:0.2f}'.format(a1.get_weight()))

代码运行结果

a1体重：10.00
eat...
run...
a1体重：10.04

定义属性

在实际的面向对象设计中，一个类是不应该有公有的实例成员变量的，这些实例成员变量被设计为私有的，然后通过共有的 setter 和 getter 访问器访问。（访问器形式的封装需要一个私有变量，需要提供 setter 和 getter 访问器，只读变量不用提供 setter 访问器）

示例代码如下

class Animal:def __init__(self,age,sex=1,weight=0.0):self.age = ageself.sex = sexself.__weight = weight #定义私有变量def eat(self):self.__weight += 0.05print("eat...")def __run(self):self.__weight -= 0.01print("run...")def get_weight(self): # 添加一个公共方法来获取私有变量的值return self.__weightdef set_weight(self,weight): # 添加一个set方法来访问self.__weight = weighta1 = Animal(2,0,10.0) # 该段代码发生错误，因为weight是私有变量，无法在类的外部访问
print('a1体重：{0:0.2f}'.format(a1.get_weight()))
a1.set_weight(20.00)
print('a1体重：{0}'.format(a1.get_weight()))

代码运行结果

a1体重：10.00
a1体重：20.0

访问器形式的封装在编写代码时比较麻烦，Python提供了属性（poperty），定义属性可以使用@property 和 @属性名.setter装饰器。

示例代码如下

class Animal:def __init__(self,age,sex=1,weight=0.0):self.age = ageself.sex = sexself.__weight = weight #定义私有变量@propertydef weight(self): # 添加一个公共方法来获取私有变量的值return self.__weight@weight.setterdef weight(self,weight): # 添加一个set方法来访问self.__weight = weighta1 = Animal(2,0,10.0) # 该段代码发生错误，因为weight是私有变量，无法在类的外部访问
print('a1体重：{0:0.2f}'.format(a1.weight))
a1.weight = 20.0
print('a1体重：{0}'.format(a1.weight))

代码运行结果

a1体重：10.00
a1体重：20.0

继承性

多态性的前提是继承性，子类继承父类时只是继承父类中公有的成员变量和方法，不能继承私有的成员变量和方法。

示例代码如下

class Person:def __init__(self,age,sex=1,weight=0.0):self.age = ageself.sex = sexself.__weight = weight #定义私有变量class Student(Person): # Student继承了Person类def __init__(self,name,age,school):super().__init__(name,age) 
# 定义子类的构造方法时先要调用父类的构造方法，初始化父类实例变量self.school = school

重写方法

如果子类方法名与父类方法名相同，而且参数列表也相同，只是方法体不同，那么子类重写了父类的构造方法；此时在用子类对象调用该方法时，会执行子类的该方法，而不是父类的。

示例代码如下

class Animal:def __init__(self,age,sex=1,weight=0.0):self.age = ageself.sex = sexself.weight = weight #定义私有变量def eat(self):self.weight += 0.1print("动物吃...")class Dog(Animal):def eat(self):self.weight += 0.1print("狗狗吃...")a1 = Dog(2,0,10.0)
a1.eat()

代码运行结果

狗狗吃...

多继承

多继承就是一个子类继承多个父类，在Java中只能单继承，因为多继承会发生方法冲突。Python支持多继承，当子类实例调用一个方法时，先从子类中查找，如果没有则查找父类，查找父类的顺序是按照子类声明的父类列表从左到右查找，若没有则查找父类的父类。

示例代码如下

class ParentClass1:def run(self):print('ParentClass1 run...')class ParentClass2:def run(self):print('ParentClass2 run...')class SubClass1(ParentClass1,ParentClass2):passclass SubClass2(ParentClass2,ParentClass1):passclass SubClass3(ParentClass1,ParentClass2):def run(self):print('SubClass3 run...')sub1 = SubClass1()
sub1.run()
sub2 = SubClass2()
sub2.run()
sub3 = SubClass3()
sub3.run()

代码运行结果

ParentClass1 run...
ParentClass2 run...
SubClass3 run...

多态性

发生多态有两个前提条件：

继承—多态发生一定是子类和父类之间
重写—子类重写了父类的方法

示例代码如下

class Figure:def draw(self):print("Figure draw...")class Ellipse(Figure):def draw(self):print("Ellipse draw...")class Triangle(Figure):def draw(self):print("Triangle draw...")f2 = Ellipse()
f2.draw()
f3 = Triangle()
f3.draw()

代码运行结果

Ellipse draw...
Triangle draw...

类型检查

与Java语言相比，多态性对于动态语言Python而言意义不大。但是无论多态性对Python的多大，Python作为面向对象的语言多态性是存在的。

函数	描述
isinstance(object,classinfo)	可以检查 object 实例是否由 classinfo 类或 infoclass 子类所创建的实例
issubclass(class,classinfo)	可以检查 class 是否是 classinfo 的子类

示例代码如下

class Figure:def draw(self):print("Figure draw...")class Ellipse(Figure):def draw(self):print("Ellipse draw...")class Triangle(Figure):def draw(self):print("Triangle draw...")
f1 = Figure()
f2 = Ellipse()
f3 = Triangle()
print(isinstance(f2,Figure)) # True
print(isinstance(f3,Figure)) # True
print(isinstance(f1,Figure)) # True
print(isinstance(f1,object)) # True,因为任何类都是 object 类的子类
print(issubclass(Figure,object)) # True
print(issubclass(Ellipse,Triangle))# False

代码运行结果

True
True
True
True
True
False

鸭子类型

不关注变量的类型，而是关注变量具有的方法。鸭子类型像多态一样工作，但是没有继承，只要像“鸭子”一样的行为（方法）就可以了。（用“鸭子类型”代替多态性设计能够充分发挥Python动态语言特点，但是对程序员要求也非常高）

示例代码如下

class Animal(object):def run(self):print("Animal run...")class Dog(Animal):def run(self):print("Dog run...")class Car:def run(self):print("Car run...")def go(animal):if not isinstance(animal, (Animal, Car)):  # 检查 animal 是否为 Animal 或 Car 的实例return  # 如果不是，则作为递归的基案结束递归animal.run()  # 调用 run 方法# 创建实例
animal_instance = Animal()
dog_instance = Dog()
car_instance = Car()# 使用实例调用 go 函数
go(animal_instance)
go(dog_instance)
go(car_instance)
#添加了一个类型检查来确保只有 Animal 或 Car 的实例才会调用 run 方法。如果传入的不是这些类的实例，#go 函数将直接返回，避免递归调用。

代码运行结果

Animal run...
Dog run...
Car run...

Python根类—object

Python所有类都直接或间接的继承 object 类，object类有很多方法。

方法	描述
__str__()	默认返回对象的类名，以及内存地址等信息；可以重写该方法，输出描述信息
__eq__()	重写该方法指定相等的规则（即指定比较的是哪些实例变量相等）

示例代码1如下

class Person:def __init__(self,name,age):self.name = nameself.age = agedef __str__(self): # 重写str方法，返回什么样的字符串可以自己指定template = 'Person[name={0},age={1}]'s = template.format(self.name,self.age)return s
Person = Person('Tony',18)
print(Person)

代码运行结果

Person[name=Tony,age=18]

示例代码2如下

class Person:def __init__(self,name,age):self.name = nameself.age = agedef __str__(self): # 重写str方法，返回什么样的字符串可以自己指定template = 'Person[name={0},age={1}]'s = template.format(self.name,self.age)return sdef __eq__(self,other): # 重写eq方法，指定只有姓名和年龄都相等时才是Trueif self.name == other.name and self.age == other.age:return Trueelse:return Falsep1 = Person('Tony',18)
p2 = Person('Tony',18)
p3 = Person('Mary',18)
print(p1 == p2)
print(p1 == p3)

代码运行结果