跳转到内容

Python 编程/循环

来自维基教科书，开放书籍，构建开放世界
上一个: 条件语句 索引 下一个: 函数


While 循环

[编辑 | 编辑源代码]

这是我们的第一个控制结构。使用的版本是 2.7。通常情况下，计算机从第一行开始，然后向下执行。控制结构改变语句执行的顺序，或决定是否执行某个语句。顺便说一下，决策语句（例如，if 语句）也会影响是否执行某个语句。下面是使用 while 控制结构的程序的源代码

a = 0
while a < 5:
    a += 1 # Same as a = a + 1 
    print (a)

下面是输出

1
2
3
4
5

那么程序做了什么？首先它看到这行a = 0并将变量 a 设置为零。然后它看到while a < 5因此计算机检查是否a < 5。计算机第一次看到这个语句时，a 是零，而零小于 5。换句话说，只要 a 小于五，计算机就会运行缩进的语句。

下面是另一个使用while: 

a = 1
s = 0
print ('Enter Numbers to add to the sum.')
print ('Enter 0 to quit.')
while a != 0:
    print ('Current Sum: ', s)
    a = input('Number? ') #raw_input() only up to Python 2.x
    a = float(a)
    s += a
print ('Total Sum = ',s)

Enter Numbers to add to the sum.
Enter 0 to quit.
Current Sum: 0
Number? 200
Current Sum: 200
Number? -15.25
Current Sum: 184.75
Number? -151.85
Current Sum: 32.9
Number? 10.00
Current Sum: 42.9
Number? 0
Total Sum = 42.9

的例子注意print 'Total Sum =',swhile只在最后运行一次。该语句只影响缩进的（也称为缩进的）行。该 !=表示不等于，所以while a != 0 

表示直到 a 为零，运行后面的缩进语句。

while 1 == 1:
    print ("Help, I'm stuck in a loop.")

现在我们有了 while 循环，就可以编写永远运行的程序。一个简单的方法是编写类似这样的程序这个程序会输出救命，我卡在循环里了。

直到宇宙热寂或你停止它。停止它的方法是同时按下 Ctrl（或 Ctrl）键和 `c`（字母）。这将杀死程序。（注意：有时你需要在 Ctrl C 后按回车键。）

示例

[编辑 | 编辑源代码]

#This program calculates the Fibonacci sequence
a = 0
b = 1
count = 0
max_count = 20
while count < max_count:
    count = count + 1
    #we need to keep track of a since we change it
    old_a = a
    old_b = b
    a = old_b
    b = old_a + old_b
    #Notice that the , at the end of a print statement keeps it
    # from switching to a new line
    print (old_a),

Fibonacci.py

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

输出

# Waits until a password has been entered.  Use control-C to break out without
# the password.

# Note that this must not be the password so that the 
# while loop runs at least once.
password = "foobar"

#note that != means not equal
while password != "unicorn":
    password = input("Password: ")
print ("Welcome in")

Password.py

Password:auo
Password:y22
Password:password
Password:open sesame
Password:unicorn
Welcome in

示例运行

For 循环

[编辑 | 编辑源代码]Python 中的下一种循环类型是forPython 中的下一种循环类型是循环。与大多数语言不同，需要一些__可迭代__对象，例如集合或列表

onetoten = range(1,11)
for count in onetoten:
    print (count)

才能工作。

1
2
3
4
5
6
7
8
9
10

输出输出看起来很熟悉，但程序代码看起来不同。第一行使用了range输出看起来很熟悉，但程序代码看起来不同。第一行使用了函数。该函数使用两个参数，如下所示. range(start,finish)start是产生的第一个数字。finish

for count in range(1,11):
    print (count)

比最后一个数字大 1。注意，这个程序可以用更短的方式实现输出看起来很熟悉，但程序代码看起来不同。第一行使用了下面是一些例子，展示了该

>>> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(-32, -20)
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> range(5,21)
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> range(21,5)
[]

函数

的行为备注：对于当前版本的 Python，我们需要将 range 函数传递给 list() 才能实际打印一个列表。例如，我们需要使用 list(range(1,10)) 来获得 [1, 2, 3, 4, 5, 6, 7, 8, 9]。在Python 中的下一种循环类型是循环中使用

for a in range(10):
    print (a)

range()

for a in range(0, 10):
    print (a)

函数的另一种方法是只提供一个参数

0 1 2 3 4 5 6 7 8 9

上面的代码与Python 中的下一种循环类型是完全相同，隐式地将 0 作为起点。输出为

代码将按预期循环 10 次，但从 0 开始而不是 1。下一行for count in onetotenPython 中的下一种循环类型是使用Python 中的下一种循环类型是控制结构。一个控制结构看起来像. for variable in listlistPython 中的下一种循环类型是从列表的第一个元素开始，一直到最后一个元素。当遍历列表中的每个元素时，它会将每个元素放入variable遍历列表中的每个元素时，它会将每个元素放入中。这允许

demolist = ['life',42, 'the universe', 6,'and',7,'everything']
for item in demolist:
    print ("The Current item is: %s" % item)

在每次运行 for 循环时使用。下面是另一个演示

The Current item is: life
The Current item is: 42
The Current item is: the universe
The Current item is: 6
The Current item is: and
The Current item is: 7
The Current item is: everything

的例子输出为注意 for 循环是如何遍历列表并为 item 设置每个元素的。（注意，如果你不想Python 中的下一种循环类型是print

list = [2,4,6,8]
sum = 0
for num in list:
    sum = sum + num
print ("The sum is: %d" % sum)

转到下一行，在语句末尾添加逗号（即，如果你想在该行上打印其他内容）。）那么，

The sum is:  20

有什么用？第一个用途是遍历列表的所有元素，并对每个元素执行操作。这里有一个快速的方法，可以将所有元素加起来

list = [4, 5, 7, 8, 9, 1,0,7,10]
list.sort()
prev = list[0]
del list[0]
for item in list:
    if prev == item:
        print ("Duplicate of ",prev," Found")
    prev = item

输出只是

Duplicate of  7  Found

或者你可以编写一个程序，找出列表中是否存在任何重复项，就像这个程序所做的那样

l = [4, 5, 7, 8, 9, 1,0,7,10]
print ("l = [4, 5, 7, 8, 9, 1,0,7,10]","\tl:",l)
l.sort()
print ("l.sort()","\tl:",l)
prev = l[0]
print ("prev = l[0]","\tprev:",prev)
del l[0]
print ("del l[0]","\tl:",l)
for item in l:
    if prev == item:
        print ("Duplicate of ",prev," Found")
    print ("if prev == item:","\tprev:",prev,"\titem:",item)
    prev = item
    print ("prev = item","\t\tprev:",prev,"\titem:",item)

为了确保万无一失，

l = [4, 5, 7, 8, 9, 1,0,7,10]   l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort()        l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
prev = l[0]     prev: 0
del l[0]        l: [1, 4, 5, 7, 7, 8, 9, 10]
if prev == item:        prev: 0         item: 1
prev = item             prev: 1         item: 1
if prev == item:        prev: 1         item: 4
prev = item             prev: 4         item: 4
if prev == item:        prev: 4         item: 5
prev = item             prev: 5         item: 5
if prev == item:        prev: 5         item: 7
prev = item             prev: 7         item: 7
if prev == item:        prev: 7         item: 7
Duplicate of  7  Found
prev = item             prev: 7         item: 7
if prev == item:        prev: 7         item: 8
prev = item             prev: 8         item: 8
if prev == item:        prev: 8         item: 9
prev = item             prev: 9         item: 9
if prev == item:        prev: 9         item: 10
prev = item             prev: 10        item: 10

它是如何工作的？这里有一个特殊的调试版本输出为输出为

注意：之所以有这么多

a = 1
b = 1
for c in range(1,10):
    print (a)
    n = a + b
    a = b
    b = n
print ("")

语句，是因为 print 语句可以在不同的时间显示每个变量的值，并帮助调试程序。首先，程序从一个旧列表开始。接下来，程序对列表进行排序。这样，任何重复项都会放在一起。程序然后初始化一个 prev(ious) 变量。接下来，列表的第一个元素被删除，这样第一个项目就不会被错误地认为是重复项。接下来进入 for 循环。列表中的每个项目都会被检查，看它是否与之前的项目相同。如果相同，则表示找到了重复项。然后 prev 的值就会改变，这样下次运行 for 循环时，prev 就是当前项目的前面那个项目。果然，7 被发现是一个重复项。

1
1
2
3
5
8
13
21
34

使用 for 循环的另一种方法是执行某些操作一定次数。下面是一些代码，用于打印出斐波那契数列的前 9 个数字Python 中的下一种循环类型是输出令人惊讶while所有可以用Python 中的下一种循环类型是循环完成的事情，也可以用


循环完成，但是

循环提供了一种简单的方法，可以遍历列表中的所有元素或执行某些操作一定次数。

range 与 xrange

[编辑 | 编辑源代码]

Python 3 注意：在 Python 3.x 中，没有名为 xrange 的函数。相反，range 函数具有下面为 xrange 描述的行为。以下是适用于旧版 Python 2 的内容。

在上面，你被介绍了 range 函数，它返回指定范围内所有整数的列表。假设你要编写类似 range(0, 1000000) 的表达式：这将创建一个包含一百万个整数的列表！这会占用大量内存。

for i in xrange(0, 1000000):
    print(i)

通常，你确实需要处理非常广泛范围内的所有数字。但是你可能只需要一次处理一个数字；在处理完每个数字后，可以在获取下一个数字之前从内存中将其丢弃。

为此，你可以使用 xrange 函数而不是 range。例如，以下简单的循环

将打印从 0 到 999999 的一百万个整数，但它将从 xrange 调用中一次获取一个整数，而不是一次获取所有整数作为单个列表，然后遍历该列表。

这是一个迭代器的例子，它在需要时一次生成一个值，而不是一次生成所有值。当你学习更多关于 Python 的知识时，你会看到很多使用迭代器的例子，并且你会学会如何编写自己的迭代器。

break 语句

[编辑 | 编辑源代码]

一个 while 循环在每次进入循环体之前检查其终止条件，如果条件变为 False，则终止。因此，循环体通常会迭代零次、一次或多次完整的迭代。

  1. 一个 for 循环对迭代器表达式返回的每个值迭代其主体一次。同样，每次迭代通常都是对完整循环体的迭代。
  2. 有时你想在循环体的中间有条件地停止循环。一个示例情况可能如下所示
  3. 获取要检查的下一个值
  4. 实际上还有另一个值要检查吗？如果没有，则退出循环并失败。

该值是我要找的吗？如果是，则退出循环并成功。

found = False # initial assumption
for value in values_to_check():
    if is_what_im_looking_for(value):
        found = True
        break
# ... found is True on success, False on failure

否则，返回步骤 1。

如你所见，从这个循环中有两种可能的退出方式。你可以使用 break 语句从 Python while 或 for 循环的中间退出。下面是编写此类循环的一种方法

这样做的问题在于两种退出循环的方式之间的不对称性：一种是通过正常的 for 循环终止，另一种是通过 break。作为一种风格上的问题，更一致的做法是遵循以下原则

如果一个循环的退出是由 break 表示的，那么所有循环的退出都应该由 break 表示。

values = iter(values_to_check())
while True:
    value = next(values, None)
    if value is None:
        found = False
        break
    if is_what_im_looking_for(value):
        found = True
        break
# ... found is True on success, False on failure

特别地，这意味着循环结构本身成为一个“永远循环”；唯一的退出方式是通过 break 语句。

我们可以通过显式地处理生成要检查的值的迭代器来做到这一点。也许上面的 values_to_check() 调用已经生成了一个迭代器；如果没有，可以通过将其包装在对 iter() 内置函数的调用中，然后使用 next() 内置函数从该迭代器中获取连续的值，将其转换为迭代器。然后循环变为

这使用特殊的 Python 值 None 来指示迭代器已到达其末尾。这是一个常见的 Python 惯例。但如果你需要将 None 作为你的值序列中的有效项目，那么很容易定义一些其他唯一的值（例如自定义的虚拟类）来表示列表的末尾。
  1. 编写一个程序，以素数计数。请用户输入一个数字，然后打印出该数字之前的每个素数。
  2. 指示用户从 1 到 100 中选择一个任意数字，并在七次尝试内猜出正确答案。在每次猜测之后，用户必须告知他们的数字是否高于、低于或等于您的猜测。

解决方案

上一个: 条件语句 索引 下一个: 函数
检索自 "https://wikibooks.cn/w/index.php?title=Python_Programming/Loops&oldid=4352125"
华夏公益教科书