「Python」数据结构——列表和元组

Author：AXYZdong 自动化专业 工科男
有一点思考，有一点想法，有一点理性！
定个小小目标，努力成为习惯！在最美的年华遇见更好的自己！
CSDN@AXYZdong，CSDN首发，AXYZdong原创
唯一博客更新的地址为：  AXYZdong的博客 
B站主页为：AXYZdong的个人主页

文章目录

• 列表
• • 1.创建列表
  • 2.增删改查
  • 3.列表反转
  • 4.列表排序
  • 5.列表应用
• 元组
• • 1.创建元组
  • 2.元组查看
  • 3.元组和列表的转换

列表

列表（list），是由一系列元素按顺序进行排列而成的容器。

• 元素：可以是任意类型。
• 顺序：按顺序排列而成，列表是有序的。

“列表”是一个值，它包含多个字构成的序列。

“列表值”指的是列表本身，而不是指列表值之内的那些值。如：[‘a’ , ‘b’ , ‘c’ , ‘d’]

“表项”：列表值之内的那些值。

1.创建列表

>>> spam = [1, 2, 'a', 'b']  #第一种方法
>>> spam
[1, 2, 'a', 'b']
>>> spam = list()			 #第二种方法
>>> spam.append(1)
>>> spam.append(2)
>>> spam.append('a')
>>> spam.append('b')
>>> spam
[1, 2, 'a', 'b']

2.增删改查

查看元素

• 用下标取得类表中的单个值

假定列表 [‘a’ , ‘b’ , ‘c’ , ‘d’] 保存在名为 sapm 的变量中。

则 spam[0] 将求值为 ‘a’，spam[1] 将求值为 ‘b’，依次类推。

>>> spam=[['a','b','c'],[1,2,3]]
>>> spam[0]
['a', 'b', 'c']
>>> spam[1][2]
3
>>> spam[0][1]
'b'

负数下标：整数 -1 指的是列表中的最后一个下标，-2 指的是列表中倒数第二个下标。

• 用 index() 方法在列表中查找值

index() 方法可以传入一个值，如果该值在列表中，就返回它的下标。如果不在列表中就会报错。

>>> spam = ['Hello', 'world']
>>> spam.index('Hello')
0

如果列表中出现重复的值，就返回它第一次出现的下标。

>>> spam = ['Hello', 'world', 'Hello', 'world']
>>> spam.index('world')
1

• 利用切片取得子列表

下标可以从列表中取得单个值，而“切片”可以从列表中取得多个值，结果是一个新的列表。

1. spam[2] 是一个列表和下标（[ ]内一个整数）
2. spam[1:4] 是一个列表和切片（[ ]内两个整数）

切片中，[ 1 : 4 ] 内第一个整数是切片开始的下标，第二个整数是切片结束处的下标。切片向上增长，直至第二个下标的值，但不包括它。类似于区间 [1,4)。

切片求值为新的列表值。

>>> spam=['a','b','c','d']
>>> spam[1:3]
['b', 'c']
>>> spam[2:]  #可省略冒号两边的下标
['c', 'd']
>>> spam[:3]
['a', 'b', 'c']

• 用 len()取得列表的长度

>>> spam=['a','b','c','d']
>>> len(spam)
4

修改元素

用下标改变列表的值

>>> spam=['a','b','c','d']
>>> spam[0]='e'
>>> spam
['e', 'b', 'c', 'd']
>>> spam[:2]=['e','f']
>>> spam
['e', 'f', 'c', 'd']

新增元素

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

>>> spam = ['Hello', 'world']
>>> spam.append('!')
>>> spam
['Hello', 'world', '!']

>>> spam = ['Hello', '!']
>>> spam.insert(1,'world')
>>> spam
['Hello', 'world', '!']

1. append() 方法调用，将参数添加到末尾。
2. insert() 方法调用，可以在列表任意下标出插入一个值。
3. 方法属于单个数据类型。append() 和 insert() 方法是列表方法，只能在列表上使用，不能在其他值上使用。

• 列表连接和列表复制

1. +操作符可以连接两个列表，得到一个新的列表
2. *操作符可以用于一个列表和一个整数，实现列表的复制

>>> spam1 = ['a','b','c']
>>> spam2 = [1,2,3]
>>> spam3 = spam1 + spam2
>>> spam3
['a', 'b', 'c', 1, 2, 3]
>>> spam1 = spam1*2
>>> spam1
['a', 'b', 'c', 'a', 'b', 'c']

删除元素

• 用 del 语句从列表中删除值

>>> spam=['a','b','c']
>>> del spam[0]
>>> spam
['b', 'c']

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

remove() 方法可以传入一个值，如果该值在列表中，它将从被调用的列表中删除。如果不在列表中就会报错。

>>> spam = ['Hello', 'world', '!']
>>> spam.remove('!')
>>> spam
['Hello', 'world']

如果列表中出现重复的值，只有第一次的值会被删除。

>>> spam = ['Hello', 'world', 'Hello', 'world']
>>> spam.remove('Hello')
>>> spam
['world', 'Hello', 'world']

两种方法区别：

1. remove() 方法通过列表中的值删除列表中的值。
2. del 语句通过列表中的下标删除列表中的值。

3.列表反转

• 使用自带的 reverse() 方法

>>> spam = ['a','b','c','d']
>>> spam.reverse()
>>> spam
['d', 'c', 'b', 'a']

• 使用切片的方法

>>> spam = ['a','b','c','d']
>>> spam[::-1]
['d', 'c', 'b', 'a']
>>> spam
['a', 'b', 'c', 'd']

两种方法区别：

1. reverse方法是原地反转，作用在原对象上
2. 切片反转是返回一个新的对象，原对象不变

4.列表排序

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

数值的列表或字符串的列表，能用 sort() 方法排序。

1. 不能对既有数字和字符串值的列表排序。
2. 对字符串排序时，使用 “ASCII字符顺序”，大写字母在小写字母之前。

>>> spam.sort()
>>> spam
[-10, -2, -1, 3, 7, 10, 19]

>>> spam = ['Alice', 'ants', 'Bob', 'badgers', 'Carol', 'cats']

>>> spam.sort()
>>> spam
['Alice', 'Bob', 'Carol', 'ants', 'badgers', 'cats']

5.列表应用

• 列表用于循环

>>> spam=['a','b','c','d']
>>> for i in range(len(spam)):
	print('Index ' + str(i) + ' in spam is: ' + spam[i])

Index 0 in spam is: a
Index 1 in spam is: b
Index 2 in spam is: c
Index 3 in spam is: d

一个常见的Python技巧，是在 for 循环中使用 range(len(spam))，迭代列表的每一个下标。通过 i 访问下标，通过 spam[i] 访问下标出的值。range(len(spam)) 将迭代 spam 的所有下标。

• in 和 not in 操作符

>>> spam=['a','b','c']
>>> 'd' in spam
False
>>> 'a' in spam
True

• 多重赋值技巧

>>> spam=['a','b','c']
>>> first ,second ,third = spam
>>> first
'a'
>>> second
'b'
>>> third
'c'

• 变量的数目和列表的长度必须相等。

• 增强的赋值操作

>>> spam = ['Hello']
>>> spam += ['world']
>>> spam
['Hello', 'world']
>>> spam *= 2
>>> spam
['Hello', 'world', 'Hello', 'world']

• += 操作符可以完成字符串和列表的连接；
• *= 操作符可以完成字符串和列表的复制。

元组

元组（tuple），和列表非常相似，也是由一系列元素按照一定顺序排列而成的容器。

和列表区别：元组是不可变的（即元组中的值不可以增加、删除和改变），而列表是可变的。

1.创建元组

• 直接使用 () ，这里有别于创建列表时使用的 []

>>> tuple1 = ('a','b',1,2)
>>> tuple1
('a', 'b', 1, 2)

• () 可有可无

>>> tuple2 = 'a','b',1,2
>>> tuple2
('a', 'b', 1, 2)

• 使用元组推导式，由于元组是不可变的，所以生成一个生成器对象。

>>> tuple3 = (i for i in range (1,3))
>>> tuple3
 at 0x000002954017FA48>

创建只有一个元素的元组时，需要在元素的后面加一个逗号。

>>> tuple4 = (1)
>>> type(tuple4)

>>> tuple4
1
>>> tuple4 = (1,)
>>> type(tuple4)

>>> tuple4
(1,)
>>> tuple4 = 'a',
>>> type(tuple4)

>>> tuple4
('a',)

创建空元组

>>> a = tuple()		#第一种方法
>>> type(a)

>>> a
()
>>> b = ()			#第二种方法
>>> type(b)

>>> b
()

2.元组查看

元组是不可变的，因此元组中的值不可以增加、删除和改变，所以只能查看元组中的元素。（修改和删除元素会报错）

>>> tuple2 = 'a','b',1,2
>>> tuple2[0]
'a'
>>> tuple2[0]=1
Traceback (most recent call last):
  File "", line 1, in 
    tuple2[0]=1
TypeError: 'tuple' object does not support item assignment

3.元组和列表的转换

元组是不可变的（immutable），其通常包含不同种类的元素，并且通过解包或者索引来访问。

列表是可变的（mutable），其中的元素一般是同种类型，并且通过迭代访问。

• 元组转换成列表

>>> tuple2 = 'a','b',1,2
>>> type (tuple2)

>>> list(tuple2)
['a', 'b', 1, 2]

• 列表转换成元组

>>> list2 = ['a', 'b', 1, 2]
>>> type(list2)

>>> tuple(list2)
('a', 'b', 1, 2)

参考文献

[1]：Python 中文指南；作者：王炳明，版本：v1.0
[2]：Python编程快速上手:让繁琐工作自动化/ (美)斯维加特(A1 Sweigart) 著;王海鹏译.北京:人民邮电出版社,2016.7

  本次的分享就到这里

---

如果我的博客对你有帮助 、如果你喜欢我的博客内容，请 “点赞” “收藏” “关注” 一键三连哦！

更多精彩内容请前往 AXYZdong的博客

---

如果以上内容有任何错误或者不准确的地方，欢迎在下面  留个言。或者你有更好的想法，欢迎一起交流学习~~~