AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Python面向对象三大特征

2022-08-27 126
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 封装：将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。 继承：子类可以继承父类的属性和方法，提高代码的复用性。 多态：多态就是具有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法。

python面向对象三大特征

封装：将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
继承：子类可以继承父类的属性和方法，提高代码的复用性。

多态：多态就是具有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法。

一、封装

封装：将属性和方法包装到类对象中，在方法内部对属性进行操作，在类对象外部调用方法。

代码实现：

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


# 封装:提高程序的安全性
# 将属性和方法包装到类对象中
# 在方法内部对属性进行操作，在类对象外部调用方法

class Car:
    def __init__(self, brand):
        self.brand = brand  # 实例属性

    @staticmethod
    def start():  # 静态方法
        print('汽车已启动...')


car = Car('奥迪A8')
car.start()
print(car.brand)

在这里插入图片描述

如果不希望实例属性在类的外部被使用，可以在前面加上两个下划线" _" 
# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 如果不希望实例属性在类的外部被使用，所以在前面加上两个下划线

    def show(self):
        return self.name, self.__age

    @staticmethod
    def eat():
        print('吃')


stu1 = Student('李华', 20)
stu1.show()  # 调用方法
print(dir(stu1))  # 查看对象可以用的属性
print('-------------')
print(stu1.name, stu1._Student__age)  # 在类外部通过_Student__age访问实例属性self.__age
stu1.eat()

在这里插入图片描述

二、继承

继承:子类可以继承父类的属性和方法，提高代码的复用性。
如果一个对象没有继承任何类，则默认继承 object类

语法格式:

class 子类名(父类1，父类2，...):
    pass

代码实现：

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


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

    def info(self):
        print(self.name, self.age)


class Student(Person):
    def __init__(self, name, age, stu_nb):
        super(Student, self).__init__(name, age)  # 继承父类的属性
        self.stu_nb = stu_nb  # 新增属性

    def __str__(self):
        return self.name, self.age, self.stu_nb


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


student = Student('张三', 20, '1001')  # 创建对象
teacher = Teach('杨老师', 34, 10)

student.info()
teacher.info()
print(student.__str__())
print(student.stu_nb)
print(teacher.teach_of_year)

在这里插入图片描述

1.方法重写

如果子类对继承自己父类的某个属性不满意，可以在子类对其（方法体）进行重新编写。

子类重写后的方法通过 super().方法名() 调用父类中被重写的方法。

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


# 如果子类对继承自己父类的某个属性不满意，可以在子类对其（方法体）进行重新编写
# 子类重写后的方法通过 super()...方法名() 调用父类中被重写的方法


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

    def info(self):
        print(self.name, self.age)


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

    def info(self):  # 方法重写
        super().info()  # 调用父类中方法
        print(f'学号:{self.stu_nb}')  # f''格式化字符串


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

    def info(self):  # 方法重写
        super().info()
        print('教龄{0}'.format(self.teach_of_year))  # 格式化字符串


student = Student('张三', 20, '1001')
teacher = Teach('杨老师', 34, 10)

student.info()
print('-----------------')
teacher.info()

在这里插入图片描述

2.object类

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


'''
object 类是所有类的父类，所有类都有object类的属性和方法
内置函数dir（）可以查看指定对象所有属性
Object有一个__str__方法，用于返回一个对于”对象的描述
对应内置函数str（）通常用于print（）方法，帮我们查看对象的信息，所以经常会对__str__进行重写“'''


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

    def __str__(self):  # 重写父类object中的方法
        return '我的名字是{0}，今年{1}岁了'.format(self.name, self.age)


stu = Student('张三', 20)
print(dir(stu))  # 查看stu这个对象的所有属性和方法 从object类中继承的
print(stu)  # 默认调用__str__()这样的方法 输出:我的名字是张三，今年20岁了

print(type(stu))  # <class '__main__.Student'>  Student类型

在这里插入图片描述

3.多重继承

一个子类可以有多个“直接父类”，这样，就具备了“多个父类”的特点，通过类的特殊属性 __mro__ 可以查看类的组织结构。

定义子类时，必须在其构造函数中调用父类的构造函数

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


# 多继承
class A(object):
    pass


class B(object):
    pass


class C(A, B):
    pass

三、多态

多态:多态就是具有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法，在运行过程中根据变量所引用的对象类型，动态决定调用那个对象中的方法。

代码实现：

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


''' 
多态:多态就是具有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法，在运行过程中根据变量所引用的对象类型，动态决定调用那个对象中的方法'''

# 动态语言多崇尚鸭子类型，当一只鸟走起来向鸭子，游起来以向鸭子，看起来也像鸭子，那么这只鸟及可以被称为鸭子


class Animal(object):
    def eat(self):
        print('动物会吃')


class Dog(Animal):
    def eat(self):
        print('够吃骨头')


class Cat(Animal):
    def eat(self):
        print('猫吃小鱼')


class Person:
    def eat(self):
        print('人吃五谷杂粮')


# 定义一个函数
def fun(fun1):
    fun1.eat()  # 调用对象的eat()方法


if __name__ == '__main__':
    # 开始调用函数
    fun(Animal())  # Cat继承了Animal Dog继承了Animal
    fun(Cat())  # Cat 和Dog是重写了父类中的eat方法，调用了自己重写后的内容
    fun(Dog())

    print('------------------')
    fun(Person())  # Person 没有继承关系 但是有eat方法，直接调用eat方法

在这里插入图片描述

1.动态语言与静态语言

Python是一门动态语言，可以在创建对象后动态的绑定属性和方法，

静态语言和动态语言关于多态的区别：

静态语言实现多态的三个必要条件( Java) 
1. 继承
2. 方法重写
3. 父类引用指向子类对象
动态语言：( Python)
动态语言的多态崇尚 “ 鸭子类型“ 一只鸟走起来像鸭子，游起来像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的 行为'''

四、类的特殊属性和方法

1.特殊属性

特殊属性 描述
__dict__ 获得类对象或实例对象所绑定的所有属性的方法的字典 
# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


# 特殊属性 __dict__ 获得类对象或实例对象所绑定的所有 属性 或 方法 的字典
class A:
    pass


class B:
    pass


class C(A, B):
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age


if __name__ == '__main__':

    # 创建C类的对象
    x = C('Jack', 20)  # x是C类的一个实例对象

    print(x.__dict__)  # 获得实例对象属性的字典
    print(C.__dict__)  # 获得类对象的属性和方法的字典
    print('-----------------')

    print(x.__class__)  # 输出对象所属的类
    print(C.__bases__)  # C类父类类型的元组  (<class '__main__.A'>, <class '__main__.B'>)
    print(C.__base__)  # 类的基类  离C类最近的父类
    print(C.__mro__)  # 查看类的层次结构
    print(A.__subclasses__())  # 子类的列表

在这里插入图片描述

2.特殊方法

特殊方法 描述
__len__() 通过重写 __len__()方法，让内置函数len()的参数可以是自定义类型
__add__() 通过重写__add__()方法，可以让自定义对象具有+的功能
__new__() 用于创建对象
__init__() 对创建的对象进行初始化

__len__()方法和 __add__() 方法

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


# 1.特殊方法  __add__()
# 通过重写 __add__()方法，可以使自定义对象具有 “+” 的功能
a = 20
b = 100
c = a + b  # 两个整数类型的对象的相加操作
d = a.__add__(b)
print(c)
print(d)


class Student:
    sex = '女'  # 类属性

    def __init__(self, name):  # 初始化方法
        self.name = name

    def __add__(self, other):  # 重写 __add__()方法 可以使自定义对象具有 “+” 的功能
        return self.name + other.name

    def __len__(self):  # 重写 __len__方法 让自定义函数len()的参数可以是自定义类型
        return len(self.name)


stu1 = Student('Jack')
stu2 = Student('李四')
s = stu1 + stu2  # 实现了两个对象的加法运算（因为在Student类中 编写__add__()特殊的方法）
print(s)

# 2.特殊方法  __len__()
# 通过重写__len__()方法，让自定义函数len()的参数可以是自定义类型
lst = [11, 22, 33, 44]
print(len(lst))  # len是内置函数，可以计算列表的一个长度
print(lst.__len__())  # 特殊方法
print(len(stu1))

在这里插入图片描述

__new__方法

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


class Person(object):
    def __new__(cls, *args, **kwargs):  # 创建对象
        print('__new__()方法被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj = super().__new__(cls)  # 创建对象 obj
        print(f'创建对象(obj)的id值为:{id(obj)}')
        print(Person)  # <class '__main__.Person'>
        print(obj)  # <__main__.Person object at 0x000001C8B13D9CA0>
        return obj

    def __init__(self, name, age):  # 对对象的属性进行初始化
        print(f'__init__()被调用执行了，self的id值为{id(self)}')
        self.nane = name
        self.age = age


if __name__ == '__main__':
    print(f'object这个类对象的id为:{id(object)}')
    print(f'Person这个类对象的id为:{id(Person)}')

    # 创建Person类的实例对象
    p1 = Person('张三', 20)

    print(f'p1这个Person类的实例对象的id为{id(p1)}')

在这里插入图片描述

__init__方法

# -*- coding: utf-8 -*-
# @File  : demo.py
# @author: Flyme awei 
# @email : Flymeawei@163.com
# @Time  : 2022/8/15 23:27


class Person(object):
    def __new__(cls, *args, **kwargs):  # 创建对象
        print('__new__()方法被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj = super().__new__(cls)  # 创建对象 obj
        print(f'创建对象(obj)的id值为:{id(obj)}')
        return obj

    def __init__(self, name, age):  # 对对象的属性进行初始化
        print(f'__init__()被调用执行了，self的id值为{id(self)}')
        self.nane = name
        self.age = age


print(f'object这个类对象的id为:{id(object)}')
print(f'Person这个类对象的id为:{id(Person)}')

# 创建Person类的实例对象
p1 = Person('张三', 20)
print(f'p1这个Person类的实例对象的id为{id(p1)}')

在这里插入图片描述

五、变量的赋值操作

只是多生成了一个变量，实际上还是指向同一个对象 
# -*- coding: utf-8 -*-
# author : Flyme awei 
# 开发时间: 2022/7/1 15:32

class CPU:
    pass


class Disk:
    pass


class Computer:
    def __init__(self, cpu, disk):  # 给对象的实例属性进行初始化
        self.cpu = cpu
        self.disk = disk


# 变量的赋值
cp1 = Computer(cpu='CPU', disk='DISK')  # 创建CPU类的实例对象
cp2 = cp1  
# 变量的赋值,一个对象的实例采用两个变量存储，实际上还是指向一个对象
print(cp1, id(cp1))
print(cp2, id(cp2))

在这里插入图片描述

赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。

六、对象的浅拷贝和深拷贝

1.浅拷贝

Python拷贝一般都是 浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象。 
# -*- coding: utf-8 -*-
# author : Flyme awei 
# 开发时间: 2022/7/1 15:32

import copy


class CPU:
    pass


class Disk:
    pass


class Computer:
    def __init__(self, cpu, disk):  # 给对象的实例属性进行初始化
        self.cpu = cpu
        self.disk = disk


cpu = CPU()  # 创建一个 CPU 类的实例对象
disk = Disk()  # 创建一个Disk 类对象
computer = Computer(cpu, disk)  # 创建一个Computer类的实例对象

# 浅拷贝
print(cpu)
print(disk)
computer2 = copy.copy(computer)  # 子对象不拷贝
print(computer, computer.cpu, computer.disk)
print(computer2, computer2.cpu, computer2.disk)


# 类的浅拷贝:
# Python的拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝
# 因此，源对象与拷贝对象会引用同一个子对象

在这里插入图片描述

**浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用
（如果用引用的方式修改其中一个对象，另外一个也会修改改变）**

哪些是浅拷贝：

  1. 完全切片方法；
  2. 工厂函数，如list()；
  3. copy模块的copy()函数。

2.深拷贝

使用 copy模块的 deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。 
# -*- coding: utf-8 -*-
# author : Flyme awei 
# 开发时间: 2022/7/1 15:32

import copy


class CPU:
    pass


class Disk:
    pass


class Computer:
    def __init__(self, cpu, disk):  # 给对象的实例属性进行初始化
        self.cpu = cpu
        self.disk = disk


cpu = CPU()  # 创建一个 CPU 对象
disk = Disk()  # 创建一个硬盘类对象
computer = Computer(cpu, disk)  # 创建一个计算机类对象

# 深拷贝
computer1 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)
print(computer1, computer1.cpu, computer1.disk)

# 类的深拷贝
# 使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象
# 源对象和拷贝对象所有的子对象也不同

在这里插入图片描述

深拷贝：创建一个新的对象，并且递归的复制它所包含的对象。

修改其中一个，另外一个不会改变。因此，新对象和原对象没有任何关联。
例如：{ copy模块的 deepcopy()函数}
文章标签：
Java
Python
关键词：
Python面向对象
Python特征
Python面向对象特征
北极的三哈
目录
相关文章
猿java
|
1月前
|
Java 程序员 C++
Python 面向对象详解！
本文详细介绍了Python中的面向对象编程（OOP），包括类、对象、继承、封装、多态和抽象等核心概念。通过具体示例，解释了如何使用类定义对象的属性和方法，以及如何通过继承实现代码重用。文章还探讨了封装和多态的重要性，并介绍了私有属性和抽象类的使用方法。最后，总结了OOP的四大支柱：封装、抽象、继承和多态，强调了这些概念在Python编程中的应用。适合Java程序员扩展Python编程知识。
猿java
74 2
toddli
|
3月前
|
Python
你真的会面向对象吗！解密Python“魔术方法”
你真的会面向对象吗！解密Python“魔术方法”
toddli
40 0
初恋叫萱萱
|
1月前
|
Python
Python面向对象（2）
【10月更文挑战第14天】
初恋叫萱萱
20 6
Python面向对象（2）
初恋叫萱萱
|
1月前
|
设计模式 程序员 C语言
Python面向对象
【10月更文挑战第13天】
初恋叫萱萱
18 2
Python面向对象
Deephub
|
2月前
|
机器学习/深度学习 算法 数据可视化
8种数值变量的特征工程技术：利用Sklearn、Numpy和Python将数值转化为预测模型的有效特征
特征工程是机器学习流程中的关键步骤，通过将原始数据转换为更具意义的特征，增强模型对数据关系的理解能力。本文重点介绍处理数值变量的高级特征工程技术，包括归一化、多项式特征、FunctionTransformer、KBinsDiscretizer、对数变换、PowerTransformer、QuantileTransformer和PCA，旨在提升模型性能。这些技术能够揭示数据中的潜在模式、优化变量表示，并应对数据分布和内在特性带来的挑战，从而提高模型的稳健性和泛化能力。每种技术都有其独特优势，适用于不同类型的数据和问题。通过实验和验证选择最适合的变换方法至关重要。
Deephub
47 5
8种数值变量的特征工程技术：利用Sklearn、Numpy和Python将数值转化为预测模型的有效特征
bruce刘晓伟-18435
|
1月前
|
机器学习/深度学习 数据格式 Python
将特征向量转化为Python代码
将特征向量转化为Python代码
bruce刘晓伟-18435
23 3
bruce刘晓伟-18435
|
1月前
|
机器学习/深度学习 数据格式 Python
将特征向量转化为Python代码
将特征向量转化为Python代码
bruce刘晓伟-18435
18 3
bruce刘晓伟-18435
|
2月前
|
前端开发 Python
Python编程的面向对象有哪些(二)
Python编程的面向对象(二)—类的多态
bruce刘晓伟-18435
25 7
游客rcxtdbgrolahs
|
2月前
|
IDE Java 开发工具
Python类与面向对象
Python类与面向对象
游客rcxtdbgrolahs
24 5
bruce刘晓伟-18435
|
2月前
|
机器学习/深度学习 数据格式 Python
将特征向量转化为Python代码
将特征向量转化为Python代码
bruce刘晓伟-18435
30 1

热门文章

最新文章

  • 1
    手把手教你用Python实践深度学习
  • 2
    3、Python与设计模式--建造者模式
  • 3
    Python编程：elasticsearch库操作Elasticsearch
  • 4
    Python中参数多个值的表示法
  • 5
    测试Flask+PYTHON的WEB框架
  • 6
    8.python之上下文管理协议
  • 7
    python目录操作一
  • 8
    第2天，Python基础
  • 9
    Foundations of Python Network Programming - 读书笔记系列(1) - Low-Level Networking
  • 10
    浅析Python 赋值、浅复制（拷贝）与深度（复制）拷贝
  • 1
    「一行分析」利用12000条招聘数据分析Python学习方向和就业方向
    62
  • 2
    构建未来：使用Python进行深度学习模型训练
    66
  • 3
    利用 python 分析基金，合理分析数据让赚钱赢在起跑线！(1)
    62
  • 4
    Python中return和yield的区别，面试官不讲武德
    52
  • 5
    python函数参数的传递、带星号参数的传递，2024年大厂Python高级面试题分享
    45
  • 6
    实时计算 Flink版产品使用合集之怎么热加载Java和Python的UDF
    80
  • 7
    学会Python自动制作Word，将看到一个5天4位数的赚钱机会
    46
  • 8
    使用Python和Twilio通过短信通知主持视频办公时间。
    38
  • 9
    Python 中下划线的 6 个作用(1)，【干货】
    48
  • 10
    vscode打造舒适的python开发环境
    84

    • 相关课程

    更多
  • Python爬虫实战
  • Python开发基础入门
  • Python常用数据科学库
  • Python网络爬虫实战
  • Python完全自学手册图文教程
  • Python基础快速入门实战教程

    • 相关电子书

    更多
  • From Python Scikit-Learn to Sc
  • Data Pre-Processing in Python:
  • 双剑合璧-Python和大数据计算平台的结合

    • 相关实验场景

    更多
  • 用Python画圣诞树
  • 语言入门-1：环境构建
  • Python选择及循环结构
  • 云端Python及基本操作
  • Python网络通信程序典型应用
  • Python新手入门（Anolis OS）

    • 推荐镜像

    更多
  • python-release
  • nodejs-release
  • pypi
    • 下一篇
    无影云桌面