Differences between revisions 13 and 14
Revision 13 as of 2006-09-26 19:09:45
Size: 23605
Editor: czk
Comment:
Revision 14 as of 2006-09-26 19:38:16
Size: 23745
Editor: czk
Comment:
Deletions are marked like this. Additions are marked like this.
Line 37: Line 37:
print Person
print p
print s
}}}

输出
{{{
__main__.Person
<__main__.Person instance at 0xb7d40d8c>
<__main__.Person instance at 0xb7d40d0c>
}}}

我们使用class语句后跟类名,创建了一个新的类。这后面跟着一个缩进的语句块形成类体。在这个例子中,我们使用了一个空白块,它由pass语句表示。

接下来,我们使用类名后跟一对圆括号来创建一个对象/实例。(我们将在下面的章节中学习更多的如何创建实例的方法)。为了验证,我们简单地打印了这个变量的类型。它告诉我们我们已经在__main__模块中有了一个Person类的实例。

可以注意到存储对象的计算机内存地址也打印了出来。这个地址在你的计算机上会是另外一个值,因为Python可以在任何空位存储对象。

== 类与对象的变量 ==
现在我们来看一下数据部分。事实上,它们只是与类和对象的名称空间 绑定 的普通变量,即这些名称只在这些类与对象的前提下有效。

有两种类型的 域 ——类的变量和对象的变量,它们根据是类还是对象 拥有 这个变量而区分。

类的变量 由一个类的所有对象(实例)共享使用。只有一个类变量的拷贝,所以当某个对象对类的变量做了改动的时候,这个改动会反映到所有其他的实例上。

对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝,即它们不是共享的,在同一个类的不同实例中,虽然对象的变量有相同的名称,但是是互不相关的。通过一个例子会使这个易于理解。
{{{#!python
#!/usr/bin/python

class Person:
    name = "Unknown"

p = Person()
s = Person()
q = Person()
Line 52: Line 87:
print s.age
print q.name
print Person.name
Line 66: Line 101:
Traceback (most recent call last):
  File "python/test.py", line 24, in ?
    print s.age
AttributeError: Person instance has no attribute 'age'
}}}

我们使用class语句后跟类名,创建了一个新的类。这后面跟着一个缩进的语句块形成类体。在这个例子中,我们使用了一个空白块,它由pass语句表示。

接下来,我们使用类名后跟一对圆括号来创建一个对象/实例。(我们将在下面的章节中学习更多的如何创建实例的方法)。为了验证,我们简单地打印了这个变量的类型。它告诉我们我们已经在__main__模块中有了一个Person类的实例。

可以注意到存储对象的计算机内存地址也打印了出来。这个地址在你的计算机上会是另外一个值,因为Python可以在任何空位存储对象。
Unknown
Unknown
}}}
Line 145: Line 172:
== 类与对象的变量 ==

我们已经讨论了类与对象的功能部分,现在我们来看一下它的数据部分。事实上,它们只是与类和对象的名称空间 绑定 的普通变量,即这些名称只在这些类与对象的前提下有效。

有两种类型的 域 ——类的变量和对象的变量,它们根据是类还是对象 拥有 这个变量而区分。

类的变量 由一个类的所有对象(实例)共享使用。只有一个类变量的拷贝,所以当某个对象对类的变量做了改动的时候,这个改动会反映到所有其他的实例上。

对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝,即它们不是共享的,在同一个类的不同实例中,虽然对象的变量有相同的名称,但是是互不相关的。通过一个例子会使这个易于理解。
{{{#!python
#!/usr/bin/python
# Filename: objvar.py
== 类与对象 ==

现在把类和对象的数据和方法都整合在一起,组成一个完整的类。

{{{#!python
#!/usr/bin/python
Line 222: Line 243:
这是一个很长的例子,但是它有助于说明类与对象的变量的本质。这里,population属于Person类,因此是一个类的变量。name变量属于对象(它使用self赋值)因此是对象的变量。 这是一个很长的例子,但是它有助于说明类与对象的本质。这里,population属于Person类,因此是一个类的变量。name变量属于对象(它使用self赋值)因此是对象的变量。
Line 260: Line 281:
# Filename: inherit.py
Line 317: Line 337:
为了使用继承,我们把基本类的名称作为一个元组跟在定义类时的类名称之后。然后,我们注意到基本类的__init__方法专门使用self变量调用,这样我们就可以初始化对象的基本类部分。这一点十分重要——Python不会自动调用基类的constructor,你得亲自专门调用它。 为了使用继承,我们把基本类的名称作为一个元组跟在定义类时的类名称之后。然后,我们注意到基本类的{{{__init__}}}方法专门使用self变量调用,这样我们就可以初始化对象的基本类部分。这一点十分重要——Python不会自动调用基类的{{{__init__}}},你得亲自专门调用它。
Line 383: Line 403:
# Filename: try_except.py

TableOfContents

类class

简介

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

类和对象是面向对象编程的两个主要方面。类创建一个新类型,而对象这个类的 实例 。这类似于你有一个int类型的变量,这存储整数的变量是int类的实例(对象)。

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

对象可以使用普通的 属于 对象的变量存储数据。属于一个对象或类的变量被称为域。对象也可以使用 属于 类的函数来具有功能。这样的函数被称为类的方法。这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为类的属性。

域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。

类使用class关键字创建。类的域和方法被列在一个缩进块中。

创建类

一个尽可能简单的类如下面这个例子所示。

   1 #!/usr/bin/python
   2 
   3 class Person:
   4     pass # An empty block
   5 
   6 p = Person()
   7 s = Person()
   8 
   9 print Person
  10 print p 
  11 print s

输出

__main__.Person
<__main__.Person instance at 0xb7d40d8c>
<__main__.Person instance at 0xb7d40d0c>

我们使用class语句后跟类名,创建了一个新的类。这后面跟着一个缩进的语句块形成类体。在这个例子中,我们使用了一个空白块,它由pass语句表示。

接下来,我们使用类名后跟一对圆括号来创建一个对象/实例。(我们将在下面的章节中学习更多的如何创建实例的方法)。为了验证,我们简单地打印了这个变量的类型。它告诉我们我们已经在main模块中有了一个Person类的实例。

可以注意到存储对象的计算机内存地址也打印了出来。这个地址在你的计算机上会是另外一个值,因为Python可以在任何空位存储对象。

类与对象的变量

现在我们来看一下数据部分。事实上,它们只是与类和对象的名称空间 绑定 的普通变量,即这些名称只在这些类与对象的前提下有效。

有两种类型的 域 ——类的变量和对象的变量,它们根据是类还是对象 拥有 这个变量而区分。

类的变量 由一个类的所有对象(实例)共享使用。只有一个类变量的拷贝,所以当某个对象对类的变量做了改动的时候,这个改动会反映到所有其他的实例上。

对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝,即它们不是共享的,在同一个类的不同实例中,虽然对象的变量有相同的名称,但是是互不相关的。通过一个例子会使这个易于理解。

   1 #!/usr/bin/python
   2 
   3 class Person:
   4     name = "Unknown"
   5 
   6 p = Person()
   7 s = Person()
   8 q = Person()
   9 
  10 p.name = "Jack"
  11 p.gender = "Male"
  12 p.age = 30
  13 s.name = "Rose"
  14 s.gender = "Female"
  15 
  16 print Person
  17 print p 
  18 print s
  19 print p.name
  20 print p.gender
  21 print p.age
  22 print s.name
  23 print s.gender
  24 print q.name
  25 print Person.name

输出

__main__.Person
<__main__.Person instance at 0xb7d40d8c>
<__main__.Person instance at 0xb7d40d0c>
Jack
Male
30
Rose
Female
Unknown
Unknown

对象的方法

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,但是在调用这个方法的时候你不为这个参数赋值,Python会提供这个值。这个特别的变量指对象本身,按照惯例它的名称是self。

虽然你可以给这个参数任何名称,但是 强烈建议 你使用self这个名称——其他名称都是不赞成你使用的。使用一个标准的名称有很多优点——你的程序读者可以迅速识别它,如果使用self的话,还有些IDE(集成开发环境)也可以帮助你。

给C++/Java/C#程序员的注释
Python中的self等价于C++中的this指针和Java、C#中的this引用。

   1 #!/usr/bin/python
   2 
   3 class Person:
   4     def sayHi(self):
   5         print 'Hello, how are you?'
   6 
   7 p = Person()
   8 p.sayHi()

输出

Hello, how are you?

这里我们看到了self的用法。注意sayHi方法没有任何参数,但仍然在函数定义时有self。

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

__init__方法

在Python的类中有很多方法的名字有特殊的重要意义。现在我们将学习__init__方法的意义。

__init__方法在类的一个对象被建立时,马上运行。这个方法可以用来对你的对象做一些你希望的 初始化 。注意,这个名称的开始和结尾都是双下划线。 使用__init__方法

   1 #!/usr/bin/python
   2 
   3 class Person:
   4     def __init__(self, name):
   5         self.name = name
   6     def sayHi(self):
   7         print 'Hello, my name is', self.name
   8 
   9 p = Person('Swaroop')
  10 p.sayHi()

输出

Hello, my name is Swaroop

这里,我们把__init__方法定义为取一个参数name(以及普通的参数self)。在这个__init__里,我们只是创建一个新的域,也称为name。注意它们是两个不同的变量,尽管它们有相同的名字。点号使我们能够区分它们。

最重要的是,我们没有专门调用__init__方法,只是在创建一个类的新实例的时候,把参数包括在圆括号内跟在类名后面,从而传递给__init__方法。这是这种方法的重要之处。

现在,我们能够在我们的方法中使用self.name域。这在sayHi方法中得到了验证。

给C++/Java/C#程序员的注释
__init__方法类似于C++、C#和Java中的 构造函数 。 

类与对象

现在把类和对象的数据和方法都整合在一起,组成一个完整的类。

   1 #!/usr/bin/python
   2 
   3 class Person:
   4     '''Represents a person.'''
   5     population = 0
   6 
   7     def __init__(self, name):
   8         '''Initializes the person's data.'''
   9         self.name = name
  10         print '(Initializing %s)' % self.name
  11 
  12         # When this person is created, he/she
  13         # adds to the population
  14         Person.population += 1
  15 
  16     def __del__(self):
  17         '''I am dying.'''
  18         print '%s says bye.' % self.name
  19 
  20         Person.population -= 1
  21 
  22         if Person.population == 0:
  23             print 'I am the last one.'
  24         else:
  25             print 'There are still %d people left.' % Person.population
  26 
  27     def sayHi(self):
  28         '''Greeting by the person.
  29 
  30         Really, that's all it does.'''
  31         print 'Hi, my name is %s.' % self.name
  32 
  33     def howMany(self):
  34         '''Prints the current population.'''
  35         if Person.population == 1:
  36             print 'I am the only person here.'
  37         else:
  38             print 'We have %d persons here.' % Person.population
  39 
  40 swaroop = Person('Swaroop')
  41 swaroop.sayHi()
  42 swaroop.howMany()
  43 
  44 kalam = Person('Abdul Kalam')
  45 kalam.sayHi()
  46 kalam.howMany()
  47 
  48 swaroop.sayHi()
  49 swaroop.howMany() 

输出

(Initializing Swaroop)
Hi, my name is Swaroop.
I am the only person here.
(Initializing Abdul Kalam)
Hi, my name is Abdul Kalam.
We have 2 persons here.
Hi, my name is Swaroop.
We have 2 persons here.
Abdul Kalam says bye.
There are still 1 people left.
Swaroop says bye.
I am the last one. 

这是一个很长的例子,但是它有助于说明类与对象的本质。这里,population属于Person类,因此是一个类的变量。name变量属于对象(它使用self赋值)因此是对象的变量。

观察可以发现__init__方法用一个名字来初始化Person实例。在这个方法中,我们让population增加1,这是因为我们增加了一个人。同样可以发现,self.name的值根据每个对象指定,这表明了它作为对象的变量的本质。

记住,你只能使用self变量来参考同一个对象的变量和方法。这被称为 属性参考 。

在这个程序中,我们还看到docstring对于类和方法同样有用。我们可以在运行时使用Person.__doc__Person.sayHi.__doc__来分别访问类与方法的文档字符串。

就如同__init__方法一样,还有一个特殊的方法__del__,它在对象消逝的时候被调用。对象消逝即对象不再被使用,它所占用的内存将返回给系统作它用。在这个方法里面,我们只是简单地把Person.population减1。

当对象不再被使用时,__del__方法运行,但是很难保证这个方法究竟在 什么时候 运行。如果你想要指明它的运行,你就得使用del语句,就如同我们在以前的例子中使用的那样。

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

继承

面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过 继承 机制。继承完全可以理解成类之间的 类型和子类型 关系。

假设你想要写一个程序来记录学校之中的教师和学生情况。他们有一些共同属性,比如姓名、年龄和地址。他们也有专有的属性,比如教师的薪水、课程和假期,学生的成绩和学费。

你可以为教师和学生建立两个独立的类来处理它们,但是这样做的话,如果要增加一个新的共有属性,就意味着要在这两个独立的类中都增加这个属性。这很快就会显得不实用。

一个比较好的方法是创建一个共同的类称为SchoolMember然后让教师和学生的类 继承 这个共同的类。即它们都是这个类型(类)的子类型,然后我们再为这些子类型添加专有的属性。

使用这种方法有很多优点。如果我们增加/改变了SchoolMember中的任何功能,它会自动地反映到子类型之中。例如,你要为教师和学生都增加一个新的身份证域,那么你只需简单地把它加到SchoolMember类中。然而,在一个子类型之中做的改动不会影响到别的子类型。另外一个优点是你可以把教师和学生对象都作为SchoolMember对象来使用,这在某些场合特别有用,比如统计学校成员的人数。一个子类型在任何需要父类型的场合可以被替换成父类型,即对象可以被视作是父类的实例,这种现象被称为多态现象。

另外,我们会发现在 重用 父类的代码的时候,我们无需在不同的类中重复它。而如果我们使用独立的类的话,我们就不得不这么做了。

在上述的场合中,SchoolMember类被称为 基本类 或 超类 。而Teacher和Student类被称为 导出类 或 子类 。

现在,我们将学习一个例子程序。

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

输出

(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)

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

为了使用继承,我们把基本类的名称作为一个元组跟在定义类时的类名称之后。然后,我们注意到基本类的__init__方法专门使用self变量调用,这样我们就可以初始化对象的基本类部分。这一点十分重要——Python不会自动调用基类的__init__,你得亲自专门调用它。

我们还观察到我们在方法调用之前加上类名称前缀,然后把self变量及其他参数传递给它。

注意,在我们使用SchoolMember类的tell方法的时候,我们把Teacher和Student的实例仅仅作为SchoolMember的实例。

另外,在这个例子中,我们调用了子类型的tell方法,而不是SchoolMember类的tell方法。可以这样来理解,Python总是首先查找对应类型的方法,在这个例子中就是如此。如果它不能在导出类中找到对应的方法,它才开始到基本类中逐个查找。基本类是在类定义的时候,在元组之中指明的。

一个术语的注释——如果在继承元组中列了一个以上的类,那么它就被称作 多重继承 。

私有变量 Private Variables

Python 对类的私有成员提供了有限的支持。任何形如 __spam(以至少双下划线开头,至多单下划线结尾)随即都被替代为 _classname__spam,去掉前导下划线的 classname 即当前的类名。这种混淆不关心标识符的语法位置,所以可用来定义私有类实例和类变量、方法,以及全局变量,甚至于将其它类的实例保存为私有变量。混淆名长度超过255个字符的时候可能会发生截断。在类的外部,或类名只包含下划线时,不会发生截断。

命名混淆意在给出一个在类中定义“私有”实例变量和方法的简单途径,避免派生类的实例变量定义产生问题,或者与外界代码中的变量搞混。要注意的是混淆规则主要目的在于避免意外错误,被认作为私有的变量仍然有可能被访问或修改。在特定的场合它也是有用的,比如调试的时候,这也是一直没有堵上这个漏洞的原因之一(小漏洞:派生类和基类取相同的名字就可以使用基类的私有变量。)

类的特殊方法和运算符重载

在类中有一些特殊的方法具有特殊的意义,比如__init____del__方法,它们的重要性我们已经学习过了。

一般说来,特殊的方法都被用来模仿某个行为。例如,如果你想要为你的类使用x[key]这样的索引操作(就像列表和元组一样),那么你只需要实现__getitem__()方法就可以了。想一下,Python就是对list类这样做的!

下面这个表中列出了一些有用的特殊方法。如果你想要知道所有的特殊方法,你可以在《Python语言参考手册》中找到一个庞大的列表。

名称

说明

__init__(self,...)

这个方法在新建对象恰好要被返回使用之前被调用。

__del__(self)

恰好在对象要被删除之前调用。

__str__(self)

在我们对对象使用print语句或是使用str()的时候调用。

__lt__(self,other)

当使用 小于 运算符(<)的时候调用。类似地,对于所有的运算符(+,>等等)都有特殊的方法。

__getitem__(self,key)

使用x[key]索引操作符的时候调用。

__len__(self)

对序列对象使用内建的len()函数的时候调用。

异常

当你的程序中出现某些 异常的 状况的时候,异常就发生了。例如,当你想要读某个文件的时候,而那个文件不存在。或者在程序运行的时候,你不小心把它删除了。上述这些情况可以使用异常来处理。

假如你的程序中有一些无效的语句,会怎么样呢?Python会引发并告诉你那里有一个错误,从而处理这样的情况。

考虑一个简单的print语句。假如我们把print误拼为Print,注意大写,这样Python会 引发 一个语法错误。

>>> Print 'Hello World'
    File "<stdin>", line 1
      Print 'Hello World'
                        ^
SyntaxError: invalid syntax

>>> print 'Hello World'
Hello World

我们可以观察到有一个SyntaxError被引发,并且检测到的错误位置也被打印了出来。这是这个错误的 错误处理器 所做的工作。

try..except

我们尝试读取用户的一段输入。按Ctrl-d,看一下会发生什么。

>>> s = raw_input('Enter something --> ')
Enter something --> Traceback (most recent call last):
  File "<stdin>", line 1, in ?
EOFError

Python引发了一个称为EOFError的错误,这个错误基本上意味着它发现一个不期望的 文件尾 (由Ctrl-d表示)

我们可以使用try..except语句来处理异常。我们把通常的语句放在try-块中,而把我们的错误处理语句放在except-块中。

   1 #!/usr/bin/python
   2 
   3 import sys
   4 
   5 try:
   6     s = raw_input('Enter something --> ')
   7 except EOFError:
   8     print '\nWhy did you do an EOF on me?'
   9     sys.exit() # exit the program
  10 except:
  11     print '\nSome error/exception occurred.'
  12     # here, we are not exiting the program
  13 
  14 print 'Done' 

输入输出

$ python try_except.py
Enter something -->
Why did you do an EOF on me?

$ python try_except.py
Enter something --> Python is exceptional!
Done

我们把所有可能引发错误的语句放在try块中,然后在except从句/块中处理所有的错误和异常。except从句可以专门处理单一的错误或异常,或者一组包括在圆括号内的错误/异常。如果没有给出错误或异常的名称,它会处理 所有的 错误和异常。对于每个try从句,至少都有一个相关联的except从句。

如果某个错误或异常没有被处理,默认的Python处理器就会被调用。它会终止程序的运行,并且打印一个消息,我们已经看到了这样的处理。

你还可以让try..except块关联上一个else从句。当没有异常发生的时候,else从句将被执行。

我们还可以得到异常对象,从而获取更多有个这个异常的信息。这会在下一个例子中说明。

引发异常

你可以使用raise语句 引发 异常。你还得指明错误/异常的名称和伴随异常 触发的 异常对象。你可以引发的错误或异常应该分别是一个Error或Exception类的直接或间接导出类。

   1 #!/usr/bin/python
   2 
   3 class ShortInputException(Exception):
   4     '''A user-defined exception class.'''
   5     def __init__(self, length, atleast):
   6         Exception.__init__(self)
   7         self.length = length
   8         self.atleast = atleast
   9 
  10 try:
  11     s = raw_input('Enter something --> ')
  12     if len(s) < 3:
  13         raise ShortInputException(len(s), 3)
  14     # Other work can continue as usual here
  15 except EOFError:
  16     print '\nWhy did you do an EOF on me?'
  17 except ShortInputException, x:
  18     print 'ShortInputException: The input was of length %d, \
  19           was expecting at least %d' % (x.length, x.atleast)
  20 else:
  21     print 'No exception was raised.'

输入输出

$ python raising.py
Enter something -->
Why did you do an EOF on me?

$ python raising.py
Enter something --> ab
ShortInputException: The input was of length 2, was expecting at least 3

$ python raising.py
Enter something --> abc
No exception was raised.

这里,我们创建了我们自己的异常类型,其实我们可以使用任何预定义的异常/错误。这个新的异常类型是ShortInputException类。它有两个域——length是给定输入的长度,atleast则是程序期望的最小长度。

在except从句中,我们提供了错误类和用来表示错误/异常对象的变量。这与函数调用中的形参和实参概念类似。在这个特别的except从句中,我们使用异常对象的length和atleast域来为用户打印一个恰当的消息。

try..finally

假如你在读一个文件的时候,希望在无论异常发生与否的情况下都关闭文件,该怎么做呢?这可以使用finally块来完成。注意,在一个try块下,你可以同时使用except从句和finally块。如果你要同时使用它们的话,需要把一个嵌入另外一个。

   1 #!/usr/bin/python
   2 
   3 import time
   4 
   5 try:
   6     f = file('poem.txt')
   7     while True: # our usual file-reading idiom
   8         line = f.readline()
   9         if len(line) == 0:
  10             break
  11         time.sleep(2)
  12         print line,
  13 finally:
  14     f.close()
  15     print 'Cleaning up...closed the file'

输出

Programming is fun
When the work is done
Cleaning up...closed the file
Traceback (most recent call last):
  File "finally.py", line 12, in ?
    time.sleep(2)
KeyboardInterrupt

我们进行通常的读文件工作,但是我有意在每打印一行之前用time.sleep方法暂停2秒钟。这样做的原因是让程序运行得慢一些(Python由于其本质通常运行得很快)。在程序运行的时候,按Ctrl-c中断/取消程序。

我们可以观察到KeyboardInterrupt异常被触发,程序退出。但是在程序退出之前,finally从句仍然被执行,把文件关闭

end

Python语言的类 (last edited 2008-02-23 15:34:55 by localhost)

ch3n2k.com | Copyright (c) 2008 czk. 浙ICP备06000584号