版本15和19间的区别 (跳过第4版)
⇤ ← 于2006-09-04 21:13:20修订的的版本15 →
大小: 26634
编辑: czk
备注:
← 于2006-09-04 21:51:54修订的的版本19 → ⇥
大小: 12040
编辑: czk
备注:
删除的内容标记成这样。 加入的内容标记成这样。
行号 1: 行号 1:
## page was renamed from Python游戏开发基础/第3讲：Python语言的控制流和函数
## page was renamed from Python游戏设计基础/第3讲：Python语言的控制流和函数
行号 25: 行号 23:
# Filename: if.py
行号 45: 行号 42:
$ python if.py
行号 49: 行号 45:
$ python if.py }}}
{{{
行号 53: 行号 50:
$ python if.py }}}
{{{
行号 97: 行号 95:
== while语句 ==
只要在一个条件为真的情况下，while语句允许你重复执行一块语句。while语句是所谓 循环 语句的一个例子。while语句有一个可选的else从句。
{{{#!python
#!/usr/bin/python
# Filename: while.py		 == 循环结构 ==
循环结构是指多次执行一个语句序列。python中最简单的循环结构是用while语句。只要在一个条件为真的情况下，while语句允许你重复执行一块语句。while语句是所谓 循环 语句的一个例子。while语句有一个可选的else从句。
{{{#!python
#!/usr/bin/python
行号 125: 行号 122:
$ python while.py
行号 149: 行号 145:
== for语句 ==

for..in是另外一个循环语句，它在一序列的对象上 递归 即逐一使用队列中的每个项目。我们会在后面的章节中更加详细地学习序列。
使用for语句

{{{#!python
#!/usr/bin/python
# Filename: for.py
for..in是另外一种循环语句，它在一序列的对象上 递归 即逐一使用队列中的每个项目。比如
{{{#!python
#!/usr/bin/python
行号 165: 行号 157:
$ python for.py
行号 188: 行号 179:
== break语句 ==
break语句是用来 终止 循环语句的，即哪怕循环条件没有称为False或序列还没有被完全递归，也停止执行循环语句。
在循环中，可以使用break语句来 终止 循环语句的，即哪怕循环条件没有称为False或序列还没有被完全递归，也停止执行循环语句。
行号 192: 行号 183:
使用break语句

{{{#!python
#!/usr/bin/python
# Filename: break.py
{{{#!python
#!/usr/bin/python
行号 208: 行号 197:
$ python break.py
行号 227: 行号 215:
我在这里输入的是我所写的一段小诗，称为G2的Python诗：
{{{
Programming is fun
When the work is done
if you wanna make your work also fun:
      use Python!
}}}

== continue语句 ==
continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。

{{{#!python
#!/usr/bin/python
# Filename: continue.py		 在循环中，还可以用continue语句来告诉Python跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。比如：

{{{#!python
#!/usr/bin/python
行号 254: 行号 232:
$ python continue.py
行号 266: 行号 243:
= 函数 =
函数是重用的程序段。它们允许你给一块语句一个名称，然后你可以在你的程序的任何地方使用这个名称任意多次地运行这个语句块。这被称为 调用 函数。我们已经使用了许多内建的函数，比如len和range。

函数通过def关键字定义。def关键字后跟一个函数的 标识符 名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。下面这个例子将说明这事实上是十分简单的：
{{{#!python
#!/usr/bin/python
# Filename: function1.py

def sayHello():
    print 'Hello World!' # block belonging to the function

sayHello() # call the function
}}}

输出
{{{
$ python function1.py
Hello World!
}}}

我们使用上面解释的语法定义了一个称为sayHello的函数。这个函数不使用任何参数，因此在圆括号中没有声明任何变量。参数对于函数而言，只是给函数的输入，以便于我们可以传递不同的值给函数，然后得到相应的结果。

== 函数形参 ==

函数取得的参数是你提供给函数的值，这样函数就可以利用这些值 做 一些事情。这些参数就像变量一样，只不过它们的值是在我们调用函数的时候定义的，而非在函数本身内赋值。

参数在函数定义的圆括号对内指定，用逗号分割。当我们调用函数的时候，我们以同样的方式提供值。注意我们使用过的术语——函数中的参数名称为 形参 而你提供给函数调用的值称为 实参 。
{{{#!python
#!/usr/bin/python
# Filename: func_param.py

def printMax(a, b):
    if a > b:
        print a, 'is maximum'
    else:
        print b, 'is maximum'

printMax(3, 4) # directly give literal values

x = 5
y = 7

printMax(x, y) # give variables as arguments
}}}
输出
{{{
$ python func_param.py
4 is maximum
7 is maximum
}}}

这里，我们定义了一个称为printMax的函数，这个函数需要两个形参，叫做a和b。我们使用if..else语句找出两者之中较大的一个数，并且打印较大的那个数。

在第一个printMax使用中，我们直接把数，即实参，提供给函数。在第二个使用中，我们使用变量调用函数。printMax(x, y)使实参x的值赋给形参a，实参y的值赋给形参b。在两次调用中，printMax函数的工作完全相同。

== 局部变量 ==

当你在函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是 局部 的。这称为变量的 作用域 。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。
{{{#!python
#!/usr/bin/python
# Filename: func_local.py

def func(x):
    print 'x is', x
    x = 2
    print 'Changed local x to', x

x = 50
func(x)
print 'x is still', x
}}}
输出
{{{
$ python func_local.py
x is 50
Changed local x to 2
x is still 50
}}}

在函数中，我们第一次使用x的 值 的时候，Python使用函数声明的形参的值。

接下来，我们把值2赋给x。x是函数的局部变量。所以，当我们在函数内改变x的值的时候，在主块中定义的x不受影响。

在最后一个print语句中，我们证明了主块中的x的值确实没有受到影响。

== global语句 ==

如果你想要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是 全局 的。我们使用global语句完成这一功能。没有global语句，是不可能为定义在函数外的变量赋值的。

你可以使用定义在函数外的变量的值（假设在函数内没有同名的变量）。然而，我并不鼓励你这样做，并且你应该尽量避免这样做，因为这使得程序的读者会不清楚这个变量是在哪里定义的。使用global语句可以清楚地表明变量是在外面的块定义的。

{{{#!python
#!/usr/bin/python
# Filename: func_global.py

def func():
    global x

    print 'x is', x
    x = 2
    print 'Changed local x to', x

x = 50
func()
print 'Value of x is', x
}}}

输出
{{{
$ python func_global.py
x is 50
Changed global x to 2
Value of x is 2
}}}

global语句被用来声明x是全局的——因此，当我们在函数内把值赋给x的时候，这个变化也反映在我们在主块中使用x的值的时候。

你可以使用同一个global语句指定多个全局变量。例如global x, y, z。

== 默认参数值 ==

对于一些函数，你可能希望它的一些参数是 可选 的，如果用户不想要为这些参数提供值的话，这些参数就使用默认值。这个功能借助于默认参数值完成。你可以在函数定义的形参名后加上赋值运算符（=）和默认值，从而给形参指定默认参数值。

注意，默认参数值应该是一个参数。更加准确的说，默认参数值应该是不可变的——这会在后面的章节中做详细解释。从现在开始，请记住这一点。
使用默认参数值

{{{#!python
#!/usr/bin/python
# Filename: func_default.py

def say(message, times = 1):
    print message * times

say('Hello')
say('World', 5)
}}}
输出
{{{
$ python func_default.py
Hello
WorldWorldWorldWorldWorld
}}}

名为say的函数用来打印一个字符串任意所需的次数。如果我们不提供一个值，那么默认地，字符串将只被打印一遍。我们通过给形参times指定默认参数值1来实现这一功能。

在第一次使用say的时候，我们只提供一个字符串，函数只打印一次字符串。在第二次使用say的时候，我们提供了字符串和参数5，表明我们想要 说 这个字符串消息5遍。

只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。这是因为赋给形参的值是根据位置而赋值的。例如，def func(a, b=5)是有效的，但是def func(a=5, b)是 无效 的。

== 关键参数 ==

如果你的某个函数有许多参数，而你只想指定其中的一部分，那么你可以通过命名来为这些参数赋值——这被称作 关键参数 ——我们使用名字（关键字）而不是位置（我们前面所一直使用的方法）来给函数指定实参。

这样做有两个 优势 ——一，由于我们不必担心参数的顺序，使用函数变得更加简单了。二、假设其他参数都有默认值，我们可以只给我们想要的那些参数赋值。
{{{#!python
#!/usr/bin/python
# Filename: func_key.py

def func(a, b=5, c=10):
    print 'a is', a, 'and b is', b, 'and c is', c

func(3, 7)
func(25, c=24)
func(c=50, a=100)
}}}
输出
{{{
$ python func_key.py
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50
}}}

名为func的函数有一个没有默认值的参数，和两个有默认值的参数。

在第一次使用函数的时候， func(3, 7)，参数a得到值3，参数b得到值7，而参数c使用默认值10。

在第二次使用函数func(25, c=24)的时候，根据实参的位置变量a得到值25。根据命名，即关键参数，参数c得到值24。变量b根据默认值，为5。

在第三次使用func(c=50, a=100)的时候，我们使用关键参数来完全指定参数值。注意，尽管函数定义中，a在c之前定义，我们仍然可以在a之前指定参数c的值。


== return语句 ==

return语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回一个值 。

{{{#!python
#!/usr/bin/python
# Filename: func_return.py

def maximum(x, y):
    if x > y:
        return x
    else:
        return y

print maximum(2, 3)
}}}
输出
{{{
$ python func_return.py
3
}}}

maximum函数返回参数中的最大值，在这里是提供给函数的数。它使用简单的if..else语句来找出较大的值，然后 返回 那个值。

注意，没有返回值的return语句等价于return None。None是Python中表示没有任何东西的特殊类型。例如，如果一个变量的值为None，可以表示它没有值。

除非你提供你自己的return语句，每个函数都在结尾暗含有return None语句。通过运行print someFunction()，你可以明白这一点，函数someFunction没有使用return语句，如同：
{{{#!python
def someFunction():
    pass
}}}
pass语句在Python中表示一个空的语句块。

== DocStrings ==

Python有一个很奇妙的特性，称为 文档字符串 ，它通常被简称为 docstrings 。DocStrings是一个重要的工具，由于它帮助你的程序文档更加简单易懂，你应该尽量使用它。你甚至可以在程序运行的时候，从函数恢复文档字符串！

{{{#!python
#!/usr/bin/python
# Filename: func_doc.py

def printMax(x, y):
    '''Prints the maximum of two numbers.

    The two values must be integers.'''
    x = int(x) # convert to integers, if possible
    y = int(y)

    if x > y:
        print x, 'is maximum'
    else:
        print y, 'is maximum'

printMax(3, 5)
print printMax.__doc__

}}}
输出
{{{
$ python func_doc.py
5 is maximum
Prints the maximum of two numbers.

        The two values must be integers.
}}}

在函数的第一个逻辑行的字符串是这个函数的 文档字符串 。注意，DocStrings也适用于模块和类，我们会在后面相应的章节学习它们。

文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。 强烈建议 你在你的函数中使用文档字符串时遵循这个惯例。

你可以使用{{{__doc__}}}（注意双下划线）调用printMax函数的文档字符串属性（属于函数的名称）。请记住Python把 每一样东西 都作为对象，包括这个函数。我们会在后面的类一章学习更多关于对象的知识。

如果你已经在Python中使用过help()，那么你已经看到过DocStings的使用了！它所做的只是抓取函数的{{{__doc__}}}属性，然后整洁地展示给你。你可以对上面这个函数尝试一下——只是在你的程序中包括help(printMax)。记住按q退出help。

自动化工具也可以以同样的方式从你的程序中提取文档。因此，我 强烈建议 你对你所写的任何正式函数编写文档字符串。随你的Python发行版附带的pydoc命令，与help()类似地使用DocStrings。


== lambda ==

lambda语句被用来创建新的函数对象，并且在运行时返回它们。

{{{#!python
#!/usr/bin/python
# Filename: lambda.py

def make_repeater(n):
    return lambda s: s*n

twice = make_repeater(2)

print twice('word')
print twice(5)
}}}
输出
{{{
$ python lambda.py
wordword
10
}}}

这里，我们使用了make_repeater函数在运行时创建新的函数对象，并且返回它。lambda语句用来创建函数对象。本质上，lambda需要一个参数，后面仅跟单个表达式作为函数体，而表达式的值被这个新建的函数返回。注意，即便是print语句也不能用在lambda形式中，只能使用表达式。

== 函数式编程 ==

对于链表来讲，有三个内置函数非常有用：filter()， map()， 和 reduce()。

"filter(function, sequence)"返回一个序列（sequence），包括了给定序列中所有调用function(item)后返回值为true的元素。（如果可能的话，会返回相同的类型）。例如，以下程序可以计算部分素数：

{{{
>>> def f(x): return x % 2 != 0 and x % 3 != 0
...
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]
}}}

"map(function, sequence)" 为每一个元素依次调用function(item)并将返回值组成一个链表返回。例如，以下程序计算立方：
{{{
>>> cube = lambda x: x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
}}}

可以传入多个序列，函数也必须要有对应数量的参数，执行时会依次用各序列上对应的元素来调用函数（如果某些序列比其它的短，就用None来代替）。如果把None做为一个函数传入，则直接返回参数做为替代。例如：
{{{
>>> seq = range(8)
>>> add = lambda x, y: x+y
...
>>> map(add, seq, seq)
[0, 2, 4, 6, 8, 10, 12, 14]
}}}
"reduce(func, sequence)" 返回一个单值，它是这样构造的：首先以序列的前两个元素调用函数，再以返回值和第三个参数调用，依次执行下去。例如，以下程序计算1到10的整数之和：
{{{
>>> add = lambda x, y: x+y
...
>>> reduce(add, range(1, 11))
55
}}}
如果序列中只有一个元素，就返回它，如果序列是空的，就抛出一个异常。

可以传入第三个参数做为初始值。如果序列是空的，就返回初始值，否则函数会先接收初始值和序列的第一个元素，然后是返回值和下一个元素，依此类推。例如：
{{{
>>> def sum(seq):
... return reduce(lambda x,y:x+y, seq, 0)
...
>>> sum(range(1, 11))
55
>>> sum([])
0
}}}

== 内置函数 ==
eval语句用来计算存储在字符串中的有效Python表达式。下面是一个简单的例子。
{{{
>>> eval('2*3')
6
}}}

repr函数用来取得对象的规范字符串表示。反引号（也称转换符）可以完成相同的功能。注意，在大多数时候有eval(repr(object)) == object。
{{{
>>> i = []
>>> i.append('item')
>>> `i`
"['item']"
>>> repr(i)
"['item']"
}}}
基本上，repr函数和反引号用来获取对象的可打印的表示形式。你可以通过定义类的__repr__方法来控制你的对象在被repr函数调用的时候返回的内容。

TableOfContents

控制流

在到目前为止我们所见到的程序中，总是有一系列的语句，Python忠实地按照它们的顺序执行它们。如果你想要改变语句流的执行顺序，该怎么办呢？例如，你想要让程序做一些决定，根据不同的情况做不同的事情，例如根据时间打印“早上好”或者“晚上好”。

你可能已经猜到了，这是通过控制流语句实现的。在Python中有三种控制流语句——if、for和while。

1. 顺序结构

顺序结构就是一个指令接着一个指令执行。比如： 

   1 import math
   2 radius = 5
   3 area = math.pi * (radius ** 2)
   4 print area

2. 分支结构

程序有多个流向可供选择时，就出现了分支结构，选择哪个流向继续执行取决于测试条件是否为真。Python用if语句来实现分支结构。if语句用来检验一个条件， 如果条件为真，我们运行一块语句（称为 if-块 ）， 否则我们处理另外一块语句（称为 else-块 ）。 else 从句是可选的。 

   1 #!/usr/bin/python
   2 
   3 number = 23
   4 guess = int(raw_input('Enter an integer : '))
   5 
   6 if guess == number:
   7     print 'Congratulations, you guessed it.' # New block starts here
   8     print "(but you do not win any prizes!)" # New block ends here
   9 elif guess < number:
  10     print 'No, it is a little higher than that' # Another block
  11     # You can do whatever you want in a block ...
  12 else:
  13     print 'No, it is a little lower than that'
  14     # you must have guess > number to reach here
  15 
  16 print 'Done'
  17 # This last statement is always executed, after the if statement is executed

输出 

Enter an integer : 50
No, it is a little lower than that
Done

Enter an integer : 22
No, it is a little higher than that
Done

Enter an integer : 23
Congratulations, you guessed it.
(but you do not win any prizes!)
Done

在这个程序中，我们从用户处得到猜测的数，然后检验这个数是否是我们手中的那个。我们把变量number设置为我们想要的任何整数，在这个例子中是23。然后，我们使用raw_input()函数取得用户猜测的数字。函数只是重用的程序段。我们将在下一章学习更多关于函数的知识。

我们为内建的raw_input函数提供一个字符串，这个字符串被打印在屏幕上，然后等待用户的输入。一旦我们输入一些东西，然后按回车键之后，函数返回输入。对于raw_input函数来说是一个字符串。我们通过int把这个字符串转换为整数，并把它存储在变量guess中。事实上，int是一个类，不过你想在对它所需了解的只是它把一个字符串转换为一个整数（假设这个字符串含有一个有效的整数文本信息）。

接下来，我们将用户的猜测与我们选择的数做比较。如果他们相等，我们打印一个成功的消息。注意我们使用了缩进层次来告诉Python每个语句分别属于哪一个块。这就是为什么缩进在Python如此重要的原因。我希望你能够坚持“每个缩进层一个制表符”的规则。你是这样的吗？

注意if语句在结尾处包含一个冒号——我们通过它告诉Python下面跟着一个语句块。

然后，我们检验猜测是否小于我们的数，如果是这样的，我们告诉用户它的猜测大了一点。我们在这里使用的是elif从句，它事实上把两个相关联的if else-if else语句合并为一个if-elif-else语句。这使得程序更加简单，并且减少了所需的缩进数量。

elif和else从句都必须在逻辑行结尾处有一个冒号，下面跟着一个相应的语句块（当然还包括正确的缩进）。

你也可以在一个if块中使用另外一个if语句，等等——这被称为嵌套的if语句。

记住，elif和else部分是可选的。一个最简单的有效if语句是： 

   1 if True:
   2     print 'Yes, it is true'

在Python执行完一个完整的if语句以及与它相关联的elif和else从句之后，它移向if语句块的下一个语句。在这个例子中，这个语句块是主块。程序从主块开始执行，而下一个语句是print 'Done'语句。在这之后，Python看到程序的结尾，简单的结束运行。

尽管这是一个非常简单的程序，但是我已经在这个简单的程序中指出了许多你应该注意的地方。所有这些都是十分直接了当的（对于那些拥有C/C++背景的用户来说是尤为简单的）。它们在开始时会引起你的注意，但是以后你会对它们感到熟悉、“自然”。 

给C/C++程序员的注释
在Python中没有switch语句。你可以使用if..elif..else语句来完成同样的工作（在某些场合，使用字典会更加快捷。）

如果你的语句块只包含一句语句，那么你可以在条件语句的同一行指明它。下面这个例子清晰地说明了这一点： 

>>> flag = True
>>> if flag: print 'Yes'
...
Yes

就如你所看见的，单个语句被直接使用而不是作为一个独立的块使用。虽然这样做可以使你的程序变得 小一些 ，但是除了检验错误之外我强烈建议你不要使用这种缩略方法。不使用它的一个主要的理由是一旦你使用了恰当的缩进，你就可以很方便地添加一个额外的语句。

3. 循环结构

循环结构是指多次执行一个语句序列。python中最简单的循环结构是用while语句。只要在一个条件为真的情况下，while语句允许你重复执行一块语句。while语句是所谓 循环 语句的一个例子。while语句有一个可选的else从句。 

   1 #!/usr/bin/python
   2 
   3 number = 23
   4 running = True
   5 
   6 while running:
   7     guess = int(raw_input('Enter an integer : '))
   8 
   9     if guess == number:
  10         print 'Congratulations, you guessed it.'
  11         running = False # this causes the while loop to stop
  12     elif guess < number:
  13         print 'No, it is a little higher than that'
  14     else:
  15         print 'No, it is a little lower than that'
  16 else:
  17     print 'The while loop is over.'
  18     # Do anything else you want to do here
  19 
  20 print 'Done'

输出 

Enter an integer : 50
No, it is a little lower than that.
Enter an integer : 22
No, it is a little higher than that.
Enter an integer : 23
Congratulations, you guessed it.
The while loop is over.
Done

在这个程序中，我们仍然使用了猜数游戏作为例子，但是这个例子的优势在于用户可以不断的猜数，直到他猜对为止——这样就不需要像前面那个例子那样为每次猜测重复执行一遍程序。这个例子恰当地说明了while语句的使用。

我们把raw_input和if语句移到了while循环内，并且在while循环开始前把running变量设置为True。首先，我们检验变量running是否为True，然后执行后面的 while-块 。在执行了这块程序之后，再次检验条件，在这个例子中，条件是running变量。如果它是真的，我们再次执行while-块，否则，我们继续执行可选的else-块，并接着执行下一个语句。

当while循环条件变为False的时候，else块才被执行——这甚至也可能是在条件第一次被检验的时候。如果while循环有一个else从句，它将始终被执行，除非你的while循环将永远循环下去不会结束！

True和False被称为布尔类型。你可以分别把它们等效地理解为值1和0。在检验重要条件的时候，布尔类型十分重要，它们并不是真实的值1。

记住，else部分是可选的。如果包含else，它总是在while循环结束后执行一次，除非遇到break语句。 

给C/C++程序员的注释
记住，你可以在while循环中使用一个else从句。

for..in是另外一种循环语句，它在一序列的对象上 递归 即逐一使用队列中的每个项目。比如 

   1 #!/usr/bin/python
   2 
   3 for i in range(1, 5):
   4     print i
   5 else:
   6     print 'The for loop is over'

输出 

1
2
3
4
The for loop is over

在这个程序中，我们打印了一个 序列 的数。我们使用内建的range函数生成这个数的序列。

我们所做的只是提供两个数，range返回一个序列的数。这个序列从第一个数开始到第二个数为止。例如，range(1,5)给出序列[1, 2, 3, 4]。默认地，range的步长为1。如果我们为range提供第三个数，那么它将成为步长。例如，range(1,5,2)给出[1,3]。记住，range 向上 延伸到第二个数，即它不包含第二个数。

for循环在这个范围内递归——for i in range(1,5)等价于for i in [1, 2, 3, 4]，这就如同把序列中的每个数（或对象）赋值给i，一次一个，然后以每个i的值执行这个程序块。在这个例子中，我们只是打印i的值。

记住，else部分是可选的。如果包含else，它总是在for循环结束后执行一次，除非遇到break语句。

记住，for..in循环对于任何序列都适用。这里我们使用的是一个由内建range函数生成的数的列表，但是广义说来我们可以使用任何种类的由任何对象组成的序列！我们会在后面的章节中详细探索这个观点。 

给C/C++/Java/C#程序员的注释
Python的for循环从根本上不同于C/C++的for循环。C#程序员会注意到Python的for循环与C#中的foreach循环十分类似。Java程序员会注意到它与Java 1.5中的for (int i : IntArray)相似。
在C/C++中，如果你想要写for (int i = 0; i < 5; i++)，那么用Python，你写成for i in range(0,5)。你会注意到，Python的for循环更加简单、明白、不易出错。

在循环中，可以使用break语句来 终止 循环语句的，即哪怕循环条件没有称为False或序列还没有被完全递归，也停止执行循环语句。

一个重要的注释是，如果你从for或while循环中 终止 ，任何对应的循环else块将不执行。 

   1 #!/usr/bin/python
   2 
   3 while True:
   4     s = raw_input('Enter something : ')
   5     if s == 'quit':
   6         break
   7     print 'Length of the string is', len(s)
   8 print 'Done'

输出 

Enter something : Programming is fun
Length of the string is 18
Enter something : When the work is done
Length of the string is 21
Enter something : if you wanna make your work also fun:
Length of the string is 37
Enter something :       use Python!
Length of the string is 12
Enter something : quit
Done

在这个程序中，我们反复地取得用户地输入，然后打印每次输入地长度。我们提供了一个特别的条件来停止程序，即检验用户的输入是否是'quit'。通过 终止 循环到达程序结尾来停止程序。

输入字符串的长度通过内建的len函数取得。

记住，break语句也可以在for循环中使用。

在循环中，还可以用continue语句来告诉Python跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。比如： 

   1 #!/usr/bin/python
   2 
   3 while True:
   4     s = raw_input('Enter something : ')
   5     if s == 'quit':
   6         break
   7     if len(s) < 3:
   8         continue
   9     print 'Input is of sufficient length'
  10     # Do other kinds of processing here...

输出 

Enter something : a
Enter something : 12
Enter something : abc
Input is of sufficient length
Enter something : quit

在这个程序中，我们从用户处取得输入，但是我们仅仅当它们有至少3个字符长的时候才处理它们。所以，我们使用内建的len函数来取得长度。如果长度小于3，我们将使用continue语句忽略块中的剩余的语句。否则，这个循环中的剩余语句将被执行，我们可以在这里做我们希望的任何处理。

注意，continue语句对于for循环也有效。

end

Python语言的控制流 (2008-02-23 15:34:06由localhost编辑)

ch3n2k.com | Copyright (c) 2004-2020 czk.