07 python基础--OOP

7.1 面向对象概述（ObjectOriented，OO）

OOP思想
    接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型构成的
几个名词
    OO:面向对象
    OOA：面向对象的分析
    OOD：面向对象的设计
    OOI：xxx的实现
    OOP：xxx的编程
    OOA->OOD->OOI: 面向对象的实现过程
类和对象的概念
    类：抽象名词，代表一个集合，共性的事物
    对象：具象的事物，单个个体
    类跟对象的关系
        一个具象，代表一类事物的某一个个体
        一个是抽象，代表的是一大类事物
类中的内容，应该具有两个内容
    表明事物的特征，叫做属性(变量)
    表明事物功能或动作，称为成员方法(函数)

7.2 类的基本实现

类的命名
    遵守变量命名的规范
    大驼峰（由一个或者多个单词构成，每个单词首字母大写，单词跟单词直接相连）
    尽量避开跟系统命名相似的命名
你如何声明一个类
    必须用class关键字
    类由属性和方法构成，其他不允许出现
    成员属性定义可以直接使用变量赋值，如果没有值，允许使用None

实例化类
        变量 = 类名() ####实例化了一个对象

访问对象成员
    使用点操作符
             obj.成员属性名称
             obj.成员方法

可以通过默认内置变量检查类和对象的所有成员
    对象所有成员检查
            # dict前后各有两个下划线
            obj.__dict__ 

    类所有的成员
            # dict前后各有两个下划线
           class_name.__dict__

# 定义一个空的类
class Student():
    # 必须使用pass占位
    pass
# 定义一个对象
mingyue = Student()

# 在定义一个类，用来描述听Python的学生
class PythonStudent():
    # 用None给不确定的值赋值
  name = None
  age = 18
  course = "Python"

  #  系统默认由一个self参数
  def doHomework(self):
        print("I 在做作业")
        # 推荐在函数末尾使用return语句
  return None

# 实例化一个叫yueyue的学生，是一个具体的人
yueyue = PythonStudent()
print(yueyue.name)
print(yueyue.age)
# 注意成员函数的调用没有传递进入参数
yueyue.doHomework()

7.3 类和对象的成员分析

类和对象都可以存储成员，成员可以归类所有，也可以归对象所有
类存储成员时使用的是与类关联的一个对象，对象存储成员是是存储在当前对象中
对象访问一个成员时，如果对象中没有该成员，尝试访问类中的同名成员， 
    如果对象中有此成员，一定使用对象中的成员

创建对象的时候，类中的成员不会放入对象当中，而是得到一个空对象，没有成员
通过对象对类中成员重新赋值或者通过对象添加成员时，对应成员会保存在对象中，而不会修改类成员

class A():
    name = 'nana'
    def stu(self):
        grade = 3
          print('今年读高中{}年纪'.format(grade))
## 实例化
a = A()
print(A.name)
print(a.name)
print(A.__dict__)
print(a.__dict__)
print(id(A))
print(id(a))
print(id(A.name))
print(id(a.name))
print('*'*20)
a.name = 'lili'
print(A.name)
print(a.name)
print(A.__dict__)
print(a.__dict__)
print(id(A))
print(id(a))
print(id(A.name))
print(id(a.name))
>nana
>nana
>{'__module__': '__main__', 'name': 'nana', 'stu': <function A.stu at 0x000002362BF61AE8>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
>{}
>2431689178280
>2431688435640
>2431687640208
>2431687640208     ## 对象成员id与类成员id相同
********************
>nana
>lili
>{'__module__': '__main__', 'name': 'nana', 'stu': <function A.stu at 0x000002362BF61AE8>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
>{'name': 'lili'}       ## 修改后增加新属性
>2431689178280
>2431688435640      ## A、a的id不变
>2431687640208
>2431688435448      ## 对象修改后成员id变化

## 成员查看
class student():
    name = 'dana'
  age = 18

  def say(self):
        print('不要惹老子')

yueyue = student()
print(yueyue.name)
print(yueyue.__dict__)   ## 查看对象成员
print(student.__dict__)  ## 查看类成员
yueyue.say()
>dana
>{}
>{'__module__': '__main__', 'name': 'dana', 'age': 18, 'say': <function student.say at 0x017578A0>, '__dict__': <attribute '__dict__' of 'student' objects>, '__weakref__': <attribute '__weakref__' of 'student' objects>, '__doc__': None}
>不要惹老子

7.4 关于self

self在对象的方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入到当前方法
的第一个参数中 
self并不是关键字，只是一个用于接受对象的普通参数，理论上可以用任何一个普通变量名代替
方法中有self形参的方法成为非绑定类的方法，可以通过对象访问， 没有self的是绑定类的方法，只能通过类访问
使用类访问绑定类的方法时， 如果类方法中需要访问当前类的成员，可以通过 __class__成员名来访问

## self 就是一个接受对象的普通参数
class Student():
    name = "dana"
    age = 18

  # 注意say的写法，参数由一个self
    def say(self):
        self.name = "aaaa"
        self.age = 200
        print("My name is {0}".format(self.name))
        print("My age is {0}".format(self.age))

    def sayAgain(s):
        ## 这里用s代替self
        print("My name is {0}".format(s.name))
        print("My age is {0}".format(s.age))

yueyue = Student()
yueyue.say()
yueyue.sayAgain()
>My name is aaaa
 My age is 200
 My name is aaaa
 My age is 200

class Teacher():
    name = "dana"
    age = 19

    def say(self):
        self.name = "yaona"
        self.age = 17
        print("My name is {0}".format(self.name))
        # 调用类的成员变量需要用 __class__
        print("My age is {0}".format(__class__.age))

    def sayAgain():
        print(__class__.name)
        print(__class__.age)
        print('hello')

t = Teacher()
t.say()
##　调用绑定类函数使用类名
Teacher.sayAgain()
>My name is yaona
>My age is 19
>dana
>19
>hello

class student():
    name = 'dana'
    age = 18

    def say(self):
        self.name = 'nana'
        print('不要惹老子')

yueyue = student()
print(yueyue.name)
print(yueyue.age)
print(yueyue.say())
>dana
 18
 不要惹老子
 None   ##None是函数执行的结果， 因为它没有return所以返回值是None

class A():
    name = " liuying"
    age = 18

    def __init__(self):
        self.name = "aaaa"
        self.age = 200

    def say(self):
        print(self.name)
        print(self.age)

class B():
    name = "bbbb"
    age = 90

a = A()
# 此时，系统会默认把a作为第一个参数传入函数
a.say()
#
# 此时，self被a替换
A.say(a)
# 同样可以把A作为参数传入
A.say(A)
#
# 此时，传入的是类实例B，因为B具有name和age属性，所以不会报错
A.say(B)
# 以上代码，利用了鸭子模型

>aaaa
>200
>aaaa
>200
>liuying
>18
>bbbb
>90

7.5 面向对象的特征

封装

封装就是对对象的成员进行访问限制

封装的三个级别：
    公开，public
    受保护的，protected
    私有的，private
    public，private，protected不是关键字
判别对象的位置
    对象内部
    对象外部
    子类中
[python中下划线使用](http://blog.csdn.net/handsomekang/article/details/40303207)

私有 private
    私有成员是最高级别的封装，只能在当前类或对象中访问
    在成员前面添加两个两个下划线即可
    
    注：Python的私有不是真私有，是一种成为name mangling的改名策略，可以使用对象._classname_attributename访问
    
受保护的封装 protected
    python中所谓的“保护”指的是顶级对象相对于module的可见性
    受保护的封装是将对象成员进行一定级别的封装，然后，在类中或者子类中都可以进行访问，但是在外部不可以,而Python中受“保护”的对象，跟java不太一样，如果是类(对象)的成员，其实相当于没保护，不管是不是夸包，都可以随意访问，而且继承也不受任何限制。如果被保护的是顶级的函数或变量，那就有用了，这些函数和变量不允许被import到其他包中。
    封装方法： 在成员名称前添加一个下划线即可

公开的，公共的 public
    公共的封装实际对成员没有任何操作，任何地方都可以访问

继承

继承就是一个类可以获得另外一个类中的成员属性和成员方法
作用： 减少代码，增加代码的复用功能， 同时可以设置类与类直接的关系

继承与被继承的概念：
    被继承的类叫父类，也叫基类，也叫超类
    用于继承的类，叫子类，也叫派生类
    继承与被继承一定存在一个 is-a 关系

继承的特征
    所有的类都继承自object类，即所有的类都是object类的子类
    子类一旦继承父类，则可以使用父类中除私有成员外的所有内容
    子类继承父类后并没有将父类成员完全赋值到子类中，而是通过引用关系访问调用
    子类中可以定义独有的成员属性和方法
    子类中定义的成员和父类成员如果相同，则优先使用子类成员
    子类如果想扩充父类的方法，可以在定义新方法的同时访问父类成员来进行代码重用，
    可以使用 [父类名.父类成员] 的格式来调用父类成员，也可以使用super().父类成员的格式来调用

继承变量函数的查找顺序问题
    优先查找自己的变量
    没有则查找父类
    构造函数如果本类中没有定义，则自动查找调用父类构造函数
    如果本类有定义，则不在继续向上查找

构造函数
    是一类特殊的函数，在类进行实例化之前进行调用
    如果定义了构造函数，则实例化时使用构造函数，不查找父类构造函数
    如果没定义，则自动查找父类构造函数
    如果子类没定义，父类的构造函数带参数，则构造对象时的参数应该按父类参数构造

super
    super不是关键字， 而是一个类
    super的作用是获取MRO（MethodResolustionOrder）列表中的第一个类
    super于父类直接没任何实质性关系，但通过super可以调用到父类
    super使用两个方,参见在构造函数中调用父类的构造函数

单继承和多继承
    单继承：每个类只能继承一个类
    多继承：每个类允许继承多个类
    优缺点
        单继承：
            传承有序逻辑清晰语法简单隐患少
            功能不能无限扩展，只能在当前唯一的继承链中扩展
        多继承：
            优点：类的功能扩展方便
            缺点：继承关系混乱

菱形继承/钻石继承问题
    多个子类继承自同一个父类，这些子类由被同一个类继承，于是继承关系图形成一个菱形图谱
    [MRO](https://www.cnblogs.com/whatisfantasy/p/6046991.html)
    关于多继承的MRO
        MRO就是多继承中，用于保存继承顺序的一个列表
        python本身采用C3算法来多多继承的菱形继承进行计算的结果
        MRO列表的计算原则：
            子类永远在父类前面
            如果多个父类，则根据继承语法中括号内类的书写顺序存放
            如果多个类继承了同一个父类，孙子类中只会选取继承语法括号中第一个父类的父类

构造函数
    在对象进行实例化的时候，系统自动调用的一个函数叫构造函数，通常此函数用来对实例对象进行初始化，顾名
    构造函数一定要有，如果没有，则自动向上查找，按照MRO顺序，直到找到为止

多态

多态就是同一个对象在不同情况下有不同的状态出现
多态不是语法，是一种设计思想
多态性： 一种调用方式，不同的执行效果
多态： 同一事物的多种形态，动物分为人类，狗类，猪类
[多态和多态性](https://www.cnblogs.com/luchuangao/p/6739557.html)

Mixin设计模式
    主要采用多继承方式对类的功能进行扩展
    [Mixin概念](https://www.zhihu.com/question/20778853)
    [Mixin的理解](https://blog.csdn.net/u010377372/article/details/70256043)
    [MRO and Mixin](http://blog.csdn.net/robinjwong/article/details/48375833)
    [Mixin模式](https://www.cnblogs.com/xybaby/p/6484262.html)
    [Mixin MRO](http://runforever.github.io/2014-07-19/2014-07-19-python-mixin%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/)
    [MRO](http://xiaocong.github.io/blog/2012/06/13/python-mixin-and-mro/)

我们使用多继承语法来实现Minxin
使用Mixin实现多继承的时候非常小心
    首先他必须表示某一单一功能，而不是某个物品
    职责必须单一，如果由多个功能，则写多个Mixin
    Mixin不能依赖于子类的实现
    子类及时没有继承这个Mixin类， 也能照样工作，只是缺少了某个功能
优点
    使用Mixin可以在不对类进行任何修改的情况下，扩充功能
    可以方便的组织和维护不同功能组件的划分
    可以根据需要任意调整功能类的组合
    可以避免创建很多新的类，导致类的继承混乱

封装

# 私有变量案例
class Person():
    # name是共有的成员
    name = "liuying"
    # __age就是私有成员
    __age = 18

p = Person()
# name是公有变量
print(p.name)
# __age是私有变量,直接访问报错
print(p.__age)
# name mangling技术
print(p._Person__age)    ## 私有变量实际改名为_Person__age
>liuying
>AttributeError: 'Person' object has no attribute '__age'
>18

继承

# 继承的语法
# 在python中，任何类都有一个共同的父类叫object

class Person():
    name = "NoName"
    age = 80
    __score = 0 # 考试成绩是秘密，只要自己知道
    _petname = "sec" # 小名，是保护的，子类可以用，但不能公用

    def sleep(self):
        print("Sleeping ... ...")
    def work(self):
        print('make some money')

# 父类写在括号内
class Teacher(Person):
    teacher_id = "9527"
    age = 18

    def make_test(self):
        print("attention")

    def work(self):
        # 扩充父类的功能只需要调用父类相应的函数
        # Person.work(self) # 扩充父类的另一种方法 # super代表得到父类  super().work()
        self.make_test()

t = Teacher()
print(t.name)
print(t.age)
print(t._petname)

t.sleep()
print(t.teacher_id)
t.make_test()
t.work()

>NoName
>18
>sec
>Sleeping ... ...
>9527
>attention
>make some money
>attention

继承中的构造函数

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

class PaxingAni(Animel):
    def __init__(self):
        print("Paxing Dongwu")

class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第二个被自动的调用(第一个为__new__) # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")

# 实例化的时候，自动调用了Dog的构造函数
# 因为找到了构造函数，则不在查找父类的构造函数
kaka = Dog()

# 猫没有写构造函数
class Cat(PaxingAni):
    pass

# 此时应该自动调用构造函数，因为Cat没有构造函数，所以查找父类构造函数
# 在PaxingAni中查找到了构造函数，则停止向上查找
c = Cat()
>I am init in dog
>Paxing Dongwu‘

********************************************************

# 构造函数的调用顺序
class A():
    def __init__(self):
        print("A")

class B(A):
    def __init__(self, name):
        print("B")
        print(name)

class C(B):
    # c中想扩展B的构造函数，
 # 即调用B的构造函数后在添加一些功能 # 由两种方法实现
    '''
 # 第一种是通过父类名调用 
    def __init__(self, name): 
    # 首先调用父类构造函数 
    B.__init__(self, name) 
    # 其次，再增加自己的功能 
    print("这是C中附加的功能") 
    '''
  # 第二种，使用super调用
    def __init__(self, name):
        # 首先调用父类构造函数
    super(C, self).__init__(name)
        # 其次，再增加自己的功能
    print("这是C中附加的功能")

# 此时，首先查找C的构造函数
# 如果没有，则向上按照MRO顺序查找父类的构造函数，知道找到为止
# 此时，会出现参数结构不对应错误
c = C("我是C")

>B
>我是C
>这是C中附加的功能

多继承

# 多继承的例子
# 子类可以直接拥有父类的属性和方法，私有属性和方法除外

class Base(object):
    def test(self):
        print("------base")

class A(Base):
    def test1(self):
        print("------test1")

class B(Base):
    def test2(self):
        print("------test2")

class C(A, B):
    pass

c = C()
c.test1()
c.test2()
c.test()
>------test1
>------test2
>------base

多态

# 多态：同一种事物的多种形态，动物分为人类，猪类（在定义角度）
class Animal:
    def run(self):
        raise AttributeError('子类必须实现这个方法')

class People(Animal):
    def run(self):
        print('人正在走')

class Pig(Animal):
    def run(self):
        print('pig is walking')

class Dog(Animal):
    def run(self):
        print('dog is running')

peo1 = People()
pig1 = Pig()
d1 = Dog()

peo1.run()
pig1.run()
d1.run()
>人正在走
>pig is walking
>dog is running

Mixin

# 实例1
## 未使用Mixin
class Person():
    name = "liuying"
    age = 18
    def eat(self):
        print("EAT.......")

class Teacher(Person):
    def work(self):
        print("Work")

class Student(Person):
    def study(self):
        print("Study")

class Tutor(Teacher, Student):
    pass

t = Tutor()

print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)
>(<class '__main__.Tutor'>, <class '__main__.Teacher'>, <class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>)
>{}
>{'__module__': '__main__', '__doc__': None}
## 使用Mixin
class Person():
    name = "liuying"
    age = 18
    def eat(self):
        print("EAT.......")

class TeacherMixin():
    def work(self):
        print("Work")

class StudentMixin():
    def study(self):
        print("Study")

class Tutor(Person, TeacherMixin, StudentMixin):
    pass

t = Tutor()
print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)
>(<class '__main__.Tutor'>, <class '__main__.Person'>, <class '__main__.TeacherMixin'>, <class '__main__.StudentMixin'>, <class 'object'>)
>{}
>{'__module__': '__main__', '__doc__': None}

7.6 类相关函数

issubclass:检测一个类是否是另一个类的子类
isinstance:检测一个对象是否是一个类的实例
hasattr:检测一个对象是否由成员xxx
getattr: get attribute
setattr: set attribute
delattr: delete attribute
dir: 获取对象的成员列表

# getattr()/setattr()/delattr()/hasattr()

class A():
    name = 'lili'
  age =18

a = A()

print(hasattr(a,'name'))    ## 判断a对象是否有name属性
print(hasattr(A,'name'))

print(getattr(a,'name'))   ## 获取对象a的name属性值
setattr(a,'name','lucy')   ##设置那么的属性值为lucy
print(getattr(a,'name'))
delattr(A,'name')          ## 删除属性
print(getattr(A,'name','not found'))
delattr(a,'name')
print(getattr(a,'name','not found'))     ## 读取是否有属性name,没有则返回default值'not found'


>True
>True
>lili
>lucy
>not found
>not found

7.7 类的成员描述符（属性）

[描述符类](https://www.cnblogs.com/jessonluo/p/4758662.html)
类的成员描述符是为了在类中对类的成员属性进行相关操作而创建的一种方式
    get： 获取属性的操作
    set：修改或者添加属性操作
    delete： 删除属性的操作
如果想使用类的成员描述符，大概有三种方法
    使用类实现描述器
    使用属性修饰符
    使用property函数
        property函数很简单
        property(fget, fset, fdel, doc)
    案例参看notebook
无论哪种修饰符都是为了对成员属性进行相应的控制  
    类的方式： 适合多个类中的多个属性共用用一个描述符
    property：使用当前类中使用，可以控制一个类中多个属性
    属性修饰符： 使用于当前类中使用，控制一个类中的一个属性

# peroperty案例
# 定义一个Person类，具有name，age属性
# 对于任意输入的姓名，我们希望都用大写方式保存
# 年龄，我们希望内部统一用整数保存
# x = property(fget, fset, fdel, doc)
class Person():
    '''
 这是一个人，一个高尚的人，一个脱离了低级趣味的人 他还他妈的有属性 '''
  # 函数的名称可以任意
  def fget(self):
        return self._name * 2

  def fset(self, name):
        # 所有输入的姓名以大写形式保存
  self._name = name.upper()

    def fdel(self):
        self._name = "NoName"

  name = property(fget, fset, fdel, "对name进行下下操作啦")

p1 = Person()
p1.name = "TuLing" ## 调用fset()
print(p1.name)            ## 调用fget()
print(p1.__dict__)        ## 获取类的成员组成
print(p1.__doc__)         ## 获取类的文档信息
print(Person.__name__)    ## 获取类的名称
print(Person.__bases__)   ## 获取所有父类

>TULINGTULING
>{'_name': 'TULING'}
>
    这是一个人，一个高尚的人，一个脱离了低级趣味的人
    他还他妈的有属性
    
>Person
>(<class 'object'>,)

7.8 类的内置属性

__dict__:以字典的方式显示类的成员组成
__doc__: 获取类的文档信息
__name__:获取类的名称，如果在模块中使用，获取模块的名称
__bases__: 获取某个类的所有父类，以元组的方式显示

7.9 类的常用魔术方法

魔术方法就是不需要人为调用的方法，基本是在特定的时刻自动触发
魔术方法的统一的特征，方法名被前后各两个下滑线包裹
操作类
    __init__: 构造函数，用于初始化一个类
    __new__: 对象实例化方法，此函数较特殊，一般不需要使用
    __call__: 对象当函数使用的时候触发
    __str__: 当对象被当做字符串使用的时候调用
    __repr__: 返回字符串，跟__str__具体区别请百度
描述符相关
    __set__
    __get__
    __delete__
属性操作相关
    __getattr__: 访问一个不存在的属性时触发
    __setattr__: 对成员属性进行设置的时候触发
        参数： 
            self用来获取当前对象
            被设置的属性名称，以字符串形式出现
            需要对属性名称设置的值
        作用：进行属性设置的时候进行验证或者修改
        注意： 在该方法中不能对属性直接进行赋值操作，否则死循环
        参看案例
运算分类相关魔术方法
    __gt__: 进行大于判断的时候触发的函数
        参数：
            self
            第二个参数是第二个对象
            返回值可以是任意值，推荐返回布尔值

class Person():
    def __init__(self):
        print('直接被调用了')

    def __call__(self, *args, **kwargs):
        print('使用函数时被调用')

    def __str__(self):
        return "当对象被当做字符串使用的时候调用"
p = Person()
p()
print(p)
>直接被调用了
>使用函数时被调用
>当对象被当做字符串使用的时候调用

# __gt__s
class Student():
    def __init__(self, name):
        self._name = name

    def __gt__(self, obj):
        print("哈哈， {0} 会比 {1} 大吗？".format(self, obj))
        return self._name > obj._name

stu1 = Student("one")
stu2 = Student("two")
print(stu1 > stu2)

>哈哈， <__main__.Student object at 0x0000022B5112FEB8> 会比 <__main__.Student object at 0x0000022B51121A58> 大吗？
>False

7.10 类和对象的三种方法

实例方法
    需要实例化对象才能使用的方法，使用过程中可能需要截止对象的其他对象的方法完成
静态方法
    不需要实例化，通过类直接访问
类方法
    不需要实例化
参看案例
三个方法具体区别自行百度

# 三种方法的案例
class Person:
    # 实例方法
  def eat(self):
        print(self)
        print("Eating.....")

    # 类方法
 # 类方法的第一个参数，一般命名为cls，区别于self  @classmethod
  def play(cls):
        print(cls)
        print("Playing.....")

    # 静态方法
 # 不需要用第一个参数表示自身或者类  @staticmethod
  def say():
        print("Saying....")

yueyue = Person()

# 实例方法
yueyue.eat()
# 类方法
Person.play()
yueyue.play()
# 静态方法
Person.say()
yueyue.say()
><__main__.Person object at 0x00000299FFF61B70>
>Eating.....
><class '__main__.Person'>
 Playing.....
><class '__main__.Person'>
 Playing.....
>Saying....
>Saying....

# 属性的三种用法
# 1. 赋值
# 2. 读取
# 3. 删除
class A():
    def __init__(self):
        self.name = "haha"
  self.age = 18

a = A()

a.name = "Lili"
print(a.name)
del a.name
# print(a.name)    # 报错
>Lili

# 类属性 property
# 对变量除了普通的三种操作，还想增加一些附加的操作，那么可以通过property完成
class A():
    def __init__(self):
        self.name = "haha"
  self.age = 18

  # 此功能，是对类变量进行读取操作的时候应该执行的函数功能
  def fget(self):
        print("我被读取了")
        return self.name

    # 模拟的是对变量进行写操作的时候执行的功能
  def fset(self, name):
        print("我被写入了，但是还可以左好多事情")
        self.name = "图灵学院：" + name

    # fdel模拟的是删除变量的时候进行的操作

  def fdel(self):
        pass

  # property的四个参数顺序是固定的
  # 第一个参数代表读取的时候需要调用的函数
  # 第二个参数代表写入的时候需要调用的函数
  # 第三个是删除
  name2 = property(fget, fset, fdel, "这是一个property的例子")

a = A()
print(a.name)
print(a.name2)
>haha
>我被读取了
 haha

7.11 抽象类

[抽象类]http://www.cnblogs.com/asaka/p/6758426.html
抽象方法： 没有具体实现内容的方法成为抽象方法
抽象方法的主要意义是规范了子类的行为和接口
抽象类的使用需要借助abc模块
       import abc
抽象类：包含抽象方法的类叫抽象类，通常成为ABC类
抽象类的使用
    抽象类可以包含抽象方法，也可以包含具体方法
    抽象类中可以有方法也可以有属性
    抽象类只能被继承，不能被实例化，继承的子类必须实现所有继承来的抽象方法
    假定子类没有是现实所有继承的抽象方法，则子类也不能实例化
    抽象类的主要作用是设定类的标准，以便于开发的时候具有统一的规范

import abc
class All_file(metaclass=abc.ABCMeta):
    all_type = 'file'
  @abc.abstractmethod #定义抽象方法，无需实现功能
  def read(self):
        '子类必须定义读功能'
  pass

  @abc.abstractmethod
  def write(self):
        '子类必须定义写功能'
  pass

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
  def read(self):
        print('文本数据的读取')

    def write(self):
        print('文本数据的读取方法')

class Process(All_file):  # 子类继承抽象类，但是必须定义read和write方法

  def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()
wenbenwenjian.read()
jinchengwenjian=Process()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(jinchengwenjian.all_type)

>文本数据的读取
 进程数据的读取方法
 file
 file

7.12 自定义类

类其实是一个类定义和各种方法的自由组合
可以定义类和函数，然后自己通过类直接赋值
可以借助于MethodType实现
借助于type实现

元类：http://python.jobbole.com/88795/
利用元类实现MetaClass
    元类是类
    备用来创造别的类

# 函数名可以当变量使用
def Person(name):
    print('我的名字是%s'%name)


Person('lili')

s = Person

s('lucy')

>我的名字是lili
 我的名字是lucy


# 自己组装一个类
class A():
    pass

def say(self):
    print('saying......')

A.say = say   ## 组装

a = A()   ## 实例化
a.say()   ## 调用方法
>saying......
--------------------------------------------------------------------------
# 利用type造一个类

# 先定义类应该具有的成员函数
def say(self):
    print('saying...')

def eat(self):
    print('eating...')
#用type来创建一个类
A = type('name', (object,), {'class_say':say,'class_eat':eat})  ## 组装类A

# 访问类
a = A()
a.class_say()
a.class_eat()

>saying...
 eating...

--------------------------------------------------------------------------
# 元类演示

# 元类写法是固定的，必须继承自type,命名以MetaClass结尾
class AMetaClass(type):
    # 注意以下写法
    def __new__(cls, name, bases, attrs):
        # 自己的业务处理
        print("哈哈，我是元类呀")
        attrs['id'] = '000000'
        attrs['addr'] = "北京海淀区公主坟西翠路12号"
        return type.__new__(cls, name, bases, attrs)


# 元类定义完就可以使用，使用注意写法
class Teacher(object, metaclass=AMetaClass):
    pass


t = Teacher()
>哈哈，我是元类呀