Python列表、元组结构详解

由于我刚开始学习Python时，被序列结构转晕了，所以写了这篇博客。

列表

导言

例如我们打开PTA网站，随便打开一个题目集，我们可以查看一个叫题目列表的页面，如图所示，在这个列表中，我们可以看到这个列表展示了我们需要练习的题目，Python中的列表结构就与这个例子类似。

什么是列表

列表是由一系列按特定顺序排列的元素组成，列表的数据项不需要具有相同的类型，你可以往列表中加入任何内容，列表中的元素之间没有任何关系。在Python中，我们用方括号“[]”来表示列表，并用逗号“,”来分隔其中的元素。

a_list = [] #这样就创建了一个空列表

例如我们创建一个高考理科科目列表,并把它输出：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
print(Subject)

然后我们就能看到这个列表的内容了。

['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']

访问列表的元素

但是我们在实际应用中，往往并不想直接输出整个列表，而是对列表中的单个元素进行操作，因此就需要学会访问列表的元素。由于列表是有序集合，因此我们可以利用索引来访问列表元素。我们还是用科目列表来举例：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
print(Subject[0])

当我们用索引来操作列表时，Python只返回索引对应的元素，同时不携带方括号和引号。输出结果：

Chinese

Python和C语言一样，索引是从0开始计数，而不是1。不同的是，Python提供了特殊的索引，即Python的索引可以是负数，例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
print(Subject[-1])

索引为-1时，Python将返回列表的最后一个元素。这种语法很有用，因为我们有时并不需要知道列表的长度，这种约定也适用于其他负数索引，索引-3返回倒数第三个列表元素，以此类推。

Biology

列表元素的修改、添加与删除

列表是一种动态的序列，例如在PTA的一个题库中，我们可以对一个题目进行了修改，然后替换原来的题目，我们可以新发现了一道好题，然后把这道题目加入进题库中，我们可以发现一道题目超纲了，把这个题目删掉。

修改列表元素

与C语言中的数组类似，通过制定列表名和要修改的索引重新赋值即可。

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'History']
Subject[5] = 'Biology'

添加列表元素

在列表末尾添加元素

使用.append()方法，该方法用于在列表末尾添加新的对象，该方法没有返回值，语法为：

list.append(obj) #obj -- 添加到列表末尾的对象。

例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry']
Subject.append('Biology')

在列表中插入元素

使用.insert()方法，该方法用于将指定对象插入列表的指定位置，该方法没有返回值，语法为：

list.insert(index, obj) 

参数	说明
list	需要操作的列表
index	对象obj需要插入的索引位置
obj	要插入列表中的对象

例如：

Subject = ['Mathematics', 'English', 'Physics', 'Chemistry','Biology']
Subject.insert(0,'Chinese')

从列表中删除元素

用del语句删除列表元素

如果你知道某个元素在列表当中的索引，你可以用del语句删除该元素，例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology', 'History']
del Subject[6]

用.pop()方法删除元素

.pop()方法可删除列表对应索引的元素，默认为最后一个元素，与del语句的不同在于，该方法返回从列表中移除的元素对象，语法为：

list.pop([index=-1]

参数	说明
list	需要操作的列表
index	可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值

例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology', 'History']
a_subject = Subject.pop()
print(Subject,a_subject)

此时列表中被删除的元素会被储存于变量“a_subject”中，因此输出结果为：

['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology'] History

• 如果你要从列表中删除一个元素，且你将不再使用这个元素，就使用del语句，反之使用.pop()方法。

根据值删除元素

使用remove()方法，该方法用于移除列表中某个值的第一个匹配项，语法为：

list.remove(obj)

参数	说明
list	需要操作的列表
obj	列表中要移除的对象

例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology', 'History']
Subject.remove('History')

• .remove()方法只能删除第一个指定的值，如果你要把所有的值全删了，就要结合循环结构。

组织列表

列表排序

使用sort()方法，该方法用于对原列表进行排序，没有返回值，如果指定参数，则使用比较函数指定的比较函数，语法为：

list.sort( key = None, reverse = False)

参数	说明
list	需要操作的列表
key	进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序
reverse	排序规则，reverse = True 降序， reverse = False 升序（默认）

例如：

a_list = ['b', 'd', 'c', 'a']
a_list.sort() #升序排序
print(a_list)
a_list.sort(reverse = True) #降序排序
print(a_list)

则输出结果为：

['a','b','c','d']
['d','c','b','a']

列表临时排序

使用sorted()函数，该函数可对所有可迭代的对象进行排序操作，返回值为重新排序的列表，该函数不影响列表元素在列表中的原始排列顺序，语法为：

sorted(iterable, cmp=None, key=None, reverse=False)

参数	说明
iterable	可迭代对象
cmp	比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0
key	主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序
reverse	排序规则，reverse = True 降序 ， reverse = False 升序（默认）

• sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

• sort 与 sorted 内部是用Timsort算法实现的，Timsort是结合了合并排序（merge sort）和插入排序（insertion sort）而得出的排序算法，它在现实中有很好的效率。Tim Peters在2002年设计了该算法并在Python中使用(TimSort 是 Python 中 list.sort 的默认实现)。

反转列表

使用reverse()方法，该方法用于反向列表中元素，没有返回值，语法为：

list.reverse()

参数	说明
list	需要操作的列表

例如：

a_list = ['a','b','c','d']
a_list.reverse()
print(a_list)

输出结果：

['d','c','b','a']

确定列表元素个数，最大值，最小值,统计某个元素在列表中出现的次数

确定列表元素个数可使用len函数，该函数返回列表元素个数，语法为：

len(list)

参数	说明
list	要计算元素个数的列表

确定列表的最大值(最小值)，使用max(min)函数，返回列表元素中的最大(小)值，语法为：

max(list)
min(list)

参数	说明
list	要返回最大(小)值的列表

统计某个元素在列表中出现的次数，使用count()方法，该方法用于统计某个元素在列表中出现的次数，返回元素在列表中出现的次数,语法为：

list.count(obj)

参数	说明
list	要操作的列表
obj	列表中统计的对象

例如：

a_list = [1,50,100,1]
num1 = len(a_list)
num2 = max(a_list)
num3 = min(a_list)
num4 = a_list.count(1)
print(num1,num2,num3,num4)

输出结果为：

4 100 1 2 

查找元素

使用index()方法，该方法用于从列表中找出某个值第一个匹配项的索引位置，返回值为该方法返回查找对象的索引位置，如果没有找到对象则抛出异常，语法为：

list.index(x[, start[, end]])

参数	说明
list	要操作的列表
x	查找的对象
start	可选，查找的起始位置
end	可选，查找的结束位置

例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
try:
    idx = Subject.index('English')
    print(idx)
expect:
    print("没找到该元素")

• 由于查找失败时，index方法会返回异常，因此要结合try-expect结构做异常处理。

新列表扩展原列表

使用extend()方法，该方法用于在列表末尾一次性追加另一个序列中的多个值，没有返回值，语法为：

list.extend(seq)

参数	说明
list	要操作的列表
seq	要添加的列表

例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics']
Subject2 = ['Chemistry', 'Biology']
Subject.extend(Subject2)
print(Subject)

输出结果为：

['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']

检查某个元素是否是序列的成员

使用“in”关键字检查某个元素是否被包含在序列当中，语法为：

value in sequence

参数	说明
value	要检查的元素
sequence	指定的序列

例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
print('English' in Subject)
print('english' in Subject)

输出结果为：

True
False

操作列表

遍历列表

类似于C语言对数组的遍历，我们遍历列表时要用到for循环结构，有两种写法实现。

写法一：直接提取变量

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
for word in Subject:
    print(word)

写法二：通过索引进行遍历

这种写法类似于C语言我们通过下标访问数组的成员。

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
for i in range(6):
    print(Subject[i])

两种写法的输出结果相同：

Chinese
Mathematics
English
Physics
Chemistry
Biology

切片

切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素。通过切片操作可以生成一个新的序列。实现切片操作的语法为：

a_list[start:end:step]

参数	说明
a_list	要检查的元素
start	切片的开始位置包括该位置，如果不指定则默认为0
end	切片的截止位置,但不包括该位置，如果不指定则默认为序列的长度
step	切片的步长，如果省略则默认为1，当省略该步长时，最后一个冒号可以省略

例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
print(Subject[1:])
print(Subject[:2])
print(Subject[-3:])
print(Subject[1:3])

输出结果为：

['Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
['Chinese', 'Mathematics', 'English']
['Physics', 'Chemistry', 'Biology']
['Mathematics', 'English']

复制列表

复制列表时，我们需要创建一个切片，不能通过直接赋值的方式进行赋值。

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
a_list = Subject[:]

• 注意，当我们直接以赋值的形式来操作的话，是不能得到两个列表的，例如：

Subject = ['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
a_list = Subject
print(a_list)
del Subject[5]
print(a_list)
print(Subject)

我们来看一下输出结果：

['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology']
['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry']
['Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry']

我们希望通过赋值来得到两个列表，并且删除了表Subject的第6个元素，但是我们发现a_list表的第6个元素也被删除了，这是因为直接赋值的写法，在实际上是把新变量a_list关联到了Subject中的列表，这两个变量指向了同一个列表。

将其他结构转换为列表

使用list()函数，该函数用于将元组或字符串转换为列表，返回值为列表，语法为：

list( seq )

参数	说明
seq	要转换为列表的元组或字符串

元组

什么是元组

Python的元组与列表类似，不同之处在于元组的元素不能修改，也可以说元组是不可变的列表。元组使用小括号，列表使用方括号。元组的索引，切片，最大值、最小值和长度的确定等操作与列表相同。
元组创建只需要在括号中添加元素，并使用逗号隔开即可,例如：

Subject = ('Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology')
print(Subject)

输出结果：

('Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology')

如果我修改了元组变量？

Subject = ('Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'History')
Subject[5] = 'Biology'

运行这样的代码，编译器会报错。

如果我非要修改元组变量，怎么办？

虽然元组中的元素不能修改，但是我们可以通过重新赋值来修改元组，例如：

Subject = ('Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology')
print(Subject)
Subject = ('Physics', 'Chemistry', 'Biology')
print(Subject)

输出结果为：

('Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology')
('Physics', 'Chemistry', 'Biology')

删除元组

虽然我们不能修改元组的元素，但是当我们不再使用元组时，可以用del 语句删除整个元组，例如：

Subject = ('Chinese', 'Mathematics', 'English', 'Physics', 'Chemistry', 'Biology')
del Subject

将其他结构转换为元组

使用tuple()函数，该函数用于将列表或字符串转换为元组，返回值为元组，语法为：

tuple( seq )

参数	说明
seq	要转换为元组的列表或字符串

列表和元组的区别

1. 列表属于可变序列，它的元素可以随时修改或者删除，而元组属于不可变序列，其中的元素不可以修改，除非重新赋值；
2. 列表可以使用append()、extend()、insert()、remove()、pop()等方法实现添加和修改列表元素，元组由于不能修改，故没有这些方法；
3. 列表可以使用切片访问和修改列表中的元素。元组只能通过切片访问元组中的元素，不支持修改；
4. 元组比列表的访问和处理速度快;
5. 列表不能作为字典的键，而元组可以。

参考资料：

《Python从入门到精通》————明日科技，清华大学出版社
《Python编程从入门到实践》————[美]Eric Matthes 著，袁国忠 译，人民邮电出版社
菜鸟教程

例题讲解

题目选择于PTA题库。

jmu-python-回文数判断

输入样例：

123321

输出样例：

yes

题目分析

我们在C语言是怎么做这件事情？我们用一个数组读入所有的数据，然后分别从头和尾向中间比较各个元素。但是学了Python之后，我们觉得这么做太麻烦了。我们可以用一个列表来装这个数字，然后倒置列表并保存副本，对比一下原列表和副本是否相等即可。

代码实现

jmu-Java&Python-统计一段文字中的单词个数并按单词的字母顺序排序后输出

输入样例：

Failure is probably the fortification in your pole
It is like a peek your wallet as the thief when you
are thinking how to spend several hard-won lepta
when you Are wondering whether new money it has laid
background Because of you, then at the heart of the
most lax alert and most low awareness and left it
godsend failed
!!!!!

输出样例：

49
Are
Because
Failure
It
a
alert
and
are
as
at

题目分析

这个是我刷的题目集中的第一题，就像个“杀威棒”，刚点进去看的时候一脸懵，但是当我们对列表的知识熟悉之后，这个问题就变得不困难了。
首先我们要决定用什么结构来解决问题，很显然是列表，因为我们要提取文字段中的每个单词，然后去除重复的单词，再进行排序，我们可以用“len()”函数得到单词个数，用“sorted()”函数来排序。有人可能会问了：为什么不用集合？的确，集合是不允许有重复元素的，用来提取单词更为合适，但是我们后续还要操作提取出来的单词，因此我们可以用集合的特点来达到提取单词的目的，然后再转换成列表操作。

解题思路

1. 以字符串的形式输入文字段；
2. 分割提取各个单词，实现列表去重；
3. 对列表进行排序；
4. 按要求输出。

代码实现

jmu-python-从列表中删除元素

输入样例：

5
1 1 1 2 1 2 1 1 1
1
1 1 1 2 2 2 1 1 1
2
ab ab ab cd cd de de
ab
1 1 1 1
1
x y x x x z
t

输出样例：

2 2
1 1 1 1 1 1
cd cd de de

x y x x x z

题目分析

这题按照常规思路，就是读入数据，然后查找删除，这种代码不难实现，但是题目当中有提示了，有一个测试点会因此过不去，这是因为我们查找删除会用到嵌套循环，这用写法的时间复杂度一般都比较大。
因此，我们转换一下思路，我们不一定要实现删除。遍历列表，然后每当遇到不需要删除的字符时，我们把这个字符利用“append()”函数加入到一个新列表里，当原表被遍历完毕时，新表就是我们希望留下来的字符。这是一种筛选的思想，我们通过选择我想要的字符，间接实现了拿走我不想要的字符！

代码实现

jmu-python-杨辉三角

输入样例：

5

输出样例：

    1 
   1 1 
  1 2 1 
 1 3 3 1 
1 4 6 4 1 

题目分析

在C语言中，解决这种题目我们可擅长了，定义一个二维数组，然后经过一系列操作就能实现。但是问题来了，Python是没有数组的，更别提二维数组，我们想要在Python中使用二维数组怎么办？
请回忆列表的定义，列表的数据项不需要具有相同的类型，可以往列表中加入任何内容，也就是说，我们可以往列表里面放列表，也可是说是列表的嵌套，列表中的每一个元素都是一个列表，这样我们就通过列表的嵌套实现了一个二维列表。

代码实现