一、概要
本片博文介绍Python的列表，从列表的增删改查，到循环遍历乃至切片操作，并间隔着介绍如何使用它
二、列表是什么
列表 由一系列按特定顺序排列的元素组成，可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系在Python中，用方括号（[] ）来表示列表，并用逗号来分隔其中的元素
三、列表实操
创建列表：
>>>bicycles = ['trek', 'cannondale', 'redline', 'specialized']
>>>print(bicycles)
['trek', 'cannondale', 'redline', 'specialized']
访问列表元素：
列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉Python即可。要访问列表元素，可指出列表的名称，再指出元素的索引，并将其放在方括号内
>>>bicycles = ['trek', 'cannondale', 'redline', 'specialized']
>>>print(bicycles[0])
trek
如果你找的元素是个字符串，还可以使用title()函数
>>>bicycles = ['trek', 'cannondale', 'redline', 'specialized']
>>>print(bicycles[0].title())
在Python中，第一个列表元素的索引为0，而不是1。在大多数编程语言中都是如此，这与列表操作的底层实现相关。如果结果出乎意料，请看看你是否犯了简单的差一错误，第二个列表元素的索引为1。根据这种简单的计数方式，要访问列表的任何元素，都可将其位置减1，并将结果作为索引。例如，要访问第四个列表元素，可使用索引3
Python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1 ，可让Python返回最后一个列表元素：
>>>bicycles = ['trek', 'cannondale', 'redline', 'specialized']
>>>print(bicycles[-1])
specialized
这种语法很有用，因为你经常需要在不知道列表长度的情况下访问最后的元素。这种约定也适用于其他负数索引，例如，索引-2 返回倒数第二个列表元素，索引-3 返回倒数第三个列表元素，以此类推，然而当列表为空时此种方法会报IndexError
使用列表中的各个值：
>>>bicycles = ['trek', 'cannondale', 'redline', 'specialized']
>>>message = "My first bicycle was a " + bicycles[0].title() + "."
>>>print(message)
My first bicycle was a Trek.
修改列表元素：
修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值
>>>motorcycles = ['honda', 'yamaha', 'suzuki']
>>>motorcycles[0] = 'ducati'
>>>print(motorcycles)
['ducati', 'yamaha', 'suzuki']
在列表中添加元素：
在列表中添加新元素时，最简单的方式是将元素附加到列表末，使用函数append()
>>>motorcycles = ['honda', 'yamaha', 'suzuki']
>>>motorcycles.append('ducati')
>>>print(motorcycles)
['honda', 'yamaha', 'suzuki', 'ducati']
>>>motorcycles = []
>>>motorcycles.append('honda')
>>>motorcycles.append('yamaha')
>>>motorcycles.append('suzuki')
>>>print(motorcycles)
['honda', 'yamaha', 'suzuki']
在列表中插入元素：
使用方法insert() 可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值。
>>>motorcycles = ['honda', 'yamaha', 'suzuki']
>>>motorcycles.insert(0, 'ducati')
>>>print(motorcycles)
['ducati', 'honda', 'yamaha', 'suzuki']
从列表中删除元素：
如果知道要删除的元素在列表中的位置，可使用del 语句，
>>>motorcycles = ['honda', 'yamaha', 'suzuki']
>>>del motorcycles[0]
>>>print(motorcycles)
['yamaha', 'suzuki']
使用del 可删除任何位置处的列表元素，条件是知道其索引，使用del 语句将值从列表中删除后，你就无法再访问它了
使用方法pop() 删除元素，方法pop() 可删除列表末尾的元素，并让你能够接着使用它。术语弹出 （pop）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素
>>>motorcycles = ['honda', 'yamaha', 'suzuki']
>>>popped_motorcycle = motorcycles.pop()
>>>print(motorcycles)
>>>print(popped_motorcycle)
['honda', 'yamaha']
suzuki
方法pop() 是怎么起作用的呢？假设列表中的摩托车是按购买时间存储的，就可使用方法pop() 打印一条消息，指出最后购买的是哪款摩托车：
>>>motorcycles = ['honda', 'yamaha', 'suzuki']
>>>last_owned = motorcycles.pop()
>>>print("The last motorcycle I owned was a " + last_owned.title() + ".")
The last motorcycle I owned was a Suzuki.
弹出列表中任何位置处的元素，可以使用pop() 来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可
>>>motorcycles = ['honda', 'yamaha', 'suzuki']
>>>first_owned = motorcycles.pop(0)
>>>print('The first motorcycle I owned was a ' + first_owned.title() + '.')
The first motorcycle I owned was a Honda.
每当你使用pop() 时，被弹出的元素就不再在列表中了,如果你不确定该使用del 语句还是pop() 方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del 语句；如果你要在删除元素后还能继续使用它，就使用方法pop() 。
根据值删除元素:有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove()
>>>motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
>>>motorcycles.remove('ducati')
>>>print(motorcycles)
['honda', 'yamaha', 'suzuki']
注意：方法remove() 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值
列表排序：
使用方法sort() 对列表进行永久性排序
>>>cars = ['bmw', 'audi', 'toyota', 'subaru']
>>>cars.sort()
>>>print(cars)
['audi', 'bmw', 'subaru', 'toyota']
方法sort() 永久性地修改了列表元素的排列顺序
你还可以按与字母顺序相反的顺序排列列表元素，为此，只需向sort() 方法传递参数reverse=True，同样，对列表元素排列顺序的修改是永久性的
>>>cars = ['bmw', 'audi', 'toyota', 'subaru']
>>>cars.sort(reverse=True)
>>>print(cars)
['toyota', 'subaru', 'bmw', 'audi']
使用函数sorted() 对列表进行临时排序
>>>cars = ['bmw', 'audi', 'toyota', 'subaru']
>>>print("\nHere is the sorted list:")
>>>print(sorted(cars))
Here is the sorted list:
['audi', 'bmw', 'subaru', 'toyota']
我们甚至可以将sorted(cars)赋值给一个新的列表，如下代码我们能看到实际上sorted并没有真正的改变原列表的顺序
>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> newcars=sorted(cars)
>>> cars
['bmw', 'audi', 'toyota', 'subaru']
>>> newcars
['audi', 'bmw', 'subaru', 'toyota']
同样的sorted也接受reverse=True
>>> cars
['bmw', 'audi', 'toyota', 'subaru']
>>> newcars=sorted(cars, reverse=True)
>>> newcars
['toyota', 'subaru', 'bmw', 'audi']
>>>
注意：在并非所有的值都是小写时，按字母顺序排列列表要复杂些。决定排列顺序时，有多种解读大写字母的方式，要指定准确的排列顺序，可能比我们这里所做的要复杂。
倒着打印列表：要反转列表元素的排列顺序，可使用方法reverse(), reverse() 不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序
>>>cars = ['bmw', 'audi', 'toyota', 'subaru']
>>>cars.reverse()
>>>print(cars)
['subaru', 'toyota', 'audi', 'bmw']
方法reverse() 永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse() 即可
确定列表的长度：使用函数len() 可快速获悉列表的长度
>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> len(cars)
4
注意：Python计算列表元素数时从1开始，因此确定列表长度时，你应该不会遇到差一错误
如果不用sort()函数进行排序，我们开可以使用循环，也就是实现所谓的冒泡：
>>> list1 = [1,3,5,7,9,12,3,45,6678,2345,45,567,23]
>>> for i in range(len(list1)-1):
... for j in range(len(list1)-i-1):
... if list1[j]>list1[j+1]:
... list1[j],list1[j+1] = list1[j+1],list1[j]# 换位
...
>>> print(list1)
[1, 3, 3, 5, 7, 9, 12, 23, 45, 45, 567, 2345, 6678]
遍历整个列表：for循环
>>> magicians = ['alice', 'david', 'carolina']
>>> for magician in magicians:
... print(magician)
...
alice
david
carolina
>>> 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")
...
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.
创建数值列表：range()
Python函数range() 让你能够轻松地生成一系列的数字
>>> for value in range(1,5):
... print(value)
...
1
2
3
4
函数range() 让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值（这里为5），要打印数字1~5，需要使用range(1,6)
要创建数字列表，可使用函数list() 将range() 的结果直接转换为列表。如果将range() 作为list() 的参数，输出将为一个数字列表
>>>numbers = list(range(1,6))
>>>print(numbers)
[1, 2, 3, 4, 5]
使用函数range() 时，还可指定步长
>>>even_numbers = list(range(2,11,2))
>>>print(even_numbers)
[2, 4, 6, 8, 10]
函数range() 从2开始数，然后不断地加2，直到达到或超过终值（11）
>>> squares = []
>>> for value in range(1,11):
... square = value**2
... squares.append(square)
... print(squares)
...
[1]
[1, 4]
[1, 4, 9]
[1, 4, 9, 16]
[1, 4, 9, 16, 25]
[1, 4, 9, 16, 25, 36]
[1, 4, 9, 16, 25, 36, 49]
[1, 4, 9, 16, 25, 36, 49, 64]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
使用函数range() 几乎能够创建任何需要的数字集，创建一个列表，其中包含前10个整数（即1~10）的平方，如下代码等效
>>>squares = []
>>>for value in range(1,11):
... squares.append(value**2)
>>>print(squares)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
对数字列表执行简单的统计计算：min(),max()和sum()
>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>> sum(digits)
45
列表解析：
列表解析让你只需编写一行代码就能生成这样的列表。列表解析 将for 循环和创建新元素的代码合并成一行，并自动附加新元素
>>>squares = [value**2 for value in range(1,11)]
>>>print(squares)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
切片：
要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range() 一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0 、1 和2 的元素
>>>players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>>print(players[0:3])
['charles', 'martina', 'michael']
如果你没有指定第一个索引，Python将自动从列表开头开始：
>>>players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>>print(players[:4])
['charles', 'martina', 'michael', 'florence']
要让切片终止于列表末尾，也可使用类似的语法
>>>players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>>print(players[2:])
['michael', 'florence', 'eli']
无论列表多长，这种语法都能够让你输出从特定位置到列表末尾的所有元素
负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任何切片，例如，如果你要输出名单上的最后三名队员，可使用切片players[-3:] ：
>>>players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>>print(players[-3:])
['michael', 'florence', 'eli']
遍历切片：
如果要遍历列表的部分元素，可在for 循环中使用切片
>>> players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>> for player in players[:3]:
... print(player.title())
...
Charles
Martina
Michael
复制列表：
要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:] ）。这让Python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表。
>>>my_foods = ['pizza', 'falafel', 'carrot cake']
>>>friend_foods = my_foods[:]
>>>print(friend_foods)
['pizza', 'falafel', 'carrot cake']
这种方法创建的friend_foods是个全新的列表与my_foods列表是独立的，而如果我们不用这个方法只是进行赋值操作friend_foods = my_foods，并不是创建了一个新的列表，只是将两个变量指向了同一个列表
反转列表：
>>> players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>> print(players[::-1])
['eli', 'florence', 'michael', 'martina', 'charles']
其他切片操作：
>>> m[:10]#取前十个数
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> m[-10:]#取后十个数
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> m[10:20]#取前11-20个数
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> m[:10:2]#前十个数中，每2个数取一个
[0, 2, 4, 6, 8]
>>> m[5:15:3]#第6-15个数中，每3个数取一个
[5, 8, 11, 14]
>>> m[::10]#所有的数中，每10个数取一个
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> m[:]#什么都不写，可以原样复制一个list
[0, 1, 2, 3, 4, 5, 6, 7,……,99]
元组：列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组
元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样
>>>dimensions = (200, 50)
>>>print(dimensions[0])
200
元组是不能修改的，只能重新赋值，如果进行修改会报TypeError
>>>dimensions = (200, 50)
>>>dimensions[0] = 250
Traceback (most recent call last):
File "dimensions.py", line 3, in <module>
dimensions[0] = 250
TypeError: 'tuple' object does not support item assignment
像列表一样，也可以使用for 循环来遍历元组中的所有值：
>>>dimensions = (200, 50)
>>>for dimension in dimensions:
... print(dimension)
200
50
虽然不能修改元组的元素，但可以给存储元组的变量赋值
>>> dimensions = (200, 50)
>>> print("Original dimensions:")
Original dimensions:
>>> for dimension in dimensions:
... print(dimension)
...
200
50
>>> dimensions = (400, 100)
>>> print("Modified dimensions:")
Modified dimensions:
>>> for dimension in dimensions:
... print(dimension)
...
400
100
元组和列表转换：
>>> players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>> tupleplayers = tuple(players)
>>> print(tupleplayers)
('charles', 'martina', 'michael', 'florence', 'eli')
>>> listplayers = list(tupleplayers)
>>> print(listplayers)
['charles', 'martina', 'michael', 'florence', 'eli']