转 Python学习（九）

原文出处
作者：Wanglikai91 
出处：http://www.cnblogs.com/wanglikai91/ 

九、面向对象的编程

到目前为止，在我们的程序中，我们都是根据操作数据的函数或语句块来设计程序的。这被称为面向过程的编程。还有一种把数据和功能结合起来，用称为对象的东西包裹起来组织程序的方法。这种方法称为面向对象的 编程理念。在大多数时候你可以使用过程性编程，但是有些时候当你想要编写大型程序或是寻求一个更加合适的解决方案的时候，你就得使用面向对象的编程技术。 
类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象这个类的实例。这类似于你有一个int类型的变量，这存储整数的变量是int类的实例（对象）。

注意：即便是整数也被作为对象（属于int类）。这和C++、Java（1.5版之前）把整数纯粹作为类型是不同的。通过help(int)了解更多这个类的详情。 C#和Java 1.5程序员会熟悉这个概念，因为它类似与封装与解封装的概念。

对象可以使用属于这个对象的变量存储数据。属于对象或类的变量称作域(fields)。对象同样可以利用属于类的函数实现所需的功能。这些函数被称作类的方法(method)。 
这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为类的属性。 
字段分为两种类型——它们既可以属于类的实例/对象也可以属于类本身，两者分别称为实例变量与类变量。 
一个类通过关键字class创建。字段与方法被列在类的缩进块里。

1、self

类方法与普通函数只有一个特殊区别——类方法必须增加一个额外的形参，而且它必须处于第一个形参的位置，但是在调用类方法时不要为这个额外的形参传值，python会自动代劳。这个特别的变量引用对象本身，按照惯例它被命名为self。 
尽管你可以随便为这个形参取名字，但我强烈建议你使用self——其它名字都不赞成你使用。使用标准名字是有很多好处的——任何你的代码的读者都会立即明白它代表什么，甚至当你使用标准名字时专业的IDE都会更好的帮助你。

注意：Python中的self等价于C++中的self指针和Java、C#中的this参考。

你一定很奇怪Python如何给self赋值以及为何你不需要给它赋值。举一个例子会使此变得清晰。假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2)——这就是self的原理了。 
这也意味着如果你有一个不需要参数的方法，你还是得给这个方法定义一个self参数。

2、类

创建一个类：

下面的例子可以是一个最简单的类了。

1
2
3
4
5
6
7
# Filename: simplestclass.py
  
class Person:
    pass # An empty block
  
p = Person()
print(p)

输出：

C:\Users\Administrator>python D:\python\simplestclass.py 
<__main__.Person object at 0x01CF8A90>

工作原理：

我们使用class语句后跟类名，创建了一个新的类。这后面跟着一个缩进的语句块形成类体。在这个例子中，我们使用了一个空白块，它由pass语句表示。 
接下来，我们使用类名后跟一对圆括号来创建一个对象/实例。为了验证，我们简单地打印了这个变量的类型。它告诉我们我们已经在__main__模块中有了一个Person类的实例。 
可以注意到存储对象的计算机内存地址也打印了出来。这个地址在你的计算机上会是另外一个值，因为Python可以在任何空位存储对象。

3、对象的方法

我们已经讨论了类/对象可以拥有像函数一样的方法，这些方法与函数的区别只是一个额外的self变量。现在我们来看一个例子：

1
2
3
4
5
6
7
8
9
10
# Filename: method.py
  
class Person:
    def sayHi(self):
        print('Hello, how are you?')
  
p = Person()
p.sayHi()
  
# This short example can also be written as Person().sayHi()

输出：

C:\Users\Administrator>python D:\python\method.py 
Hello, how are you?

工作原理：

本例中我们使用了self，注意方法sayHi虽无需参数但在函数中仍然要写上self。

4、__init__方法：

在Python的类中有很多方法的名字有特殊的重要意义。现在我们将学习__init__方法的意义。 
__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是双下划线。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
# Filename: class_init.py
  
class Person:
    def __init__(self, name):
        self.name = name
    def sayHi(self):
        print('Hello, my name is', self.name)
  
p = Person('Swaroop')
p.sayHi()
  
# This short example can also be written as Person('Swaroop').sayHi()

输出：

C:\Users\Administrator>python D:\python\class_init.py 
Hello, my name is Swaroop

工作原理：

这里，我们把__init__方法定义为取一个参数name（以及普通的参数self）。在这个__init__里，我们只是创建一个新的域，也称为name。注意它们是两个不同的变量，尽管它们有相同的名字。点号使我们能够区分它们。 
最重要的是，我们没有专门调用__init__方法，只是在创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给__init__方法。这是这种方法的重要之处。 
现在，我们能够在我们的方法中使用self.name域。这在sayHi方法中得到了验证。

注意：__init__方法类似于C++、C#和Java中的constructor。

5、类与对象的方法

我们已经讨论了类与对象的功能部分，现在我们来看一下它的数据部分。事实上，它们只是与类和对象的名称空间绑定的普通变量，即这些名称只在这些类与对象的前提下有效。 
有两种类型的域——类变量和对象变量，它们根据是类还是对象 拥有 这个变量而区分。 
类变量由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。 
对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。通过一个例子会使这个易于理解。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# Filename: objvar.py
  
class Robot:
    '''Represents a robot, with a name.'''
  
    # A class variable, counting the number of robots
    population = 0
  
    def __init__(self, name):
        '''Initializes the data.'''
        self.name = name
        print('(Initializing {0})'.format(self.name))
  
        # When this person is created, the robot
        # adds to the population
        Robot.population += 1
  
    def __del__(self):
        '''I am dying.'''
        print('{0} is being destroyed!'.format(self.name))
  
        Robot.population -= 1
  
        if Robot.population == 0:
            print('{0} was the last one.'.format(self.name))
        else:
            print('There are still {0:d} robots working.'.format(Robot.population))
  
    def sayHi(self):
        '''Greeting by the robot.
  
        Yeah, they can do that.'''
        print('Greetings, my masters call me {0}.'.format(self.name))
  
    def howMany():
        '''Prints the current population.'''
        print('We have {0:d} robots.'.format(Robot.population))
    howMany = staticmethod(howMany)
  
droid1 = Robot('R2-D2')
droid1.sayHi()
Robot.howMany()
  
droid2 = Robot('C-3PO')
droid2.sayHi()
Robot.howMany()
  
print("\nRobots can do some work here.\n")
  
print("Robots have finished their work. So let's destroy them.")
del droid1
del droid2
  
Robot.howMany()

输出：

C:\Users\Administrator>python D:\python\objvar.py 
(Initializing R2-D2) 
Greetings, my masters call me R2-D2. 
We have 1 robots. 
(Initializing C-3PO) 
Greetings, my masters call me C-3PO. 
We have 2 robots. 
Robots can do some work here. 
Robots have finished their work. So let's destroy them. 
R2-D2 is being destroyed! 
There are still 1 robots working. 
C-3PO is being destroyed! 
C-3PO was the last one. 
We have 0 robots.

工作原理：

这是一个很长的例子，但是它有助于说明类与对象的变量的本质。这里，population属于Person类，因此是一个类的变量。name变量属于对象（它使用self赋值）因此是对象的变量。 
所以，我们使用Robot.population引用类变量populatin而不是self.population.。而在方法中引用对象变量name时使用self.name语法。 
请记住这个类变量和类对象中简单的差异，还要注意对象变量会隐藏同名的类变量！ 
howMany实际上是一个属于类的方法而不是对象。这意味着我们可以将及其定义为classmethod也可以定义为staticmethod，这取决于我们是否需要知道我们是哪个类的一部分。因为我们无需类似信息，所以我们使用staticmethod。 
另外我们还可以通过装饰符(decorators)达到同样的效果：

1
2
3
4
@staticmethod
   def howMany():
       '''Prints the current population.'''
       print('We have {0:d} robots.'.format(Robot.population))

装饰符可以被想象成调用一条显式语句的捷径，就像在这个例中看到的一样。

观察__init__方法，它用于以一个指定的名字初始化Robot实例。其内部对population累加1，因为我们又添加了一个机器人。同时观察self.name，它的值特定于每个对象，这也指出了类对象的本质。 
记住，你只能使用self引用相同对象的变量和方法。这被称作属性引用。 
本例中，我们还在类与方法中使用了文档字符串。我们可以在运行时使用Robot.__doc__和Robot.sayhi.__doc__分别访问类和方法的文档字符串。就像__init__方法，这里还有另一个特殊方法__del__，当对象销毁的时候将被调用。对象销毁是指对象不再被使用了，它占用的空间将返回给系统以便重复使用。在__del__中我们只是简单的将Robot.population减1。当对象不再被使用时__del__方法将可以被执行，但无法保证到底什么时执行它。如果你想显式执行它则必须使用del语句，就象本例中做的那样。（注：本例中del后对象的引用计数降为0）。

注意：Python中所有的类成员（包括数据成员）都是 公共的 ，所有的方法都是 有效的 。只有一个例外：如果你使用的数据成员名称以 双下划线前缀 比如__privatevar，Python的名称管理体系会有效地把它作为私有变量。 
这样就有一个惯例，如果某个变量只想在类或对象中使用，就应该以单下划线前缀。而其他的名称都将作为公共的，可以被其他类/对象使用。记住这只是一个惯例，并不是Python所要求的（与双下划线前缀不同）。 
同样，注意__del__方法与 destructor 的概念类似。

6、继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过 继承 机制。继承完全可以理解成类之间的 类型和子类型关系。 
假设你想要写一个程序来记录学校之中的教师和学生情况。他们有一些共同属性，比如姓名、年龄和地址。他们也有专有的属性，比如教师的薪水、课程和假期，学生的成绩和学费。 
你可以为教师和学生建立两个独立的类来处理它们，但是这样做的话，如果要增加一个新的共有属性，就意味着要在这两个独立的类中都增加这个属性。这很快就会显得不实用。 
一个比较好的方法是创建一个共同的类称为SchoolMember然后让教师和学生的类 继承 这个共同的类。即它们都是这个类型（类）的子类型，然后我们再为这些子类型添加专有的属性。 
使用这种方法有很多优点。如果我们增加/改变了SchoolMember中的任何功能，它会自动地反映到子类型之中。例如，你要为教师和学生都增加一个新的身份证域，那么你只需简单地把它加到SchoolMember类中。然而，在一个子类型之中做的改动不会影响到别的子类型。另外一个优点是你可以把教师和学生对象都作为SchoolMember对象来使用，这在某些场合特别有用，比如统计学校成员的人数。一个子类型在任何需要父类型的场合可以被替换成父类型，即对象可以被视作是父类的实例，这种现象被称为多态现象。 
另外，我们会发现在 重用 父类的代码的时候，我们无需在不同的类中重复它。而如果我们使用独立的类的话，我们就不得不这么做了。 
在上述的场合中，SchoolMember类被称为基本类或超类 。而Teacher和Student类被称为导出类或子类 。

下面我们看一个范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# Filename: inherit.py
  
class SchoolMember:
    '''Represents any school member.'''
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('(Initialized SchoolMember: {0})'.format(self.name))
  
    def tell(self):
        '''Tell my details.'''
        print('Name:"{0}" Age:"{1}"'.format(self.name, self.age), end=" ")
  
class Teacher(SchoolMember):
    '''Represents a teacher.'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print('(Initialized Teacher: {0})'.format(self.name))
  
    def tell(self):
        SchoolMember.tell(self)
        print('Salary: "{0:d}"'.format(self.salary))
  
class Student(SchoolMember):
    '''Represents a student.'''
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks = marks
        print('(Initialized Student: {0})'.format(self.name))
  
    def tell(self):
        SchoolMember.tell(self)
        print('Marks: "{0:d}"'.format(self.marks))
  
t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 25, 75)
  
print() # prints a blank line
  
members = [t, s]
for member in members:
    member.tell() # works for both Teachers and Students

输出：

C:\Users\Administrator>python D:\python\inherit.py 
(Initialized SchoolMember: Mrs. Shrividya) 
(Initialized Teacher: Mrs. Shrividya) 
(Initialized SchoolMember: Swaroop) 
(Initialized Student: Swaroop)

 

Name:"Mrs. Shrividya" Age:"40" Salary: "30000" 
Name:"Swaroop" Age:"25" Marks: "75"

工作原理：

为了使用继承，我们把基本类的名称作为一个元组跟在定义类时的类名称之后。然后，我们注意到基本类的__init__方法专门使用self变量调用，这样我们就可以初始化对象的基本类部分。这一点十分重要——Python不会自动调用基本类的constructor，你得亲自专门调用它。 
我们还观察到我们在方法调用之前加上类名称前缀，然后把self变量及其他参数传递给它。 
注意，在我们使用SchoolMember类的tell方法的时候，我们把Teacher和Student的实例仅仅作为SchoolMember的实例。 
另外，在这个例子中，我们调用了子类型的tell方法，而不是SchoolMember类的tell方法。可以这样来理解，Python总是首先查找对应类型的方法，在这个例子中就是如此。如果python没有找到被调用方法，则会在基类中逐个查找，查找顺序由类定义时在元组中指定的基类顺序决定。 
一个术语的注释——如果一个类继承了多个基类，则被称做多重继承。

 

posted @ 2016-12-02 23:48  凯心宝牙  阅读(148)  评论(0)  编辑  收藏  举报