Python面向对象（详细讲解）

目录

前言：随着对Python的不断学习，你将会接触到面向对象编程这一重要内容。

本文就介绍了Python面向对象编程。

一、面向对象编程（初阶）

1.成员属性和成员方法的操作

(1)对象操作成员

成员方法：

(2)类操作成员（不推荐）

成员属性∶

成员方法：

(3)总结：

2.成员方法中的self

3.方法的分类

4.魔术方法

5.应用实例：

二、面向对象编程（高阶）

1.封装

(1)封装的级别

(2)封装的实现

公有的封装：

受保护封装

私有的封装

查看对象的成员

了解:

2.继承

(1)继承的意义:

(2)继承语法格式

(3)继承的特征

(4）单继承与多继承

(5）菱形继承（钻石继承）

3.多态

4.内置成员

5.方法的分类

6.常用函数

 7.魔术方法

成员相关的魔术方法 

---

前言：随着对Python的不断学习，你将会接触到面向对象编程这一重要内容。

本文就介绍了Python面向对象编程。

---

一、面向对象编程（初阶）

1.成员属性和成员方法的操作

(1)对象操作成员

成员属性：

访问:    对象，成员属性名

修改： 对象，成员属性名法 = 新值。（此时等于给这个对象创建了一个自己的属性） 

添加： 对象新成员属性 = 值（此时是给这个对象自己新建了一个属性）

删除： del对象成员属性（注意：只能删除这个对象自己的属性）

成员方法：

访问：对象成员方法名()

修改：对象.成员方法名=func(此时等于给这个对象创建了一个自己的方法)

添加：对象方法名=func(此时是给这个对象自己新建了一个方法)

删除：del对象.方法名（注意：只能删除这个对象自己的方法）

(2)类操作成员（不推荐）

成员属性∶

访问： 类名成员属性名

修改： 类名成员属性名法=新值。（此时通过这个类创建的对象都具有这个属性）(其余同上)

添加： 类名新成员属性=值（此时通过这个类创建的对象都具有这个属性）

删除： 类名成员属性（注意：除这个类的属性后，这个类创建的对象也没有这几个属性了）

成员方法：

访问：类名成员方法名

修改：类名.成员方法名=func(此时等于给这个对象创建了一个自己的方法)

添加:   类名.方法名=func(此时是给这个对象自己新建了一个方法

删除： del类名.方法名（注意：只能除这个对象自己的方法） 

(3)总结：

• 一个类可以实例化出多个对象，每个对象在内存中都独立存在的
• 当通过类实例化对象时，并不会把类中的成员复制份给对象，而去给对象了一个引用
• 访问对象成员的时候，如果对象自己没有这个成员，对象会向实例化它的类去查找
• 对象成员的添加和修改，都只会影响当前对象自己，不会影响类和其它对象
• 刪除对象的成员时，必是该对象自己具备的成员才可以，不能刪除类中引用的成员
• 对类的成员操作，会影响通过这个类创建的对象，包括之前创建的。

---

2.成员方法中的self

• self在方法中只是一个形参，并不是关键字
• self在类的方法中代表当前这个对象
• self代表调用这个方法的对象谁调用了这个方法，self就代表谁
• self就可以在类的内部代替对象进行各种操作

---

3.方法的分类

• ·含有self或者可以接受对象作为参数的方法：非绑定类方法
• ·不含self或者不能接受对象作为参数的方法：绑定类方法

绑定类方法，只能通过类去访问

非绑定类方法只能使用对象去访问

---

4.魔术方法

魔术方法也和普通方法样都是类中定义的成员方法

• 魔术方法不需要去手动调用的，魔术方法会在某种情况下，自动触发（自动执行）
• 魔术方法还有一个比特殊的地方：就是多数的魔术方法前后都有两个连续的下划线
• 魔术方法不是我们自己定义的，而是系统定义好的，我们来使用

1.__init__初始化方法

• 触发机制：在通过类实例对象后，自动触发的一个方法
• 作用：可以在对象实例化后完成对象的初始化（属性的赋值，方法的调用）
• 应用场景：文件的打开，数据的获取，干活前的一些准备功能

2.__del__析构方法

• 触发机制：析构方法会在对象被毀时自动触发
• 作用：关闭一些开发的资源

注意：是对象被销毀时触发了析构方法，而不是触发析构方法销毀了对象

对象会在哪些情况下被毀？

• 1.当程序执行完华，内存中所有的资源都会被毀释放
• 2使用del删除时
• 3.对象没有被引用时，会自动被销毀

---

5.应用实例：

• 定义一个类，完成一个日志的记录
• 调用这个对象的时候，传递一个日志信息
• 这个对象会创建一个文件，开始写入，并在最后关闭这个文件

#封装日志类
import time
class writelog():
    file_url = './'
    file_name = str(time.strftime('%Y年-%m月-%d日')) + '.log'
    file0bj = None
    def __init__(self):
        print('inint方法被执行')
        self.file0bj = open(self.file_url + self.file_name,'a+',encoding = 'utf-8')
    def wlog(self,log):
        date = time.strftime("%Y-%m-%d %H:%M:%S")
        mylog = date + ' ' + log + '\n'
        self.file0bj.write(mylog)
        print(f'{log}已经被写入日志文件中')
    def __del__(self):
        print('析构方法被触发，文件被关闭')
        self.file0bj.close()
l = writelog()
l.wlog('今天天气很好ye')  

二、面向对象编程（高阶）

1.封装

• 封装就是使用特殊的语法，对成员属性和成员方法进行包装，达到保护和隐藏的目的
• 但是一定注意，不能把成员全部封装死，否则就失去意义了
• 被封装的成员主要是供类的内部使用
• 被特殊语法封装的成员，会有不同的访问的权限

(1)封装的级别

• 成员  --->公有的
• _成员 --->受保护的(约定俗成，在pythoni中没有体现)
• __成员 --->私有的

                        公有的public       受保护的protected      私有的private

在类的内郎            ✔                             ✔                           ✔ 

在类的外部            ✔                             ✔                           × 

---

(2)封装的实现

公有的封装：

• 定义：默认定义的成员都属于公有成员
• 特征：公有的成员可以在任何位置进行访问和操作

受保护封装

• 定义：在成员名称前面加一个下划线成员名称
• 特征：受保护的成员和公有成员一样可以在任何位置进行访问，但是一般不要随便访问和操作受保护成员

私有的封装

• 定义：在成员名称前面加两个下划线成员名
• 特征：私有的成员只能在当前类的内部去访问和操作，不能在类的外部进行操作

查看对象的成员

#查看对象的所以成员
 
print(Pr._dict_)#可以获取当前对象的所有成员信息
 
print(Person.dict)#可以获取当前类的所有成员信息
 

了解:

• 1.在python 中并没有实现受保护的封装，属于开发者的约定俗成,可通过类名成员名访问被私有化的值(可通过_类名__成员名访问被私有化的值)
• 2.python 中的私有化封装是通过改名策略实现的，不是真正的私有化

---

2.继承

• 被其他类继承的类，这个类称为父类，也叫基类或者超类
• 继承其他类的类，这个类称为子类或者派生类

(1)继承的意义:

提高代的重用性，建立新的类与类的关系，方便其它辑的操作

(2)继承语法格式

class 父类():
    pass
class 子类(父类):
    pass

(3)继承的特征

• 在不指定承的父类时，所有类都承自objects 类（系统提供）    了解
• 子类继承了父类后，就拥有了父类中的所有成员包括魔术方法（除了私有成员）
• 子类继承父类后，并不会把父类的成员复制给子类，而去引用
• 子类继承父类后可以重写父中的方法，叫做重写
• 子类重写父类的方法，依然可以使用super().父类方法名()的方式调用父类的方法
• 子类中如果定义了父类不存在的方法，称对父类的扩展

注意：super ().父类法名在多继承中只会调用继承的第一个父类

#mro()取MR0列表，就是类的继承关系

C.mro()

• 使用super去调用父级的方法时，实际上是在用super 调用MRO列表中的上一级中的方法
• 使用super去访问父级的属性时，实际上是在用supert 访问MR0列表中的上一级中的属性
• super()本身调用父级方法时，传递的self对象，就是这个方法中的那个self对象自己

---

(4）单继承与多继承

• 一个父类可以被多个子类继承，还可以存在链式继承
• 链式继承A继承了B类，B类継承了C类，C类継承了D类。

单继承:一个类只能维承一个父类的方式

语法格式：

class father():
    pass
class sub(father):
    pass

多继承:一个类去继承多个父类的方式

语法格式：

class father():
    pass
class mother():
    pass
class sub(father,mother):
    pass

---

(5）菱形继承（钻石继承）

                        A     

               B                C

                        D

#D类去承了B类和c类，然后B类和C类又分别承了A类，这种继承关系称为菱形维承

问题：在这种菱形継承关系中，类与类的关系，及supert (调用时的顺序）

在定义类后，程序会自动生成一个继承的列表MRO(Method Realtion Order )方法关系列表

MRO列表生成原则

1.子类永远在父类的前面

2.同一等级的类，按照子类中的继承顺序摆放

3.先子，后父类的顺序原则，最终的类是由系统提供的object 类

MRO的调用方法

类名. mro()

---

super()在调用时，并不是查找父类，而是去MRO列表上找上一个类

super()方法在调用时，会自动把当前self传入到上一级的类的方法中

类关系检测issubclass ()

res = issubclass(A,B)

检验一个类是否是另一个类的子类

按照mro列表中的继承顺序，若另一个类是这一个类的上一级则为True，反之则为Flase

---

3.多态

对于同一个方法，由于调用的对象不同，产生了不同形态的结果

示例：

多态普通版

#定义电脑类
class computer():
    #定义接口方法
    def usb(self,obj):
        obj.start()
#定义鼠标类
class mouse():
    def start(self):
        print("鼠标启动")
#定义键盘类
class keyboard():
    def start(self):
        print("键盘启动")
#定义U盘类
class udisk():
    def start(self):
        print("U盘启动")
#实例化对象
c = computer()
m = mouse()
k = keyboard()
u = udisk()
#把不同的设备连接到电脑的usb接口
c.usb(m)
c.usb(k)
c.usb(u)

多态继承版

class usb():
    '''
    当前定义一个接口规范类,需要子类继承并实现start方法
    start方法不做任何具体功能的实现
    '''
    def start(self):
        pass
#定义鼠标类
class mouse(usb):
    def start(self):
        print("鼠标启动")
#定义键盘类
class keyboard(usb):
    def start(self):
        print("键盘启动")
#定义U盘类
class udisk(usb):
    def start(self):
        print("U盘启动")
#实例化对象
m = mouse()
k = keyboard()
u = udisk()
#把不同的设备连接到电脑的usb接口
m.start()
k.start()
u.start()

---

 

4.内置成员

#获取类/对象的所属成员   类/对象.__dict__
 
res = Demo. __dict__
 
#获取类的文档信息          类/对象.__doc__
 
res = Demo.__doc__
 
#获取类名称组成的字符串
 
res = Demo.__name__
 
#获取类所在的文件名称，如果是当前文件，显示为__main__
 
res = Demo. __module__
 
#__bases__ 获取当前类的父类列表
 
res = Demo.__bases__#获取承的第一个父类
 
res = Demo.__bases__ #获取维承的所有的父类列表
 
#MRO列表 获取当前类的继承链
 
res = Demo. __mro__
 
与mro的区別是：生成的继承链数据类型不同，它是生成元组，mro()是列表

---

 

5.方法的分类

1.对象方法

特征：

1.在类中定义的方法，含有self参数

2.含有self的方法，只能使用对象进行调用

3.该方法会把调用的对象传递进来

2.类方法

特征

1.在类中定义的方法，使用装饰器@classmethod 进行了装饰

2.方法中有cls这个行参，不需要实例化对象，直接使用类进行调用

3.会把调用这个方法的类传递进来

3.绑定类方法

特征：

1.在类中定义的方法

2.只能使用类进行调用

3.不会传递对象或者类进来

4.静态方法

特征

1.在类中定义的方法使用了装怖器@staticmethod 进行了装饰

2.可以使用对象或者类进行调用

3.不会传递对象或者类进来

---

6.常用函数

#检测类和对象相关

#issubclass(子类，父类)检测一个类是否为另个类的子类

res = issubclass( D, B)

#isinatance(对象类)检测一个对象是否是该类或该类的子类的实例化结果

res = isinatance( d, A)

#操作类和对象成员相关

#hasattr (对象/类，成员名称)检测类/对象是否包含指定名称的成员

res = hasattr(d,'name')

#getattr (对象/类，成员名称)获取类/对象的成员的值

res = hasattr(d,'name')

#setattr (对象/类，成员名称，成员的值)设置类/对象的成员的属性值

res = setattr( d, 'name', 'yyds')

#delattr (类/对象，成员名称)除类/对象的成员属性和del语句直接除对象的成员是一样的结果

res = delattr( d, 'name')

#dir() 获取当前对象所有可以访问成员的列表

res = dir(d)

---

 

 7.魔术方法

• str和repr函数都能够把其它类型的数据转为字符串类型
• str函数会把对象转为更合人类阅该的形式
• repr函数会把对象转为解释器读取的形式
• 如果数据对象并没有更明的区别的化，str和repr的结果是一样的

---

 

成员相关的魔术方法