class Cat(object):def say(self):print("i am a cat")class Dog(object):def say(self):print("i am a fish")
class Duck(object):def say(self):print("i am a duck")animal_list=[Cat,Dog,Duck]
for animal in animal_list:animal().say()# 不同的对象实现了相同的方法，多态i am a cat
i am a fish
i am a duck
---a = ["lewen1", "lewen2"]
b = ["lewen2", "lewen"]
name_tuple = ["lewen3", "lewen4"]
name_set = set()
name_set.add("lewen5")
name_set.add("lewen6")
a.extend(name_set) # extend() 括号里面为可迭代对象
print(a)['lewen1', 'lewen2', 'lewen6', 'lewen5']
---class Company(object):def __init__(self, employee_list):self.employee = employee_listdef __getitem__(self, item):return self.employee[item]def __len__(self):return len(self.employee)company = Company(["tom", "bob", "jane"])
b.extend(company) # 可以接受
print(b)['lewen2', 'lewen', 'tom', 'bob', 'jane']

#我们去检查某个类是否有某种方法
class Company(object):def __init__(self, employee_list):self.employee = employee_list
​def __len__(self):return len(self.employee)
​
​
com = Company(["bobby1","bobby2"])
print(hasattr(com, "__len__"))
True
#我们在某些情况之下希望判定某个对象是否是某个类型
from collections.abc import Sized
isinstance(com, Sized)
class A:pass
​
class B(A):pass
​
b = B()
print(isinstance(b, A))
True
#我们需要强制某个子类必须实现某些方法
#实现了一个web框架，集成cache(redis, cache, memorychache)
#需要设计一个抽象基类， 指定子类必须实现某些方法
​
#如何去模拟一个抽象基类
​
class CacheBase(object):def get(self, key):raise NotImplementedErrordef set(self, key, value):raise NotImplementedError
​
# class RedisCache(CacheBase):
#     pass                           #没有实现父类对应的方法，调用时会报错
class RedisCache(CacheBase):def set(self, key, value):      #调用不会再报错pass
​
redis_cache = RedisCache()
redis_cache.set("key", "value")
#上面更规范的写法
import abc
#from collections.abc import *
​
​
class CacheBase(metaclass=abc.ABCMeta):@abc.abstractmethoddef get(self, key):pass
​@abc.abstractmethoddef set(self, key, value):pass
class RedisCache(CacheBase):
#     def set(self, key, value):pass
redis_cache = RedisCache()    #初始化的时候就需要重载基类被装饰器修饰的方法
# redis_cache.set("key", "value")
---------------------------------------------------------------------------
​
TypeError                                 Traceback (most recent call last)
​
<ipython-input-16-a30c00982960> in <module>15 #     def set(self, key, value):16         pass
---> 17 redis_cache = RedisCache()    #初始化的时候就需要重载基类方法18 # redis_cache.set("key", "value")
TypeError: Can't instantiate abstract class RedisCache with abstract methods get, set
抽象基类用的比较少
​
mixin

class A:pass
​
class B(A):pass
​
b = B()
​
print(isinstance(b, B))
print(isinstance(b, A))
​
print(type(b))
print(type(b) is B)  #  is 去判断两个对象是不是一个对象，
print(type(b) == B)  # == 是对值是否相等的判断
print(type(b) is A)
print(isinstance(b, A))
True
True
<class '__main__.B'>
True
True
False
True
尽量使用isinstance 而不是type去判断一个类型isinstance 返回一个对象是否是类或其子类的一个实例。(Return whether an object is an instance of a class or of a subclass thereof)type 对象的类型

class A:aa = 1 # 类变量def __init__(self, x, y):self.x = x        # 实例变量self.y = ya = A(2,3)A.aa = 11     # 修改类变量
a.aa = 100    # 将值赋给实例变量
print(a.x, a.y, a.aa)print(A.aa)b = A(3,5)
print(b.aa)
---
2 3 100
11
11

class Date:#构造函数def __init__(self, year, month, day):self.year = yearself.month = monthself.day = daydef tomorrow(self):self.day += 1#静态方法    @staticmethoddef parse_from_string(date_str):year, month, day = tuple(date_str.split("-"))return Date(int(year), int(month), int(day))#硬编码的方式，只要类名修改，这反回的类名就得修改#类方法@classmethoddef from_string(cls, date_str):year, month, day = tuple(date_str.split("-"))return cls(int(year), int(month), int(day))# 判断是否是合法的字符串，不需要反回函数@staticmethoddef 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) >0 and int(day)<=31):return Trueelse:return Falsedef __str__(self):return "{year}/{month}/{day}".format(year=self.year, month=self.month, day=self.day)
​
if __name__ == "__main__":new_day = Date(2018, 12, 31)new_day.tomorrow()print(new_day)
2018/12/32#2018-12-31date_str = "2018-12-31"year, month, day = tuple(date_str.split("-"))new_day = Date(int(year), int(month), int(day))print (new_day)#用staticmethod(静态方法)完成初始化new_day = Date.parse_from_string(date_str)print (new_day)#用classmethod完成初始化new_day = Date.from_string(date_str)print(new_day)
​print(Date.valid_str("2018-12-32"))
2018/12/31
2018/12/31
2018/12/31
False
​
​

class User:def __init__(self, birthyear):self.__birthyear = birthyear  # 双下划线def get_age(self):# 返回年龄return 2018 - self.__birthyearif __name__ == "__main__":user = User(1990)print(user.get_age())# print(user.__birthyear)  # 私有属性是无法通过,实例访问的print(user._User__birthyear)  # 双下划线并不是绝对安全的
"""
28
1990
"""

#自省是通过一定的机制查询到对象的内部结构
​
class Person:name = "user"
​
class Student(Person):def __init__(self, scool_name):self.scool_name = scool_name
​
​
user = Student("慕课网")
#通过__dict__查询属性
print(user.__dict__)

#---

{'scool_name': '慕课网'}
#---
user.__dict__["school_addr"] = "北京市"
print(user.school_addr)

#---
北京市
#---
print(Person.__dict__)
print(user.name)

#---
{'__module__': '__main__', 'name': 'user', '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
user
#---

a = [1,2]
print(dir(a))

#---
['__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']

class A:def __init__(self):print ("A")
​
class B(A):def __init__(self):print ("B")#super(B,self).__init__()  # py2中的写法super().__init__()
​
b = B()

#---
B
A
既然我们重写B的构造函数， 为什么还要去调用super？
super到底执行顺序是什么样的？from threading import Thread
class MyThread(Thread):def __init__(self, name, user):self.user = usersuper().__init__(name=name)  # 重用父类的代码class A:def __init__(self):print ("A")
​
class B(A):def __init__(self):print ("B")super().__init__()
​
class C(A):def __init__(self):print ("C")super().__init__()class D(B, C):def __init__(self):print ("D")super(D, self).__init__()
​
if __name__ == "__main__":print(D.__mro__)d = D()
​
# 有共同父类，广度优先
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
D
B
C
Asuper() 调用的顺序是mro的顺序

try:print ("code started")raise KeyError
except KeyError as e:print ("key error")
else:                           #没有抛异常才会运行 elseprint ("other error")
finally:                        # 不管有没有异常，最后会执行print ("finally")           # 资源的释放# ---
code started
key error
finally
# ---
def exe_try():try:print ("code started")raise KeyErrorreturn 1except KeyError as e:print ("key error")return 2else:print ("other error")return 3finally:print ("finally")return 4  # 有返回值会反回，没有反回上一层的返回值
exe_try()
# ---
code started
key error
finally
4
# ---
# 上下文管理器协议， 由 __enter__,__exit__ 实现
# with 支持上下文管理器协议
class Sample:def __enter__(self):print ("enter")#获取资源return selfdef __exit__(self, exc_type, exc_val, exc_tb):#释放资源print ("exit")def do_something(self):print ("doing something")
​
with Sample() as sample:sample.do_something()# ---
enter
doing something
exit
​

import contextlib          #上下文管理器
@contextlib.contextmanager  # 用装饰器，将一个函数变成上下文管理器
def file_open(file_name):print ("file open")yield {}   # 必须是生成器print ("file end")with file_open("lewen.txt") as f_opened:print ("file processing")---
file open
file processing
file end
---