一、深入类和对象
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 """
这样就大大简化我们的上下文管理器啦。