Python基础之列表

一、摘要

本片博文将介绍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 
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']