目录
一、列表是什么
列表是由一系列特定顺序排列的元素组成。你可以创建包含字母表中所有字母，数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。鉴于列表通常包含多个元素，给列表指定一个表示复数的名称(如letters、digits或names)是个不错的主意。
在python中，用方括号([ ])来表示列表，并用逗号来分隔其中的元素。下面是一个简单的列表表示例，这个列表包含几种自行车：
bicycles.py
bicycle = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)如果你让python将列表打印出来，python将打印列表的内容表示，包括方括号：
['trek', 'cannondale', 'redline', 'specialized']
鉴于这不是你要让用户看到的输出，下面来学习如何访问列表元素。
1、访问列表元素
列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉python告诉即可。要访问列表元素，可指出列表的名称，再指出元素的索引，并将其放在方括号内。
例如，下面的代码从列表bicycles中提取第一款自行车：
bicycle = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[0])当你请求获取列表元素时，python只返回该元素，而不包括方括号和索引号：
trek
这正是你要让用户看到的结果------整洁、干净的输出。
2、索引从0而不是1开始
在python中，第一个列表元素的索引为0，而不是1。在大多数编程语言中都是如此，这与列表操作的底层实现相关。如果结果出乎意料，请看看你是否犯了简单的差一错误。第二个列表元素的索引为1.个结局这种简单的计数方式，要访问列表中的任何元素，都可以将其位置减1，并将结果作为索引。例如，要访问第四个列表元素，可使用索引3。
下面的代码访问索引1和3处的自行车：
bicycle = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[1])
print(bicycles[3])这些代码返回列表中的第二个和死四个元素：
cannondale
specialized
python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1，可让python返回最后一个列表元素：
bicycle = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[-1])这些代码返回'specilized'。这种语法很有用，因为你经常需要在不知道列表的情况下访问最后的元素。这种约定也适用于其他负数索引，例如，索引-2返回倒数第二个元素，索引-3返回倒数第三个列表元素，以此类推。
3、使用列表中的各个值
可像使用其他变量一样使用列表中的各个值。例如，你可以使用拼接根据列表中的值来创建消息。
bicycle = ['trek', 'cannondale', 'redline', 'specialized']
message = “My first bicycle was a ” + bicycle[0].title() + "."
print(message)使用bicycle[0]的值生成了一个句子，并将其存储在变量message中。输出是一个简单的句子，其中包含列表中的第一款自行车：
My first bicycle was a Trek.
二、修改、添加和删除元素
创建的大多数列表都将是动态的，这意味着列表创建后，将随着程序的运行增删元素。例如，你创建一个游戏，要求玩家射杀从天而降的外星人；为此，可在开始时将一些外星人存储在列表中，然后每当有外星人被射杀时，都将其从列表中删除，而每次有新的外星人出现在屏幕上时，都将其添加到列表中。在整个游戏运行期间，外星人的长度将不断变化。
1、修改列表元素
修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。例如，假设有一个摩托车列表，其中的第一个元素为'honda'，如何修改它的值呢？
motorcycles.py
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcyles)
motorcycles[0] = 'ducati'
print(motorcycles)首先定义一个摩托车列表，其中的第一个元素为'honda'。接下来，将第一个元素的值改为'ducati'。输出表明，第一个元素的值确实变了，但其他列表元素的值没有：
['honda', 'yamaha', 'suzuki']
['ducati', 'yamaha', 'suzuki']
你可以修改任何列元素的值，而不仅仅是第一个元素的值。
2、在列表中添加元素
你可能出于众多原因要在列表中添加新元素，例如，你可能希望游戏中出现新的外星人、添加可视化数据或给王振添加新注册的用户。python提供了多种在既有列表中添加新数据的方式。
1、列表末尾添加元素
在列表中添加新元素时，最简单的方式是将元素附加到列表末尾。给列表附加元素时，它将添加到列表末尾。继续使用前一个示例中的列表，期末未添加新元'ducati'：
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles.append('ducati')
print(motorcycles)方法append( )将元素'ducati'添加到了列表末尾，而不影响列表中的其他所有元素：
['honda', 'yamaha', 'suzuki', 'ducati']
['ducati']
方法append( )让动态地创建列表易如反掌，例如，你可以先创建一个空列表。再使用一系列的append( )语句添加元素。下面来创建一个空列表，再在其中添加元素'honda', 'yamaha',和'suzuki'：
motorcycles = []
motorcycles.append('honda')
motorcycles.append('yamaha')
motorcycles.append('suzuki')
print(motorcycles)['honda', 'yamaha', 'suzuki']
这种创建列表的方式及其常见，因为经常要等待程序运行后，你才知道用户要在程序中存储哪些数据。为控制用户，可首先创建一个空列表，用于存储用户将要输入的值，然后将用户提供的每个新值附加到列表中。
2、在列表中插入元素
motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.insert(0, 'ducati')
print(motorcycles)在这个示例中，值'ducati'被插入到了列表开头；方法insert( )在索引0处添加空间，并将值'ducati'存储到这个地方。这种操作将列表中既有的每个元素都右移一个位置：
[‘ducati’, 'honda', 'yamaha', 'suzuki']
3、从列表中删除元素
你经常需要从列表中山狐一个或多个元素。例如，玩家将空中的一个外星人射杀后，你很可能要将其从存货的外星人列表中杉树；当用户在你创建的WEb应用中注销其账户时，你需要将该用户从活跃用户列表中删除。你可以根据位置或值来删除列表洪的元素。
1.使用del语句删除元素
如果你知道要删除的元素在列表中的位置迈克适用del语句。
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[0]
print(motorcycles)del处的代码使用del删除了列表motorcycles中的第一个元素------'honda'：
['honda', 'yamaha', 'suzuki']
['yamaha', 'suzuki']
使用del语句可删除任何设置处的列表元素，条件是知道其索引。下例演示了如何删除前述列表中的第二个元素------'yamaha'：
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[1]
print(motorcycles)['honda', 'yamaha', 'suzuki']
['honda', 'suzuki']
在这两个示例中，使用de语句将值从列表中删除后，你就无法再访问它了。
2、使用方法pop删除元素
有时候，你要将元素从列表中删除，并接着使用它的值。例如，你可能需要获取刚被射杀的外星人的x和y坐标，以以便在相应的位置显示爆炸效果；在Web应用程序中，你可能要将用户从活跃成员列表中删除，并将其加入到非活跃成员列表中。
方法pop( )可删除列表末尾的元素，并让你能够接着用它。属于弹出(pop)源自这样的类比：列表就一个栈，而删除列表末尾的元素相当于弹出栈顶元素。
下面从列表motorcycles中弹出一款摩托车：
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
poped_motorcycle = motorcycles.pop( )
print(motorcycles)
print(poped_motorcycle)首先定义并打印了列表motorcycles。接下来，从这个列表中弹出一个值，并将其存储带变量poped_motorcycles中。然后打印这个列表，以核实从其中删除了一个值。最后，打印弹出的值，以证明我们依然能够访问被删除的值。
输出表明，列表末尾的值'suzuki'已删除，它现在存储在变量poped_motorcycles中：
['honda', 'yamaha', 'suzuki']
['honda', 'suzuki']
suzuki
方法pop( )是怎么起作用的呢？假设列表中的摩托车是按购买时间存储的，就可以使用方法pop( )打印一条消息，指出最后购买的是哪款摩托车：
motorcycles = ['honda', 'yamaha', 'suzuki']
last_owned = motorcycles.pop( )
print("The last motorcycle I owned was a "+ last_owned.title( ) + ".")输出是一个简单的句子，指出了最新购买的是哪款摩托车：
The last motorcycles I owned was a Suzuki
3、弹出列表中的人位置处的元素
实际上，你可以使用pop( )来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。
motorcycles = ['honda', 'yamaha', 'suzuki']
first_owned = motorcycles.pop(0)
print('The first motorcycles I owned was a ' + first_owned.title( ) + '.')首先，弹出了一个列表中的第一款摩托车，然后打印了一条有关这两摩托车的消息。输出的是一个简单的句子，描述我购买的第一辆摩托车：
The first motorcycles I owned was a Honda.
别忘了，每当你使用pop( )时，被弹出的元素就不再在列表中了。如果你不确定该使用del语句还是pop( )方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要删除元素后还能继续使用它，就使用方法pop( )。
4、根据值删除元素
有时候，你不知道要从列表中删除的值所在的位置。如果你只知道要删除的元素的值，可使用方法remove( )。
例如，假设我们要从列表motorcycles中删除值'ducati'。
motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles)
motorcycles.remove('ducati')
print(motorcycles)['honda', 'yamaha', 'suzuki', 'ducati']
['honda', 'yamaha', 'suzuki']
使用remove( )从列表删除元素时，也可接着使用它的值。下面删除值'ducati'，并打印一条消息，指出要将其从列表中删除的原因：
motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles)
too.expensive = 'ducati'
matorcycles.remove(too_expensive)
print(motorcycles)
print("\nA " + too_expensive.title() + " is too expensive for me.")定义列表后，将值'ducati'存储在变量too_expensive中。接下来，使用这个变量来告诉python将哪个值从列表中删除。最后，值'ducati'已经从列表中删除，但它还存储在变量too_expensive中，让我们能够打印一条消息，指出将'dacati'从列表motorcycles中删除的原因:：
['honda', 'yamaha', 'suzuki', 'ducati']
['honda', 'yamaha', 'suzuki']
A Ducati is too expensive for me.
注意：方法remove( )只删除第一个指定的值。如果要删除的值可能在列表洪出现多次，就需要使用循环来判断是否删除了所有这样的值。
三、组织列表
在你创建的列表中，元素的排列顺序常常是无法预测的，因为你并非总能控制用户提供数据的顺序。这虽然在大多数情况下是不可避免的，但你经常需要以特定顺序呈现信息。有时候，你希望保留列表元素最初的排列顺序，而有时候又需要调整排列顺序。python提供很多组织列表的方式，可根据具体情况选用。
1、使用sort( )对列表进行永久性排序
python方法sort( )让你能够较为轻松地对列表进行排序。假设你有一个汽车列表，并要让其中的汽车按字母顺序排列。魏建华这项任务，假设该列表中的所有值都是小写的。
cars.py
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)方法sort()永久性的修改了列表元素的排列顺序。现在，汽车是按字母顺序排列的，再也无法恢复到原来的排列顺序：
['bmw', 'audi', 'toyota', 'subaru']
还可以按与字母顺序相反的顺序排列元素，为此，只需向sort()方法传递参数reverse=True。下面的实例将汽车列表按与字母顺序相反的顺序排列：
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort(reverse = True)
print(cars)同样，对列表元素排列顺序的修改是永久性的：
['subaru', 'toyota','audi','bmw']
2.使用函数sorted()对列表进行临时排序
要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted( )。函数sorted( )让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排序。
下面尝试对汽车列表调用这个函数。
cars = ['bmw', 'audi', 'toyota', 'subaru']
print("Here is the original list: ")
print(cars)
print("\nHere is the sorted list: ")
print(sorted(cars))
print("\nHere is the original list again: ")
print(cars)首先按原始顺序打印列表，再按字母顺序显示列表，然后以特定顺序显示列表后，进行核实，确认列表元素的排列顺序与以前相同。
Here is the original list:
['bmw', 'audi', 'toyota', 'subaru']
Here is the sorted list:
['audi', 'bmw', 'subaru', 'toyoto']
Here is the original list again:
['bmw', 'audi', 'toyota', 'subaru']
调用函数sorted( )后列表元素的排列顺序并没有变。如果你要按与字母顺序相反的顺序显示列表，也可向函数sorted()传递参数reverse = True。
注意：并非 所有的值都是小写的，按字母顺序排列列表要复杂些。决定排列顺序时，有多种解读大写字母的方式，要制定准确的排列顺序，肯能比我们这里所做的复杂些。然而，大多数排序方式都是基于此。
3.倒着打印列表
要反转打印列表的排列顺序，可使用方法reverse()。假设汽车列表是按购买时间排列的，可轻松地按相反顺序排列其中的汽车：
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.reverse()
print(cars)
注意，reverse( )不是按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序：
['bmw', 'audi', 'toyota', 'subaru']
['subaru', 'toyota', 'audi', 'bmw']
方法reverse( )永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表元素再次调用reverse( )即可。
4.确定列表的长度
使用函数len( )可快速获悉列表的长度。在下面的示例中，列表包含四个元素，因此其长度为4：
>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> len(cars)
4python计算列表元素时从1，开始，因此确定列表长度时，你应该不会遇到一点差错。
四、使用列表时避免索引错误
刚开始使用列表时，经常遇到一种错误。假设你有一个包含三个元素的列表，却要求获取第四个元素：
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles[3])这将导致索引错误：
Traceback (most recent call last) :
File "motorcycles.py", line 3, in <module>
print(motorcycles[3])
IndexError: list index out of range
python试图调用向你提供于索引3处的元素，但它搜索列表motorcylcles时，却发现索引3处没有元素。鉴于列表索引差一的特恒，这种错误很常见。有些人从1开始数，因此以为第三个元素的索引为3；但在python中，第三个元素的索引为2，因为索引是从0开始的。
索引错误意味着python无法理解你指定的索引。程序发生索引错误时，请尝试将你指定的索引减1，然后再次运行程序，看看结果是否正确。别忘了，每当需要访问最后一个列表元素时，都可使用索引-1.这在任何情况下都行之有效，即便你最后一次访问列表后，其长度发生了变化：
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles[-1])
索引-1总是返回最后一个列表元素，这里值为'suzuki'：
'suzuki'
金当列表为空时，这种访问最后一个元素的方式才会导致错误：
motorcycles = []
print(motorcycles[-1])列表motorcycles不包含任何元素，因此python返回一条索引错误消息：
Traceback (most recent call last):
File "motorcycles.py", line 3, in <module>
print(motorcycles[-1])
IndexError: list index out of range
发生索引错误却找不到解决办法时，请尝试将列表或其长度打印出来。列表可能与你以为的截然不同，在程序对其进行了动态处理时。通过查看列表或其包含的元素数，可帮助你找出这种逻辑错误。
五、遍历整个列表
你经常需要遍历列表的所有元素，对每个元素执行相同的操作。例如，在游戏中，可能需要将每个界面元素平移相同的距离；对于包含数字的列表，可能需要对每个元素执行相同的统计运算；在网站中，可能需要显示文章列表中的每个标题。需要对列表中的每个元素都执行相同的操作时，可使用python中的for循环。
假设有一个魔术师名单，需要将其中每个魔术师的名字都打印出来。为此，可以分别获取名单中的每个名字，但这种做法会导致多个问题。例如，如果名单很长，将包含大量重复的代码。另外，当名单的长度发生变化时，都必须修改代码。通过使用for循环，可让python去处理这些问题。
magicians.py
magicians = ['alice', 'divid', 'carolina']
for magician in magicians:
print(magician)首先定义一个列表，定义了一个for循环，这行代码让python从列表magicians中取出一个名字，并将其存储在变量magicians中。最后，让python打印前面存储到变量magician中的名字。这样，对于列表中的每个名字，python都将重复执行for处的代码。可以这样解读这些代码：对于列表magicians中的每位魔术师，都将其名字打印出来。输出很简单，就是列表中所有的姓名：
alice
david
carolina
1、深入的研究循环
循环这种概念很重要，因为它是让计算机自动完成重复工作的常见方式之一。例如，在下面的magician.py中使用的简单循环中，python将首先读取其中的第一行代码：
for magician in magicians:这行代码让python获取列表magicians中的第一个值('alice')，并将其存储到变量magician中。接下来，python读取下一行代码：
print(magician)它让python打印magician的值------依然是'alice'。鉴于该列表还包含其他值，python返回到循环的第一行：
for magician in magicians:python获取列表中的下一个名字------'david'，并将其存储到变量magicians中，再执行下面这行代码：
print(magician)python再次打印变量magicians的值------当前为'david'。接下来，python再次执行整个循环，对列表中的最后一个值------'carolina'进行处理。至此，列表中没有其他的值了，因此python接着执行程序的西一行代码。在这个示例中，for循环后面没有其他的代码，因此程序就此结束。
刚开始使用循环时请牢记，对列表中的每个元素，都执行循环指定的步骤，而不管列表包含多少元素。如果列表包含一百万个元素，python就重复执行指定步骤一百万次，且通常速度非常快。另外，编写for循环时，对于用于存储列表中每个值的临时变量，可指定任何名称。然而，选择描述单个列表元素的有意义的名称大有帮助。例如，对于小猫列表、小狗列表，向下面这样编写for循环的第一行代码是不错的选择：
for cat in cats
for dog in dogs
for item in items这些命名约定有助于让你明白for循环中将对每个元素执行的操作。使用单数和复数式名称，可帮助你判断代码段处理的是耽搁列表元素还是整个列表。
2、在for循环中执行简单的操作
在for循环中，可对每个元素执行任何操作。下面来扩展前面的示例，对于每位魔术师，都打印一条消息，指出他的表演太精彩了。
magicians = ['alice', 'david', 'carolina']
for magician in magicians:
print(magician.title() + ", that was a great trick!")相比于前一个示例，唯一不同的是，都打印了一条以其名字为抬头的消息。这个循环第一次迭代时，变量magicians的值为'alice'，因此python打印的第一条消息的抬头为'Alice'。第二次迭代时，消息的抬头为'David'，而第三次迭代时，抬头为'Carolina'。
Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!
在for循环中，想包含多少航代码都可以。在代码行for magician in magicians后面，每个缩进的代码行都是循环的一部分，且将针对列表中的每个值都执行一次。因此，可对列表中的每个值执行任意次数的操作。
下面再添加一行代码，告诉每位魔术师，期待他的下一次表演：
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语句都缩进了，因此他们都将针对列表中的每位魔术师执行一次。第二条print语句中的换行符"\n"在每次迭代结束后都插入一个空行，从而整洁地针对各位魔术师的消息编组：
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!
在for循环中，想包含多少行代码都可以。实际上，你会发现使用for循环对每个元素执行众多不同的操作很有用。
3、在for循环结束后执行一些操作
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!
使用for循环处理数据时一种对数据集执行整体操作的不错的方式。例如，你可能使用for循环来初始化游戏------遍历角色列表，将每个角色都显示到屏幕上；再在循环后面添加一个不缩进的代码块，屏幕上绘制所有角色后显示一个Play Now按钮。
六、避免缩进错误
python根据缩进来判断代码行与前一个代码行的关系。在前面的示例中，向各位魔术师显示消息的代码行是for循环的一部分，因为它们缩进了。python通过使用缩进让代码更易读；简单地说，它要求你使用缩进让代码整洁而结构清晰。在脚上的python程序中，你将看到缩进程度各不相同的代码块，这让你对程序的组织结构有大致的认识。
当你开始编写必须正确缩进的代码时，需要注意一些常见的缩进错误。例如，有时候，程序员会将不需要缩进的代码块缩进，而对于必须缩进的代码块却忘了缩进。通过查看这样的错误示例，有助于你以后避开它们，以及它们出现在程序中时进行修复。
1、忘记缩进
对于位于for语句后面且属于循环组成部分的代码行，一定要缩进。如果你忘记缩进，python会提醒你：
magicians.py
magicians = ['alice', 'david', 'carolina']
for magician in magcians
print(magician)print语句应缩进却没有缩进。python没有找到期望缩进的代码块时，会让你知道哪行代码有问题。
File "magicians.py", line3
print(magician)
^
IndentationError:expected an indented block
通常，将紧跟在for语句后面的代码行缩进，可消除这种缩进错误。
2、忘记缩进额外的代码行
有时候，循环能够运行而不会报告错误，但结果可能会出乎意料。试图在循环中执行多项任务，且忘记缩进其中的一些代码行时，就会出现这种情况。
例如，如果忘记缩进循环中的第二行代码(它告诉每位魔术师，我们期待他的第一次表演)，就会出现这种情况：
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语句原本要缩进，但python发现语句后面有一行代码时缩进的，因此它没有报告错误。最终的结果是，对于列表中的每位魔术师，都执行了第一条print语句，因为它缩进了；而第二条print语句没有缩进，因此它只在循环结束后执行一次。由于变量magician的终值为'carolina'，因此只有她收到了消息“looking forward to the next trick”：
Alice, that was a great trick!
David, that was a great trick!
Carolina, that was a great trick!
I can't wait to see your next trick, Carolina!
这是一个逻辑错误。从语法上看，这些python代码时合法的，但由于存在逻辑错误，结果并不符合预期。如果你预期某项操作将针对每个列表元素都执行一次，但它却只执行了，请确定是否需要将一行或多行代码缩进。
3、不必要的缩进
如果你不小心缩进了无需缩进的代码行，python将指出这一点：
hello_world.py
message = "Hello Python world!"
print(messgae)print语句无需缩进，因为它并不属于前一行代码，因此Python将指出这种错误：
File "hello_world.py", line2
print(message)^
IndentationError: unexpected indent
为避免意外缩进错误，请只缩进需要缩进的代码，只有要在for循环中对每个元素执行的代码需要缩进。
4、循环后不必要的缩进
如果你不小心缩进了应在循环结束后执行的代码，这些代码将针对每个列表元素重复执行。在有些情况下，这可能导致python报告语法错误，但在大多数情况下，这只会导致逻辑错误。
例如，如果不小心缩进了感谢全体魔术师精彩表演的代码行，结果将如何呢？
magicians = ['alice', 'david', 'carolina']
for magician in magician:
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!Thank you, everyone. That was a great magic show!
David, that was a great trick!
I can't wait to see your next trick, David!
Thank you, everyone. That was a great magic show!
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不知道你的本意，只要代码符合语法，它就会运行。如果原本知应执行一次的操作执行了多次，请确定你是否应该缩进执行该操作的代码。
5、遗漏了冒号
for语句末尾的冒号告诉python，下一行是循环的第一行。
magicians = ['alice', 'david', 'carolina']
for magician in magicians
print(magician)如果你不小心遗漏了冒号，将导致语法错误，因为python不知道你意欲何为。这种语法错误虽然易于消除，但并不那么容易发现。程序员为找出这样的单字符错误，花费的时间多得令人惊讶。这样的错误之所以难发现，是因为通常在我们的意料之外。
七、创建数值列表
需要存储一组数字的原因有很多，例如，在游戏中，需要跟踪每个角色的位置，还可能需要跟踪玩家的几个最高分。在数据可视化中，处理的几乎都是是由数字(如温度、距离、人口数量、经度和维度等)组成的集合。列表非常适合用于存储数字集合，而python提供了很多工具，可帮助你高效地处理数字列表。明白如何有效地使用这些工具后，即便列表包含数百万个元素，你编写的代码也能运行得很好。
1、使用函数range( )
python函数range()让你能够很轻松送地生成一系列数字。例如，可以像下面这样使用函数range( )来打印一系列数字：
numbers.py
for value in range(1,5):
print(value)上述代码好像应该打印数字1~5，但实际上它不会打印数字5：
1
2
3
4
在这个示例中，range( )只是打印数字1~4，这是你在编程语言中经常看到的差一行为的结果。函数range( )让python从你指定的第一个值，并在到达你指定的第二值后停止，因此输出不包含第二个值(这里为5)。
要打印数字1~5，需要使用range(1, 6):
for value in range(1,6):
print(value)这样，输出将从1开始，到5结束：
1
2
3
4
5
使用range( )时，如果输出不符合预期，请尝试将指定的值加1或减1.
2、使用range( )创建数字列表
要创建数字列表，可使用函数list( )将range( )的结果直接转换为列表。如果将range( )作为list( )的参数，输出将为一个数字列表。
要将数字换换为列表，可使用list( )：
numbers = list(range(1,6))
print(numbers)结果如下：
[1, 2, 3, 4, 5]
使用函数range( )时，还可指定步长。例如，下面的代码打印1~10内的偶数：
even_numbers.py
even_numbers = list(range(2,11,2))
print(even_numbers)在这个示例中，函数range( )从2开始数，然后不断加2，直到达到或超过终值(11)，因此输出如下：
[2, 4, 6, 8, 10]
使用函数range( )几乎能够创建任何需要的数字集，例如，如何创建一个列表，其中包含前10个参数(即1~10)的平方呢？在python中，两个星号(**)表示乘方运算。下面的代码演示了如何将前10个整数的平方加入到一个列表中：
square.py
squares = []
for value in range(1, 11):
square = value**2
square.append(square)
print(squares)首先创建了一个空列表，接下来使用函数range( )让python遍历1~10的值。在循环中，计算当前值的平方，并将结果存储到变量aquare中。然后，将新计算得到的平放置附加到列表squares末尾。最后，循环结束后，打印列表squares：
[1, 4, 9, 16, 25, 46, 49, 64, 81, 100]
为让这些代码更简洁，可不使用临时变量square，而直接将每个计算得到的值附加到列表末尾：
squares = [ ]
for value i nrange(1,11):
squares.qppend(value**)
print(squares)在循环中，计算每个值的平方，并立即将结果附加到列表squares的末尾。创建更复杂的列表是，可使用上述两种方法中的任何一种。有时候，使用临时变量会让代码更易读；而在其他情况下，这样只会让代码无谓地变长。你首先应该考虑的是，编写清晰易懂且能完成所需功能的代码；等到审核代码时，再考虑更高效的方法。
3、对数字列表执行简单的统计计算
有几个专门用于处理数字列表的python函数。例如，你可以轻松地找出数字列表的最大值、最小值和总和：
>>> digits = [1, 2, 3, 4, 5, 6, 7, 8,9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>>sum(digits)
454、列表解析
列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素。下面的示例使用列表解析创建你在前面看到的平方数列表：
squares.py
squares = [value**2 for value in range(1,11)]
print(squares)要使用这种语法，首先指定一个描述性的列表，如squares；然后，指定一个左方括号，并定义一个表达式，用于生成你要存储列表中的值。在这个示例中，表达式为value**2，它计算平方值。接下来，编写一个for循环，用于给表达式提供值，在机上右方括号。在这个示例中，for循环为for value in range(1, 11)，它将值1~10提供给表达式value**2.请注意，这里的for语句末尾没有逗号。结果与你在前面看到的平方数列表相同：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
八、使用列表的一部分
1、切片
要创建切片，可指定要使用的第一个元素的索引和最后一个元素的索引加1.与杉树range( )一样，python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素。
下面的示例处理的是一个运动队成员列表：
players.py
players = ['charles', 'martina', 'michael', 'florence', 'eil']
print(players[0:3])print处的代码打印该列表的一个切片，其中只包含三名队员。输出也是一个列表，其中包含前三名队员：
['charles', 'martina', 'michael']
你可以生成任何子集，例如，如果你要提取列表的第2~4个元素，可将起始索引指定为1，并将终止索引指定为4：
players = ['charles', 'martina', 'michael', 'florence', 'eil']
print(players[1:4])这一次，切片始于'martina'，终于'florence'：
['martina', 'michael', 'florence']
如果你没有指定第一个索引，python将自动从列表开头开始：
players = ['charles', 'martina', 'michael', 'florence', 'eil']
print(players[:4])由于没哟指定起始索引，python从列表开头开始提取：
['charles', 'martina', 'michael', 'florence']
要让切片终止于列表末尾，也可使用类似的语法。例如，如果要提取从第3个元素到列表末尾的所有元素，可将起始索引指定为2，并省略终止索引：
players = ['charles', 'martina', 'michael', 'florence', 'eil']
print(players[2:])python将返回从第3个元素到列表末尾的所有元素：
['michael', 'florence', 'eil']
无论列表多长，这种语法都能让你输出从特定位置到列表末尾的所有元素。负数索引返回离列表末尾响应距离的元素，因此你可以输出列表末尾的任何切片。例如，如果你要输出名单上的最后三名队员，可使用切片players[-3 : 1]:
players = ['charles', 'martina', 'michael', 'florence', 'eil']
print(players[-3:])上述代码打印最后三名队员的名字，畸变队员名单的长度发生变化，也依然如此。
2、遍历切片
如果要遍历列表的部分元素，可在for循环中使用切片。在下面的示例中，遍历前三名队员，并打印他们的名字：
players = ['charles', 'martina', 'michael', 'florence', 'eil']
print("Here are the first three players on my team: ")
for player in players[:3]:
print(player.title())这段代码没有遍历整个队员列表，只遍历前三名队员：
Here are the first three players on my team:
Charles
Martina
Michael
在很多情况下，切片都很有用。例如，编写游戏时，你可以在玩家退出游戏时将其最终得分加入到一个列表中。然后，为获取该玩家的三个最该得分，你可以将该列表按降序排列，再创建一个只包含前三个得分的切片。处理数据时，可使用切片来进行批量处理；编写Web应用程序时，可使用切片来分页显示信息，并在每页显示数量合适的信息。
3、复制列表
经常需要根据既有列表创建全新的列表。下面来介绍复制列表的工作原理，以及复制列表可提供极大帮助的一种情形。要复制列表，可创建一个包含整个列表的切片，方法是同时圣罗起始索引和终止索引([:])。这让python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表。
假设有一个列表，其中包含你最喜欢的三种视频，而你还想创建另一个列表。在其中包含一位朋友喜欢的所有食品。不过，你喜欢的视频，这位评优都喜欢，因此你可以通过复制来创建这个列表：
foods.py
my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
print("My favorite foods are:")
print(my_foods)
print("\nMy friends's favorite foods are: ")
print(friend_foods)首先创建了一个名为my_foods的食品列表，然后创建了一个名为friend_foods的新列表。在不指定任何索引的情况下从列表my_friends中提取一个切片，从而创建了这个列表的副本，再将该副本存储到变量friends_foods中。打印每个列表后，发现它们包含的食品相同：
My favorite foods are:
['pizza', 'falafel', 'carrot cake']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake']
为核实确实有两个列表，下面再每个列表中都添加一种视频，并核实每个列表都记录了行营人员喜欢的食品：
my_foods = ['pizza', 'fatafel', 'carrot cake']
friend_foods = my_foods[:]
my_foods.qppend('cannoli')
friend_foods.append('ice cream')
print("My favorite foods are: ")
print(my_foods)
print("\nMy friend's favorite foods are:")
print(friend_foods)与前一个实例一样，首先将my_foods的元素复制到新列表friend_foods中。接下来，在每个类表中都添加一种视频：在列表my_foods中添加'cannoli'，而在friend_foods中添加'ice cream'。最后，打印这两个列表，核实这两种食品包含在正确的列表中。
My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'ice cream']
'cannoli'包含在你喜欢的食品列表中，而'ice cream'没有，输出表明，'ice cream'包含在你朋友喜欢的视频列表中，而'cannoli'没有，倘若只是简单地将my_foods赋给friends_foods，就不能得到两个列表。例如，下例演示了在不使用切片的情况下复制列表的情况：
my_foods = ['pizza', 'falafel', 'carrot cake']
# 这行不通
friend_foods = my_foods
my_foods.qppend('cannoli')
friend_foods.append('ice cream')
print("My favorite foods are: ")
print(my_foods)
print("\n My favorite foods are: ")
print(friend_foods)这里将my_freinds赋给freind_foods，而不是my_foods的副本存储到friend_foods。这种语法实际上是让python将新变量friend_foods关联到包含在my_foods中的列表，因此这两个变量都指向同一个列表，鉴于此，将'cannoli'添加到my_foods中时，它也将出现在friend_foods中；同样，虽然'ice cream'好像只被加入到了friend_foods中，但它将出现在这两个列表中。输出表明，两个列表是相同的，这并非我们想要的结果：
My favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
My friend's favorite foods are:
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
现在暂时不考虑这个示例中的细节。基本上，当你试图使用列表的副本时，如果结果出乎意料，请确认你想第一个十里那样使用切片复制了过来。
九、元组
列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏的角色，列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。python将不能修改的值称为不可变的，而可变的列表被称为元组。
1、定义元组
元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。例如，如果有一个大小不应改变的矩形，可将其长度和宽度存储在一个元组中，从而确保它们不能修改：
dimensions.py
dimensions = (200,50)
print(dimensions[0])
print(dimensions[1])首先定义了元组dimensions，为此使用了圆括号而不是方括号、接下来，分别打印该元组的各个元素，使用的语法与访问列表时使用的语法相同：
200
50
下面来尝试修改元组dimensions中的元素，看看结果如何：
dimensions = (200,50)
dimension[0] = 250第二行的代码试图修改第一个元素的值，导致python返回类型错误消息。由于试图修改元组的操作是被禁止的，因此python指出不能给元组的元素赋值：
Traceback (most recent call last):
File "dimension.py", line 3, in <module>
dimension[0] = 250
TypeError: 'tuple' object does not support item assignment代码试图修改矩形的尺寸时，python报告错误，这很好，因为这正是我们希望的。
2、遍历元组中的所有值
像列表一样，也可以使用for循环来遍历元组中的所有值：
dimensions = (200, 50)
for dimension in dimensions:
prints(dimension)就像遍历列表一样，python返回元组中所有的元素：
200
50
3、修改元组变量
虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改前述矩形的尺寸，可重新定义整个元组：
dimensions = (200,50)
print("Original dimensions:")
for dimension in dimensions:
print(dimension)
dimensions = (400,100)
print("\nModified dimensions:")
for dimension in dimensions:
print(dimension)首先定义了一个元组，并将其存储的尺寸打印了出来；接下来，将一个新元组存储到变量dimension中；然后，打印新的尺寸。这次，python不会报告任何错误，因为给元组变量赋值是合法的：
Original dimensions:
200
50Modified dimensions:
400
100
相比列表，元组是更简单的数据结构。如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。
4114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
