Python入门学习---第四天

面向对象编程

---

类和实例

概念与其他面向对象编程语言类似。

以Student类为例，在Python中，定义类是通过class关键字：

class Student(object):
    pass

(object)表示继承自 object 类。

定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：

>>> bart = Student()
>>> bart
<__main__.Student object at 0x10a67a590>
>>> Student
<class '__main__.Student'>

bart指向的是Student的实例，0x10a67a590是这个实例的内存地址。
Student是一个类。

与静态语言(JAVA)不同，动态语言(Python)可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：

>>> bart.name = 'Bart Simpson'
>>> bart.name
'Bart Simpson'

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的init方法，在创建实例的时候，就把name，score等属性绑上去：

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

_ _ init _ _是一个特殊方法(创建对象时，这个方法会被调用)。

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递self参数。除此之外，与普通函数没什么区别。

---

数据封装

面向对象编程的一个重要特点就是数据封装。

我们可以通过函数来访问这些数据，比如打印一个学生的成绩：

>>> def print_score(std):
...     print('%s: %s' % (std.name, std.score))
...
>>> print_score(bart)
Bart Simpson: 59

但是，既然Student实例本身就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s: %s' % (self.name, self.score))

记住第一个参数永远都是 self 参数。

调用时，除了 self 不用传递，其他参数正常传入：

>>> bart.print_score()
Bart Simpson: 59

这些数据和逻辑被“封装”起来了，调用很容易，不用知道内部实现的细节。

封装的另一个好处是可以给Student类增加新的方法，比如get_grade：

class Student(object):
    ...
    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

内部细节就被封装起来。

从上面看到，Python不仅仅有静态语言的特点，还有和静态语言不同的地方。比如：Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但 拥有 的 变量名 可能 不同 ：

>>> bart = Student('Bart Simpson', 59)
>>> lisa = Student('Lisa Simpson', 87)
>>> bart.age = 8
>>> bart.age
8
>>> lisa.age
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'

---

访问限制

从前面Student类的定义来看，外部代码还是可以自由地修改一个实例的name、score**属性**：

>>> bart = Student('Bart Simpson', 59)
>>> bart.score
59
>>> bart.score = 99
>>> bart.score
99

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线 _ _ ，在Python中，实例的变量名如果以 _ _ 开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。

所以，我们把Student类改一改：

class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

无法从外部访问 实例变量. _ _ name 和 实例变量 . _ _ score 了：

>>> bart = Student('Bart Simpson', 59)
>>> bart.__name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'

这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮。

但是如果外部代码要获取name和score怎么办？可以给Student类增加 get_name 和 get_score 这样的方法：

class Student(object):
    ...
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score

如果又要允许外部代码修改score怎么办？可以再给Student类增加set_score方法：

class Student(object):
    ...
    def set_score(self, score):
        self.__score = score

如此一来，Python与静态语言有着类似的功能了。

但是我们需要注意的是，在Python中，变量名类似 _ _ xxx _ _ 的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用 _ _ name _ _ 、 _ _ score _ _ 这样的变量名。

有些时候，你会看到以一个下划线开头的实例变量名，比如 _ name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

不能直接访问 _ _ name是因为Python解释器对外把 _ _ name变量改成了 _ Student _ _ name，所以，仍然可以通过 _ Student _ _ name来访问 _ _ name变量：

>>> bart._Student__name
'Bart Simpson'

但是强烈建议你不要这么干，因为不同版本的Python解释器可能会把 _ _ name**改成不同的变量名**。

总的来说就是，Python本身没有任何机制阻止你干坏事，一切全靠自觉。

最后，我们看一个 陷阱 例子：

>>> bart = Student('Bart Simpson', 59)
>>> bart.get_name()
'Bart Simpson'
>>> bart.__name = 'New Name' # 设置__name变量！
>>> bart.__name
'New Name'

从表面上看，我们成功的创建了一个外部private的变量。但实际上class内部的private的变量已经被Python解释器改为其他变量名。所以，我们只是增加了一个public的变量。尝试下面代码：

>>> bart.get_name() # get_name()内部返回self.__name
'Bart Simpson'

我们的练习题：

请把下面的 Student 对象的 gender 字段对外隐藏起来，用 get _ gender() 和 set _ gender() 代替，并检查参数有效性：

class Student(object):
    def __init__(self, name, gender):
        self.__name = name
        self.__gender = gender
    def get_name(self):
        return self.__name
    def set_name(self,name):
        self.__name = name
    def get_gender(self):
        return self.__gender
    def set_gender(self,gender):
        self.__gender = gender

# 测试如下
bart = Student('Bart', 'male')
if bart.get_gender() != 'male':
    print('测试失败!')
else:
    bart.set_gender('female')
    if bart.get_gender() != 'female':
        print('测试失败!')
    else:
        print('测试成功!')

---

继承和多态

与其他面向对象语言的 继承 类似。

只介绍语法：

# 基类
class Animal(object):
    def run(self):
        print('Animal is running...')

# 子类
class Dog(Animal):
    pass

class Cat(Animal):
    pass

# 测试
dog = Dog()
dog.run()

cat = Cat()
cat.run()

# 输出
Animal is running...
Animal is running...

多态 也与其他语言类似。

以下的一个例子：

# Tortoise继承自Animal
class Tortoise(Animal):
    def run(self):
        print('Tortoise is running slowly...')

# 定义一个函数，以Animal类型为参数。
# 注意：这里的animal并不是一定为Animal类型。
def run_twice(animal):
    animal.run()
    animal.run()

# 测试
>>> run_twice(Animal())
Animal is running...
Animal is running...

>>> run_twice(Dog())
Dog is running...
Dog is running...

>>> run_twice(Cat())
Cat is running...
Cat is running...

>>> run_twice(Tortoise())
Tortoise is running slowly...
Tortoise is running slowly...

对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：

• 对扩展开放：允许新增Animal子类；
• 对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

---

静态语言 VS 动态语言

对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。

对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了：

# 定义一个类
class Timer(object):
    def run(self):
        print('Start...')

# 测试
>>> run_twice(Timer())
Start...
Start...

这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

Python的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个read()方法，返回其内容。但是，许多对象，只要有read()方法，都被视为“file-like object“。许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了read()方法的对象。

只要记住：看起来像鸭子，走起路来像鸭子。就可以把它当做是一只鸭子。

动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。

---

获取对象信息

当我们拿到一个对象的引用时，如何知道这个对象是什么类型、有哪些方法呢？

第一种办法，使用type()函数：

基本类型 都可以用 type() 判断：

>>> type(123)
<class 'int'>
>>> type('str')
<class 'str'>
>>> type(None)
<type(None) 'NoneType'>

如果一个变量指向 函数 或者 类 ，也可以用 type() 判断：

>>> type(abs)
<class 'builtin_function_or_method'>
>>> type(a)
<class '__main__.Animal'>

但是type()函数返回的是什么类型呢？它返回对应的Class类型。如果我们要在if语句中判断，就需要比较两个变量的type类型是否相同：

>>> type(123)==type(456)
True
>>> type(123)==int
True
>>> type('abc')==type('123')
True
>>> type('abc')==str
True
>>> type('abc')==type(123)
False

判断基本数据类型可以直接写int，str等，但如果要判断一个对象是否是函数怎么办？可以使用types模块中定义的常量：

>>> import types
>>> def fn():
...     pass
...
>>> type(fn)==types.FunctionType
True
>>> type(abs)==types.BuiltinFunctionType
True
>>> type(lambda x: x)==types.LambdaType
True
>>> type((x for x in range(10)))==types.GeneratorType
True

第二种办法，使用isinstance()：

对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。

我们回顾上次的例子，如果继承关系是：

object -> Animal -> Dog -> Husky

那么，isinstance()就可以告诉我们，一个对象是否是某种类型。

# 先创建3种类型的对象：
>>> a = Animal()
>>> d = Dog()
>>> h = Husky()

# 判断：
>>> isinstance(h, Husky)
True

>>> isinstance(h, Dog)
True

>>> isinstance(h, Animal)
True

>>> isinstance(d, Dog) and isinstance(d, Animal)
True

>>> isinstance(d, Husky)
False

我们看到，isinstance可以判断出继承关系。h本身和h父类的结果都为True。同理，d本身和父类也一样，但d不是它的子类Husky。

能用type()判断的基本类型也可以用isinstance()判断：

>>> isinstance('a', str)
True
>>> isinstance(123, int)
True
>>> isinstance(b'a', bytes)
True

并且还可以判断一个变量是否是某些类型中的一种，比如下面的代码就可以判断是否是list或者tuple：

>>> isinstance([1, 2, 3], (list, tuple))
True
>>> isinstance((1, 2, 3), (list, tuple))
True

第三种方式，使用dir()：
如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法：

# str的所有属性和方法如下：
>>> dir('ABC')
['__add__', '__class__',..., '__subclasshook__', 'capitalize', 'casefold',..., 'zfill']

仅仅把属性和方法列出来是不够的，配合getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态：

# 定义一个类
>>> class MyObject(object):
...     def __init__(self):
...         self.x = 9
...     def power(self):
...         return self.x * self.x
...
>>> obj = MyObject()

# 测试
>>> hasattr(obj, 'x') # 有属性'x'吗？
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有属性'y'吗？
False
>>> setattr(obj, 'y', 19) # 设置一个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
>>> getattr(obj, 'y') # 获取属性'y'
19
>>> obj.y # 获取属性'y'
19

# 如果试图获取不存在的属性，会抛出AttributeError的错误：
>>> getattr(obj, 'z') # 获取属性'z'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyObject' object has no attribute 'z'

# 可以传入一个default参数，如果属性不存在，就返回默认值：
>>> getattr(obj, 'z', 404) # 获取属性'z'，如果不存在，返回默认值404
404

# 也可以获得对象的方法：
>>> hasattr(obj, 'power') # 有属性'power'吗？
True
>>> getattr(obj, 'power') # 获取属性'power'
<bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>
>>> fn = getattr(obj, 'power') # 获取属性'power'并赋值到变量fn
>>> fn # fn指向obj.power
<bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>>
>>> fn() # 调用fn()与调用obj.power()是一样的
81

最后一个测试，由于返回的是一个内存地址。所以我们知道它不是属性，即power是一个方法。

---

实例属性和类属性

由于Python是动态语言，根据类创建的实例可以任意绑定属性。

给实例绑定属性的方法是通过实例变量，或者通过self变量：

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

s = Student('Bob')
s.score = 90

但是，如果Student类本身需要绑定一个属性呢？可以直接在class中定义属性，这种属性是类属性，归Student类所有：

class Student(object):
    name = 'Student'

当我们定义了一个类属性后，这个属性虽然归类所有(有点想静态成员)，但类的所有实例都可以访问到。来测试一下：

>>> class Student(object):
...     name = 'Student'
...
>>> s = Student() # 创建实例s
>>> print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
Student
>>> print(Student.name) # 打印类的name属性
Student
>>> s.name = 'Michael' # 给实例绑定name属性
>>> print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
Michael
>>> print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
Student
>>> del s.name # 如果删除实例的name属性
>>> print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
Student

从上面的例子可以看出，在编写程序的时候，千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称，访问到的将是类属性。

练习练习：

为了统计学生人数，可以给Student类增加一个类属性，每创建一个实例，该属性自动增加：

# -*- coding: utf-8 -*-
class Student(object):
    count = 0

    def __init__(self, name):
        self.name = name
        Student.count += 1

# 测试:
if Student.count != 0:
    print('测试失败!')
else:
    bart = Student('Bart')
    if Student.count != 1:
        print('测试失败!')
    else:
        lisa = Student('Bart')
        if Student.count != 2:
            print('测试失败!')
        else:
            print('Students:', Student.count)
            print('测试通过!')

---

总结

Python入门学习到此为止，接下来将展开对Python高级特性的了解甚至是深入学习。

---

转载处：廖雪峰Python教程