python 面向对象篇

佛系的老肖

已于 2022-06-17 18:51:31 修改

阅读量114

点赞数

分类专栏： python 文章标签： python 开发语言

于 2022-06-16 12:00:10 首次发布

本文链接：https://blog.csdn.net/a883774913/article/details/125313499

版权

python 专栏收录该内容

20 篇文章 2 订阅

订阅专栏

在这里插入图片描述

文章目录

面向对象的基础知识
类的实例化
- 实例属性
- 类属性
类的操作（调用方法和属性）
self参数的作用
类方法
面向对象的三大特性

面向对象的基础知识

opo：object oriented programming 面向对象的程序设计，一种程序设计理念，核心对象类+对象

类：类是对一组具有相同属性和行为的对象的抽象

对象：对象指的是一个具体的实体，不用于指代一个抽象的群体，类的实例化，具体的类的体现

属性：

类属性：类属性是隶属于类的属性，用于描述类的特征
实例属性：实例属性是隶属于具体对象的属性，用于描述具体的对象
私有属性：
- 定义：属性名称前加上前缀 __，表示该属性为私有属性
- 只能在类的实例方法中访问私有属性，不允许在类的外部访问私有属性
  
  例：
```
class Person:
    def __init__(self, name):
        self.__name = name

tom = Person('tom')
print(tom.__name)

-----------------------------------

Traceback (most recent call last):
  File "attr-get.py", line 6, in <module>
    print(tom.__name)
AttributeError: 'Person' object has no attribute '__name'
```
  在第 1 行，定义了类 Person
  
  在第 3 行，创建私有属性 __name
  
  在第 5 行，创建一个实例 tom
  
  在第 6 行，直接访问实例的属性 __name
  
  程序运行报错：‘Person’ object has no attribute ‘__name’，表示无法找到属性 __name’。因此，在类 Person 的外部无法直接读取实例的私有属性。

类的实例化

实例属性

定义：实例属性是隶属于具体对象的属性，用于描述具体的对象

class Person:
    pass

zhou = Person()    
zhou.name = 'Zhou'
zhou.age = 58
print('name = %s, age = %d' % (zhou.name, zhou.age))

liu = Person()
liu.name = 'Liu'
liu.age = 53
print('name = %s, age = %d' % (liu.name, liu.age))

在第 1 行，定义了类 Person
在第 4 行，使用类 Person 创建一个对象 zhou
- 在第 5 行，设置对象 zhou 的属性 name，该属性为实例属性
- 在第 6 行，设置对象 zhou 的属性 age，该属性为实例属性
- 在第 7 行，打印对象 zhou 的属性 name 和 age
在第 9 行，使用类 Person 创建一个对象 liu
- 在第 10 行，设置对象 liu 的属性 name，该属性为实例属性
- 在第 11 行，设置对象 liu 的属性 age，该属性为实例属性
- 在第 12 行，打印对象 liu 的属性 name 和 age

类属性

定义：类属性是隶属于类的属性，用于描述类的特征

在 Python 中，类属性在类中的定义如下所示：

class 类名：

   类属性 = 值

示例代码如下：

class Person:
    count = 0

zhou = Person()    
zhou.name = 'Zhou'
zhou.age = 58
Person.count = Person.count + 1
print('Person.count = %d' % Person.count)

liu = Person()
liu.name = 'Liu'
liu.age = 53
Person.count = Person.count + 1
print('Person.count = %d' % Person.count)

在第 1 行，定义了类 Person
在第 2 行，定义了类 Person 的属性 count，该属性是类属性，描述了 Person 对象的数量
在第 4 行，使用类 Person 创建一个对象 zhou
- 在第 5 行，设置对象 zhou 的属性 name，该属性为实例属性
- 在第 6 行，设置对象 zhou 的属性 age，该属性为实例属性
因为新创建了一个对象 zhou
- 在第 7 行，访问 Person 的类属性 count，对其增加 1
- 在第 8 行，打印 Person 的类属性 count
在第 10 行，使用类 Person 创建一个对象 liu
- 在第 11 行，设置对象 liu 的属性 name，该属性为实例属性
- 在第 12 行，设置对象 liu 的属性 age，该属性为实例属性
因为新创建了一个对象 liu
- 在第 13 行，访问 Person 的类属性 count，对其增加 1
- 在第 14 行，打印 Person 的类属性 count
程序运行输出如下：

Person.count = 1
Person.count = 2

类的操作（调用方法和属性）

实例方法

定义：实例方法是用于访问对象实例属性的方法

class 类:
    def 实例方法(self):
        self.属性

实例方法定义在类中，它的第一个参数 self 指向调用该方法的对象，在实例方法中通过 “self.属性” 访问对象的实例属性。

例：每个人具有 name 和 age 的属性，创建一个类 Person，在类 Person 中定义实例方法 introduce 访问对象的属性，代码示例如下：

class Person:
    def introduce(self):
        print('name = %s, age = %d' % (self.name, self.age))

tom = Person()    
tom.name = 'tom'
tom.age = 10
tom.introduce()

jerry = Person()
jerry.name = 'jerry'
jerry.age = 20
jerry.introduce()

在第 1 行，定义了类 Person

在第 2 行，定义了类 Person 的方法 introduce，introduce 的 self 参数指向调用 introduce 方法的对象
在第 3 行，introduce 方法通过 self.name 和 self.age 访问对象的属性
在第 5 行，使用类 Person 创建一个对象 tom
在第 6 行，设置对象 tom 的属性 name，该属性为实例属性
在第 7 行，设置对象 tom 的属性 age，该属性为实例属性
在第 8 行，调用对象 tom 的方法 introduce，对象 tom 被传递给方法 introduce，作为 self 参数，在执行 introduce 时，self 参数指向对象 tom
在第 10 行，使用类 Person 创建一个对象 jerry
在第 11 行，设置对象 jerry 的属性 name，该属性为实例属性
在第 12 行，设置对象 jerry 的属性 age，该属性为实例属性
在第 13 行，调用对象 jerry 的方法 introduce，对象 jerry 被传递给方法 introduce，作为 self 参数，在执行 introduce 时，self 参数指向对象 jerry

程序运行结果：

name = tom, age = 10
name = jerry, age = 20

构造方法

语法：

class 类:
    def __init__(self, 参数):
        self.属性 = 参数

对象 = 类(参数)

方法名的前缀和后缀是两个下划线 _
方法的第一个参数 self 指向新创建的对象
方法的其余参数用于设定对象的属性

例子：每个人具有 name 和 age 的属性，创建一个类 Person，在类 Person 中定义构造方法 init，创建对象时设定对象的属性，代码示例如下：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print('name = %s, age = %d' % (self.name, self.age))

tom = Person('tom', 10)
tom.introduce()

jerry = Person('jerry', 20)
jerry.introduce()

在第 1 行，定义了类 Person
在第 2 行，定义了类 Person 的构造方法 init
init 的 self 参数指向新创建的对象
在第 3 行和第 4 行，初始化对象的 name 和 age
在第 6 行，定义了类 Person 的实例方法 introduce
introduce 的 self 参数指向调用 introduce 方法的对象
在第 7 行，输出对象的 name 和 age
在第 9 行，使用类 Person 创建一个对象 tom
新创建对象 tom 时，tom 的属性 name 和 age 为空
将对象 tom 作为参数传递给类 Person 的构造方法 init
在构造方法 init** 设置属性 name 和 age
在第 12 行，使用类 Person 创建一个对象 jerry
新创建对象 jerry 时，jerry 的属性 name 和 age 为空
将对象 jerry 作为参数传递给类 Person 的构造方法 init
在构造方法 init** 设置属性 name 和 age 程序运行输出如下：

name = tom, age = 10
name = jerry, age = 20

析构方法

定义：Python 提供了一种机制使得对象被删除前能够得到通知。对象被删除时，如果该对象拥有名为 del 的方法，该方法在删除前被调用，该方法又被称为析构方法

语法：

class 类:
    def __del__(self):
        self.属性

方法名的前缀和后缀是两个下划线 _
方法的参数 self 指向将被删除的对象

例:

创建一个类 Person，并定义析构方法 del，然后使用类 Person 创建两个对象，最后再使用 del 语句删除他们，验证析构方法，代码示例如下：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __del__(self):
        print('del %s' % self.name)

    def introduce(self):
        print('name = %s, age = %d' % (self.name, self.age))

tom = Person('tom', 10)
tom.introduce()

jerry = Person('jerry', 20)
jerry.introduce()

del tom
del jerry

在第 1 行，定义了类 Person
在第 2 行，定义了构造方法 init
在第 6 行，定义了析构方法 del
在第 9 行，定义了实例方法 introduce
在第 12 行，使用类 Person 创建一个对象 tom
在第 13 行，使用类 Person 创建一个对象 jerry
在第 18 行，使用 del 语句删除对象 tom，调用析构方法 tom.del()
在第 19 行，使用 del 语句删除对象 jerry，调用析构方法 jerry.del() 程序运行输出如下：

name = tom, age = 10
name = jerry, age = 20
del tom
del jerry

self参数的作用

self 出现在方法上：表示内置方法，自定义方法

def cat(self):

self出现在类属性中：调用类属性

print(f'这是一只猫！,我叫{self.name}')

self出现在类中的方法中：调用类中其他方法

def run(self):
self.cat()

self：类自己，只能使用在类的内部

类方法

普通方法:self必须参数

类方法：classmethod,必须参数：cls

静态方法：staticmethod 没有必须参数

面向对象的三大特性

封装：

开放接口，隐藏实现 ,python中封装很普遍，数据的封装：列表，字典，元组，集合；接口封装-方法【内置函数，外部函数】

继承：

定义：

在面向对象的程序设计中，定义一个新的 class 的时候，可以从某个现有的 class 继承，新的 class 称为子类，而被继承的 class 称为基类、父类或超类。

语法：

class Parent:
    pass

class Child(Parent):
    pass

多态：来源于继承，一个事务具备多个形态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HiE7nImu-1655351962755)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fefe6750418a41af809f9ee9cbd15189~tplv-k3u1fbpfcp-watermark.image?)]

扩展：多态性，不同的对象可以使用相同的函数名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eugCUxR4-1655351962757)(https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/388b976a6c9e438a83588c7673a81cbb~tplv-k3u1fbpfcp-watermark.image?)]