python面向对象编程基础

1 面向对象编程的基本思想

类用来定义抽象类型

实例的一个类的具备实现

python中 

class Person:

    pass

数据封装

class Person:

    def __init__(self, name,age )

        self.name = name

        self.age = age

p = Person('xiaoming',23)

2.类的定义与建立实例

在Python中，类经过 class 关键字定义。以 Person 为例，定义一个Person类以下：

class Person(object):
    pass

按照 Python 的编程习惯，类名以大写字母开头，紧接着是(object)，表示该类是从哪一个类继承下来的。类的继承将在后面的章节讲解，如今咱们只须要简单地从object类继承。

有了Person类的定义，就能够建立出具体的xiaoming、xiaohong等实例。建立实例使用 类名+()，相似函数调用的形式建立：

xiaoming = Person()
xiaohong = Person()

3. python中建立实例属性

虽然能够经过Person类建立出xiaoming、xiaohong等实例，可是这些实例看上除了地址不一样外，没有什么其余不一样。在现实世界中，区分xiaoming、xiaohong要依靠他们各自的名字、性别、生日等属性。

如何让每一个实例拥有各自不一样的属性？因为Python是动态语言，对每个实例，均可以直接给他们的属性赋值，例如，给xiaoming这个实例加上name、gender和birth属性：

xiaoming = Person()
xiaoming.name = 'Xiao Ming'
xiaoming.gender = 'Male'
xiaoming.birth = '1990-1-1'

给xiaohong加上的属性不必定要和xiaoming相同：

xiaohong = Person()
xiaohong.name = 'Xiao Hong'
xiaohong.school = 'No. 1 High School'
xiaohong.grade = 2

实例的属性能够像普通变量同样进行操做：

xiaohong.grade = xiaohong.grade + 1

任务

请建立包含两个 Person 类的实例的 list，并给两个实例的 name 赋值，而后按照 name 进行排序。

 1 #python 2.7
 2 class Person(object):
 3     pass
 4 
 5 p1 =Person()
 6 p1.name ='Bart'
 7 p2 =Person()
 8 p2.name ='Adam'
 9 p3 =Person()
10 p3.name ='Lisa'
11 L1 =[p1, p2, p3]
12 L2 = sorted(L1,key=lambda x: x.name)
13 print L2[0].name
14 print L2[1].name
15 print L2[2].name

 

输出

Adam
Bart
Lisa

4.python中初始化实例属性

虽然咱们能够自由地给一个实例绑定各类属性，可是，现实世界中，一种类型的实例应该拥有相同名字的属性。例如，Person类应该在建立的时候就拥有 name、gender 和 birth 属性，怎么办？

在定义 Person 类时，能够为Person类添加一个特殊的__init__()方法，当建立实例时，__init__()方法被自动调用，咱们就能在此为每一个实例都统一加上如下属性：

1 class Person(object):
2     def __init__(self, name, gender, birth):
3         self.name = name
4         self.gender = gender
5         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'

要特别注意的是，初学者定义__init__()方法经常忘记了 self 参数：

>>> class Person(object):
...     def __init__(name, gender, birth):
...         pass
... 
>>> xiaoming = Person('Xiao Ming', 'Male', '1990-1-1')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 3 arguments (4 given)

这会致使建立失败或运行不正常，由于第一个参数name被Python解释器传入了实例的引用，从而致使整个方法的调用参数位置所有没有对上。

任务

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

 1 #python2.7
 2 class Person(object):
 3     def __init__(self,name,gender,birth,**kw):
 4         self.name = name
 5         self.gender = gender
 6         for k,w in kw.items():
 7             setattr(self,k,w)
 8         
 9 xiaoming =Person('xiao ming','Male','1990-1-1', job='Student')
10 print xiaoming.name
11 print xiaoming.job

输出

xiao ming
Student

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'

可见，只有以双下划线开头的"__job"不能直接被外部访问。

可是，若是一个属性以"__xxx__"的形式定义，那它又能够被外部访问了，以"__xxx__"定义的属性在Python的类中被称为特殊属性，有不少预约义的特殊属性可使用，一般咱们不要把普通属性用"__xxx__"定义。

以单下划线开头的属性"_xxx"虽然也能够被外部访问，可是，按照习惯，他们不该该被外部访问。

任务

请给Person类的__init__方法中添加name和score参数，并把score绑定到__score属性上，看看外部是否能访问到。

 1 #python2.7
 2 class Person(object):
 3     def __init__(self, name, score):
 4         self.name = name
 5         self.__score = score
 6     def __str__(self):
 7         return str(self.__score)
 8 
 9 p =Person('Bob',59)
10 print p.name
11 print p
12 print p.__score

输出

Bob
59
Traceback (most recent call last):
File "test.py", line 12, in <module>
print p.__score
AttributeError: 'Person' object has no attribute '__score'

6. python中建立类属性

类是模板，而实例则是根据类建立的对象。

绑定在一个实例上的属性不会影响其余实例，可是，类自己也是一个对象，若是在类上绑定一个属性，则全部实例均可以访问类的属性，而且，全部实例访问的类属性都是同一个！也就是说，实例属性每一个实例各自拥有，互相独立，而类属性有且只有一份。

定义类属性能够直接在 class 中定义：

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

由于类属性是直接绑定在类上的，因此，访问类属性不须要建立实例，就能够直接访问：

print Person.address
# => Earth

对一个实例调用类的属性也是能够访问的，全部实例均可以访问到它所属的类的属性：

p1 = Person('Bob')
p2 = Person('Alice')
print p1.address
# => Earth
print p2.address
# => Earth

因为Python是动态语言，类属性也是能够动态添加和修改的：

Person.address = 'China'
print p1.address
# => 'China'
print p2.address
# => 'China'

由于类属性只有一份，因此，当Person类的address改变时，全部实例访问到的类属性都改变了。

任务

请给 Person 类添加一个类属性 count，每建立一个实例，count 属性就加 1，这样就能够统计出一共建立了多少个 Person 的实例。

 1 #python 2.7
 2 class Person(object):
 3     count =0
 4     def __init__(self,name):
 5         self.name = name
 6 
 7 p1 =Person('Bob')
 8 Person.count +=1
 9 print Person.count
10 p2 =Person('Alice')
11 Person.count +=1
12 print Person.count
13 p3 =Person('Tim')
14 Person.count +=1
15 print Person.count

输出

1
2
3

7. 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' 后，p1访问 address 确实变成了 'China'，可是，Person.address和p2.address仍然是'Earch'，怎么回事？

缘由是 p1.address = 'China'并无改变 Person 的 address，而是给 p1这个实例绑定了实例属性address ，对p1来讲，它有一个实例属性address（值是'China'），而它所属的类Person也有一个类属性address，因此:

访问 p1.address 时，优先查找实例属性，返回'China'。

访问 p2.address 时，p2没有实例属性address，可是有类属性address，所以返回'Earth'。

可见，当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。

当咱们把 p1 的 address 实例属性删除后，访问 p1.address 就又返回类属性的值 'Earth'了：

del p1.address
print p1.address
# => Earth

可见，千万不要在实例上修改类属性，它实际上并无修改类属性，而是给实例绑定了一个实例属性。

任务

请把上节的 Person 类属性 count 改成 __count，再试试可否从实例和类访问该属性。

1 class Person(object):
2     __count =0
3     def __init__(self, name):
4         Person.__count +=1
5         self.name = name
6 
7 p1 =Person('Bob')
8 p2 =Person('Alice')
9 print Person.__count

输出

Traceback (most recent call last):
File "test.py", line 9, in <module>
print Person.__count
AttributeError: type object 'Person' has no attribute '__count'

 

 

8. python中定义实例方法

一个实例的私有属性就是以__开头的属性，没法被外部访问，那这些属性定义有什么用？

虽然私有属性没法从外部访问，可是，从类的内部是能够访问的。除了能够定义实例的属性外，还能够定义实例的方法。

实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例自己，其余参数和一个普通函数是彻底同样的：

class Person(object):

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

    def get_name(self):
        return self.__name

get_name(self) 就是一个实例方法，它的第一个参数是self。__init__(self, name)其实也可看作是一个特殊的实例方法。

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

p1 = Person('Bob')
print p1.get_name()  # self不须要显式传入
# => Bob

在实例方法内部，能够访问全部实例属性，这样，若是外部须要访问私有属性，能够经过方法调用得到，这种数据封装的形式除了能保护内部数据一致性外，还能够简化外部调用的难度。

任务

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

 1 #python 2.7
 2 class Person(object):
 3     def __init__(self, name, score):
 4         self.name = name
 5         self.__score = score
 6     def get_grade(self):
 7         if self.__score >=85:
 8             return'A'
 9         elif self.__score >=60:
10             return'B'
11         else:
12             return'C'
13             
14 p1 =Person('Bob',90)
15 p2 =Person('Alice',65)
16 p3 =Person('Tim',48)
17 print p1.get_grade()
18 print p2.get_grade()
19 print p3.get_grade()

输出

A
B
C

9. python中方法也是属性

咱们在 class 中定义的实例方法其实也是属性，它其实是一个函数对象：

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def get_grade(self):
        return 'A'

p1 = Person('Bob', 90)
print p1.get_grade
# => <bound method Person.get_grade of <__main__.Person object at 0x109e58510>>
print p1.get_grade()
# => A

也就是说，p1.get_grade 返回的是一个函数对象，但这个函数是一个绑定到实例的函数，p1.get_grade() 才是方法调用。

由于方法也是一个属性，因此，它也能够动态地添加到实例上，只是须要用 types.MethodType() 把一个函数变为一个方法：

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()
# => A
p2 = Person('Alice', 65)
print p2.get_grade()
# ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
# 由于p2实例并无绑定get_grade

给一个实例动态添加方法并不常见，直接在class中定义要更直观。

任务

因为属性能够是普通的值对象，如 str，int 等，也能够是方法，还能够是函数，你们看看下面代码的运行结果，请想想 p1.get_grade 为何是函数而不是方法：

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
        self.get_grade = lambda: 'A'

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

结果

<function <lambda> at 0x029F9AF0>
A

4.10 python中定义类方法

和属性相似，方法也分实例方法和类方法。

在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。

由于是在类上调用，而非实例上调用，所以类方法没法得到任何实例变量，只能得到类的引用。

任务

若是将类属性 count 改成私有属性__count，则外部没法读取__score，但能够经过一个类方法获取，请编写类方法得到__count值。

 1 #python 2.7
 2 class Person(object):
 3     __count =0
 4     @classmethod
 5     def how_many(cls):
 6         return cls.__count
 7     def __init__(self,name):
 8         self.name = name
 9         Person.__count +=1
10 
11 print Person.how_many()
12 p1 =Person('Bob')
13 print Person.how_many()

输出

01