【Python】列表

列表数据类型

“列表”是一个值，它包含多个同种或不同种值构成的序列。

[1,2,3]                             # 这是一个全是整型列表
['cat','bat','rat','elephant']      # 这是一个全是字符串型列表
['hello',3.1415,True,None,42]       # 这也是一个五花八门的列表
spam=['cat','bat','rat','elephant'] # 将这个列表“值”赋给变量spam
template=[]                         # 这是一个空列表

用下标取得列表值

和C++的数组下标相似，下标从0开始到“列表值个数-1”分别对应列表的每个值

spam=['hello',3.1415,True,None,42]
print(spam[0])
print(spam[1])
print(spam[2])
print(spam[3])
print(spam[4])

hello
3.1415
True
None
42

负数下标

负数也可做列表下标，整数-1指列表倒数第一个值，以此类推。

spam=['cat','bat','rat','elephant']
print(spam[-1])
print(spam[-2])

elephant
rat

利用切片取得子列表

“切片”可以从列表中取得多个值，结果是一个新列表

切片形式:

• 两个整数

• 第一个整数为切片开始处下标，第二个整数为切片结束处下标

• 切片从包括第一个下标值向上增长，直至第二个下标值，但不包括它

    spam[1:4]
  

举个栗子↓

spam=[1,2,3]
print(spam[0:2])

[0,1]

切片快捷方法

可以省略切片第一个或第二个下标：

• 省略第一个下标相当于使用0

• 省略第二个下标相当于使用列表的长度

spam=[1,2,3,4]
print(spam[:])
print(spam[:2])
print(spam[1:])

[1,2,3,4]
[1,2,3]
[2,3,4]

用len()函数获取列表长度

直接一个栗子

spam=[1,2,3,4]
print(len(spam))

4

列表连接和列表复制

+操作符可以连接两个列表，得到一个新列表

a=[1,2,3,4]
t=[1,2,3,4]
print(a+t)

[1,2,3,4,1,2,3,4]

*操作符可以作用于一个列表和一个整数，实现列表的复制，得到一个新列表

spam=[1,2,3]
print(spam*3)

 [1,2,3,1,2,3,1,2,3]

用del语句从列表中删除值

del语句将删除列表中下标处的值，被删除的值的后面的所有值，都将向前移动一位

spam=[1,2,3,4,5]
print(spam[2])
del spam[2]
print(spam[2])
print(spam)

3
4
[1,2,4,5]

del语句几乎总用于删除列表中的值

使用列表

for循环遍历列表方法

1.在关键字in后输入列表名，变量i迭代列表的值

someList=['a','b','c','d']
for i in someList:
    print(i)

a
b
c
d

输出的是i对应的每个值，而不是列表

2.在关键字in后使用 range(len(someList))，变量i迭代列表的下标

someList=['a','b','c','d']
for i in range(len(someList)):
    print(someList[i])

a
b
c
d

in和not in操作符

利用in和not in操作符可以确定一个值是否在列表中

someList=[1,2,3,4]
print(1 in someList)
print('a' in someList)

True
False

多重赋值技巧

多重赋值技巧是一种快捷方式，在一行代码中，用列表的值给多个变量赋值

someList=[1,2,3,4,5]
a,b,c,d,e=someList
print(a,b,c,d,e)

1,2,3,4,5

变量的数目和列表的长度必须严格相等，否则python将给出ValueError

someList=[1,2,3,4,5]
a,b,c,d,e,f=someList   #报错
a,b,c=someList         #报错

处理列表的方法

index()方法列表中查找值

• 列表值有一个index()方法，可以传入一个值。
• 如果该值存在于列表中，就返回它的下标。
  （如果列表中有重复的值，就返回它第一次出现的下标）
• 如果该值不在列表中，python就报ValueError

使用

列表名.index(待查值)

来个栗子↓

someList=[1,2,3,4,5,3]
print(someList.index(1))
print(someList.index(3))
print(someList.index(4 4 4))

0
2
*报错*

append()和insert()方法在列表中添加值

append()方法调用，将参数添加到列表末尾

列表名.append(新值)

insert()方法可以在列表任意下标处添加一个值

列表名.insert(新值下标,新值)

举个栗子↓

someList=[1,2,3,4,5]
someList.append(6)
print(someList)
someList.insert(1,7)
print(someList)

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

注

• append()和insert()返回值都为None
• 该方法属于单个数据类型，只是列表方法，不能在其他值调用，否则会报错

remove()方法从列表中删除值

给remove()方法传入一个值，他将从被调用的列表中删除

列表名.remove(删除值)

试图删除一个列表中不存在的值会报错

举个栗子

someList=[1,2,3,4]
someList.remove(3)
print(someList)

[1,2,4]

sort()方法将列表的值排序

• 数值的列表或字符串的列表，能用sort()方法排序
• 指定reverse关键字参数为True，让sort()按逆序排序

使用

列表名.sort()               #正序排序
列表名.sort(reverse=True)   #逆序排序

强烈注意三件事：

1. sort()方法当场对列表排序（不要写出someList=someList.sort()试图记录其返回值）
2. 不能对既有数字又有字符串值的列表排序（因为Python也不会啊）
3. sort()对字符串排序时，使用ASCII字符顺序
   这意味着大写字母排在小写字母前面，因此在排序是a永远在Z后面

上栗子↓

someList=[1,3,2,4,6,5]
someList.sort()
print(someList)
someList.sort(reverse=True)
print(someList)

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

再来个字符串的栗子↓

someList=['A','a','B','b','C','c']
someList.sort()
print(sort)

['A','B','C','a','b','c']

copy模块实现列表的拷贝

分析以下程序

spam=[1,2,3,4,5]
cheese=spam 
cheese[1]=1
print(spam)
print(cheese)

[1,1,3,4,5]
[1,1,3,4,5]

分析

cheese=spam  

这样将列表赋给一个变量时，只是将列表的“引用”（地址？）赋给了该变量，当改变该变量对应的列表时，原先的列表也会改动。

如果希望修改新的变量对应的列表，而不影响原来的列表，即实现列表的先拷贝再修改

调用copy模块中的copy()和deepcopy()函数
1.copy.copy():
用来复制列表或字典这样的可变值，而不是复制引用

spam=[1,2,3,4,5]
cheese=copy.copy(spam) 
cheese[1]=1
print(spam)
print(cheese)

[1,2,3,4,5] # spam列表没有改变
[1,1,3,4,5]

2.copy.deecopy():
如果要拷贝的列表中包含列表，就用copy.deecopy()函数代替。

类似列表类型：字符串和元组

字符串类型

• 字符串可被看作“单个文本字符组成”的列表
  很多操作对于列表的操作都可以用于字符串

name='SYolin'
print(name[0])     #通过下标取值
print(name[-2])    #通过下标取值（负数）
print(name[0:2])   #切片获得新串
print(Yo in name)  #in,not in操作符
for i in name[0:2]:
    print('***'+i+'***') #用于for循环遍历

S
i
SY
True
***S***
***Y***

• 字符串属于“不可变”数据类型，无法用赋值改变内部字符

sententce='What the surprise!'
sentence[6]='a'     #报错

“改变”一个字符串的正确方法，是使用切片和连接
（for循环也无法改变单个元素）

sentence = 'What the surprise!'
ans=sentence[:5]+'a'+sentence[8:]
print(ans)

What a surprise!

元组数据类型

元组

除了两个方面，元组和列表一模一样

1. 元组输入时用(),而不是[]
2. 元组像字符串一样，是不可变得。元组不能让它们的值被修改、添加或删除

spam=(1,2,3,4,5) #这是一个元组

如果元组中只有一个值，可以在括号后面跟一个逗号，表明这种情况。否则python将认为，你只是在一个普通的()中输了一个值

spam=(1,) #这是一个只有一个值的元组

你可以用元组告诉所有读代码的人，你不打算读这个序列的值

用someList()和tuple()函数实现元组和列表的转换

直接上一个栗子

someList=(1,2,3,4,5)
spam=['a','b']
list(spam)      # 元组转换为列表（实现可修改）
print(spam)
tuple(someList) # 列表转换为元组（实现不可改）
print(someList)  

[1,2,3,4,5]
('a','b')

附：Python中代码跨行规则

• 列表中的值可以跨越几行，缩进并不重要，Python知道，没有看到“]”，列表就没结束

比如说

someList=[1,
2,3
4
　　　　　　　　5]    # 没有问题的列表

• 可以在行末使用续行字符\，将一条指令写成多行。可以把\看成“这条指令在下一行继续”

比如说：

print('My name is '+\
      'SYolin')           #增强可读性