图解python | 面向对象编程

ShowMeAI研究中心

作者：韩信子@ShowMeAI
教程地址：https://www.showmeai.tech/tutorials/56
本文地址：https://www.showmeai.tech/article-detail/88
声明：版权所有，转载请联系平台与作者并注明出处

1.Python面向对象

面向对象编程，在英文中称之为Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

Python是一个纯天然面向对象的编程语言，在Python中，所有数据类型都可以视为对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。

Python 面向对象编程知识地图@ShowMeAI

2.面向对象概念

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

相比其它编程语言，Python的类机制非常简洁，Python中的类提供了面向对象编程的所有基本功能

类的继承机制允许多个基类
派生类可以覆盖基类中的任何方法
方法中可以调用基类中的同名方法

对象可以包含任意数量和类型的数据。

3.类定义

语法格式如下：

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

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

4.类对象

创建类对象

（1）属性引用和实例化

类对象支持两种操作：属性引用和实例化。

属性引用使用和Python中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

 class NewClass:
    """一个简单的类实例"""
    num = 123456
    def f(self):
        return 'hello ShowMeAI'
 
# 实例化类
x = NewClass()
 
# 访问类的属性和方法
print("NewClass 类的属性 num 为：", x.num)
print("NewClass 类的方法 f 输出为：", x.f())

以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。

执行以上程序输出结果为：

 NewClass 类的属性 num 为： 123456
NewClass 类的方法 f 输出为： hello ShowMeAI

（2）构造函数

类有一个名为 __init__() 的特殊方法（构造方法/构造函数），该方法在类实例化时会自动调用，像下面这样：

 def __init__(self):
    self.data = []

类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。如下实例化类NewClass，对应的 __init__() 方法就会被调用:

 x = NewClass()

当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如（代码可以在在线python3环境中运行）:

 class MyComplex:
    def __init__(self, real_part, imag_part):
        self.r = real_part
        self.i = imag_part
x = MyComplex(5.0, -3.4)
print(x.r, x.i)   # 输出结果：5.0 -3.4

（3）self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

 class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

以上实例执行结果为：

 <__main__.Test instance at 0x100724179>
__main__.Test

通过执行结果，可以看出，self代表的是类的实例（包含当前对象的地址信息），而self.class则指向类。

注意这里的self并不是python关键字，把他换成其他名称，比如showmeai，也是可以正常执行的（代码可以在在线python3环境中运行）:

 class Test:
    def prt(showmeai):
        print(showmeai)
        print(showmeai.__class__)
 
t = Test()
t.prt()

以上实例执行结果为：

 <__main__.Test instance at 0x100724179>
__main__.Test

5.类的方法

在类的内部，我们可以使用 def 关键字来定义类方法，类方法必须包含参数self, 且其为第一个参数，self代表的是类的实例。例如（代码可以在在线python3环境中运行）

 class Person:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def talk(self):
        print("%s的年龄是 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = Person('ShowMeAI',30,30)
p.talk()

执行以上程序输出结果为：

 ShowMeAI的年龄是 30 岁。

6.继承

Python 同样支持类的继承。派生类的定义如下所示:

 class DerivedClass(BaseClass):
    <statement-1>
    .
    .
    .
    <statement-N>

子类（派生类/DerivedClass）会继承父类（基类/BaseClass）的属性和方法。

BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

 class DerivedClassName(modname.BaseClassName):

 #类定义
class person:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def talk(self):
        print("%s的年龄是 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(person):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def talk(self):
        print("%s的年龄是 %d 岁，目前在读 %d 年级"%(self.name,self.age,self.grade))
 
s = student('小Show',12,60,5)
s.talk()

执行以上程序输出结果为：

 小Show的年龄是 12 岁，目前在读 5 年级

7.多继承

Python同样支持多继承形式。多继承的类定义形如下例:

 class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找父类中是否包含方法。

 #类定义
class person:
    #定义基本属性
    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(person):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def talk(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 talk(self):
        print("%s是一个演说家，今天ta演讲的主题是 %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("ShowMeAI",25,80,4,"Python")
test.talk()   #方法名同，默认调用的是在括号中排前地父类的方法

执行以上程序输出结果为：

 ShowMeAI是一个演说家，今天ta演讲的主题是 Python

8.方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：

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

super()函数是用于调用父类(超类)的一个方法。

执行以上程序输出结果为：

 调用子类方法
调用父类方法

9.类属性与方法

（1）类的私有属性

__private_attrs：由两个下划线开头，声明为私有属性，不能在类的外部被使用或直接访问。在类内部的方法中可以使用，使用方法为 self.__private_attrs。

（2）类的方法

在类的内部定义的成员方法，必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但建议还是按照约定使用 self。

（3）类的私有方法

__private_method：由两个下划线开头，声明为私有方法，只能在类的内部调用，使用方法为 self.__private_methods。

类的私有属性示例代码如下：

 class NewCounter:
    __secret_count = 0  # 私有变量
    public_count = 0    # 公开变量
 
    def count(self):
        self.__secret_count += 1
        self.public_count += 1
        print (self.__secret_count)
 
counter = NewCounter()
counter.count()
counter.count()
print (counter.public_count)
print (counter.__secret_count)  # 报错，实例不能访问私有变量

执行以上程序输出结果为：

 1
2
2
Traceback (most recent call last):
  File "test.py", line 16, in <module>
    print (counter.__secret_count)  # 报错，实例不能访问私有变量
AttributeError: 'NewCounter' object has no attribute '__secret_count'

类的私有方法实例如下：

 class WebSite:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = WebSite('ShowMeAI知识社区', 'www.showmeai.tech')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

（4）类的专有方法：

__init__ ：构造函数，在生成对象时调用
__del__ ：析构函数，释放对象时使用
__repr__ ：打印，转换
__setitem__ ：按照索引赋值
__getitem__：按照索引获取值
__len__：获得长度
__cmp__：比较运算
__call__：函数调用
__add__：加运算
__sub__：减运算
__mul__：乘运算
__truediv__：除运算
__mod__：求余运算
__pow__：乘方

（5）运算符重载

Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下：

 class MyVector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = MyVector(2,10)
v2 = MyVector(5,-2)
print(v1 + v2)

以上代码执行结果如下所示:

 Vector(7,8)

10.视频教程

也可以点击这里到B站查看有【中英字幕】的版本

【双语字幕+资料下载】Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~

https://www.bilibili.com/video/BV1yg411c7Nw?p=30&share_source=copy_web

资料与代码下载

本教程系列的代码可以在ShowMeAI对应的github中下载，可本地python环境运行，可以访问google的宝宝也可以直接借助google colab一键运行与交互操作学习哦！

本教程系列涉及的Python速查表可以在以下地址下载获取：

Python速查表

拓展参考资料

ShowMeAI图解Python编程系列推荐（要点速查版）

ShowMeAI系列教程精选推荐

posted @ 2022-02-23 17:10 ShowMeAI 阅读(481) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 图解python | 基础数据类型

· 图解python | 函数

· 开心档之Python3 面向对象

· Python-——面向对象

· Python类与面向对象

公告

http://www.showmeai.tech/

昵称： ShowMeAI
园龄： 3年3个月
粉丝： 87
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

ShowMeAI

『为AI硬核资料库(cool)而生！』构建AI解决方案，用知识加速每一次技术成长！公众号：ShowMeAI研究中心

图解python | 面向对象编程

1.Python面向对象

2.面向对象概念

3.类定义

4.类对象

（1）属性引用和实例化

（2）构造函数

（3）self代表类的实例，而非类

5.类的方法

6.继承

7.多继承

8.方法重写

9.类属性与方法

（1）类的私有属性

（2）类的方法

（3）类的私有方法

（4）类的专有方法：

（5）运算符重载

10.视频教程

资料与代码下载

拓展参考资料

ShowMeAI图解Python编程系列推荐（要点速查版）

ShowMeAI系列教程精选推荐

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	class NewClass:
	"""一个简单的类实例"""
	num = 123456
	def f(self):
	return 'hello ShowMeAI'

	# 实例化类
	x = NewClass()

	# 访问类的属性和方法
	print("NewClass 类的属性 num 为：", x.num)
	print("NewClass 类的方法 f 输出为：", x.f())

	NewClass 类的属性 num 为： 123456
	NewClass 类的方法 f 输出为： hello ShowMeAI

	class MyComplex:
	def __init__(self, real_part, imag_part):
	self.r = real_part
	self.i = imag_part
	x = MyComplex(5.0, -3.4)
	print(x.r, x.i) # 输出结果：5.0 -3.4

	class Test:
	def prt(self):
	print(self)
	print(self.__class__)

	t = Test()
	t.prt()

	class Test:
	def prt(showmeai):
	print(showmeai)
	print(showmeai.__class__)

	t = Test()
	t.prt()

	class Person:
	#定义基本属性
	name = ''
	age = 0
	#定义私有属性,私有属性在类外部无法直接进行访问
	__weight = 0
	#定义构造方法
	def __init__(self,n,a,w):
	self.name = n
	self.age = a
	self.__weight = w
	def talk(self):
	print("%s的年龄是 %d 岁。" %(self.name,self.age))

	# 实例化类
	p = Person('ShowMeAI',30,30)
	p.talk()

	#类定义
	class person:
	#定义基本属性
	name = ''
	age = 0
	#定义私有属性,私有属性在类外部无法直接进行访问
	__weight = 0
	#定义构造方法
	def __init__(self,n,a,w):
	self.name = n
	self.age = a
	self.__weight = w
	def talk(self):
	print("%s的年龄是 %d 岁。" %(self.name,self.age))

	#单继承示例
	class student(person):
	grade = ''
	def __init__(self,n,a,w,g):
	#调用父类的构函
	people.__init__(self,n,a,w)
	self.grade = g
	#覆写父类的方法
	def talk(self):
	print("%s的年龄是 %d 岁，目前在读 %d 年级"%(self.name,self.age,self.grade))

	s = student('小Show',12,60,5)
	s.talk()

	class DerivedClassName(Base1, Base2, Base3):
	<statement-1>
	.
	.
	.
	<statement-N>

	class Parent: # 定义父类
	def my_method(self):
	print ('调用父类方法')

	class Child(Parent): # 定义子类
	def my_method(self):
	print ('调用子类方法')

	c = Child() # 子类实例
	c.my_method() # 子类调用重写方法
	super(Child,c).my_method() #用子类对象调用父类已被覆盖的方法

	class NewCounter:
	__secret_count = 0 # 私有变量
	public_count = 0 # 公开变量

	def count(self):
	self.__secret_count += 1
	self.public_count += 1
	print (self.__secret_count)

	counter = NewCounter()
	counter.count()
	counter.count()
	print (counter.public_count)
	print (counter.__secret_count) # 报错，实例不能访问私有变量

	1
	2
	2
	Traceback (most recent call last):
	File "test.py", line 16, in <module>
	print (counter.__secret_count) # 报错，实例不能访问私有变量
	AttributeError: 'NewCounter' object has no attribute '__secret_count'

	class WebSite:
	def __init__(self, name, url):
	self.name = name # public
	self.__url = url # private

	def who(self):
	print('name : ', self.name)
	print('url : ', self.__url)

	def __foo(self): # 私有方法
	print('这是私有方法')

	def foo(self): # 公共方法
	print('这是公共方法')
	self.__foo()

	x = WebSite('ShowMeAI知识社区', 'www.showmeai.tech')
	x.who() # 正常输出
	x.foo() # 正常输出
	x.__foo() # 报错

	class MyVector:
	def __init__(self, a, b):
	self.a = a
	self.b = b

	def __str__(self):
	return 'Vector (%d, %d)' % (self.a, self.b)

	def __add__(self,other):
	return Vector(self.a + other.a, self.b + other.b)

	v1 = MyVector(2,10)
	v2 = MyVector(5,-2)
	print(v1 + v2)