Python面向对象一文详解实例-XAMPP中文组官网

在介绍python面向对象编程之前，先来了解几个术语：

类: 用来描述具有相同的属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法。
数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
类变量：类变量在整个实例化的对象中是公用的，类变量定义在类中且在函数体之外，类变量通常不作为实例变量使用。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
方法：类中定义的函数。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例，对象包括数据成员（类变量和实例变量）和方法。
继承：即一个派生类继承基类的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
多态：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖，也称为方法的重写。

一个简单的实例：

# 创建一个学生类
class Student:
course_count = 4 # 类变量
# 定义学生属性（构造函数）
def __init__(self, name, number):
self.name = name # 实例变量
self.number = number # 实例变量
# 定义方法
def show(self):
print(f’姓名: {self.name}，学号: {self.number}’)# 实例化
stu1 = Student(‘当打之年’,’001′)
stu1.show()
print(f’共 {stu1.course_count} 门课程’)
# 姓名: 当打之年，学号: 001
# 共 4 门课程
stu2 = Student(‘欧K’,’002′)
stu2.show()
print(f’共 {stu2.course_count} 门课程’)
# 姓名: 欧K，学号: 002
# 共 4 门课程

1. 类

1.1 创建

语法格式：

class ClassName:
”’变量”’
”’方法”’
pass

class 是关键字，表示类。例如 class Student 即创建了一个 Student 类。

1.2 数据成员

数据成员包括：变量和方法。

1.2.1 变量：

类变量：定义在类中且在函数体之外，在实例化对象中是公有的。

course_count = 4 # 类变量

实例变量：在类的内部，但是在类的其他成员方法之外声明，在实例化对象中是私有的。

def __init__(self, name, number):
self.name = name # 实例变量
self.number = number # 实例变量

本例是通过构造函数来声明，类变量和实例变量的区别很大，访问方式也也不一样。

1.2.2 方法：

类中定义的函数：

# 定义方法
def show(self):
print(f’姓名: {self.name}，学号: {self.number}’)

初始化时的构造函数也是一种方法。

提示：

在对象的方法里面都有一个self参数, 比如__init__(self), show(self)。这里的self是指对象本身而非类本身。

构造方法__init__(self,….)：在生成对象时调用，可以用来进行一些初始化操作，不需要显示去调用，系统会默认去执行。构造方法支持重载，如果用户自己没有重新定义构造方法，系统就自动执行默认的构造方法。

1.4 私有/公有

类里面的私有属性和私有方法以双下划线__开头。私有属性或方法不能在类的外部被使用或直接访问，公有属性和公有方法可以在类的外部被使用或直接访问。

def __init__(self, name, number, score):
self.name = name # 实例变量
self.number = number # 实例变量
self.__score = score # 私有变量# 实例化
stu1 = Student(‘当打之年’,’001′,90)
print(stu1.name) # 当打之年
print(stu1.__score) # AttributeError: ‘Student’ object has no attribute ‘__score’

2. 对象/实例

2.1 创建（类的实例化）

实例化两个Student对象：

# 实例化
stu1 = Student(‘当打之年’,’001′)
stu2 = Student(‘欧K’,’002′)

实例化需要传入相应的参数。

2.2 调用

调用一般指类方法的调用：

# 实例化
stu1 = Student(‘当打之年’,’001′)
stu1.show()
print(f’共 {stu1.course_count} 门课程’)
# 姓名: 当打之年，学号: 001
# 共 4 门课程
stu2 = Student(‘欧K’,’002′)
stu2.show()
print(f’共 {stu2.course_count} 门课程’)
# 姓名: 欧K，学号: 002
# 共 4 门课程

直接通过实例对象调用即可。

print语句中使用了f-string格式化，具体用法可参考下面这篇文章(点击跳转)：

超全解析Python三种格式化输出方式[% / format / f-string]

2.2.1 @classmethod（类方法）

@classmethod将函数定义为类方法，函数可通过类和实例调用：

声明前：

def get_course_count(self):
print(f’共 {self.course_count} 门课程’)# 实例化
stu1 = Student(‘当打之年’,’001′)
stu1.get_course_count() # 共 4 门课程
Student.get_course_count() # TypeError: get_course_count() missing 1 required positional argument: ‘self’

声明后：

@classmethod
def get_course_count(cls):
print(f’共 {self.course_count} 门课程’)# 实例化
stu1 = Student(‘当打之年’,’001′)
stu1.get_course_count() # 共 4 门课程
Student.get_course_count() # 共 4 门课程

这里的cls和self相似，是惯用写法，均可用其他字符代替。

2.2.2 @staticmethod（静态函数）

@staticmethod 将函数定义为静态函数，类和实例都可以访问，但是静态函数无法访问类变量：

@staticmethod
def student_info(a,b,c):
print(f’姓名: {a}，学号: {b}，共 {c} 门课程’) # 姓名: 当打之年，学号: 001，共 4 门课程
print(f’姓名: {a}，学号: {b}，共 {course_count} 门课程’) # 错误# 实例化
stu1 = Student(‘当打之年’,’001′)
stu1.student_info(‘当打之年’,’001′,4) # 姓名: 当打之年，学号: 001，共 4 门课程

course_count为类变量，直接访问会报错，此外静态函数参数个数没有要求，可有可无。

2.2.3 @property（伪装）

@property 将函数伪装成属性：

@property
def get_student_info(self):
print(f’姓名: {self.name}，学号: {self.number}，共 {self.course_count} 门课程’)# 实例化
stu1 = Student(‘当打之年’,’001′)
stu1.get_student_info() # TypeError: ‘NoneType’ object is not callable
stu1.get_student_info # 姓名: 当打之年，学号: 001，共 4 门课程

此时的get_student_info函数被伪装成实例属性（类似变量）而不在是函数，所以通过函数调用的方式会报错，可直接通过属性调用。

3. 继承

面向对象的编程带来的最大好处之一就是代码的复用，实现这种复用的方法之一是通过继承。先定义一个基类（父类），再按通过class子类名（父类名）来创建子类，这样子类就可以从父类那里获得其已有的属性与方法。3.1 子类 语法格式（单继承、多继承）：

# 单继承
class ChildClassName(FatherClassName):
”’变量”’
”’方法”’
pass# 多继承
class ChildClassName(FatherClassName1,FatherClassName2,…):
”’变量”’
”’方法”’
pass

父类：大学学生类，子类：某专业学生类

# 创建一个大学学生类
class CollegeStudent:
print(‘我是父类’)
# 定义学生属性（构造函数）
def __init__(self, name, number):
self.name = name # 实例变量
self.number = number # 实例变量
# 定义方法
def show(self):
print(f’姓名: {self.name}，学号: {self.number}’)# 创建某专业学生子类
class Student(CollegeStudent):
print(‘我是子类’)
pass# 实例化
stu1 = Student(‘当打之年’,’001′)
stu1.show() # 姓名: 当打之年，学号: 001

3.2 派生

派生就是子类在继承父类的基础上衍生出新的属性或者方法。即子类中有，父类中没有；或子类定义与父类重名的东西。子类也叫派生类。

3.2.1 增加属性：

# 创建某专业学生子类
class Student(CollegeStudent):
def __init__(self, name, number, score):
CollegeStudent.__init__(self, name, number)
self.score = score # 实例变量
# 定义方法
def show_score(self):
print(f’姓名: {self.name}，学号: {self.number}，成绩: {self.score}’)# 实例化
stu1 = Student(‘当打之年’,’001′,99)
stu1.show() # 姓名: 当打之年，学号: 001
stu1.show_score() # 姓名: 当打之年，学号: 001，成绩: 99

stu1.show()是调用父类方法，stu1.show_score()是调用子类新增的方法。

3.2.2 方法重写：

# 创建某专业学生子类
class Student(CollegeStudent):
def __init__(self, name, number, score):
CollegeStudent.__init__(self, name, number)
self.score = score # 实例变量# 重写方法
def show(self):
print(f’姓名: {self.name}，学号: {self.number}，成绩: {self.score}’)# 实例化
stu1 = Student(‘当打之年’,’001′,99)
stu1.show() # 姓名: 当打之年，学号: 001，成绩: 99

父类和子类中都有show()方法，子类中show()方法是对父类该方法的重写（重定义）。

3.2.3 super()关键字：

如果父类方法被重写，但是还需要调用父类方法的话，可以使用super()关键字。

# 创建某专业学生子类
class Student(CollegeStudent):
def __init__(self, name, number, score):
CollegeStudent.__init__(self, name, number)
self.score = score # 实例变量# 重写方法
def show(self):
super().show()
”’其他代码”’# 实例化
stu1 = Student(‘当打之年’,’001′,99)
stu1.show() # 姓名: 当打之年，学号: 001

4. 多态

Python中的变量是弱类型的，对于弱类型的语言来说，变量并没有声明类型，因此，同一个变量完全可以在不同的时间引用不同的对象，当同一个变量在调用不同的方法时，完全可能呈现多种行为（具体呈现出哪种行为由该变量所引用的对象决定），即多种形态。4.1 方法多态

创建两个类：学生类、教师类

# 创建学生类
class Student:
def __init__(self, name, number, score):
self.name = name # 实例变量
self.number = number # 实例变量
self.score = score # 私有变量def show(self):
print(f’学生姓名: {self.name}，学号: {self.number}，成绩: {self.score}’)# 创建教师类
class Teacher:
def __init__(self, name, number):
self.name = name # 实例变量
self.number = number # 实例变量def show(self):
print(f’教师姓名: {self.name}，工号: {self.number}’)# 实例化学生对象
stu1 = Student(‘当打之年’,’001′,99)
stu1.show() # 学生姓名: 当打之年，学号: 001，成绩: 99
# 实例化教师对象
tec1 = Teacher(‘Python’,’t101′)
tec1.show() # 教师姓名: Python，工号: t101

两个类都具有show()方法，但是实现的功能不一样，即同一种方法不同的功能。

4.2 运算符多态

加法多态：

def add(data1, data2):
return data1 + data2print(add(3, 5)) # 8
print(add(‘Python ‘, ‘当打之年’)) # Python 当打之年

上述定义的加法运算符我们不用关心两个参数data1和data2具体是什么类型，只要是支持加法运算的对象就可以，即可以是多种形态的对象。

4.3 运算符重载

以加法、减法重载为例：

# 运算符类
class Operate:
def __init__(self, data):
self.data = data# 内置魔法函数
def __repr__(self): # 消除两边的尖括号
return f’Operate({self.data})’# 制定self + other规则
def __add__(self, other):
a = self.data + other.data
return Operate(a)# 制定self – other规则
def __sub__(self, other):
a = self.data – other.data
return Operate(a)r1 = Operate(100)
r2 = Operate(300)
r3 = r1 + r2 # Operate(400)
print(r3)
r4 = r3 – r2 # Operate(100)

所有重载方法的名称前后都有两个下划线字符，以便把同类中定义的变量名区别开来。

5. 总结

两个核心：类、对象。

三大特征：封装、继承、多态。

重点注意继承和多态，旨在提高代码的复用性以及灵活性。

END

转载请注明：XAMPP中文组官网 » Python面向对象一文详解实例

Python面向对象一文详解实例

与本文相关的文章

您必须登录才能发表评论！

与本文相关的文章

您必须 登录 才能发表评论！

您必须登录才能发表评论！