多态

abelina20060705

于 2019-07-29 20:54:00 发布

阅读量64

点赞数

文章标签： python

原文链接：http://www.cnblogs.com/chendaodeng/p/11266431.html

版权

## 概念:

一种事物具备多种不同的形态

## 好处:

　　对于使用者而言,大大的降低了使用难度

　　我们之前写的USB接口,下的鼠标,键盘,就属于多态

## 实现多态

　　接口抽象类鸭子类型都可以写出具备多态的代码,最简单的就是鸭子类型

class Chicken:

    def bark(self):

        print('jjj')

    def spawn(self):

        print('下鸡蛋。。')

class Duck:

    def bark(self):

        print('ggggg')

    def spawn(self):

        print('xiayadan')

class E:

    def bark(self):

        print('eeeee')


    def spawn(self):

        print("下鹅蛋")



j = Chicken()

y = Duck()

e = E()

# j.spawn()
# y.spawn()
# e.spawn()

def mange(obj):  ## 使用相同的方法 mange()

    obj.spawn()

mange(j)
mange(y)
mange(e)

多态-鸭子类型

## isinstance

判断一个对象是否是某个类的实例

参数1 要判断的对象

参数2 要判断的类型

# def add_num(a, b):
#
#     if isinstance(a, int) and isinstance(b, int):
#
#         return a+b
#
#     return None
#
# print(add_num(20, 10))

## issubclass

判断一个类是否是另一类的子类

参数一是子类

参数二是父类

class Animal:

    def eat(self):
        print('动物得吃东西')


class Pig(Animal):

    def eat(self):

        print("猪吃猪食。。。")


class Tree:

    def light(self):

        print("植物光合作用。。")


pig = Pig()

t = Tree()

def mange(obj):

    if issubclass(type(obj), Animal):

        obj.eat()

    else:

        print("不是一头动物")



mange(pig)
mange(t)

# print(issubclass(Tree, object))

# def add_num(a, b):
#
#     if isinstance(a, int) and isinstance(b, int):
#
#         return a+b
#
#     return None
#
# print(add_num(20, 10))

class Animal:

    def eat(self):
        print('动物得吃东西')


class Pig(Animal):

    def eat(self):

        print("猪吃猪食。。。")


class Tree:

    def light(self):

        print("植物光合作用。。")


pig = Pig()

t = Tree()

def mange(obj):

    if issubclass(type(obj), Animal):

        obj.eat()

    else:

        print("不是一头动物")



mange(pig)
mange(t)

# print(issubclass(Tree, object))

isinstance, issubclass

# str

__str__ 会在对象被转换为字符串时，转换的结果就是这个函数的返回值

使用场景：我们可以利用该函数来自定义，对象的打印格式

# Person 的父类是 object, object 中包含了__str__方法，所以所以的数据都可以转成字符串


class Person:

    def __init__(self, name, age):

        self.name = name
        self.age = age

    def __str__(self):


        return f"这是一个对象{self.name,self.age}"



p = Person('jack', 20)

print(p)

# __del__

执行时机：手动删除对象时立马执行，或是程序运行结束是也会自动执行

使用场景：当你的对象在使用过程中，打开来不属于解释器的资源，例如文件，端口

# del 使用案例

class FileTool:
    """该类用于简化文件的读写操作"""

    def __init__(self, path):

        self.file = open(path, 'rt', encoding='utf-8')

        self.a = 100

    def read(self):
        return self.file.read()

    # 在这里可以确定一个事，这个对象肯定不使用，所以可以放心的关闭文件了

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


tool = FileTool('a.txt')

print(tool.read())

## call

执行时机，在调用对象时自动执行(对象加括号)

测试：

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

a = A()
a(1,a=100)

## slots

该属性是一个类属性，用于优化对象的内存占用

优化的原理，将原本不固定的属性，变得固定了

这样的解释器就不会为这个对象创建名称空间，所以 __dict__ 也没有了

从而达到减少内存的开销

另外当类中出现了 slots 时将导致这个类的对象无法在添加新的属性

slots 的使用

import sys

class Person:

    __slots__ = ['name']
    def __init__(self, name):
        self.name = name

p = Person('jack')

# 查看内存占用
print(sys.getsizeof(p))
# p.age = 20 无法添加

# dict 没有类
print(p.__dict__)

# getattr setattr delattr

getattr 用点访问属性时，如果属性不存在时执行

setattr 用点设置属性时

delattr 用del 对象.属性删除属性时执行

这几个函数反映了 python 解释器是如何实现用点来访问属性

getattribute 该函数也是用来获取属性

在获取属性时，如果存在 getattribute 则先执行该函数，如果没有拿到属性则继续调用getattr 函数，、

如果拿到了则直接返回

class Person:

    # def __setattr__(self, key, value):
    #
    #     print(key)
    #
    #     print(value)
    #
    #     print('__setattr__')
    #
    #     self.__dict__[key] = value
    #
    #
    #
    # def __delattr__(self, item):
    #
    #     print('__delattr__')
    #
    #     print(item)
    #
    #     self.__dict__.pop(item)

    def __getattr__(self, item):

        print("__getattr__")
        return 1

    def __getattribute__(self, item):

        print("__getattribute__")

        return super().__getattribute__(item)





a = Person()

# a.name = 'jack'  ## key = 'name' , value = 'jack'
#
# print(a.name)


# del a.name
#
# print(a.name)
#
a.name = "xxx"

print(a.name)

# [] 的实现原理

任何的符号都会被解释器解释成特殊含义，例如 . [] ()

python

getitem 当你用中括号去获取属性时执行

setitem 当你用中括号去设置属性时执行

delitem 当你用中括号去删除属性时执行

class A:

    # getitem 当你用中括号去获取属性时 执行
    def __getitem__(self, item):

        print("__getitem__")

        return self.__dict__[item]

    # setitem  当你用中括号去设置属性时 执行
    def __setitem__(self, key, value):

        print('__setitem__')

        self.__dict__[key] = value

    # delitem 当你用中括号去删除属性时 执行
    def __delitem__(self, key):

        del self.__dict__[key]

        print("__delitem__")


a = A()

a.name = 'jack'
#
# print(a['name'])

del a["name"]

## 需求让一个对象支持点语法来取值也支持括号取值。。。。

class MyDict(dict):  #父类是 dict

    def __getattr__(self, key):

        return self.get(key)

    def __setattr__(self, key, value):

        self[key] = value


    def __delattr__(self, item):

        del self[item]


a = MyDict()
a.name = "jack"

print(a["name"])

print(a.name)

# 运算符重载

当我们在使用某个符号时,python解释器都会为这个符号定义一个含义,同时调用对应的处理函数, 当我们需要自定义对象的比较规则时,就可在子类中覆盖大于等于等一系列方法....

class Student(object):

    def __init__(self, name, height, age):

        self.name = name

        self.height = height

        self.age = age

    def __gt__(self, other):

        return self.height > other.height


    def __lt__(self, other):

        return self.age > other.age


    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('rose', 170, 25)

print(stu1 > stu2)  # 返回 True

print(stu1 == stu2)

上述代码中， other指的是另一个参与比较的对象

大于和小于只要实现一个即可,符号如果不同解释器会自动交换两个对象的位置

# 迭代器协议

class MyRange:

    def __init__(self, start, end, step):

        self.start = start

        self.end = end

        self.step = step


    def __iter__(self):
        return self


    def __next__(self):

        a = self.start

        self.start += self.step

        if a < self.end:
            return a

        else:

            raise StopIteration



for i in MyRange(1, 10,1):

    print(i)

### 上下文管理

上下文 context

这个概念属于语言学科,指的是一段话的意义,要参考当前的场景,既上下文

在python中,上下文可以理解为是一个代码区间,一个范围 ,例如with open 打开的文件仅在这个上下文中有效

涉及到的两个方法:

## enter

表示进入上下文,(进入某个场景了)

## exit

表示退出上下文,(退出某个场景了)

当执行with 语句时,会先执行enter ,

当代码执行完毕后执行exit,或者代码遇到了异常会立即执行exit,并传入错误信息

包含错误的类型.错误的信息.错误的追踪信息

注意:

```python

enter 函数应该返回对象自己

exit函数可以有返回值,是一个bool类型,用于表示异常是否被处理,仅在上下文中出现异常有用

如果为True 则意味着,异常以及被处理了

False,异常未被处理,程序将中断报错

```

转载于:https://www.cnblogs.com/chendaodeng/p/11266431.html

abelina20060705

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多态

## 概念:一种事物具备多种不同的形态## 好处:　　　　对于使用者而言,大大的降低了使用难度　　　　我们之前写的USB接口,下的鼠标,键盘,就属于多态## 实现多态　　接口抽象类鸭子类型都可以写出具备多态的代码,最简单的就是鸭子类型 class Chicken: def bark(se...
复制链接

扫一扫

多态

“相关推荐”对你有帮助么？