《Python编程：从入门到实践》笔记（一）＜基础语法＞

一、变量和简单数据类型

1、注释

在Python中，注释用井号（#）标识。井号后面的内容都会被Python解释器忽略

#向大家问好
print("Hello Python people!")

Python解释器将忽略第1行，只执行第2行。

Hello Python people!

2、变量命名规则

在Python中使用变量时，需要遵守一些规则和指南。违反这些规则将引发错误，而指南旨在让你编写的代码更容易阅读和理解。请务必牢记下述有关变量的规则。
1、 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。

2、 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。

3、 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print。

4、 变量名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。

5、 慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。

注意：就目前而言，应使用小写的Python变量名。在变量名中使用大写字母虽然不会导致错误，但避免使用大写字母是个不错的主意。

3、字符串

字符串就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号，如下所示：

“This is a string.”
‘This is also a string.’

使用方法修改字符串的大小写

对于字符串，可执行的最简单的操作之一是修改其中的单词的大小写。

name = "ada lovelace"
print(name.title())

Ada Lovelace

在name.title()中，name 后面的句点（. ）让Python对变量name 执行方法title() 指定的操作。每个方法后面都跟着一对括号，这是因为方法通常需要额外的信息来完成其工作。这种信息是在括号内提供的。函数title() 不需要额外的信息，因此它后面的括号是空的。

title() #以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。
lower() #将所有字母转换为小写
upper() #将所有字母转换为大写

合并（拼接）字符串

在很多情况下，都需要合并字符串。Python使用加号（+）来合并字符串，这种合并字符串的方法称为拼接。通过拼接，可使用存储在变量中的信息来创建完整的消息。
例如，你可能想将姓和名存储在不同的变量中，等要显示姓名时再将它们合而为一：

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
print(full_name)
print("Hello, " + full_name.title() + "!")

ada lovelace
Hello, Ada Lovelace!

制表符及换行符

要在字符串中添加制表符，可使用字符组合\t
要在字符串中添加换行符，可使用字符组合\n

print('message:\n\tpython\n\tprint')

message:
	python
	print

删除空白

rstrip() #删除末尾空白
lstrip() #删除开头空白
strip()  #删除两端空白

避免语法错误

程序中包含非法的Python代码时，就会导致语法错误。例如，在用单引号括起的字符串中，如果包含撇号，就将导致错误。因为这会导致Python将第一个单引号和撇号之间的内容视为一个字符串，进而将余下的文本视为Python代码，从而引发错误。

message = 'One of Python's strengths is its diverse community.'

正确写法：

message = "One of Python's strengths is its diverse community."

3、数字

整数

在Python中，可对整数执行加（+ ）减（- ）乘（* ）除（/ ）运算。

浮点数

Python将带小数点的数字都称为浮点数。
需要注意的是，结果包含的小数位数可能是不确定的：

>>> 0.2 + 0.1
0.30000000000000004
>>> 3 * 0.1
0.30000000000000004

所有语言都存在这种问题，没有什么可担心的。 Python会尽力找到一种方式，以尽可能精确地表示结果，但鉴于计算机内部表示数字的方式，这在有些情况下很难。就现在而言，暂时忽略多余的小数位数即可；在下一部分中，将学习在需要时处理多余小数位的方式。

使用函数str() 避免类型错误

你经常需要在消息中使用变量的值。例如，假设你要祝人生日快乐，可能会编写类似于下面的代码：

age = 23
message = "Happy " + age + "rd Birthday!"
print(message)

这时会发生类型错误

TypeError: Can’t convert ‘int’ object to str implicitly

Python发现你使用了一个值为整数（int ）的变量，但它不知道该如何解读这个值，这个变量表示的可能是数值23，也可能是字符2和3。像上面这样在字符串中使用整数时，需要显式地指出你希望Python将这个整数用作字符串。为此，可调用函数str() ，它让Python将非字符串值表示为字符串。

age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)

Happy 23rd Birthday!

4、Python之禅

执行命令

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!

二、列表

1、访问列表

列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉Python即可。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)

打印整个列表包括方括号：

[‘trek’, ‘cannondale’, ‘redline’, ‘specialized’]

请求获取列表元素时， Python只返回该元素， 而不包括方括号和引号

print(bicycles[0])

trek

在Python中， 第一个列表元素的索引为0， 而不是1。

负数索引可倒序访问。 通过将索引指定为-1，可让Python返回最后一个列表元素，索引-2 返回倒数第二个列表元素，索引-3 返回倒数第三个列表元素，以此类推。

print(bicycles[-1])

specialized

可像使用其他变量一样使用列表中的各个值。

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
message = "My first bicycle was a " + bicycles[0].title() + "."
print(message)

My first bicycle was a Trek.

2、修改、添加和删除元素

修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。

如修改列表中第一个元素的值：

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles[0] = 'ducati'
print(motorcycles)

[‘honda’, ‘yamaha’, ‘suzuki’]
[‘ducati’, ‘yamaha’, ‘suzuki’]

在列表中添加新元素时，最简单的方式是将元素附加到列表末尾。
使用方法append():

motorcycles.append('ducati')
print(motorcycles)

[‘honda’, ‘yamaha’, ‘suzuki’, ‘ducati’]

使用方法insert() 可在列表的任何位置添加新元素，需要指定新元素的索引和值。如在列表开头添加元素：

motorcycles.insert(0, 'ducati')
print(motorcycles)

[‘ducati’, ‘honda’, ‘yamaha’, ‘suzuki’]

使用del 可删除任何位置处的列表元素，条件是知道其索引。如删除列表中的第二个元素：

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[1]
print(motorcycles)

[‘honda’, ‘yamaha’, ‘suzuki’]
[‘honda’, ‘suzuki’]

方法pop() 可删除列表末尾的元素， 并让你能够接着使用它。

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
popped_motorcycle = motorcycles.pop()
print(motorcycles)
print(popped_motorcycle)

[‘honda’, ‘yamaha’, ‘suzuki’]
[‘honda’, ‘yamaha’]
suzuki

可以使用pop() 来删除列表中任何位置的元素， 只需在括号中指定要删除的元素的索引即可。

first_owned = motorcycles.pop(0)
print(first_owned)

honda

根据值删除元素

有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove()

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles.remove('honda')
print(motorcycles)

[‘honda’, ‘yamaha’, ‘suzuki’]
[‘yamaha’, ‘suzuki’]

注意：方法remove() 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。

3、组织列表

使用方法sort() 对列表进行永久性排序，按字母顺序排列。还可以按与字母顺序相反的顺序排列列表元素，向sort() 方法传递参数reverse=True。

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)
cars.sort(reverse=True)
print(cars)

[‘audi’, ‘bmw’, ‘subaru’, ‘toyota’]
[‘toyota’, ‘subaru’, ‘bmw’, ‘audi’]

使用函数sorted() 对列表进行临时排序。要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted()。按与字母顺序相反的顺序显示列表，也可向函数sorted() 传递参数reverse=True。

print(sorted(cars))
print(sorted(cars,reverse=True))

[‘audi’, ‘bmw’, ‘subaru’, ‘toyota’]
[‘toyota’, ‘subaru’, ‘bmw’, ‘audi’]

要反转列表元素的排列顺序，可使用方法reverse()。reverse() 不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序：

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.reverse()
print(cars)

[‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
[‘subaru’, ‘toyota’, ‘audi’, ‘bmw’]

方法reverse() 永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse() 即可。

使用函数len() 可快速获悉列表的长度。

len(cars)

4

4、操作列表-

遍历列表 – for 循环

使用for 循环打印列表中所有元素

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician)

alice
david
carolina

这行代码让Python从列表magicians 中取出一个名字，并将其存储在变量magician 中。 最后让Python打印前面存储到变量magician 中的名字。

for 语句末尾的冒号告诉Python，下一行是循环的第一行，漏写冒号将导致语法错误。
Python根据缩进来判断代码行与前一个代码行的关系。 在前面的示例中，print(magician) 是for 循环的一部分，因为它们缩进了。

在for 循环后面，没有缩进的代码都只执行一次，而不会重复执行，代表for 循环结束。

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician.title() + ", that was a great trick!")
    print("I can't wait to see your next trick, " + magician.title() + ".\n")
print("Thank you, everyone. That was a great magic show!")

Alice, that was a great trick!
I can’t wait to see your next trick, Alice.

David, that was a great trick!
I can’t wait to see your next trick, David.

Carolina, that was a great trick!
I can’t wait to see your next trick, Carolina.

Thank you, everyone. That was a great magic show!

储存数值列表

列表非常适合用于存储数字集合， 而Python提供了很多工具， 可帮助你高效地处理数字列表。

函数range() 让你能够轻松地生成一系列的数字。从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值。

for value in range(1,5):
    print(value)

1
2
3
4

要创建数字列表，可使用函数list() 将range() 的结果直接转换为列表。

numbers = list(range(1,6))
print(numbers)

[1, 2, 3, 4, 5]

函数range() 时，还可指定步长。 例如，下面的代码打印1~10内的偶数：

even_numbers = list(range(2,11,2))
print(even_numbers)

[2, 4, 6, 8, 10]

使用函数range() 几乎能够创建任何需要的数字集，例如，创建一个列表，其中包含前10个整数的平方：

squares = []
for value in range(1,11):
    squares.append(value**2)
print(squares)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

有几个专门用于处理数字列表的Python函数。 例如，你可以轻松地找出数字列表的最大值、 最小值和总和：

>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>> sum(digits)
45

5、列表解析

将for 循环和创建新元素的代码合并成一行，并自动附加新元素。

squares = [value**2 for value in range(1,11)]
print(squares)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

请注意，这里的for 语句末尾没有冒号。

6、切片

你还可以处理列表的部分元素——Python称之为切片。

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range() 一样，Python在到达你指定的第二个索引前面的元素后停止。

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])

[‘charles’, ‘martina’, ‘michael’]

如果你没有指定第一个索引， Python将自动从列表开头开始：

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[:4])

要让切片终止于列表末尾，也可使用类似的语法。

print(players[2:])

Python将返回从第3个元素到列表末尾的所有元素。

负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任何切片。
如果你要输出名单上的最后三名队员，可使用切片

players[-3:]

复制列表

要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:]）。这让Python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表。

三、元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。 Python将不能修改的值称为不可变的，而不可变的列表被称为元组。

1、定义元组

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])

200
50

2、修改元组变量

虽然不能修改元组的元素，但可以给存储元组的变量赋值，重新定义整个元组。

dimensions = (200, 50)
print("Original dimensions:")
for dimension in dimensions:
    print(dimension)
dimensions = (400, 100)
print("\nModified dimensions:")
for dimension in dimensions:
    print(dimension)

Original dimensions:
200
50

Modified dimensions:
400
100

四、if 语句

编程时经常需要检查一系列条件，并据此决定采取什么措施。 在Python中，if 语句让你能够检查程序的当前状态，并据此采取相应的措施。
这个示例中的循环首先检查当前的汽车名是否是’bmw’。 如果是，就以全大写的方式打印它；否则就以首字母大写的方式打印：

cars = ['audi', 'bmw', 'subaru', 'toyota']
for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

Audi
BMW
Subaru
Toyota

1、条件测试

每条if 语句的核心都是一个值为True 或False 的表达式，这种表达式被称为条件测试 。
Python根据条件测试的值为True 还是False 来决定是否执行if 语句中的代码。如果条件测试的值为True，Python就执行紧跟在if 语句后面的代码；如果为False，Python就忽略这些代码。

使用and 检查多个条件
要检查是否两个条件都为True，可使用关键字and 将两个条件测试合而为一； 如果每个测试都通过了，整个表达式就为True；如果至少有一个测试没有通过，整个表达式就为False。

>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 and age_1 >= 21
False

>>> age_1 = 22
>>> age_0 >= 21 and age_1 >= 21
True

关键字or 也能检查多个条件，但只要至少有一个条件满足，就能通过整个测试。仅当两个测试都没有通过时，使用or 的表达式才为False。

>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 or age_1 >= 21
True

>>> age_0 = 18
>>> age_0 >= 21 or age_1 >= 21
False

2、检查特定值是否包含在列表中

要判断特定的值是否已包含在列表中，可使用关键字in。

>>> requested_toppings = ['mushrooms', 'onions', 'pineapple']
>>> 'mushrooms' in requested_toppings
True
>>> 'pepperoni' in requested_toppings
False

检查特定值是否不包含在列表中可使用关键字not in

banned_users = ['andrew', 'carolina', 'david']
user = 'marie'
if user not in banned_users:
    print(user.title() + ", you can post a response if you wish.")

Marie, you can post a response if you wish.

3、简单的if 语句

最简单的if 语句只有一个测试和一个操作：

if conditional_test:
    do something

在第1行中，可包含任何条件测试，而在紧跟在测试后面的缩进代码块中，可执行任何操作。 如果条件测试的结果为True，Python就会执行紧跟在if 语句后面的代码；否则Python将忽略这些代码。

在if 语句中，缩进的作用与for 循环中相同。 如果测试通过了，将执行if 语句后面所有缩进的代码行，否则将忽略它们。

age = 19
if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")

条件测试通过了，而两条print 语句都缩进了，因此它们都将执行：

You are old enough to vote!
Have you registered to vote yet?

4、if-else 语句

经常需要在条件测试通过了时执行一个操作，并在没有通过时执行另一个操作；在这种情况下，可使用Python提供的if-else 语句。if-else 语句块类似于简单的if 语句， 但其中的else 语句让你能够指定条件测试未通过时要执行的操作。

age = 17
if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")
else:
    print("Sorry, you are too young to vote.")
    print("Please register to vote as soon as you turn 18!")

5、if-elif-else 结构

经常需要检查超过两个的情形，为此可使用Python提供的if-elif-else 结构。 Python只执行if-elif-else 结构中的一个代码块，它依次检查每个条件测试， 直到遇到通过了的条件测试。 测试通过后，Python将执行紧跟在它后面的代码，并跳过余下的测试。可根据需要使用任意数量的elif 代码块。Python并不要求if-elif 结构后面必须有else 代码块，可都写成elif。

age = 12
if age < 4:
    price = 0
elif age < 18:
    price = 5
else:
    price = 10

print("Your admission cost is $" + str(price) + ".")

Your admission cost is $5.

五、字典

在Python中，字典是一系列键—值对。每个键都与一个值相关联，可以使用键来访问与之相关联的值。与键相关联的值可以是数字、 字符串、 列表乃至字典。 事实上，可将任何Python对象用作字典中的值。键和值之间用冒号分隔，而键—值对之间用逗号分隔。在字典中，你想存储多少个键—值对都可以。

1、定义字典

在Python中，字典用放在花括号{}中的一系列键—值对表示：

alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])

green
5

2、使用字典

字典是一种动态结构，可随时在其中添加键—值对。要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的值。

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)

{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘green’, ‘points’: 5, ‘y_position’: 25, ‘x_position’: 0}

要修改字典中的值， 可依次指定字典名、 用方括号括起的键以及与该键相关联的新值。

alien_0 = {'color': 'green'}
print("The alien is " + alien_0['color'] + ".")
alien_0['color'] = 'yellow'
print("The alien is now " + alien_0['color'] + ".")

The alien is green.
The alien is now yellow.

对于字典中不再需要的信息，可使用del 语句将相应的键—值对彻底删除。使用del 语句时，必须指定字典名和要删除的键。

alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']
print(alien_0)

{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘green’}

3、遍历字典

方法items()，返回一个键—值对列表

user_0 = {
    'username': 'efermi',
    'first': 'enrico',
    'last': 'fermi',
    }

for key, value in user_0.items():
    print("\nKey: " + key)
    print("Value: " + value)

Key: last
Value: fermi

Key: first
Value: enrico

Key: username
Value: efermi

注意：即便遍历字典时，键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。

方法keys()，可以返回字典中的所有键，而不包括值。
方法values()，它返回一个值列表，而不包含任何键。

4、嵌套

有时候，需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套。

在列表中储存字典

我们首先创建了三个字典，然后将这些字典都放到一个名为aliens 的列表中。

alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
aliens = [alien_0, alien_1, alien_2]

在字典中储存列表

其中toppings 的值是一个列表，要访问该列表，使用字典名和键’toppings’，就像访问字典中的其他值一样。

pizza = {
    'crust': 'thick',
    'toppings': ['mushrooms', 'extra cheese'],
    }

for topping in pizza['toppings']:
    print(topping)

mushrooms
extra cheese

在字典中储存字典

users = {
    'aeinstein': {
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton',
        },
    'mcurie': {
        'first': 'marie',
        'last': 'curie',
        'location': 'paris',
        },
    }
for username, user_info in users.items():
    print("\nUsername: " + username)
    full_name = user_info['first'] + " " + user_info['last']
    location = user_info['location']
    print("\tFull name: " + full_name.title())
    print("\tLocation: " + location.title())

Username: aeinstein
	Full name: Albert Einstein
	Location: Princeton

Username: mcurie
	Full name: Marie Curie
	Location: Paris

六、用户输入和while 循环

使用函数input() 可以接受用户输入，让程序对其进行处理。使用while 循环让程序不断地运行，直到指定的条件不满足为止。

1、用户输入

函数input() 让程序暂停运行，等待用户输入一些文本。函数int() 来获取数值输入。获取用户输入后，Python将其存储在一个变量中，以方便使用。

message = input("Tell me something, and I will repeat it back to you: ")
print(message)

Tell me something, and I will repeat it back to you: Hello everyone!
Hello everyone!

有时候，提示可能超过一行，可将提示存储在一个变量中，再将该变量传递给函数input()。这样，即便提示超过一行，input() 语句也非常清晰。

prompt = "If you tell us who you are, we can personalize the messages you see."
prompt += "\nWhat is your first name? "

name = input(prompt)
print("\nHello, " + name + "!")

If you tell us who you are, we can personalize the messages you see.
What is your first name? Eric

Hello, Eric!

2、while 循环

for 循环用于针对集合中的每个元素都一个代码块，而while 循环不断地运行，直到指定的条件不满足为止。

current_number = 1
while current_number <= 5:
    print(current_number)
    current_number += 1

1
2
3
4
5

可使用while 循环让程序在用户愿意时不断地运行。我们在其中定义了一个退出值，只要用户输入的不是这个值，程序就接着运行：

prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
message = ""
while message != 'quit':
    message = input(prompt)
    print(message)

我们定义了一条提示消息，告诉用户他有两个选择：要么输入一条消息，要么输入退出值（这里为’quit’）。接下来，创建了一个变量——message，用于存储用户输入的值。将变量message 的初始值设置为空字符串""，让Python首次执行while 代码行时有可供检查的东西。 Python首次执行while 语句时，需要将message 的值与’quit’ 进行比较，但此时用户还没有输入。如果没有可供比较的东西，Python将无法继续运行程序。为解决这个问题， 我们必须给变量message 指定一个初始值。 虽然这个初始值只是一个空字符串，但符合要求，让Python能够执行while 循环所需的比较。只要message 的值不是’quit’，这个循环就会不断运行。

使用标志

在要求很多条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量被称为标志，充当了程序的交通信号灯。 让程序在标志为True 时继续运行，并在任何事件导致标志的值为False 时让程序停止运行。这样，在while 语句中就只需检查一个条件——标志的当前值是否为True，让程序变得更简洁。

prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
active = True
while active:
    message = input(prompt)
    if message == 'quit':
        active = False
    else:
        print(message)

使用break 退出循环

要立即退出while 循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用break 语句。 break 语句用于控制程序流程，可使用它来控制哪些代码行将执行，哪些代码行不执行，从而让程序按你的要求执行你要执行的代码。

prompt = "\nPlease enter the name of a city you have visited:"
prompt += "\n(Enter 'quit' when you are finished.) "
while True:
    city = input(prompt)
    if city == 'quit':
        break
    else:
        print("I'd love to go to " + city.title() + "!")

以while True 打头的循环将不断运行，直到遇到break 语句。

使用continue

要返回到循环开头， 并根据条件测试结果决定是否继续执行循环， 可使用continue 语句， 它不像break 语句那样不再执行余下的代码并退出整个循环。

current_number = 0
while current_number < 10:
    current_number += 1
    if current_number % 2 == 0:
        continue

    print(current_number)

我们首先将current_number 设置成了0，由于它小于10，Python进入while 循环。进入循环后，以步长1的方式往上数， 因此current_number 为1。接下来if 语句检查current_number 与2的求模运算结果。如果结果为0，就执行continue 语句，让Python忽略余下的代码，并返回到循环的开头。 如果当前的数字不能被2整除，就执行循环中余下的代码，Python将这个数字打印出来。

1
3
5
7
9

避免无限循环

每个while 循环都必须有停止运行的途径，这样才不会没完没了地执行下去。
例如：下面的循环从1数到5，若不小心遗留代码行 x += 1，这个循环将无休止的运行

x = 1
while x <= 5:
    print(x)
    x += 1

3、使用while 循环来处理列表和字典

for 循环是一种遍历列表的有效方式，但在for 循环中不应修改列表，否则将导致Python难以跟踪其中的元素。要在遍历列表的同时对其进行修改，可使用while 循环。通过将while 循环同列表和字典结合起来使用，可收集、存储并组织大量输入，供以后查看和显示。

在列表之间移动元素

假设有一个列表，其中包含新注册但还未验证的网站用户；验证这些用户后，将他们移到另一个已验证用户列表中。
一种办法是使用一个while 循环，在验证用户的同时将其从未验证用户列表中提取出来，再将其加入到另一个已验证用户列表中。

# 首先，创建一个待验证用户列表
# 和一个用于存储已验证用户的空列表
unconfirmed_users = ['alice', 'brian', 'candace']
confirmed_users = []
# 验证每个用户，直到没有未验证用户为止
# 将每个经过验证的列表都移到已验证用户列表中
while unconfirmed_users:
    current_user = unconfirmed_users.pop()
    print("Verifying user: " + current_user.title())
    confirmed_users.append(current_user)
# 显示所有已验证的用户
print("\nThe following users have been confirmed:")
for confirmed_user in confirmed_users:
    print(confirmed_user.title())

Verifying user: Candace
Verifying user: Brian
Verifying user: Alice
The following users have been confirmed:
Candace
Brian
Alice

使用用户输入来填充字典

可使用while循环提示用户输入任意数量的信息。下面来创建一个调查程序，其中的循环每次执行时都提示输入被调查者的名字和回答。我们将收集的数据存储在一个字典中，以便将回答同被调查者关联起来：

responses = {}
# 设置一个标志，指出调查是否继续
polling_active = True
while polling_active:
    # 提示输入被调查者的名字和回答
    name = input("\nWhat is your name? ")
    response = input("Which mountain would you like to climb someday? ")
    # 将答卷存储在字典中
    responses[name] = response
    # 看看是否还有人要参与调查
    repeat = input("Would you like to let another person respond? (yes/ no) ")
    if repeat == 'no':
        polling_active = False
# 调查结束， 显示结果
print("\n--- Poll Results ---")
for name, response in responses.items():
    print(name + " would like to climb " + response + ".")

这个程序首先定义了一个空字典responses，并设置了一个标志polling_active，用于指出调查是否继续。只要polling_active 为True，Python就运行while 循环中的代码。在这个循环中，提示用户输入其用户名及其喜欢爬哪座山。 将这些信息存储在字典responses，然后询问用户调查是否继续。如果用户输入yes，程序将再次进入while 循环；如果用户输入no，标志polling_active 将被设置为False，而while 循环将就此结束。