介绍Python基础，包括变量和简单数据类型、列表基础、操作列表、if语句、字典、输入函数和while循环

在文件名和文件夹名中，最好使用小写字母，并使用下划线来表示空格，因为这是Python采用的命名约定

如果输出的时间太长，按Ctrl + C停止输出，或关闭输出窗口

每当要运行Python代码片段时，都请打开一个命令窗口并启动Python终端会话。要关闭该终端会话，可按Ctrl + Z，再按回车键，也可执行命令exit() 。

python.org：浏览Python主页(http://python.org/)，寻找你感兴趣的主题。你对Python越熟悉，这个网站对你来说就越有用。

每个变量都存储了一个值——与变量相关联的信息。在程序中可随时修改变量的值，而Python将始终记录变量的最新值。

程序存在错误时，Python解释器将竭尽所能地帮助你找出问题所在。程序无法成功地运行时，解释器会提供一个traceback。traceback是一条记录，指出了解释器尝试运行代码时，在什么地方陷入了困境。

名称错误通常意味着两种情况：要么是使用变量前忘记了给它赋值，要么是输入变量名时拼写不正确。

方法是Python可对数据执行的操作。在name.title()中，name后面的句点(.)让Python对变量name执行方法title()指定的操作。每个方法后面都跟着一对括号，这是因为方法通常需要额外的信息来完成其工作。这种信息是在括号内提供的。函数title()不需要额外的信息，因此它后面的括号是空的。title()以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。

要将字符串改为全部大写或全部小写的处理方法：upper()、lower()。存储数据时，方法lower()很有用。很多时候，你无法依靠用户来提供正确的大小写，因此需要将字符串先转换为小写，再存储它们。以后需要显示这些信息时，再将其转换为最合适的大小写方式。

使用加号(+)来合并字符串。这种合并字符串的方法称为 拼接 。通过拼接，可使用存储在变量中的信息来创建完整的消息。

要在字符串中添加制表符，可使用字符组合\t，eg：print("\tPython")

要在字符串中添加换行符，可使用字符组合\n，eg：print("C\nJavaScript\n")

Python能够找出字符串开头和末尾多余的空白。要确保字符串末尾没有空白，可使用方法rstrip()。然而，这种删除只是暂时的，接下来再次询问 该变量的值时，你会发现这个字符串与输入时一样，依然包含多余的空白。要永久删除这个字符串中的空白，必须将删除操作的结果存回到变量中。你还可以剔除字符串开头的空白，或同时剔除字符串两端的空白。为此，可分别使用方法lstrip()和strip()：

使用两个乘号表示乘方运算，空格不影响Python计算表达式的方式，它们的存在旨在让你阅读代码时，能迅速确定先执行哪些运算。Python将带小数点的数字都称为浮点数。

但需要注意的是，结果包含的小数位数可能是不确定的：所有语言都存在这种问题，没有什么可担心的。Python会尽力找到一种方式，以尽可能精确地表示结果，但鉴于计算机内部表示数字的方式，这在有些情况下很难。就现在而言，

暂时忽略多余的小数位数即可。eg：>>> 0.2 + 0.1    0.30000000000000004

调用函数str()，Python将非字符串值表示为字符串：

Python社区的理念都包含在Tim Peters撰写的“Python之禅”中。要获悉这些有关编写优秀Python代码的指导原则，只需在解释器中执行命令import this。

列表

列表由一系列按特定顺序排列的元素组成。在Python中，用方括号([])来表示列表，并用逗号来分隔其中的元素。列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉Python即可。要访问列表元素，可指出列表的名称，再指出元素的索引，并将其放在方括号内。在Python中，第一个列表元素的索引为0，而不是1。Python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1，可让Python返回最后一个列表元素。

你创建的大多数列表都将是动态的，这意味着列表创建后，将随着程序的运行增删元素。要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。

方法append()将元素添加到了列表末尾，而不影响列表中的其他所有元素：eg: motorcycles.append('ducati')

方法insert()可在列表的任何位置添加新元素。需要指定新元素的索引和值。这种操作将列表中既有的每个元素都右移一个位置：eg: motorcycles.insert(0, 'ducati')

可以根据位置或值来删除列表中的元素。如果知道要删除的元素在列表中的位置，可使用del语句。eg：del motorcycles[0]使用del语句将值从列表中删除后，你就无法再访问它了。

方法pop()可删除列表末尾的元素，并让你能够接着使用它。术语弹出(pop)源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。eg: popped_motorcycle = motorcycles.pop()实际上也可以使用pop()来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。eg: first_owned = motorcycles.pop(0)每当使用pop()时，被弹出的元素就不再在原列表中了。

根据值删除元素，可使用方法remove()，在括号中写入要删除的值。方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。要删除的值可以存储在其他变量中，并被其他变量使用。

方法sort()永久性地修改了列表元素的排列顺序。按与字母顺序相反的顺序排列列表元素,只需向sort()方法传递参数reverse=True。eg: cars.sort(reverse=True)

函数sorted()能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。eg: sorted(cars)调用函数sorted()后，列表元素的排列顺序并没有变。如果要按与字母顺序相反的顺序显示列表，也可向函数sorted()传递参数reverse=True。

要反转列表元素的排列顺序，可使用方法reverse()。reverse()不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序：eg: cars.reverse()方法reverse()永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse()即可。

函数len()可快速获悉列表的长度。eg: len(cars)

操作列表

需要对列表中的每个元素都执行相同的操作时，可使用Python中的for循环。

eg: magicians = ['alice', 'david', 'carolina']

for magician in magicians: (从列表magicians中取出一个名字，并将其存储在变量magician中)

print(magician)

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

注意代码缩进错误

for语句末尾的冒号告诉Python，下一行是循环的第一行。

在数据可视化中，处理的几乎都是由数字(如温度、距离、人口数量、经度和纬度等)组成的集合，列表非常适合用于存储数字集合。

函数range()让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值(这里为5)。

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

print(value)

要创建数字列表，可使用函数list()将range()的结果直接转换为列表。如果将range()作为list()的参数，输出将为一个数字列表。

eg: numbers = list(range(1,6))

使用函数range()时，还可指定步长。在Python中，两个星号(**)表示乘方运算。

eg: even_numbers = list(range(2,11,2))

数字列表的最大值、最小值和总和：eg:min(digits)/ max(digits)/ sum(digits)

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

eg: squares = [value**2 for value in range(1,11)]表达式为value**2，它计算平方值。接下来，编写一个for循环，用于给表达式提供值，再加上右方括号。在这个示例中，for循环为for value in range(1,11)，它将值1~10提供给表达式value**2。

处理列表的部分元素——Python称之为切片

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

eg: players[0:3]如果你没有指定第一个索引，Python将自动从列表开头开始

如果要遍历列表的部分元素，可在for循环中使用切片。

eg: for player in players[:3]:

要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引([:])。

eg: friend_foods = my_foods[:]将my_foods已有的的副本存储到friend_foods，在其后对my_foods列表中元素的更改不会影响到friend_foods中的元素。

而friend_foods = my_foods则是让Python将新变量friend_foods关联到包含在my_foods中的列表，因此这两个变量都指向同一个列表，两个列表是相同的。

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组。试图修改元组的操作是被禁止的(eg : dimensions[0] = 250)

使用圆括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改前述矩形的尺寸，可重新定义整个元组：

eg : dimensions = (400, 100)将一个新元组存储到变量dimensions中

若要提出Python语言修改建议，需要编写Python改进提案 (Python Enhancement Proposal，PEP)。PEP 8是最古老的PEP之一，它向Python程序员提供了代码格式设置指南。

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

大多数条件测试都将一个变量的当前值同特定值进行比较。最简单的条件测试检查变量的值是否与特定值相等(==)：不等(!=)

eg: >>> car = 'bmw'

>>> car == 'bmw'

True首先使用一个等号将car的值设置为'bmw'，这种做法你已见过很多次。接下来，使用两个等号(==)检查car的值是否为'bmw'。这个相等运算符在它两边的值相等时返回True，否则返回False。在这个示例中，两边的值相等，因此Python返回True。

要检查是否两个条件都为True，可使用关键字and将两个条件测试合而为一。为改善可读性，可将每个测试都分别放在一对括号内，但并非必须这样做。

eg: (age_0 >= 21) and (age_1 >= 21)

关键字or也能够让你检查多个条件，但只要至少有一个条件满足，就能通过整个测试。

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

eg: >>> requested_toppings = ['mushrooms', 'onions', 'pineapple']

>>> 'mushrooms' in requested_toppings

True

还有些时候，确定特定的值未包含在列表中很重要；在这种情况下，可使用关键字not in。

eg: banned_users = ['andrew', 'carolina', 'david']

user = 'marie'

if user not in banned_users:

print(user.title() + ", you can post a response if you wish.")

布尔表达式 ，是条件测试的别名。与条件表达式一样，布尔表达式的结果要么为True，要么为False。

if-else语句if-elif-else结构测试通过后，Python将执行紧跟在它后面的代码，并跳过余下的测试。Python并不要求if-elif结构后面必须有else代码块。

else是一条包罗万象的语句，只要不满足任何if或elif中的条件测试，其中的代码就会执行，这可能会引入无效甚至恶意的数据。如果知道最终要测试的条件，应考虑使用一个elif代码块来代替else代码块。这样，你就可以肯定，仅当满足相应的条件时，你的代码才会执行。

有时候需检查你关心的所有条件。在这种情况下，应使用一系列不包含elif和else代码块的简单if语句。

eg: requested_toppings = ['mushrooms', 'extra cheese']

if 'mushrooms' in requested_toppings:

print("Adding mushrooms.")

if 'pepperoni' in requested_toppings:

print("Adding pepperoni.")

if 'extra cheese' in requested_toppings:

print("Adding extra cheese.")

print("\nFinished making your pizza!")

确定列表不是空的

eg: requested_toppings = []

if requested_toppings:在if语句中将列表名用在条件表达式中时，Python将在列表至少包含一个元素时返回True，并在列表为空时返回False。

for requested_topping in requested_toppings:

print("Adding " + requested_topping + ".")

print("\nFinished making your pizza!")

else:

print("Are you sure you want a plain pizza?")

对于requested_toppings中的每个元素，都检查它是否是比萨店供应的配料，再决定是否在比萨中添加它：

eg: available_toppings = ['mushrooms', 'olives', 'green peppers','pepperoni', 'pineapple', 'extra cheese']如果比萨店供应的配料是固定的，也可使用一个元组来存储它们。

requested_toppings = ['mushrooms', 'french fries', 'extra cheese']

for requested_topping in requested_toppings:

if requested_topping in available_toppings:

print("Adding " + requested_topping + ".")

else:

print("Sorry, we don't have " + requested_topping + ".")

print("\nFinished making your pizza!")

在条件测试的格式设置方面，PEP 8提供的唯一建议是，在诸如==、>=和<=等比较运算符两边各添加一个空格，

在Python中，字典是一系列键—值对 。每个键都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。在Python中，字典用放在花括号{}中的一系列键—值对表示，键—值对是两个相关联的值。指定键时，Python将返回与之相关联的值。键和值之间用冒号分隔，而键—值对之间用逗号分隔。在字典中，你想存储多少个键—值对都可以，最简单的字典只有一个键—值对。

eg:alien_0 = {'color': 'green', 'points': 5}

print(alien_0['color'])

print(alien_0['points'])

要获取与键相关联的值，可依次指定字典名和放在方括号内的键。

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

添加键—值对

eg: alien_0 = {'color': 'green', 'points': 5}

alien_0['x_position'] = 0

alien_0['y_position'] = 25

键—值对的排列顺序与添加顺序不同。Python不关心键—值对的添加顺序，而只关心键和值之间的关联关系。

可先使用一对空的花括号定义一个空字典，再分行添加各个键—值对。

eg: alien_0 = {}

alien_0['color'] = 'green'

alien_0['points'] = 5

使用字典来存储用户提供的数据或在编写能自动生成大量键—值对的代码时，通常都需要先定义一个空字典。

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

eg: alien_0 = {'x_position': 0, 'y_position': 25, 'speed': 'medium'}

print("Original x-position: " + str(alien_0['x_position']))

#向右移动外星人

#据外星人当前速度决定将其移动多远

if alien_0['speed'] == 'slow':

x_increment = 1

elif alien_0['speed'] == 'medium':

x_increment = 2

else:

#这个外星人的速度一定很快

x_increment = 3

#新位置等于老位置加上增量

alien_0['x_position'] = alien_0['x_position'] + x_increment

print("New x-position: " + str(alien_0['x_position']))通过修改外星人字典中的值，可改变外星人的行为。

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

eg: alien_0 = {'color': 'green', 'points': 5}

del alien_0['points']注意 删除的键 — 值对永远消失了。

字典可以存储一个对象(如游戏中的一个外星人)的多种信息，但你也可以使用字典来存储众多对象的同一种信息。确定需要使用多行来定义字典时，在输入左花括号后按回车键，再在下一行缩进四个空格，指定第一个键—值对，并在它后面加上一个逗号。

eg: favorite_languages = {

'jen': 'python',

'sarah': 'c',

'edward': 'ruby',

'phil': 'python',

}在最后一个键—值对后面加上逗号，为以后在下一行添加键—值对做好准备。

将较长的print语句分成多行, 按回车键进入print语句的后续各行，并使用Tab键将它们对齐并缩进一级。在print语句的最后一行末尾加上右括号。

遍历所有的键—值对

eg: user_0 = {

'username': 'efermi',

'first': 'enrico',

'last': 'fermi',

}

for key, value in user_0.items():

print("\nKey: " + key)

print("Value: " + value)

编写用于遍历字典的for循环，可声明两个变量，用于存储键—值对中的键和值。对于这两个变量，可使用任何名称。for语句的第二部分包含字典名和方法items()，它返回一个键—值对列表。接下来，for循环依次将每个键—值对存储到指定的两个变量中。

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

在不需要使用字典中的值时，方法keys()很有用。

eg: for name in favorite_languages.keys():代码行让Python提取字典favorite_languages中的所有键，并依次将它们存储到变量name中。

遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for name in favorite_languages.keys():替换为for name in favorite_languages:，输出将不变。

eg: favorite_languages = {

'jen': 'python',

'sarah': 'c',

'edward': 'ruby',

'phil': 'python',

}

friends = ['phil', 'sarah']

for name in favorite_languages.keys():

print(name.title())

if name in friends:

print(" Hi " + name.title() +

", I see your favorite language is " +

favorite_languages[name].title() + "!")

方法keys()并非只能用于遍历；实际上，它返回一个列表，其中包含字典中的所有键，eg: if  'erin'  not  in  favorite_ languages.keys():

按顺序遍历字典中的所有键

字典总是明确地记录键和值之间的关联关系，但获取字典的元素时，获取顺序是不可预测的。一种办法是在for循环中对返回的键进行排序。为此，可使用函数sorted()来获得按特定顺序排列的键列表的副本：

eg: favorite_languages = {

'jen': 'python',

'sarah': 'c',

'edward': 'ruby',

'phil': 'python',

}

for name in sorted(favorite_languages.keys()):

print(name.title() + ", thank you for taking the poll.")

遍历字典中的所有值

使用方法values()，它返回一个值列表，而不包含任何键。

eg: for language in favorite_languages.values():

这种做法提取字典中所有的值，而没有考虑是否重复。为剔除重复项，可使用集合(set)。集合类似于列表，但每个元素都必须是独一无二的：

eg:for language in set(favorite_languages.values()):

通过对包含重复元素的列表调用set()，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。

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

字典列表

eg: 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]

for alien in aliens:

print(alien)创建一个外星人列表，其中每个外星人都是一个字典，包含有关该外星人的各种信息。

eg: #创建一个用于存储外星人的空列表每个外星人都是使用代码自动生成, 可以使用for循环和if语句来修改某些外星人的颜色。

aliens = []

#创建30个绿色的外星人

for alien_number in range(30):

new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}

aliens.append(new_alien)

for alien in aliens[0:3]:

if alien['color'] == 'green':

alien['color'] = 'yellow'

alien['speed'] = 'medium'

alien['points'] = 10

#显示前五个外星人

for alien in aliens[:5]:

print(alien)

print("...")

#显示创建了多少个外星人

print("Total number of aliens: " + str(len(aliens)))

在字典中存储列表

每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表。

eg: favorite_languages = {

'jen': ['python', 'ruby'],

'sarah': ['c'],

'edward': ['ruby', 'go'],

'phil': ['python', 'haskell'],

}

for name, languages in favorite_languages.items():

print("\n" + name.title() + "'s favorite languages are:")

for language in languages:

print("\t" + language.title())   ’ \t’制表符，Tab

为进一步改进这个程序，可在遍历字典的for循环开头添加一条if语句，通过查看len(languages)的值来确定当前的被调查者喜欢的语言是否有多种。如果他喜欢的语言有多种，就像以前一样显示输出；如果只有一种，就相应修改输出的措辞，如显示Sarah's favorite language is C。

注意 列表和字典的嵌套层级不应太多。如果嵌套层级比前面的示例多得多，很可能有更简单的解决问题的方案。

在字典中存储字典

例如，如果有多个网站用户，每个都有独特的用户名，可在字典中将用户名作为键，然后将每位用户的信息存储在一个字典中，并将该字典作为与用户名相关联的值。

eg: 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())

注意，表示每位用户的字典的结构都相同，虽然Python并没有这样的要求，但这使得嵌套的字典处理起来更容易。倘若表示每位用户的字典都包含不同的键，for循环内部的代码将更复杂。

输入函数input()，通过获取用户输入并学会控制程序的运行时间，可编写出交互式程序。函数input()让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在一个变量中。

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

print(message)通过在提示末尾(这里是冒号后面)包含一个空格，可将提示与用户输入分开，让用户清楚地知道其输入始于何处，

函数input()接受一个参数：即要向用户显示的 提示 或说明，让用户知道该如何做。程序等待用户输入，并在用户按回车键后继续运行。输入存储在变量message中。

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

eg: 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 + "!")

使用函数input()时，Python将用户输入解读为字符串。函数int()将数字的字符串表示转换为数值表示。将数值输入用于计算和比较前，务必将其转换为数值表示。

求模运算符(%)将两个数相除并返回余数，可利用这一点来判断一个数是奇数还是偶数：

如果你使用的是Python 2.7，应使用函数raw_input()来提示用户输入。这个函数与Python 3中的input()一样，也将输入解读为字符串。Python 2.7也包含函数input()，但它将用户输入解读为Python代码，并尝试运行它们。

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

如使用while循环来数数

eg: current_number = 1

while current_number <= 5:

print(current_number)

current_number += 1

例如，游戏使用while循环，确保在玩家想玩时不断运行，并在玩家想退出时停止运行。

eg: 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)

if message != 'quit':

print(message)

在要求很多条件都满足才继续运行的程序中(例如，在游戏中，多种事件都可能导致游戏结束)，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量被称为标志 ，充当了程序的交通信号灯。你可让程序在标志为True时继续运行，并在任何事件导致标志的值为False时让程序停止运行。这样，在while语句中就只需检查一个条件——标志的当前值是否为True，并将所有测试(是否发生了应将标志设置为False的事件)都放在其他地方，从而让程序变得更为整洁。

eg: 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)

在复杂的程序中，如很多事件都会导致程序停止运行的游戏中，标志很有

用：在其中的任何一个事件导致活动标志变成False时，主游戏循环将退出，此时可显示一条游戏结束消息，并让用户选择是否要重新玩。

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

哪些代码行不执行，从而让程序按你的要求执行你要执行的代码。

eg: 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() + "!")

注意 在任何Python循环中都可使用break语句。例如，可使用break语句来退出遍历列表或字典的for循环。

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

eg: current_number = 0

while current_number < 10:

current_number += 1

if current_number % 2 == 0:

continue

print(current_number)如从1数到10，但只打印其中奇数的循环

如果程序陷入无限循环，可按Ctrl + C，也可关闭显示程序输出的终端窗口。要避免编写无限循环，务必对每个while循环进行测试，确保它按预期那样结束。如果你希望程序在用户输入特定值时结束，可运行程序并输入这样的值；如果在这种情况下程序没有结束，请检查程序处理这个值的方式，确认程序至少有一个这样的地方能让循环条件为False或让break语句得以执行。

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

使用一个while循环，在验证用户的同时将其从未验证用户列表中提取出来，再将其加入到另一个已验证用户列表中。

eg:  #首先，创建一个待验证用户列表

#和一个用于存储已验证用户的空列表

unconfirmed_users = ['alice', 'brian', 'candace']

confirmed_users = []

#验证每个用户，直到没有未验证用户为止

#将每个经过验证的列表都移到已验证用户列表中

while unconfirmed_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())

删除包含特定值的所有列表元素

eg: pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']

print(pets)

while 'cat' in pets:

pets.remove('cat')

print(pets)

使用用户输入来填充字典，可使用while循环提示用户输入任意数量的信息。

eg: 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 + ".")