首页 > 其他分享 >Day22笔记-多态&函数重写&运算符重载&对象的内置内容

Day22笔记-多态&函数重写&运算符重载&对象的内置内容

时间：2024-09-18 18:49:08浏览次数：16  
标签：__ self 多态 Day22 运算符 class print age def

一、多态

多态的前提：继承

体现1：同一种事物的多种体现形式，如：动物有很多种

体现2：在定义的过程无法确定变量的类型，只有当程序正常运行的时候才会确定该变量是什么类型，调用哪个函数

# 体现1：同一种事物的多种体现形式，如：动物有很多种
class Animal():
    pass
class Cat(Animal):
    pass
class SmallCat(Cat):
    pass
​
sc = SmallCat()
# isinstance(对象,类型):判断一个对象是否是指定的类型
print(isinstance(sc,SmallCat))
print(isinstance(sc,Cat))
print(isinstance(sc,Animal))
print(isinstance(sc,object))
​
# 体现2：在定义的过程中无法确定变量的类型和调用的函数，只有当程序正常运行的时候才会确定该变量是什么类型，调用哪个函数
class Animal():
    def style(self):
        print('walking')
class Cat(Animal):
    pass
class Dog(Animal):
    pass
class Pig(Animal):
    pass
class Bird(Animal):
    def style(self):
        print('flying')
class Fish(Animal):
    def style(self):
        print('swimming')
​
def func(ani):   # ani有多种类型的体现形式，所以此处是多态的体现
    ani.style()
​
cat = Cat()
func(cat)
​
bird = Bird()
func(bird)
​
fish = Fish()
func(fish)

二、函数重写【重点掌握】

重写：override,在继承的前提下，如果在子类中重新实现了父类中的函数

"""
注意：
    1.什么时候需要重写函数
        如果一个类有很多子类，大多数子类可以直接使用父类中实现的功能
        但是，如果父类中实现的需求满足不了部分子类的使用，则需要在子类中重写函数
    2.重写需要注意的事项
        保留函数的声明部分：def  xxx(self,形参列表)
        重新实现函数的实现部分【函数体】
"""
# 1.自定义函数的重写
# class Animal():
#     def style(self):
#         print('walking')
# class Cat(Animal):
#     pass
# class Dog(Animal):
#     pass
# class Pig(Animal):
#     pass
# class Bird(Animal):
#     def style(self):
#         print('flying')
# class Fish(Animal):
#     def style(self):
#         print('swimming')
​
# 2.系统函数的重写
# a.
class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
​
    def show(self):
        print(f'name:{self.name},age:{self.age}')
​
p = Person('小明',10)
# 注意1：当输出对象时，默认会调用魔术函数__str__,__str__是object中的函数，该函数默认返回当前对象在计算机中的地址
print(p)    # <__main__.Person object at 0x0000026DE30C5FD0>
print(p.__str__())  # <__main__.Person object at 0x0000026DE30C5FD0>
​
# b
class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
​
    def show(self):
        print(f'name:{self.name},age:{self.age}')
​
    # 注意2：当重写__str__时，返回值必须是一个字符串，表示一个对象的字符串描述信息，一般是和当前对象相关的属性信息
    def __str__(self):
        # TypeError: __str__ returned non-string (type NoneType)
        return f'name:{self.name},age:{self.age}'
​
p = Person('小明',10)
print(p)
print(p.__str__())
​
# c.
class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
​
    def show(self):
        print(f'name:{self.name},age:{self.age}')
​
    # 方式一：只重写__repr__
    # def __repr__(self):
    #     return f'name:{self.name},age:{self.age}'
    # 方式二：
    def __str__(self):
        return f'name:{self.name},age:{self.age}'
    __repr__ = __str__
​
p = Person('小明',10)
print(p)  # 输出对象的时候，调用子类中重写之后的__str__
print(p.__str__())
# 注意3：当将对象作为作为存储在列表等容器中时，输出列表，元素仍然以地址的形式呈现，则重写__repr__
lst = [p]
print(lst)   # 前：[<__main__.Person object at 0x000001A553037FD0>]  后：[name:小明,age:10]
​
# 3.注意4：当子类中重写了父类中的函数，创建子类对象调用函数，优先调用的是子类中的函数
# a.如果在子类的构造函数中需要用到父类中绑定的属性，则可以在子类的构造函数中调用父类中的构造函数
class A():
    def __init__(self,a):
        self.a = a
class B(A):
    def __init__(self,a,b):
        super().__init__(a)
        self.b = b
b = B(23,4)
​
# b.当在子类重写之后的函数中需要用到父类中对应函数中的功能，则可以在子类函数中调用父类中的函数
class Animal():
    def style(self):
        print('walking')
class Bird(Animal):
    def style(self):
        # super(Bird,self).style()
        # super().style()
        Animal.style(self)
        print('flying')
bird = Bird()
bird.style()

三、运算符重载

重载：overload

# 1.+
'''
除了数字之外，其他数据类型但凡支持+的运算，底层都是调用了__add__
'''
# a
print('abc' + '123')   # str + str ---- >str
print('abc'.__add__('123'))
​
print([2,3] + [5,6])  # list + list --->list
print([2,3].__add__([5,6]))
​
# __dict__
# print(str.__dict__)
# print(list.__dict__)
​
# b
# class Person():
#     def __init__(self,age):
#         self.age = age
# p1 = Person(10)
# p2 = Person(23)
# print(p1 + p2)  # TypeError: unsupported operand type(s) for +: 'Person' and 'Person'
# print(Person.__dict__)
​
# c,如果一个类不支持+，则可以在类中重载__add__
class Person():
    def __init__(self,age):
        self.age = age
    # 重写：函数存在但是实现的需求不满足使用
    # 重载：不支持指定的运算，通过重载让支持运算
    def __add__(self, other):
        return Person(self.age + other.age)
​
    # 重写
    def __str__(self):
        return str(self.age)
​
p1 = Person(10)
p2 = Person(23)
# 问题1:Person + Person ----》int ,解决：Person + Person ----》Person
# 问题2：当__add__返回 Person(self.age + other.age)，输出p1 + p2结果为对象的地址， 解决：重写__str__
p = p1 + p2
print(p)   # 本质上相加两个人的属性【年龄】
# print(p.__str__())   # 33
# print(p1.__add__(p2))  # 33
​
​
# 2.
'''
> ---->__gt__   greater than
< ----> __lt__  less than
== ---> __eq__  equal
!= ---> __ne__  not equal
>= ---> __ge__
<= --->__le__
比较的结果都是布尔值，重载上述运算符时，返回值都设置为布尔值
'''
class Person():
    def __init__(self,age):
        self.age = age
    def __gt__(self, other):
        return self.age > other.age
​
p1 = Person(10)
p2 = Person(23)
print(p1 > p2)
print(p1.__gt__(p2))
print(Person.__dict__)
​

四、对象的内置内容

1.内置对象
# 1.__slots__:限制对象属性的动态绑定
​
# 2.__dict__:获取类或对象的所有信息【属性和函数】，返回一个字典   ****
# print(str.__dict__)
​
# 3.__module__;获取指定对象属于哪个模块，如果时当前模块，则结果为__main__,如果是其他模块，则结果为模块名
print(str.__module__)  # builtins
​
class Person():
    def __init__(self,age):
        self.age = age
p = Person(45)
# print(p.__module__)  # __main__
​
# 4. __name__:可以用来判断正在执行的是否是当前文件    ******
# 如果结果为__main__则说明运行的是当前文件，如果是模块名则表示运行的是其他文件
# print(__name__)
import t1
​
# 适用的场景:当作代码的规范，认为是程序执行的入口
if __name__ == '__main__':
    # 函数的调用
    pass
​
# 5.__class__：类似于type(),获取指定对象的数据类型
print(type(p))
print(p.__class__)
​
2.内置函数
# 1.id():获取一个对象的内存地址
​
# 2.type():获取一个对象的数据类型
​
# 3.isinstance():判断一个对象的数据类型是否是指定类型   ******
print(isinstance(45,str))
print(type(45) == str)
​
# 练习
lst = ['faf',24,6,False,34,True,'535',18]
l1 = [ele for ele in lst if isinstance(ele,int)]  # 涉及到继承，继承自int或int都会挑选
print(l1)  # [24, 6, False, 34, True, 18]
l2 = [ele for ele in lst if type(ele) == int]  # 精确匹配，只挑选int
print(l2)  # [24, 6, 34, 18]
​
# 4.issubclass(类1，类2)：判断类1和类2直接是否具有继承关系
class Animal():
    pass
class Cat(Animal):
    pass
class SmallCat(Cat):
    pass
print(issubclass(Cat,Animal))  

标签：__,self,多态,Day22,运算符,class,print,age,def
From： https://blog.csdn.net/m0_61388098/article/details/142340897

相关文章

  • Day23笔记-Day21和Day22作业讲解&单例类
    Day22作业讲解'''学生类Student:属性:学号，姓名，年龄，性别，成绩​班级类Grade:属性:班级名称，班级中的学生【使用列表存储学生】​方法:1.查看该班级中的所有学生的信息2.查看指定学号的学生信息3.查看......
  • 【C++】多态的认识和理解
    个人主页文章目录⭐一、多态的概念......
  • C# 面向对象编程的三大支柱：封装、继承与多态
    面向对象编程（OOP）是一种广泛使用的编程范式，它通过封装、继承和多态这三大支柱来构建灵活且可维护的代码结构。本文将详细介绍这三大支柱在C#语言中的应用，并通过示例代码展示它们的具体实现。一、封装（Encapsulation）封装是指将对象的属性（字段）和行为（方法）结合在一起，并对外部隐藏对象......
  • Rust中的&运算符取一个变量的地址与C/C++中意义相同么？如果不同又有什么区别呢？
    Rust中的&运算符与C/C++中的&运算符有相似之处，但它们的行为和作用有一些关键区别，特别是在所有权、内存安全和编译期检查方面。1.相似之处在Rust和C/C++中，&运算符都用于获取变量的地址，即生成一个指针或引用。它们的作用可以概括为：将一个值的引用或地址作为结果，而不......
  • java_day2_常量，变量，数据类型，运算符
    一、常量常量：在Java程序运行过程中其值不能发生改变的量分类：1、字面值常量：整数常量表示所有的整数，包括负数10-8小数常量表示所有的小数1.23-3.14布尔常量truefalse空常量null......
  • Python中的赋值运算符：编程的魔法棒
    在编程的世界里，赋值运算符就像是一根魔法棒，它将数据的流动变得有序而高效。无论是简单的变量赋值还是复杂的表达式计算，赋值运算符都是构建程序逻辑不可或缺的一部分。本文将带你深入探索Python中的赋值运算符，从基础语法到实战应用，再到一些鲜为人知的小技巧，帮助你更好地理解......
  • Python中的“秘密武器”：成员运算符的奥秘与妙用
    在Python编程的世界里，成员运算符就像是隐藏在背后的超级英雄，它们虽然不像循环或条件判断那样经常出现在舞台中央，但却在构建高效、简洁的代码时扮演着至关重要的角色。今天，让我们一起揭开成员运算符的神秘面纱，探索它如何帮助我们解决实际问题，并让我们的代码更加优雅。引言......
  • C++：多态
    目录一.多态的概念二.多态的定义及其实现1.虚函数2.虚函数的重写/覆盖3.实现多态的条件 4.虚函数重写的例外5.析构函数的重写6.经典例题7.C++11override和final关键字8.重载、重写/覆盖、隐藏的区别三.抽象类四.多态的原理1.虚函数表指针2.多态如何实现3.动态......
  • C++面试考点：拷贝赋值运算符和拷贝构造函数有什么区别？
    定义和功能拷贝构造函数拷贝构造函数是一种特殊的构造函数，用于创建一个新对象，该新对象是作为另一个同类型对象的副本而创建的。其函数原型通常为类名(const类名&other)（在C++11之前，const也可省略）。例如：classMyClass{public:MyClass(constMyClass&ot......
  • Python中的逻辑运算符：解锁编程世界的隐形钥匙
    引言逻辑运算符是任何编程语言的基础组成部分之一，在Python中也不例外。它允许我们基于一个或多个布尔表达式的真假值来决定程序的行为。在日常开发工作中，逻辑运算符广泛应用于条件判断、循环控制等场合，是构建复杂逻辑不可或缺的一部分。掌握好逻辑运算符，不仅可以提高代码的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99