目录

人生苦短 | Python列表和元组归纳整理

1. 列表

1.1. 列表是什么?

列表是由一系列按特定顺序排列的元素组成,所以是有序的集合。**列表中的元素可以是不同类型的,列表中也可以嵌套列表。**在Python中,用方括号[]来表示列表,并用逗号来分隔其中的元素。如下所示:

1
2
3
4
5
digits = [1, 2, 3, 4, 5]	
names = ["Dawn", "Jack"]
alls = [1, 2, 3, "Dawn", "Jack"]	# 列表中的元素可以是不用类型的	
listIn = [[1, 2, 3], [4, 5]]		# 列表嵌套
tupleIn = [(1, 2), (3, 4)]			# 元素为元组

1.2. 列表的相关操作

1.2.1. 索引访问列表元素

Python列表也支持索引访问元素,并且与C语言一样索引访问也是从0开始的,但是Python支持负数索引方式访问,如-1表示访问倒数第一个元素,-2表示访问倒数倒数第二个元素。

1
2
3
4
5
6
7
>>> digits = [1, 2, 3, 4, 5]
>>> digits[0]
1
>>> digits[-1]
5
>>> digits[-2]
4

个人感觉,Python的负数索引挺nice的,在访问最后一个元素的时候超级方便。

下面再说一下多维列表的访问,跟C语言多维数组访问一样,第一个[]访问第一维的,第二个[]访问第二维的。

1
2
3
>>> digits  = [[1,2,3], [4,5,6]]
>>> digits[0][1]
2

1.2.2. 切片操作

Python还有一个比较骚气的操作就是支持切片,什么是切片呢?通过[num1:num2:num3]的形式来取列表中指定的某一区域的元素。其中num1表示切片的起始位置(取得到),num2表示切片结束的位置(取不到),num3表示步长。如下所示:

1
2
3
>>> digits = [13, 2, 31, 24, 45]
>>> digits[0👎2]
[13, 31]

0表示从索引为0的位置开始,-1表示到最后的一个元素(但是这个元素是取不到的),2表示所取的步长为2,所以依次取13,31,但是45这个元素因为是索引为-1的元素,取不到。当然上述的这种方式是最全的使用方式,我们可以省略其中一些,比如省略num1,那么默认是从0开始:

1
2
3
>>> digits = [13, 2, 31, 24, 45]
>>> digits[:3:2]
[13, 31]

比如省略num2,那么默认到最后一个元素但是最后一个元素取得到

1
2
>>> digits[0::2]
[13, 31, 45]

比如省略num3,那么默认步长为1,当省略掉num3之后,那么最后一个:也可以省略了,如下

1
2
3
4
>>> digits[0👎]
[13, 2, 31, 24]
>>> digits[0:-1]
[13, 2, 31, 24]

当然切片还有以下这些省略的操作,我简单列举一下,自己多多尝试一下是最nice的:

1
2
3
4
5
6
7
>>> digits = [13, 2, 31, 24, 45]
>>> digits[:]
[13, 2, 31, 24, 45]
>>> digits[:2]
[13, 2]
>>> digits[1:]
[2, 31, 24, 45]

个人总结:切片操作中,必须要有冒号在才算是切片操作,当有了冒号之后,那么接下去就是根据冒号的位置来进行判断,第一个冒号左右指定的就是起始位置和结束位置。当省略了结束的位置,那么默认是到最后一个元素,但是此时最后一个元素也是取得到的。

1.2.3. 修改列表元素

通过索引来确定要修改的是哪个元素,然后再进行修改。

1
2
3
4
>>> digits = [1, 2, 3, 4, 5]
>>> digits[0] = 8
>>> digits
[8, 2, 3, 4, 5]

1.2.4. 增加列表元素

list.append()

该方式是在列表最后添加元素。

1
2
3
4
>>> digits = [1, 2, 3, 4, 5]
>>> digits.append(6)
>>> digits
[1, 2, 3, 4, 5, 6]

list.extend()

该方式可以将参数中指定的集合中的元素逐一添加到列表中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
>>> digits = [1, 2, 3, 4, 5]
>>> digits.extend([1, 2])
>>> digits
[1, 2, 3, 4, 5, 1, 2]

>>> digits = [1, 2, 3, 4, 5]
>>> digits.extend((1, 2))
>>> digits
[1, 2, 3, 4, 5, 1, 2]

>>> digits = [1, 2, 3, 4, 5]
>>> digits.extend(range(2))
>>> digits
[1, 2, 3, 4, 5, 0, 1]

list.insert(index, object)

在指定index前插入元素object

1
2
3
4
>>> digits = [1, 2, 3, 4, 5]
>>> digits.insert(0, 0)
>>> digits
[0, 1, 2, 3, 4, 5]

1.2.5. 删除列表元素

del语句

使用del语句删除指定位置的列表元素。

1
2
3
4
>>> digits = [1, 2, 3, 4, 5]
>>> del digits[2]
>>> digits
[1, 2, 4, 5]

list.pop()

将值从列表中删去,并将值返回。方法pop()可删除列表末尾的元素,并返回末尾的元素值,此操作中的列表相当于一个栈,删除末尾的元素相当于弹出栈顶元素。当然pop()函数还支持删除列表中任何位置的元素,只需要在括号中指定要删除的元素的索引即可。如下所示:

1
2
3
4
5
6
7
8
9
>>> digits = [1, 2, 3, 4, 5]
>>> digits.pop()
5
>>> digits
[1, 2, 3, 4]
>>> digits.pop(1)
2
>>> digits
[1, 3, 4]

list.remove()

假如只知道要删除的元素的值,而不知道某个值所在的位置,那么就可以用这种方法。

1
2
3
4
>>> digits = [1, 2, 3, 4, 5]
>>> digits.remove(2)
>>> digits
[1, 3, 4, 5]

该方法只删除第一个指定的值。如果要删除的值可能在列表中出现多次,就需要使用循环来判断是否删除了所有这样的值。

list.clear()

该方法是清空列表中所有的元素。

1
2
3
4
>>> digits = [1, 2, 3, 4, 5]
>>> digits.clear()
>>> digits
[]

1.2.6. in操作

Python的in关键字表示存在的意思,假如要判断一个元素是否存在于一个列表中,那么直接可以使用in关键字,如果存在则返回True

1
2
3
4
5
>>> digits = [1, 2, 3, 4, 5]
>>> 1 in digits
True
>>> 6 in digits
False

1.2.7. list.index()方法

index()方法是返回元素在列表中的位置,当元素不在列表中会报错,所以最好加一个异常处理操作,当列表中存在多个一样的值,返回的是第一个。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
>>> digits = [1, 2, 1, 4, 5]
>>> digits.index(2)
1
>>> digits.index(1)
0
>>> digits.index(6)
Traceback (most recent call last):
  File "<pyshell#160>", line 1, in <module>
    digits.index(6)
ValueError: 6 is not in list

1.2.8. list.count()方法

对元素进行计数,不存在的元素计数的结果就是0。

1
2
3
4
5
>>> digits = [1, 2, 1, 4, 1]
>>> digits.count(1)
3
>>> digits.count(5)
0

1.2.9. list.sort()和sorted()方法

list.sort()方法是将list按特定顺序重新排列,默认为由小到大,参数reverse=True可改为倒序,由大到小。排序后的结果直接保存到list中去。

1
2
3
4
5
6
7
8
9
>>> digits = [13, 2, 31, 24, 45]
>>> digits.sort()
>>> digits
[2, 13, 24, 31, 45]

>>> digits = [13, 2, 31, 24, 45]
>>> digits.sort(reverse=True)
>>> digits
[45, 31, 24, 13, 2]

sorted()方法同list.sort()方法类似都是用于排序,只是这种方法不会改变原列表,而是将排序好的列表返回,同样可以指定参数reverse=True将其改为倒序。后面讲字典的时候,还会讲到key这个参数,可以指定用于排序的值。

1
2
3
4
5
6
7
8
9
>>> digits = [13, 2, 31, 24, 45]
>>> sortedDigits = sorted(digits)
>>> sortedDigits
[2, 13, 24, 31, 45]

>>> digits = [13, 2, 31, 24, 45]
>>> sortedDigits = sorted(digits, reverse=True)
>>> sortedDigits
[45, 31, 24, 13, 2]

1.2.10. list.reverse()方法

将list进行逆置,并且原list为逆置之后的结果。

1
2
3
4
>>> digits = [13, 2, 31, 24, 45]
>>> digits.reverse()
>>> digits
[45, 24, 31, 2, 13]

1.2.11. enumerate()方法

enumerate()方法可以实现下标和值的对应。

1
2
3
4
5
6
7
8
>>> digits = [13, 2, 31, 24, 45]
>>> for i, val in enumerate(digits):
	print(i, val)	
0 13
1 2
2 31
3 24
4 45

2. 元组

2.1. 元组是什么?

元组和列表类似,都是有序集合。元组中的元素可以是不同类型的,也可以嵌套元组。Python中使用小括号()来表示元组,同样使用逗号来分割其中的元素。

1
2
3
4
digits = (1,2,3)
names = ('Dawn', 'Jack')
alls = (1, 'Dawn')
tupleIn = ((1,2),(3,4))

2.2. 元组的操作

元组与列表最大最大最大的不同操作之处在于**元组的元素不能修改,只能访问。**假如理解了这点,下面的具体操作就可以忽略了。

2.2.1. 索引访问元组元素

元组也支持索引访问,跟列表访问一样,在访问多维元组的时候也是一样的。

1
2
3
4
5
6
7
8
9
>>> digits = (13, 2, 31, 24, 45)
>>> digits[1]
2
>>> digits[-1]
45

>>> digits = ((32,43) ,(31, 24, 45))
>>> digits[0][1]
43

2.2.2. 切片操作

元组跟列表的切片方式一样,只是返回的是元组的形式,这边就简单举个例子昂。

1
2
3
>>> digits = (13, 2, 31, 24, 45)
>>> digits[0👎2]
(13, 31)

2.2.3. 元组元素不能修改

元组元素不能修改也就意味着不能增加、删除、修改元素等。

1
2
3
4
5
6
>>> digits = (13, 2, 31, 24, 45)
>>> digits[2] = 1
Traceback (most recent call last):
  File "<pyshell#115>", line 1, in <module>
    digits[2] = 1
TypeError: 'tuple' object does not support item assignment

2.2.4. in操作

元组的in操作如下所示,同列表。

1
2
3
4
5
>>> digits = (13, 2, 31, 24, 45)
>>> 13 in digits
True
>>> 12 in digits
False

2.2.5. tuple.index()方法

与列表一样,返回指定元素的索引值,当有元组中有同样的值时,返回的是第一个。

1
2
3
4
5
6
7
8
>>> digits = (13, 2, 13, 24, 45)
>>> digits.index(13)
0
>>> digits.index(12)
Traceback (most recent call last):
  File "<pyshell#136>", line 1, in <module>
    digits.index(12)
ValueError: tuple.index(x): x not in tuple

2.2.6. tuple.count()方法

对指定的元素计算元组中有多少个一样的值。

1
2
3
4
5
6
7
>>> digits = (13, 2, 13, 24, 45)
>>> digits.count(13)
2
>>> digits.count(2)
1
>>> digits.count(3)
0

2.2.7. sorted()方法

虽然元组不支持.sort()方法进行排序,但是sorted()方法还是可以的,因为该方法返回的是一个新的。

1
2
3
4
>>> digits = (13, 2, 13, 24, 45)
>>> sortedDigits = sorted(digits)
>>> sortedDigits
[2, 13, 13, 24, 45]

2.2.8. enumerate()方法

1
2
3
4
5
6
7
8
>>> digits = (13, 2, 13, 24, 45)
>>> for i,val in enumerate(digits):
	print(i, val)
0 13
1 2
2 13
3 24
4 45

本文参考

  1. Python编程如入门到实践
  2. 一口程序锅之前看视频的笔记