面向对象之多态以及魔法函数

一：多态

【1】基础概念

（1）基础概念：

　　（1）一种事物拥有多种形态：

　　　　例如：水--->气态--->液态--->固态

　　（2）在python中是多个对象可以相应同一种方法产生不同的结果

PS：多态不是一种语法而是一种特殊的状态特性即多个对象有相同的使用方法

例如：

# 案例一
class Chicken:
    def span(self):
        print('下鸡蛋')

class Duck:
    def span(self):
        print('下鸭蛋')

class Goose:
    def span(self):
        print('下鹅蛋')

j = Chicken()

y = Duck()

e = Goose()

j.span() # 下鸡蛋
y.span() # 下鸭蛋
e.span() # 下鹅蛋

# 案例二
a = '10'

b = [10]

c = (10,)

print(len(a),len(b),len(c)) # 2 1 1

多态案例

（2）优点：

　　（1）增加的程序的灵活性以不变应万变无论对象怎么变化使用者调用方式不变

　　（2）如果通过继承类而创建一个新的类使用者无需更改自己的代码还是以原始方式调用

PS：继承抽象类鸭子类型都可以写出具备多态的代码但是鸭子类型更加方便以及快捷

【2】内置方法

（1）isinstance：

作用：判断一个对象是否为一个类的实例

例如：

def add_num(x,y):
    # 判断整形是否为某个类
    if isinstance(x,int) and isinstance(y,int):
        return x + y
    return '错误的相加'

# 情景一
　print(add_num('10',20)) # 报错 字符串与整形不能相加

# 情景二 print(add_num('10',20)) # 错误的相加

# 情景三 判断所属的类
print(add_num(10,20)) # 30

PS：

（1）参数一：所传的对象

（2）参数二：所属的类

（2）issubclass：

作用：判断一个类是否为一个类的子类

例如：

class Animal:
    def eat(self):
        print('动物需要吃东西！')

class Pig(Animal):
    def eat(self):
        print('猪正在吃猪食！')

class Tree:
    def sunshine(self):
        print('树在进行光合作用！')

def manage(animal):
    # 判断一个类是否为另外一个类的子类
    if issubclass(type(animal),Animal):
        animal.eat()
    else:
        print('不是动物 而是植物！')



pig = Pig()
tree = Tree()

manage(pig)
# 没加条件判断之前
manage(tree)  # 报错 因为tree没有继承Animal

# 添加添加判断
manage(tree) # 不是动物 而是植物！

判断一个类是否为另外一个类子类

（3）str

（1）作用：在对象被转换成字符串的时候被调用调用的结果就是函数的返回值

例如：

class Person:
    def __str__(self):
        print('run')

        return 'SR'

p = Person()

# 没加返回值之前
print(p)  # 报错 希望得到一串字符串返回值

# 添加返回值
print(p)  # 执行函数代码 并且有返回值

str(p) # run
#PS:对象在被转换成字符串的时候 调用__str__函数

PS：

（1）如果对象在被转换成字符串的时候首先会执行__str__的执行

（2）__str__执行完毕之后在进行函数的打印

（4）del:

作用：手动删除对象的时候或者程序结束会立马执行释放内存

使用场景：但是其作用不是用来清除解释器中的资源而是不属于解释器的资源例如某些文本端口号等

例如：

class  File:
    # 创建文件的初始属性 赋值函数的地址
    def __init__(self,path):
        self.file = open(path,'rt',encoding='utf-8')

    def read(self):
        # 返回读取的文件
        return self.file.read()

    def __del__(self):
        self.file.close()


file = File('a.txt')
print(file.read())
file .__del__()
print(file.read()) # 报错显示文件已经被关闭

PS：上述可以通过del删除非解释器的资源

（5）call

作用：在调用对象的时候被执行

例如：

class A:
    def __call__(self, *args, **kwargs):
        print("call run")
        print(args)
        print(kwargs)


a = A()
a(18,a = 100)

（6）solts

作用：

　　（1）一种优化机制防止浪费不必要的内存

　　（2）其将不固定的属性数量变的固定了

　　（3）这样解释器不会为对象创建名称空间减少了__dict__

　　（4）当类中出现了该参数对象也不能在添加属性

例如：

import sys
class Person:
    __slots__ = ['name']

    def __init__(self,name):
        self.name = name

p = Person('SR')
# print(p.__dict__) # 报错

# 加slots之前
print(sys.getsizeof(p)) # 56

# 加slots
print(sys.getsizeof(p)) # 48

# 添加新属性
p.age = 20 # 报错

（7）

（1）getattr

　　作用：当用点访问属性的时候如果属性不存在则会执行

（2）setattr

　　作用：当用点设置属性的时候会执行改函数

（3）delattr

　　作用：用del 删除属性的时候会执行改函数

（4）getattribute

　　作用：当在调用属性的时候如果属性存在则会调用该函数并且将属性值返回如果属性不存在的情况下则会调用getattr

例如：

class A:

    def __setattr__(self, key, value):

        print("__setattr__")
        self.__dict__[key] = value

    def __delattr__(self, item):
        print("__delattr__")
        self.__dict__.pop(item)


    def __getattr__(self, item):
        print("__getattr__")
        return 1

    def __getattribute__(self, item):
        print("__getattribute__")
        # return self.__dict__[item]
        return super().__getattribute__(item)

方法演示

PS：

（1）当在__getattribute__代码块中，再次执行属性的获取操作时，会再次触发__getattribute__方法的调用，代码将会陷入无限递归，直到Python递归深度限制（重载__setter__方法也会有这个问题）

（2）为了避免无限递归，应该把获取属性的方法指向一个更高的超

（8）

（1）getitem

　　作用：当使用[]调用属性的时候会执行该函数

（2）setitem

　　作用：当使用[]设置属性的时候会执行该函数

（8）delitem

　　作用：当使用[]删除属性的时候会执行该函数

例如：

class A:
    def __getitem__(self, item):
        print("__getitem__")
        return self.__dict__[item]

    def __setitem__(self, key, value):
        print("__setitem__")
        self.__dict__[key] = value

    def __delitem__(self, key):
        del self.__dict__[key]
        print("__delitem__")


a = A()
# a.name = "jack"
a["name"] = "jack"
print(a["name"])
del a["name"]
print(a["name"])

（9）运算符重载：

作用：

（1）当在python中调用某个符号的时候 python都会为该符号定义一个含义并且调用该含义背后所对应的函数

（2）当我们需要自己定义比较规则的时候就可以自己在子类中覆盖父类中所对应的大于等于小于等方法

例如：

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

    def __gt__(self, other):
        # print(self)
        # print(other)
        # print("__gt__")
        return self.height > other.height
    
    def __lt__(self, other):
        return self.height < other.height

    def __eq__(self, other):
        if self.name == other.name and  self.age == other.age and self.height == other.height:
            return True
        return False

stu1 = Student("jack",180,28)
stu2 = Student("jack",180,28)
# print(stu1 < stu2)
print(stu1 == stu2)

PS：

（1）gt 大于 lt 小于 eq等于

（2）在代码中other指的是其余对象 self作为本身

（9）上下文管理：

（1）在生活中一段话的意义要看情景上问和下文有关联

（2）在python中上下文可以看做一个范围某些代码只在一个范围内有效

　　（1）enter 进入上下文

　　（2）exit 退出上下文

例如：

class MyOpen(object):


    def __init__(self,path):
        self.path = path

    def __enter__(self):
        self.file = open(self.path)
        print("enter.....")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("exit...")
        # print(exc_type,exc_val,exc_tb)
        self.file.close()
        return True

（1）代码执行完毕之后执行exit结束上下文

（2）代码执行错误也会执行exit结束上下文

（3）其会返回错误类型错误的信息以及错误的路径追踪信息

PS：

（1）enter返回值为对象自己

（2）exit返回值为布尔值表示错误信息是否被处理如果为真则表示已经处理为假则未处理

posted @ 2019-07-29 23:15 SR丶阅读(208) 评论(0) 编辑收藏举报

刷新页面返回顶部

星辰大海(｀・ω・´)

面向对象之多态以及魔法函数

一：多态

公告