03-深入类和对象

一、深入类和对象

1.1、鸭子类型和多态

维基百科中的解释为：

　　鸭子类型（英语：duck typing）在程序设计中是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由"当前方法和属性的集合"决定。这个概念的名字来源于由詹姆斯·惠特科姆·莱利提出的鸭子测试，“鸭子测试”可以这样表述：

　　“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”在鸭子类型中，关注点在于对象的行为，能作什么；而不是关注对象所属的类型。

class Cat():
    def say(self):
        print("I am a cat")

class Dog():
    def say(self):
        print("I am a dog")

class Duck():
    def say(self):
        print("I am a duck")

animal_list = [Cat,Dog,Duck]
for animal in animal_list:
    animal().say()#实例化对象，在调用say方法  三个类实现同一个方法名，这就是多态。然后可以将这些类归为一种类型（鸭子类型）
                  #python中的魔法函数充分也利用了鸭子类型的特性，可以在任一类中定义
name_list = ["list1","list2"]
name_list1 = ["love","python"]
name_tuple = (3,4)
name_set = set()
name_set.add(5)
name_set.add(6)
name_list.extend(name_set)   #参数name_set：['list1', 'list2', 5, 6]参数name_tuple：['list1', 'list2', 3, 4] 
print(name_list)              # 参数：name_list1：['list1', 'list2', 'love', 'python']
"""
这里说的是只要传入的参数是一个可迭代的类型就可以，
就连我们自定义的类将类的魔法函数__getitem__(返回 )、__iter__就可以变成可迭代的，都可以传入
 def extend(self, *args, **kwargs): # real signature unknown
        Extend list by appending elements from the iterable. 
        pass
"""
#首先这三个类里面都包含了这个say()方法，如果在JAVA里边，要实现多态的话，需要继承父类在覆盖父类的方法实现多态。
# 例如：一般情况先定义一个父类Animal，然后这个Animal有一个say()方法。
# 然后在写其他类例如上面的Cat类，Cat类继承Animal类，然后重写say()方法。
# 然后指定类型实例化这个Cat对象，在python中不需要指定类型，在JAVA中(静态语言)必须指定类型，
#这是动态语言和静态语言最大的区别。在python中都要做的一件事就是每个对象下都要写这个say()方法

1.2、抽象基类(abc)

　　python里边的抽象基类，是不能够实例化的。python是动态语言，动态语言是没有变量的类型的。在python中变量只是一个符号而已，这个符号可以指向任何类型的对象。动态语言缺少编译时检查错误的环境，在python中编写代码是很难发现错误的，只有要运行解释器才能找到错误。这也是动态语言共有的一个缺陷。python信奉的是鸭子类型，鸭子类型贯穿于整个面向对象之中。抽象基类是什么意思？在这个基础的类当中，设定好一些方法，然后所有的继承这个基类的类，都必须覆盖这个抽象基类里面的方法。抽象基类是无法实例化的。

##################去检查某个类是否有某种方法#############################
class Students(object):
    def __init__(self,student_list):
        self.student = student_list

    def __len__(self):
        return len(self.student)
students = Students(["lishuntao","test","python"])
# print(hasattr(students,"__len__"))#True
# print(hasattr(students,"__getitem__"))#False

##############################判定某个对象的类型#####################################
from collections.abc import Sized
print(isinstance(students,Sized))#True

######################利用抽象基类实现接口的 强制规定##########################
#强制某些子类必须实现某些方法
#实现了一个web框架，集成cache（redis，cache，memorychache）
#需要设计一个抽象基类，指定子类必须实现某些方法
#如何去模拟一个抽象基类呢？
class  CacheBase():
    def get(self,key):
        raise NotImplementedError
    def set(self,key,value):
        raise NotImplementedError
#用户在实现这个抽象基类的子类时候，必须实现这里面的两个方法
class RedisCache(CacheBase):
    pass
redis = RedisCache()
#redis.get("key")#抛出异常raise NotImplementedError NotImplementedError

#但这样做不好，我们需要刚初始化的时候就抛出异常，接下来就换成abc实现个人基类
import abc

class Cache1Base(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def get(self,key):
        pass
    @abc.abstractmethod
    def set(self,key,value):
        pass

class RedisCache1(Cache1Base):
    pass

redis_cache1 = RedisCache1() #TypeError: Can't instantiate abstract class RedisCache1 with abstract methods get, set
#利用抽象基类直接初始化抛出异常

#在python当中已经实现了一些通用的抽象基类，放在
from collections.abc import *

　　抽象基类不是用来继承的，它只是利用抽象基类来理解继承之间的关系，以及接口的定义，我们去使用的时候一定要用我们的鸭子类型，如果一定要用接口的话，那么推荐使用mixin多继承的方式去实现它。抽象基类使用的时候设计过度，反而不容易理解它。

1.3、isinstance和type的区别

class A:
    pass
class B(A):
    pass

b = B()
print(isinstance(b,B)) #True
print(isinstance(b,A)) #True

print(type(b) is B) #True   is与==的区别，==判断值是否相等，is判断是不是同一个对象（id（b）地址是否一样）
print(type(b),A) #False  
###########判断类型：为什么更推荐用isinstance而不是type？##############
#因为如果判断某个对象的类型的话，用isinstance会根据树的形状去搜索，从叶子搜索到跟就可以判断是否是相同类型，
#就算是不同对象可能是相同类型，然而type是同种类型，但不同对象。

1.4、类变量和实例变量

class A:
    a = 1 #a是类变量
    def __init__(self,x,y):#self是类的实例 x与y已经绑定到实例上的属性上了
        self.x = x
        self.y = y

num = A(2,3)
# A.a = 11   #如果修改类属性，那么实例的值也会跟着变
# num.a = 100  #如果修改实例属性，那么类属性的值不变，
# 会在对象中新建一个实例属性的值，寻找的时候直接对象属性中寻找。
print(num.x,num.y,num.a) #2 3 1  为什么实例num能够找到A的类属性呢，
# 首先实例num先在实例属性种寻找，如果没有找到的话就会向上寻找，找到类属性
print(A.a) # 1 类属性
print(A.x)#AttributeError: type object 'A' has no attribute 'x'
#类找实例属性找不到是因为类首先到自己的属性中找，如果没有找到的话，就不会向下寻找

1.5、类和实例属性的查找顺序----mro查找

类查找属性的查找顺序有深度优先查找和广度优先查找。

广度优先查找：

#python3以后称为新式类，全部都继承object
class D:
    pass
class C(D):
    pass
class B(D):
    pass
class A(B,C):
    pass
print(A.__mro__) #(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)
#__mro__魔法方法直接显示出类查找属性的顺序

深度优先查找：

#python3以后称为新式类，全部都继承object
class E:
    pass
class D:
    pass
class C(E):
    pass
class B(D):
    pass
class A(B,C):
    pass
print(A.__mro__)
#(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class 'object'>)

　　但在python3中为了避免深度优先算法与广度优先算法混乱，出现了C3算法避免了两种算法出现的问题，例如菱形搜索应用深度优先算法，从A找B再到D找到方法，可能C中重写了D的方法，因此深度优先算法不能解决菱形搜索的情况，然而C3算法解决了以上出现的两种情况。

1.6、类方法、静态方法和实例方法

class Date:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day
    #静态方法的缺点就是硬编码，如果换类名又要重新改返回的类名
    @staticmethod
    def parse_from_string(date_str):
        year,month,day = tuple(date_str.split("-"))
        return Date(int(year),int(month),int(day))
    #为啥不用classmethod替换staticmethod呢？
    #检查时间格式是否正确,不需要对象返回回来，因此这个时候它就有用了，而其余都是要将对象返回回来
    @staticmethod
    def valid_str(date_str):
        year, month, day = tuple(date_str.split("-"))
        if int(year)>0 and (int(month)>0 and int(month)<=12) and int(day)<=31:
            return True
        else:
            return False
    #类方法就解决掉刚才的硬编码问题
    @classmethod
    def from_string(cls,date_str):
        year, month, day = tuple(date_str.split("-"))
        return cls(int(year), int(month), int(day))
    def __str__(self):
        return "{year}/{month}/{day}".format(year=self.year,month=self.month,day=self.day)


if __name__ == '__main__':
    days = Date(2019,12,1)
    print(days) #2019/12/1
    #方法中传入self这个参数叫实例方法，

    #用staticmethod完成初始化
    date_str = "2019-12-01"
    new_day = Date.parse_from_string(date_str)
    print(new_day) #2019/12/1

    # 用classmethod完成初始化
    new_day = Date.from_string(date_str)
    print(new_day) #2019/12/1

    print(Date.valid_str("2019-12-01")) #True

1.7、数据封装和私有属性

导入的Date是上面写的类：

from chapter04.class_method import Date
class User:
    def __init__(self,birthday):
        self.__birthday = birthday#在属性前面加上双下划线，
        # 就变成了私有属性，外面实例化对象不能直接访问

    def get_age(self):
        """
        希望用户看不见出生日期(我们提供计算年龄的接口)在这里只能用公共方法调用，子类都不能使用私有属性
        :return:返回用户年龄，
        """
        return 2019 - self.__birthday.year

if __name__ == '__main__':
    user = User(Date(1999,9,9))
    print(user._User__birthday) #1999/9/9  如果想要访问那么对象名._classname__attr就可以获取python的私有属性
    print(user.get_age())#20
    #从语言的角度来讲，没有绝对的私有属性的安全性的，都是可以突破的，

1.8、python对象的自省机制

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

from chapter04.class_method import Date
class Person:
    name = "user"


class Student(Person):
    def __init__(self,school_name):
        self.school_name = school_name

if __name__ == '__main__':
    student = Student("清华大学")#实例
    #通过__dict__查询属性
    print(student.__dict__) #{'school_name': '清华大学'}
    #上面打印的是实例的属性,为啥name属性没有进入__dict__呢？因为name属于Person类，
    # 实例查询到name的值，但并不是说name属性属于实例
    print(student.name) #user
    print(Person.__dict__)#结果如下：类的__dict__比对象也就是实例更加丰富
    #{'__module__': '__main__', 'name': 'user', '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
    #给实例添加属性
    student.__dict__["school_addr"] = "四川市"
    print(student.school_addr)#四川市
    #会列出我们对象的所有属性
    print(dir(student))
    #['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'school_addr', 'school_name']
    list1 = [1,2,3,4]
    print(dir(list1))#列表不可以用__dict__，列表没有这个属性
    #['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

1.9、super真的是调用父类吗？

class A:
    def __init__(self):
        print("A")

class B(A):
    def __init__(self):
        print("B")
        super(B,self).__init__() # 想让他初始化B之后，运行A的初始化，这是python2的用法
        super().__init__() #python3的用法

#既然重写了A的构造函数，为什么还要调用super？
#super函数到底执行顺序是什么？（遵循__mro__算法逻辑顺序）
from threading import Thread


class MyThread(Thread):
    def __init__(self,name,user):
        self.user = user
        # self.name = name  #实际上父类Thread的参数有了name这个参数，我们直接可以调用父类
        super().__init__(name=name)#这样我们就不用写具体的name相关的逻辑了



if __name__ == '__main__':
    b = B() #运行结果：B,A,A

2.0、mixin继承案例----django-rest-framework

mixin模式特点：

　　1、Mixin类功能单一

　　2、不和基类关联（mixin只是定义一个方法（接口）），可以和任一基类组合、基类可以不和mixin组合就能初始化成功

　　3、在mixin中不要使用super的用法

　　4、设置mixin的时候尽量以Mixin结尾，这样别人就可以读懂代码（规范）

接下来展示的代码就是Django-REST-Framework的Mixins的设计模式(Mixin源代码)：

"""
Basic building blocks for generic class based views.

We don't bind behaviour to http method handlers yet,
which allows mixin classes to be composed in interesting ways.
"""
from rest_framework import status
from rest_framework.response import Response
from rest_framework.settings import api_settings


class CreateModelMixin:
    """
    Create a model instance.
    """
    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        serializer.save()

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}


class ListModelMixin:
    """
    List a queryset.
    """
    def list(self, request, *args, **kwargs):
        queryset = self.filter_queryset(self.get_queryset())

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)


class RetrieveModelMixin:
    """
    Retrieve a model instance.
    """
    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)


class UpdateModelMixin:
    """
    Update a model instance.
    """
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)

        if getattr(instance, '_prefetched_objects_cache', None):
            # If 'prefetch_related' has been applied to a queryset, we need to
            # forcibly invalidate the prefetch cache on the instance.
            instance._prefetched_objects_cache = {}

        return Response(serializer.data)

    def perform_update(self, serializer):
        serializer.save()

    def partial_update(self, request, *args, **kwargs):
        kwargs['partial'] = True
        return self.update(request, *args, **kwargs)


class DestroyModelMixin:
    """
    Destroy a model instance.
    """
    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def perform_destroy(self, instance):
        instance.delete()

看这些源代码是不是和上面的规范要求都是符合的呢？好接下来看我项目中的实战代码：

class GoodsListViewSet(mixins.ListModelMixin,mixins.RetrieveModelMixin,viewsets.GenericViewSet):
    """
    商品列表页 分页 搜索 过滤 排序
    """
    queryset = Goods.objects.all()
    serializer_class = GoodsSerializer
    pagination_class = GoodsSetPagination
    filter_backends = [DjangoFilterBackend,filters.SearchFilter,filters.OrderingFilter]
    #这是精确搜索过滤，我们需要的是模糊搜索
    # filterset_fields = ['name', 'shop_price']
    filter_class = GoodsFilter
    search_fields = ("name","goods_brief","goods_desc")
    ordering_fields = ("shop_price","sold_num","add_time")

基类和Mixin组合成新类，实现想要的功能。

2.1、python中的with语句

#try  except  else  finally
def exe_try():
    try:
        print("coding is started")
        raise KeyError
    except KeyError as e:
        print("key error")
        return 2
    else: #要程序没有出异常就会运行else
        print("other coding")
        return 3
    finally:
        print("finally")
        return 4
#python会自动识别自己的协议
#上下文管理器协议(with调用)（简化try-finally用法的）
class Sample():
    def __enter__(self):
        #获取资源
        print("enter")
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        #释放资源
        print("exit")
    def do_something(self):
        print("do something")

with Sample() as sample:
    sample.do_something()
    """
    当我们离开with语句的时候，就会调用__exit__方法
    运行结果：
    enter
    do something
    exit
    """

# if __name__ == '__main__':
#     result = exe_try()
#     print(result)
    """
    运行结果：为什么会出现这样的结果？程序运行，直接抛出异常KeyError先返回2进入栈底（栈的知识），
    然后执行finally中的返回4，4进入栈顶，栈的规则是后进先出，则返回的是4
    coding is started
    key error
    finally
    4
    """

2.2、contextlib简化上下文管理器

import contextlib

@contextlib.contextmanager#装饰器将函数变为上下文管理器（上下文管理器都可以用with用）
def file_open(filename):
    print("file open") #yield之前的相当于__enter__函数的操作
    yield {}
    print("file end")#之后相当于__exit__函数的操作

with file_open("test.txt") as fp:
    print("file open processing")
    """
    运行结果：
    file open
    file open processing
    file end
    """

这样就大大简化我们的上下文管理器啦。