美文网首页
python入门系列:深入类和对象

python入门系列:深入类和对象

作者: Java丶python攻城狮 | 来源:发表于2019-02-13 18:45 被阅读0次

    鸭子类型和多态

    引言

    在鸭子类型中,关注的不是对象的类型本身,而是它是如何使用的。

    例如,在不使用鸭子类型的语言中,我们可以编写一个函数,它接受一个类型为鸭子的对象,并调用它的 走 和 叫方法。

    在使用鸭子类型的语言中,这样的一个函数可以接受一个任意类型的对象,并调用它的 走 和 叫 方法。如果这些需要被调用的方法不存在,那么将引发一个运行时错误。任何拥有这样的正确的 走 和 叫 方法的对象都可被函数接受的这种行为引出了以上表述,这种决定类型的方式因此得名。

    使用案例

    class Cat(object):

    def say(self):

    print("I am a cat")

    class Dog(object):

    def say(self):

    print("I am a dog")

    class Duck(object):

    def say(self):

    print("I am a duck")

    # 这里又是一切皆对象的说明,把类作为对象放入 list

    animal_list = [Cat, Dog, Duck]

    for animal in animal_list:

    animal().say()

    # result:

    # I am a cat

    # I am a dog

    # I am a duck

    上面的案例中,我们并不需要确定 animal 的类型,只要具有了 say() 这个方法,就能满足调用的条件,程序就可以正常运行。如果在 java 中,则需要抽象出一个 Animal的类,其中包含了 say() 方法,让一系列子类来实现这个方法。这就是动态语言的灵活所在。

    再来看一个平时经常使用的例子:

    li_a, li_b =[1, 2], [3, 4]

    # 初学列表时,应该都知道列表的 extend()方法,将两个列表合并

    li_a.extend(li_b)

    print(li_a)

    # result:

    # [1, 2, 3, 4]

    实际上,extend() 这个方法的原型是什么样的呢

    def extend(self, iterable):

    pass

    它的参数并未要求是一个列表,而是一个可迭代对象即可,所以,下面这种使用方都是可以的:

    li_a = [1, 2]

    tuple_b = (3, 4) # 元组

    set_c = set([5, 6]) # 集合,用列表转换而成

    li_a.extend(tuple_b)

    print(li_a)

    li_a.extend(set_c)

    print(li_a)

    # result:

    # [1, 2, 3, 4]

    # [1, 2, 3, 4, 5, 6]

    可迭代对象的本质就是定义了某些魔法函数,使用特定的语法时,魔法函数会隐式地去调用。这里和上一个案例中的 say() 方法是有些类似的。

    抽象基类和abc模块

    引言

    可以类比于 java 中的接口

    这个类无法实例化

    用来检测某个类是否具有某种方法属性

    用来模拟实现抽象类

    使用案例

    检测对象属性

    class Language(object):

    def __init__(self, lan_list):

    self.lans = lan_list

    # 有了这个魔法函数,它的对象可以用 len()

    def __len__(self):

    return len(self.lans) # 具体的实现委托给了底层列表

    language = Language(["C"], ["Python"])

    print(len(language))

    # result:

    # 2

    如果我们不知道某个对象能不能作为 len() 的参数,直接调用会报异常。我们可以采用一种方式来检验这个对象能否用 len():

    print(hasattr(language, "__len__"))

    # result:

    # True

    不过这种方式语义不够明显,我们可以像 Java 一样,采用更加适合于编码习惯的方式。 collections.abc 模块中定义好了很多抽象基类,每一个都具有不同的属性,下一小节会讨论一下 Sized 这个抽象基类。

    # 这里的 Sized 就是定义了某些必须实现函数的抽象基类

    from collections.abc import Sized

    print(isinstance(language, Sized))

    """

    isinstance放在下一个话题详细讨论

    这里先理解为 language 有了 Sized 里定义的属性

    """

    # result:

    # True

    构建抽象类

    还有一个位于全局的直接 abc 模块,可以通过它来声明一个抽象的类,然后通过其他具体的类去继承实现这个类。强制约束类的行为。具体说明可以查看 这里

    # 首先需要导入这个模块,abstract base class

    import abc

    class Base(metaclass=abc.ABCMeta): # metaclass? 放在元类编程里讲

    @abc.abstractmethod # 采用装饰器将这个方法修饰成抽象方法

    def get(self, key):

    pass

    class Test(Base):

    pass # 未实现抽象方法

    test = Test() # 实例化阶段就会报错

    # result:

    # TypeError: Can't instantiate abstract class Test with abstract methods get

    看看 Sized 这个抽象基类中都有什么东西:

    """

    接上一小节

    """

    class Sized(metaclass=ABCMeta):

    __slots__ = ()

    @abstractmethod

    def __len__(self): # 上一小节使用 Sized 做检测的关键

    return 0

    @classmethod

    def __subclasshook__(cls, C): # 能打印 True 是因为这个魔法函数自动调用了

    if cls is Sized:

    if any("__len__" in B.__dict__ for B in C.__mro__):

    return True

    return NotImplemented

    关于 __subclasshook__(),参阅:https://docs.python.org/3/library/abc.html#abc.ABCMeta.subclasshook

    小结

    abc 模块可以让我们定义自己的抽象基类,但是你可能已经注意到,这样的功能似乎和 Python 的动态语言灵活特性相违背,所以,这里并不推荐采用这种方式来编写代码,鸭子类型才应该是我们关注的重点。

    collections.abc 中定义了各种抽象基类,每一种都具有专门的特性,这些抽象基类不是为我们提供的,只是以一种类似文档的方式让我们了解 Python 灵活的各种内置对象的构成。

    isinstance 和 type

    引言

    isinstance(obj, class) : 判断前面的对象是不是后面类的一个实例。

    type(obj): 获得对象的类型

    使用案例

    class A:

    pass

    class B(A):

    pass

    b = B()

    print(isinstance(b, B))

    print(isinstance(b, A)) # 内部会沿着继承链往上找

    # result:

    # True

    # True

    print(type(b) is B)

    print(type(b) is A)

    # result:

    # True

    # False

    如果要判断一个对象的类型,应尽量采用 isinstance()。

    类变量和实例变量

    引言

    类变量属于类,是由所有实例共享的

    实例变量只属于特定的实例

    使用案例

    class Vector:

    v = 1

    def __init__(self, x, y):

    self.x = x

    self.y = y

    m = Vector(2, 3)

    print(m.x, m.y, m.v, Vector.v) # 实例可以访问到类变量

    # result:

    # 2, 3, 1, 1

    Vector.v = 11

    print(m.x, m.y, m.v, Vector.v) # 通过类修改了类变量的值

    # result:

    # 2, 3, 11,11

    """

    通过实例无法修改类变量

    这样写本质上是给实例 m 增加了一个实例变量 v

    """

    m.v = 111

    print(m.x, m.y, m.v, Vector.v)

    # result:

    # 2, 3, 111, 11

    MRO

    引言

    MRO:方法解析顺序(Method Resolution Order)

    对象在使用属性或者调用方法的时候会按照一定的顺序进行查找

    使用案例

    现在有这样两种多继承的关系结构:

    在 1 中若在A中调用了某一个方法,但是这个方法并不存在于A中,则它就会按照如下顺序向上查找并调用:A->B->D->C->E

    在 2 中,会沿着这样的一个顺序:A->B->C->D

    详细的算法步骤比较复杂,就不仔细讲解。我们可以通过__mro__属性来查看这种搜索顺序

    """

    图2中的继承关系

    """

    class D:

    pass

    class B(D):

    pass

    class C(D):

    pass

    class A(B, C):

    pass

    print(A.__mro__)

    # result:

    # (, , , , )

    类方法 静态方法 实例方法

    引言

    类方法静态方法在使用时要加上特殊的装饰器

    类方法和整个类有关,而且需要引用这个类

    静态方法和类有关,但不需要引用类或者实例

    使用案例

    class Date:

    def __init__(self, year, month, day):

    self.year = year

    self.month = month

    self.day = day

    def __str__(self):

    return "{y}/{m}/{d}".format(y=self.year, m=self.month, d=self.day)

    def tommorrow(self):

    self.day += 1

    @classmethod

    def parse_from_str(cls, data_str):

    year, month, day = tuple(data_str.split("-"))

    return cls(int(year), int(month), int(day))

    @staticmethod

    def is_valid_str(data_str):

    year, month, day = tuple(data_str.split("-"))

    valid_year = int(year)>0

    valid_month = int(month)>0 and int(month)<=12

    valid_day = int(day)>0 and int(day)<31

    return valid_year and valid_month and valid_day

    # 1.测试实例方法

    new_day = Date(2019, 8, 1)

    new_day.tommorrow()

    """

    实例方法定义的时候会有 self 参数

    实际调用时,不需要进行传递,谁调用谁就是self

    解释器会把它转化成:tommorrow(new_day)

    """

    print(new_day)

    # result:

    # 2019/8/2

    # 2.使用 classmethod 完成初始化

    new_day = Date.parse_from_str("2019-8-1")

    print(new_day)

    # result:

    # 2019/8/1

    # 3.使用 staticmethod 进行格式校验

    date_str = "2019-8-32"

    print(Date.is_valid_str(date_str))

    # result:

    # False

    数据封装和私有属性

    引言

    Python中对象的私有属性都是通过双下划线开头

    Python语言中并没有严格地数据私有化机制,而是通过名字重整,间接私有属性

    使用案例

    class Person:

    def __init__(self, age):

    self.__age = age

    def get_age():

    return self.age

    person = Person(20)

    print(person.age)

    # result:

    # AttributeError: 'Person' object has no attribute 'age'

    """

    名字重整就是将双下划线开头的私有变量,在内部用另外一个名字替换掉了

    替换方式:_ClassName__property

    """

    print(person._Person__age) # 还是访问到了我们所谓的 “私有属性”

    # result:

    # 20

    Python自省机制

    引言

    自省是通过一定的机制查询到对象的内部结构

    通过__dict__来查询属性

    通过dir(obj)查看更加详细的属性

    使用案例

    class Person:

    name = "MetaTian"

    class Student(Person):

    def __init__(self, school_name):

    self.school_name = school_name

    me = Student("Rity")

    print(me.__dict__) # 查看 me 的所有属性

    # result:

    # {'school_name': 'Rity'}

    """

    name 是属于 Person 的属性,能被打印不报错是因为

    按照了一定的查找规则,找到了它,可以调用,但并不属于 me

    """

    print(me.name)

    # result:

    # MetaTian

    """

    类也是对象,但是它的属性结构要比对象复杂的多

    """

    print(Person.__dict__)

    # result:

    # {'__module__': '__main__', 'name': 'MetaTian', '__dict__': , '__weakref__': , '__doc__': None}

    """

    这就是对象属性存储的本质了

    """

    me.__dict__["hobby"] = "reading"

    print(me.hobby)

    # result:

    # reading

    print(dir(me))

    这里给出的属性会更加详细,不过没有对应的值。通过给出的这些属性,我们大概就能猜到它实现了哪些魔法函数

    关于super

    引言

    调用父类的方法?

    多半用在构造函数中,既然重写了父类构造函数,为什么还要去调用?

    使用案例

    """

    定义自己的一个线程

    可以重用父类的构造方法,完成线程创建

    """

    from threading import Thread

    class MyThread(Thread):

    def __init__(self, myname, user):

    self.user = user

    super().__init__(name=myname) # 调用父类的构造方法

    """

    这里参考 MRO 小结中的第二种继承关系

    可以看到,B被打印后并没有找到其父类D,进行D的打印,而是打印了C

    super() 调用顺序与 mro 中定义的顺序是一样的

    """

    class D:

    def __init__(self):

    print("D")

    class B(D):

    def __init__(self):

    print("B")

    super().__init__()

    class C(D):

    def __init__(self):

    print("C")

    super().__init__()

    class A(B, C):

    def __init__(self):

    print("A")

    super().__init__()

    a = A()

    # result:

    # A

    # B

    # C

    # D

    # (, , , , )

    小结

    super()函数一般用在子类的构造函数中,可以让我们重用父类构造函数的代码,特别是父类构造函数非常复杂的情况下。

    这里的父类也不是严格的继承关系上的父类,而是MRO顺序中的上一个,对于复杂的继承关系结构,把super()简单地理解为调用父类是不准确的。

    with和contexlib

    引言

    就是上下文管理器,涉及到两个魔法函数__enter__()和__exit__()

    用来简化try和finally的用法

    实现了上下文管理器协议的类都可以直接使用with语句

    使用案例

    class Sample:

    def __enter__(self):

    print("enter") # 获取资源

    return self

    def __exit__(self, exc_type, exc_val, exc_tb):

    print("exit") # 释放资源

    def do_sth(self):

    print("doing something")

    with Sample() as sample:

    sample.do_sth()

    # result:

    # enter

    # doing something

    # exit

    import contexlib

    """

    使用contexlib库中提供的一个装饰器可以将一个函数变成上下文管理器

    所修饰的函数必须是一个生成器

    yield 语句之前的代码对应 __enter__()中的逻辑

    yield 语句之后的代码对应 __exit__()中的逻辑

    """

    @contexlib.contexmanager

    def file_open(file_name):

    print("file open")

    yield {} # 模拟一下,后面部分会详细讲解生成器

    print("file end")

    with file_open("Metatian.txt") as f_opened:

    print("file processing")

    # result:

    # file open

    # file processing

    # file end

    喜欢python + qun:839383765 可以获取Python各类免费最新入门学习资料!

    相关文章

      网友评论

          本文标题:python入门系列:深入类和对象

          本文链接:https://www.haomeiwen.com/subject/hdzdeqtx.html