001day—类，多态，封装，装饰器，反射

类的种类：
新式类：继承object，存在在python2和py3中（python3中都是新式类，python2中只有继承object的类才算新式类）
经典类：只在py2中
继承顺序：
深度优先：经典类
广度优先：新式类
查看广度优先顺序：类名.mro()
遵循的算法：C3
抽象类
为什么用抽象类：为了规范子类必须实现和父类的相同方法

 #抽象类用到的模块
        #不需要模块的
        # class 父类：
        #     def 子类必须实现的方法名(self,参数们)：
        #         raise NotImplementedError('提示信息')
        # 
        # class 子类(父类)：
        #     def 父类要求实现的方法(self,参数们)：
        #         print('''code''')
        
        # 需要模块的
        # from abc import ABCMeta,abstractmethod
#         class 父类(metaclass=ABCMeta)：
#              @abstractmethod
#              def 子类必须实现的方法名(self,参数们)：pass
#         class 子类(父类)：
#               def 父类要求实现的方法(self,参数们)：
#                   print('''code''')

归一化设计

# class A:
#     def 同名功能(self):
#         pass  
# class B
#     def 同名功能(self):
#         pass    
# def 函数名(obj):
#     obj.同名功能()

多态
什么是多态：一个类表现出的多种形态，实际也是通过继承来完成的。
如果狗类继承动物类，猫类也继承动物类
我们就说猫类的对象也是动物类型的
狗类的对象也是动物类型的
在这个例子里，动物这个类型表现出了猫和狗的形态
python处处是多态
鸭子类型
子类继承父类，我们说子类是继承父类类型的（猫类继承动物，我们说猫也是动物）
在python中，一个类是不是属于某个类型，不仅仅通过继承来完成
还可以是不继承，但是如果这个类满足某些类的特征条件
我们就说他长得像这个类型，那么他就是这个类型的鸭子类型
封装：把属性和方法装起来
广义：把属性和方法装起来，外面不能直接调用，要通过类的名字调用
狭义：把属性和方法藏起来，外面不能调用，只能在内部调用
使用私有的三种情况：
不想让你看也不想让你改
能让你看但是不能改
既能让你看也能让你改，但要按规定的规则改
封装的语法
私有的静态变量
私有的实例变量
私有的绑定方法
所有的私有化都是为了不让用户在外部调用某个名字

加了双下划线的名字不能在外部调用
私有的内容不能被子类使用
数据级别：
public 公有的 类内类外都能用 父类子类都能用 python支持
protect 保护的 类内能用，父类子类都能用，类外不能用 python不支持
private 私有的 本类的内部使用，其他不能用 python支持

    # class Foo:
#     def __init__(self):
#         self.func()
#     def func(self):
#         print('in Foo')
# class Son(Foo):
#     def func(self):
#         print('in son')
# Son()           #in son


# class Foo:
#     def __init__(self):
#         self.__func()
#     def __func(self):
#         print('in Foo')
# class Son(Foo):
#     def __func(self):
#         print('in son')
# Son()           #in Foo

# class Foo:
#     def __func(self):
#         print('in Foo')
# class Son(Foo):
#     def __init__(self):
#         self.__func()
# Son()           #报错

装饰器

#property
from math import pi
class Circle(object):
    def __init__(self,r):
        self.r = r
    @property   #把一个方法伪装成属性
    def area(self):#装饰器这个方法不能有参数
        return pi*self.r**2
c1 = Circle(2)
print(c1.r)
print(c1.area)


class Goods(object):
    discount = 0.8
    def __init__(self,name,origin_price):
        self.name=name
        self.__origin_price = origin_price
    @property
    def price(self):
        return self.__origin_price*self.discount
    @price.setter
    def price(self,new_value):
        print('调用我了')
        if isinstance(new_value,int):
            self.__origin_price=new_value
apple = Goods('Apple',5)
print(apple.price)
apple.price=10 #被setter装饰的
print(apple.price)

a.py

class Wechat:pass
class Alipay:pass
def sww():
    print('helo')
lst = [1,2,34,5,6]
dic = {'k':'v'}
we = Wechat()

  

反射.py
```python
import a
print(a.sww)
print(getattr(a,'sww'))
print(a.lst)
print(getattr(a,'lst'))
print(a.dic)
print(getattr(a,'dic'))
print(a.we)
print(getattr(a,'we'))
'''<function sww at 0x7fd4d88e7790>
<function sww at 0x7fd4d88e7790>
[1, 2, 34, 5, 6]
[1, 2, 34, 5, 6]
{'k': 'v'}
{'k': 'v'}
<a.Wechat object at 0x7fd4d89af670>
<a.Wechat object at 0x7fd4d89af670>

import sys#反射本模块的名字
cat = 'xiaoA'
dog = 'xiaoB'
def pig():
    print('xiaoP')
print(getattr(sys.modules['__main__'],'cat'))
print(getattr(sys.modules['__main__'],'dog'))
getattr(sys.modules['__main__'],'pig')()

'''
xiaoA
xiaoB
xiaoP
'''
# 判断是否可调用(是否是函数)：callable()
# 判断是否含有age属性：hasattr(a,'age')