Python学习笔记——第三章 列表和元组

3.1 序列

Python中内置了多种序列，其中列表和元组是最常用的两种序列。

列表和元组最大的区别在于：列表元素是可以修改的，而元组元素则不能随意修改。所以列表适合需要随时向序列中增减元素的场景，元组则适合定义某种基准或其他用处的不可对元素进行修改的场合。

3.2 序列操作

对于序列，Python提供了索引、切片、相加、相乘和成员检查资格的通用操作，同时，也提供了内置函数，用于确定序列长度、找出最大最小值等操作。

3.2.1 索引

序列中的元素同其他语言中的数组一样，都有它对应的下标，并且也和其它语言一样（Lua等少数语言除外）下标从0开始。这个代表元素位置的下标即为索引（indexing），可以通过索引来获取或更改特定的元素。

例如，我们可以通过获取一个单词中索引为0的元素来获取他的首字母：

print("Hello"[0])

# 运行结果为打印 H

索引除了大于等于0的整数，也可以使用负数，使用负数时将会从序列右侧（尾部）向前查找，如我们想要获得单词索引为-1的元素，它将返回最末的元素，也就是“o”：

print("Hello"[-1])

# 运行结果为打印 o

3.2.2 切片

基础使用

除了使用单个索引获取单个元素外，我们也可以用多个索引来获取某一段区间内的元素，这就是切片（slicing），他的基础使用方法为使用两个索引，中间用冒号隔开，即可获得这第一个索引开始第二个索引结束（不包含第二个索引元素）的一部分。

例如，我们有一个nums序列，我们想要获得它索引为2到8的元素：

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(nums[2:8])

[3, 4, 5, 6, 7, 8]

切片的索引也可以为负数，例如我们想要获得倒数第三个元素到最后一个元素中的序列：

扫描二维码关注公众号，回复： 17502936 查看本文章

print(nums[-3:-1])

[8, 9]

但通过负数索引，并不会获得最后一个元素，但如果使用0作为第二个索引，是不是就可以获得包含最后一个元素在内的序列呢？其实并不会：

print(nums[-3:0])

[]

理由其实很简单，再在通过切片获取序列元素时，第一个索引位置如果位于第二个索引位置之后，计算机便不能获取第一个索引往后一直到第二个索引的元素，所以返回一个空序列。

缩写

而对于从头开始或者从末尾结束，Python提供了一种简单的缩写，即：省略第一个索引表示从序列第一个元素开始截取，省略第二个索引表示一直截取到最末尾一个元素（包含最末尾的元素）。

例如，我们获取从开始到索引为5的元素与从-3到最末尾的元素：

print(nums[:5])
print(nums[-3:])

[1, 2, 3, 4, 5]
[8, 9, 10]

如果我们将两个索引都省略掉，获得的就是整个序列。

步长

除了可以通过两个索引来获取序列以外，还可以设置第三个参数步长，这个数值将告诉程序我们获取元素的间隔，而当我们省略不写的时候，该参数为1，

例如，我们可以通过下面的写法，获得序列中第0，2，4…元素：

print(nums[::2])

[1, 3, 5, 7, 9]

步长可以是除0以外的数（当他为0时无法向前获取元素），当步长为负数时，表示从索引区间反向（从尾部到头部）获取元素。

3.2.3 序列相加

不同的序列可以通过+运算符进行拼接。

print([1, 2, 3] + [4, 5, 6])

[1, 2, 3, 4, 5, 6]

但一般情况下，不同类型的序列不能进行拼接，如不可以将一个数字列表和字符串进行拼接。

print("Hello" + [4, 5, 6])

    print("Hello" + [4, 5, 6])
          ~~~~~~~~^~~~~~~~~~~
TypeError: can only concatenate str (not "list") to str

3.2.4 乘法

序列可以对一个整数做乘法，这会让这一个序列连续重复。

print("Hello" * 3)

HelloHelloHello

使用这种方法可以快速对一些序列进行处理，如快速初始化、快速重置等等。

3.2.5 成员资格（成员检测）

我们可以使用布尔运算符in来检测某一元素是否包含在序列当中，如果包含在序列中，它将返回布尔值True，没有包含在序列中则会返回False。

hanasi = "Hello World!"
if("Hello" in hanasi):
    print('include "Hello"')
else:
    print('not include "Hello"')

include "Hello"

3.2.6 获取长度、最小值、最大值

要获取序列的长度、最小值或者最大值，Python内置了len、max、min三个函数：

nums = [100, 200, 333, -5]
print(f"len:{
      
      len(nums)}")
print(f"max:{
      
      max(nums)}")
print(f"min:{
      
      min(nums)}")

len:4
max:333
min:-5

3.3 列表

3.3.1 list

字符串并不能进行修改，但我们可以将其转化为一个列表，在修改元素后再将它转换回字符串，这样便可以完成对它的修改：

s = "Hello"
print(type(s))
s = list(s)  # 将字符串转换为列表
print(type(s))
s[1] = "a"  # 修改列表中的元素
s = "".join(s)  # 将列表转换为字符串
print(s)
print(type(s))

<class 'str'>
<class 'list'>
Hallo
<class 'str'>

3.3.2 列表的基本操作

修改列表（给元素赋值）

需要修改某一个元素的值或给某一个元素赋值，只需要使用=即可，这里不再进行举例，但需要注意的是，赋值对象不可以是超出范围的对象，

删除元素

如果需要删除列表中的元素，我们可以使用del语句，删除后对应元素将永久消失，列表的长度也会重新进行更新。

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(f"nums[0]: {
      
      nums[0]},len(nums):{
      
      len(nums)}")
del nums[0]
print(f"nums[0]: {
      
      nums[0]},len(nums):{
      
      len(nums)}")

nums[0]: 1,len(nums):10
nums[0]: 2,len(nums):9

切片赋值

前面介绍过通过切片的方式获取某一段序列的值，除了获取某一段的值，我们还可以对某一段元素直接进行替换。

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(f"nums:{
      
      nums},len(nums): {
      
      len(nums)}")
nums[1:5] = [11, 33, 22]
print(f"nums:{
      
      nums},len(nums): {
      
      len(nums)}")

nums:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],len(nums): 10
nums:[1, 11, 33, 22, 6, 7, 8, 9, 10],len(nums): 9

我们也可以在不改变原有元素的同时，对列表进行插入操作

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(f"nums:{
      
      nums},len(nums): {
      
      len(nums)}")
nums[2:2] = [520, 1314]
print(f"nums:{
      
      nums},len(nums): {
      
      len(nums)}")

nums:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],len(nums): 10
nums:[1, 2, 520, 1314, 3, 4, 5, 6, 7, 8, 9, 10],len(nums): 12

3.3.3 列表相关的方法（函数）

方法名	含义	方法名	含义
append	添加元素到末尾	insert	插入元素
clear	清空列表内容	pop	从列表中删除一个元素，默认为最末尾元素
copy	复制列表	remove	删除第一个为指定值的元素
count	元素出现的数量	reverse	反转列表
extend	将多个值附加到列表末尾	sort	对列表进行排序，默认为从小到大
index	查找指定值第一次出现的索引位置

append

append方法会就地修改列表，在列表末尾添加元素，所以它并不会返回任何值，只会返回None。

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(f"nums[-1]:{
      
      nums[-1]},len(nums): {
      
      len(nums)}")
nums.append(15)
print(f"nums[-1]:{
      
      nums[-1]},len(nums): {
      
      len(nums)}")

nums[-1]:10,len(nums): 10
nums[-1]:15,len(nums): 11

clear

clear会就地清空列表的所有内容

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(f"nums:{
      
      nums},len(nums): {
      
      len(nums)}")
nums.clear()
print(f"nums:{
      
      nums},len(nums): {
      
      len(nums)}")

nums:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],len(nums): 10
nums:[],len(nums): 0

copy

常规的赋值操作只是名称关联的行为，两个变量名指向的内容为同一个列表，copy则会构建一个列表的副本，让被赋值的变量名指向的列表变为经过copy产生的副本，这样便可以对他们分别进行操作（类比于C/C++的浅拷贝和深拷贝）。

使用常规赋值：

a = [1, 2, 3, 4]
b = a
print(f"a:{
      
      a},b:{
      
      b}")
b.append(5)
print(f"a:{
      
      a},b:{
      
      b}")

a:[1, 2, 3, 4],b:[1, 2, 3, 4]
a:[1, 2, 3, 4, 5],b:[1, 2, 3, 4, 5]

copy：

a = [1, 2, 3, 4]
b = a.copy()
print(f"a:{
      
      a},b:{
      
      b}")
b.append(5)
print(f"a:{
      
      a},b:{
      
      b}")

a:[1, 2, 3, 4],b:[1, 2, 3, 4]
a:[1, 2, 3, 4],b:[1, 2, 3, 4, 5]

count

count可以用于计算特定元素出现的次数：

a = [1, 2, 2, 3, 4]
print(f"1出现的次数:{
      
      a.count(1)}，2出现的次数:{
      
      a.count(2)}")

1出现的次数:1，2出现的次数:2

extend

extend可以就地同时将多个元素添加到列表末尾，他与列表拼接、切片末尾插入列表效果相同，不过拼接效率相对较低，因为他无法就地修改列表，需要重新赋值。

a = [1, 2, 2, 3, 4]
b = [[100, 20], 15, 32]
a.extend(b)
print(a)

[1, 2, 2, 3, 4, [100, 20], 15, 32]

index

index可以用于寻找指定元素第一次出现的位置索引，但是当指定的值并不包含在列表中时，程序将会报错

c = ["hello", "python", "hello", "world"]
print(f'index of "hello": {
      
      c.index("hello")}')

index of "hello": 0

print(f'index of "hell": {
      
      c.index("hell")}')	# 查找不包含在内的元素时，程序报错无法运行

    print(f'index of "hell": {c.index("hell")}')
                              ^^^^^^^^^^^^^^^
ValueError: 'hell' is not in list

insert

insert函数也是对列表进行就地插入，它包含两个参数，第一个参数为插入元素的位置，第二个参数为插入元素的值。

c = ["hello", "python", "hello", "world"]
c.insert(4, "halo")
print(c)

['hello', 'python', 'hello', 'world', 'halo']

pop

pop会从列表中删除一个指定位置的元素（没有指定则默认最末尾的元素），然后返回被删除的值。

c = ["hello", "python", "hello", "world"]
pop_1 = c.pop()
pop_2 = c.pop(0)
print(f"c: {
      
      c}, pop_1: {
      
      pop_1}, pop_2: {
      
      pop_2}")

c: ['python', 'hello'], pop_1: world, pop_2: hello

remove

remove可以就地删除第一个出现的指定值，但如果列表中不包含这个值，程序将会报错。

c = ["hello", "python", "hello", "world"]
c.remove("hello")
print(f"c: {
      
      c}")

c: ['python', 'hello', 'world']

reverse

reverse可以将列表进行逆转，但不会返回任何值。

c = ["hello", "python", "hello", "world"]
c.reverse()
print(f"c: {
      
      c}")

c: ['world', 'hello', 'python', 'hello']

sort与sorted

sort会就地对列表进行排序，而sorted则更像是先将序列复制转化为列表，再对其进行排序。

sort排序示例：

a = [12, 56, 55, 96, 32, 565, 6]
a.sort()
print(a)

[6, 12, 32, 55, 56, 96, 565]

sorted排序示例：

a = [12, 56, 55, 96, 32, 565, 6]
b = sorted(a)
print(a)
print(b)

[12, 56, 55, 96, 32, 565, 6]
[6, 12, 32, 55, 56, 96, 565]

高级sort排序方法

sort还可以接受两个可选参数：key和reverse，其中key指定排序时比较的值，reverse则是反向排序（从大到小）。

w = ["banana", "apple", "orange", "pear", "grape"]
w.sort(key=len)  # 按照单词长度排序
print(w)
w.sort(key=len, reverse=True) # 按照单词长度排序，降序
print(w)

['pear', 'apple', 'grape', 'banana', 'orange']
['banana', 'orange', 'apple', 'grape', 'pear']

3.3.4 元组（不可修改）

元组定义非常简单，只需要用逗号隔开即可，也可以用圆括号包裹起来。

t = 1, 2, 3
print(t)

(1, 2, 3)

而如果要定义只有一个元素的元组，需要在这个元素后面打上逗号，只用圆括号包裹起来并不能将其定义为元组。

print(type((1,)))
print(type((1)))

<class 'tuple'>
<class 'int'>

使用tuple关键字可以将列表转化为元组。

a = [1, 2, 3]
print(type(a))
a = tuple(a)
print(type(a))

<class 'list'>
<class 'tuple'>

元组除没有增、删、改、排序操作外，其他操作方式与列表相同。