12、python进阶-面向对象编程

1、面向对象概念

最重要的思想：数据封装
在类中将不同实例的属性封装起来，不同实例具有相同的数据类型，但是具有不同的属性

2、python之定义类并创建实例

class Person():
   pass

xiaoming = Person()
xiaohong = Person()

print xiaoming
print xiaohong
print xiaoming==xiaohong
#<__main__.Person instance at 0x7fe65af99050>
#<__main__.Person instance at 0x7fe65af9d3f8>
#False

3、python中创建实例属性

如何让每个实例拥有各自不同的属性？ 由于Python是动态语言，对每一个实例，都可以直接给他们的属性赋值
例子：请创建包含3个 Person 类的实例的 list，并给3个实例的 name 赋值，然后按照 name 进行排序。

class Person(object):
   pass
p1 = Person()
p1.name = 'Bart'

p2 = Person()
p2.name = 'Adam'

p3 = Person()
p3.name = 'Lisa'

L1 = [p1, p2, p3]
L2 = sorted(L1,lambda p1, p2: cmp(p1.name, p2.name))
L3 = sorted(L1,key=lambda x:x.name)

print L2[0].name
print L2[1].name
print L2[2].name

print L3[0].name
print L3[1].name
print L3[2].name

4、python中初始化实例属性

虽然我们可以自由地给一个实例绑定各种属性，但是，现实世界中，一种类型的实例应该拥有相同名字的属性
在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，init()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：

class Person(object):
    def __init__(self, name, gender, birth):
        self.name = name
        self.gender = gender
        self.birth = birth

init() 方法的第一个参数必须是 self，指向调用该方法的实例本身，（ 也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。

相应地，创建实例时，就必须要提供除 self 以外的参数：
xiaoming = Person(‘Xiao Ming’, ‘Male’, ‘1991-1-1’)
xiaohong = Person(‘Xiao Hong’, ‘Female’, ‘1992-2-2’)
有了__init__()方法，每个Person实例在创建时，都会有 name、gender 和 birth 这3个属性，并且，被赋予不同的属性值，访问属性使用.操作符：

print xiaoming.name
#输出 'Xiao Ming'
print xiaohong.birth
#输出 '1992-2-2'

例子：
请定义Person类的__init__方法，除了接受 name、gender 和 birth 外，还可接受任意关键字参数，并把他们都作为属性赋值给实例。

class Person(object):
    def __init__(self,name,gender,birth,**kw):
        self.name = name
        self.gender = gender
        self.birth = birth
        for key in kw:
            setattr(self, key, kw[key]) #除了可以直接使用self.name = 'xxx'设置一个属性外，还可以通过 setattr(self, 'name', 'xxx') 设置属性。
            # 
           # self.key = kw[key]  #这个不行 self.key无法区分是字符串key还是变量key
        #或者  self.__dict__.update(kw)    
xiaoming = Person('Xiao Ming', 'Male', '1990-1-1', job='Student')

print xiaoming.name
print xiaoming.job

self.dict.update(kw)： python class 通过内置成员__dict__ 存储成员信息（字典） 参考： https://blog.csdn.net/xiaolewennofollow/article/details/51455185

5、python中访问限制

Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。看例子：

class Person(object):
    def __init__(self, name):
        self.name = name
        self._title = 'Mr'
        self.__job = 'Student'
p = Person('Bob')
print p.name
# => Bob
print p._title
# => Mr
print p.__job
# => Error
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute '__job'

如果一个属性以_xxx_的形式定义，那它又可以被外部访问了，以_xxx_定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用_xxx_定义。

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.__sorce = score

p = Person('Bob', 59)

print p.name
try:
    print p.__score
except AttributeError:
    print "AttributeError"
#输出
#Bob
#AttributeError

6、python中创建类属性

6.1 实例属性每个实例各自拥有，互相独立，而类属性有且只有一份

类是模板，而实例则是根据类创建的对象。绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。

定义类属性可以直接在 class 中定义：

class Person(object):
    address = 'Earth'
    def __init__(self, name):
        self.name = name

因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问：

print Person.address
#=> Earth
对一个实例调用类的属性也是可以访问的，所有实例都可以访问到它所属的类的属性

由于Python是动态语言，类属性也是可以动态添加和修改的：
Person.address = ‘China’
因为类属性只有一份，所以，当Person类的address改变时，所有实例访问到的类属性都改变了。

6.2 例子：请给 Person 类添加一个类属性 count，每创建一个实例，count 属性就加 1

这样就可以统计出一共创建了多少个 Person 的实例

class Person(object):
    count = 0 
    def __init__(self, name):
        Person.count += 1 # 注意这里 内部的函数访问类对象用类名，因为函数属于实例的
p1 = Person('Bob')
print Person.count

p2 = Person('Alice')
print Person.count

p3 = Person('Tim')
print Person.count
#输出 1 2 3

6.3 python中类属性和实例属性名字冲突怎么办

class Person(object):
    address = 'Earth'
    def __init__(self, name):
        self.name = name

p1 = Person('Bob')
p2 = Person('Alice')

print 'Person.address = ' + Person.address

p1.address = 'China'
print 'p1.address = ' + p1.address

print 'Person.address = ' + Person.address
print 'p2.address = ' + p2.address

输出：
Person.address = Earth
p1.address = China
Person.address = Earth
p2.address = Earth
原因是 p1.address = 'China’并没有改变 Person 的 address，而是给 p1这个实例绑定了实例属性address ，

当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。
当我们把 p1 的 address 实例属性删除后，访问 p1.address 就又返回类属性的值 'Earth’了：

del p1.address
print p1.address
#=> Earth
可见，千万不要在实例上修改类属性，它实际上并没有修改类属性，而是给实例绑定了一个实例属性。

7、python中定义实例方法

7.1实例的方法就是在类中定义的函数，

它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：

class Person(object):

    def __init__(self, name):
        self.__name = name

    def get_name(self):
        return self.__name

调用实例方法必须在实例上调用：

p1 = Person(‘Bob’)
print p1.get_name() # self不需要显式传入
#=> Bob
在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得，这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度。

7.2 例子：

请给 Person 类增加一个私有属性 __score，表示分数，再增加一个实例方法 get_grade()，能根据 __score 的值分别返回 A-优秀, B-及格, C-不及格三档。

# -- coding: utf-8 --
class Person(object):

    def __init__(self, name, score):
        self.__score = score

    def get_grade(self):
        if self.__score >= 90:
            return "A-优秀"
        elif self.__score >= 60:
            return "B-及格"
        else:
            return "C-不及格三档"

p1 = Person('Bob', 90)
p2 = Person('Alice', 65)
p3 = Person('Tim', 48)

print p1.get_grade()
print p2.get_grade()
print p3.get_grade()

7.3 注意：python中方法也是属性 所以，可以动态地添加到实例上

我们在 class 中定义的实例方法其实也是属性，它实际上是一个函数对象，所以，可以动态地添加到实例上只是需要用 types.MethodType() 把一个函数变为一个方法： 给一个实例动态添加方法并不常见，直接在class中定义要更直观。

import types
def fn_get_grade(self):
    if self.score >= 80:
        return 'A'
    if self.score >= 60:
        return 'B'
    return 'C'

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

p1 = Person('Bob', 90)
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
print p1.get_grade()

8、定义类方法

和属性类似，方法也分实例方法和类方法。
在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。
要在class中定义类方法，需要这么写：

class Person(object):
    count = 0
    @classmethod
    def how_many(cls):
        return cls.count
    def __init__(self, name):
        self.name = name
        Person.count = Person.count + 1

print Person.how_many()
p1 = Person('Bob')
print Person.how_many()

通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。
因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。

class Person(object):
    __count = 0
    def __init__(self,name):
       Person.__count = Person.__count + 1
       Person.name = name       
    @classmethod
    def how_many(cls):
        return cls.__count
print Person.how_many()
p1 = Person('Bob')
print p1.how_many()