1. Johngo学长首页
  2. 技术点详细复盘专题
  3. Python

Python面向对象三大特征

• Python • 阅读 38

Python面向对象三大特征

🤵‍♂️ 个人主页: @Flyme awei 个主页
👨‍💻 作者简介： Python领域新星创作者。
📒 系列专栏：《在线编程-Python篇》
🌐推荐一款 找工作神器网站：《牛客网》| 笔试题库| 面试经验| 实习经验内推|
🐋 希望大家多多支持😘一起进步呀！
📝 如果文章对你有帮助的话，欢迎评论 💬点赞 👍收藏 📂加关注

前言

今天是《CSDN21天学习挑战赛》的第17天
上一节学习了Python基础语法类和对象
今天将Python面向三大特征：封装、继承、多态

《牛客题库-Python篇 》

python的学习还是得基础知识+自己动手同步进行。如果是 python新手，需要找一个可以在线练习得网站，我建议你去牛客网多练习。

Python面向对象三大特征

活动地址：CSDN21天学习挑战赛

文章目录

; python面向对象三大特征

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

继承：子类可以继承父类的属性和方法，提高代码的复用性。

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

一、封装

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

代码实现：


class Car:
    def __init__(self, brand):
        self.brand = brand

    @staticmethod
    def start():
        print('汽车已启动...')

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

Python面向对象三大特征

如果不希望实例属性在类的外部被使用，可以在前面加上两个下划线” _“


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)
stu1.eat()

Python面向对象三大特征

二、继承

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

语法格式:

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

代码实现：


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)

Python面向对象三大特征

1.方法重写

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

子类重写后的方法通过 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}')

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()

Python面向对象三大特征

2.object类


'''
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):
        return '我的名字是{0}，今年{1}岁了'.format(self.name, self.age)

stu = Student('张三', 20)
print(dir(stu))
print(stu)

print(type(stu))

Python面向对象三大特征

3.多重继承

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

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


class A(object):
    pass

class B(object):
    pass

class C(A, B):
    pass

三、多态

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

代码实现：


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

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()

if __name__ == '__main__':

    fun(Animal())
    fun(Cat())
    fun(Dog())

    print('------------------')
    fun(Person())

Python面向对象三大特征

1.动态语言与静态语言

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

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

静态语言实现多态的三个必要条件(Java)
1. 继承
2. 方法重写
3. 父类引用指向子类对象

动态语言：(Python)
动态语言的多态崇尚 ” 鸭子类型” 一只鸟走起来像鸭子，游起来像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的 行为”’

四、类的特殊属性和方法

1.特殊属性

特殊属性描述 __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__':

    x = C('Jack', 20)

    print(x.__dict__)
    print(C.__dict__)
    print('-----------------')

    print(x.__class__)
    print(C.__bases__)
    print(C.__base__)
    print(C.__mro__)
    print(A.__subclasses__())

Python面向对象三大特征

2.特殊方法

特殊方法描述 __len__()

通过重写 __len__()

方法，让内置函数 len()

的参数可以是自定义类型 __add__()

通过重写 __add__()

方法，可以让自定义对象具有 +

的功能 __new__()

用于创建对象 __init__()

对创建的对象进行初始化

__len__() 方法和 __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):
        return self.name + other.name

    def __len__(self):
        return len(self.name)

stu1 = Student('Jack')
stu2 = Student('李四')
s = stu1 + stu2
print(s)

lst = [11, 22, 33, 44]
print(len(lst))
print(lst.__len__())
print(len(stu1))

Python面向对象三大特征

__new__ 方法


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

    p1 = Person('张三', 20)

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

Python面向对象三大特征

__init__ 方法


class Person(object):
    def __new__(cls, *args, **kwargs):
        print('__new__()方法被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj = super().__new__(cls)
        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)}')

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

Python面向对象三大特征

五、变量的赋值操作

只是多生成了一个变量，实际上还是指向同一个对象


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')
cp2 = cp1

print(cp1, id(cp1))
print(cp2, id(cp2))

Python面向对象三大特征

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

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

1.浅拷贝

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


import copy

class CPU:
    pass

class Disk:
    pass

class Computer:
    def __init__(self, cpu, disk):
        self.cpu = cpu
        self.disk = disk

cpu = CPU()
disk = Disk()
computer = Computer(cpu, disk)

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函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。


import copy

class CPU:
    pass

class Disk:
    pass

class Computer:
    def __init__(self, cpu, disk):
        self.cpu = cpu
        self.disk = disk

cpu = CPU()
disk = Disk()
computer = Computer(cpu, disk)

computer1 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)
print(computer1, computer1.cpu, computer1.disk)

Python面向对象三大特征

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

修改其中一个，另外一个不会改变。因此，新对象和原对象没有任何关联。
例如：{ copy模块的 deepcopy()函数}

七、总结

面向对象三大特征：

  1. 封装：将属性和方法包装到类对象中，在方法内部对属性进行操作，在类对象外部调用方法。
  2. 继承：多继承、方法重写
  3. 多态：即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法，在运行过程中根据变量所引用的对象类型，动态决定调用那个对象中的方法。
  • 动态语言：关注对象的行为
  • 静态语言：继承、方法重写、父类引用指向子类对象

object类

  1. 所有类的父类
  2. __new__()创建对象
  3. __init__()初始化对象
  4. __str__()返回对象的描述
    ​

推 荐:牛客题霸-经典高频面试题库

🌐 找工作神器-|笔试题库|面试经验|大厂面试题 👉 点击链接进行注册学习

Python面向对象三大特征

Original: https://blog.csdn.net/m0_68744965/article/details/126376382
Author: 北极的三哈
Title: Python面向对象三大特征

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/730077/

转载文章受原作者版权保护。转载请注明原作者出处！

赞 (0)
0

【自取】最近整理的，有需要可以领取学习：



Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言 刷题答案下载！

大家都在看

亲爱的 Coder【最近整理，可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球