Python常用序列结构——列表、元组、字符串、字典和集合

本文最后更新于：2020年5月17日 晚上

概览：Python常用序列结构总结。

图片来源见图中水印。

列表

列表的主要特征

  1. 在形式上，列表的所有元素都存放在一对中括号[]中，相邻元素使用逗号分隔。
  2. 可以将数字、字符串、列表、元组等任何数据类型的内容放入列表之中。
  3. 同一个列表的元素类型可以是不同的，非常的灵活。

创建与删除列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 1. 创建空列表
empty_list = []

empty_list1 = list()

# 2. 创建含有内容的列表
num_list = [1,2,3,4,5]
print(num_list) #[1, 2, 3, 4, 5]

my_list = ['21',1,2,3,4,5,['qq','wechat']]
print(my_list)  #['21', 1, 2, 3, 4, 5, ['qq', 'wechat']]

range_list = list(range(10,20,2))
print(range_list) #[10, 12, 14, 16, 18]

char_list = list('道阻且长行将则至')
print(char_list) #['道', '阻', '且', '长', '行', '将', '则', '至']

# 3. 使用列表生成式创建列表
char_list = list('道阻且长行将则至')
new_char_list = [item for item in char_list]
print(new_char_list) #['道', '阻', '且', '长', '行', '将', '则', '至']

num_list = [i for i in range(1,10)]
print(num_list)      #[1, 2, 3, 4, 5, 6, 7, 8, 9]

# 3. 删除列表
del char_list

访问列表元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
char_list = list('道阻且长行将则至')

# 1. 通过下标访问
print(char_list[1])     #阻
print(char_list[-1])    #至
# 负数也可做为索引，从右向左，从-1开始作为索引

# 2. 切片操作
print(char_list[0:7:2]) #['道', '且', '行', '则']

# 3. 遍历列表
for item in char_list:
    print(item)

for index,item in enumerate(char_list):
    print(index,item) #同时输出索引值和元素内容

增加、修改与删除列表元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
char_list = list('道阻且长行将则至')

# 1. insert()向指定位置插入元素
char_list.insert(len(char_list),'加')
print(char_list) #['道', '阻', '且', '长', '行', '将', '则', '至', '加']

# 2. append()向末尾添加元素
char_list.append('油')
print(char_list) #['道', '阻', '且', '长', '行', '将', '则', '至', '加', '油']

# 3. extend()将一个列表的内容加入另一个列表
new_char_list = ['吧']

char_list.extend(new_char_list)
print(char_list) #['道', '阻', '且', '长', '行', '将', '则', '至', '加', '油', '吧']

# 4. 修改元素，通过索引直接重新赋值
char_list[-3] = '减'
print(char_list) #['道', '阻', '且', '长', '行', '将', '则', '至', '减', '油', '吧']

# 5. 删除元素，根据索引删除
del char_list[-1]
print(char_list) #['道', '阻', '且', '长', '行', '将', '则', '至', '减', '油']

# 6. 删除元素，根据元素值删除，使用remove()方法
del_value = '油'
if del_value in char_list:
    char_list.remove(del_value)

print(char_list) #['道', '阻', '且', '长', '行', '将', '则', '至', '减']
  • append()的效率要高于insert()方法
  • 使用remove()方法前最好判断要删除的元素是否存在

统计元素次数、获取元素索引

1
2
3
4
5
6
7
8
9
char_list = list('道阻且长行将则至')

# 1. 使用count()方法获取元素在列表中的出现次数
num = char_list.count('且')
print(num) # 1

# 2. 获取指定元素首次出现的下标
position = char_list.index('将')
print(position) # 5

对列表进行排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 1. 使用列表的sort()进行排序
num_list = [14, 51, 19, 35, 16, 13, 15, 60, 90, 77]
print(num_list) #[14, 51, 19, 35, 16, 13, 15, 60, 90, 77]

num_list.sort()
print(num_list) #[13, 14, 15, 16, 19, 35, 51, 60, 77, 90]

num_list.sort(reverse=True)
print(num_list) #[90, 77, 60, 51, 35, 19, 16, 15, 14, 13]

# 2. 使用内置sorted()函数排序
num_list = [14, 51, 19, 35, 16, 13, 15, 60, 90, 77]
print(num_list) #[14, 51, 19, 35, 16, 13, 15, 60, 90, 77]

num_as = sorted(num_list)
print(num_list) #[14, 51, 19, 35, 16, 13, 15, 60, 90, 77]
print(num_as)   #[13, 14, 15, 16, 19, 35, 51, 60, 77, 90]

num_des = sorted(num_list,reverse=True)
print(num_list) #[14, 51, 19, 35, 16, 13, 15, 60, 90, 77]
print(num_des)  #[90, 77, 60, 51, 35, 19, 16, 15, 14, 13]
  • sort()函数会改变原先列表的元素顺序。
  • sort()函数默认从小到大排序，指定reverse=True就可以逆序排序
  • sorted()函数用法和sort()基本相同，不过sorted()函数默认不会改变原来的列表。

元组

元组的主要特征

  1. 在形式上，元组使用小括号()括起来，元素使用逗号分开。
  2. 元组可以按照特定顺序存放一组元素，但元组是不可变序列，元素不能修改。
  3. 同一个元组的元素可以是不同的数据类型。
  4. 元组比列表的访问以及处理速度都要快。

创建删除元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 1. 创建空元组
empty_tuple = ()

empty_tuple = tuple()

# 2. 使用()创建元组

num_tuple = (1,2,3,4,5)
print(num_tuple) #(1, 2, 3, 4, 5)

untitle = (1,'2',num_tuple)
print((untitle)) #(1, '2', (1, 2, 3, 4, 5))

my_str = ('hello')
print(type(my_str)) #<class 'str'>

my_str_tuple = ('hello',) # 多加一个逗号来创建元组
print(my_str_tuple) #('hello',)
print(type(my_str_tuple)) #<class 'tuple'>

# 3. 使用tuple()创建元组

num_tuple = tuple(range(1,10))
print(num_tuple) #(1, 2, 3, 4, 5, 6, 7, 8, 9)

str_tuple = tuple('hello')
print(str_tuple) #('h', 'e', 'l', 'l', 'o')

# 4. 使用元组生成式创建元组
import random
my_num_tuple = (random.randint(10,100) for i in range(0,10))

print(my_num_tuple) #<generator object <genexpr> at 0x00000221286B7748>
                    # 使用元组生成式产生的是一个生成器对象，还需要额外转换

my_num_tuple = tuple(my_num_tuple)
print(my_num_tuple) #(96, 93, 60, 22, 78, 59, 43, 32, 85, 40)

# 5. 删除元组
del str_tuple

访问元组元素

1
2
3
4
5
6
7
8
9
num_tuple = (96, 93, 60, 22, 78, 59, 43, 32, 85, 40)

# 1. 通过下标访问元组元素
print(num_tuple[0])     #96
print(num_tuple[0:4])   #(96, 93, 60, 22)

# 2. for循环遍历
for item in num_tuple:
    print(item)

元组连接组合

1
2
3
4
5
6
7
8
9
# 元组内的元素不能修改
num_tuple = (96, 93, 60, 22, 78, 59, 43, 32, 85, 40)
# num_tuple[-1] = 22 #TypeError: 'tuple' object does not support item assignment

my_num_tuple = (1,2)

# 元组连接时要求连接的内容必须的元组
num_tuple += my_num_tuple
print(num_tuple) #(96, 93, 60, 22, 78, 59, 43, 32, 85, 40, 1, 2)

字符串

字符串的特征

  1. 字符串是不可变的序列，不能修改内容。
  2. Python中的字符串可以使用单引号、双引号以及三个单引号的形式括起来。
  3. Python字符串也支持转义符\。

字符串的表示

1
2
3
4
5
my_str0 = 'hello'
my_str1 = "123"
my_str2 = '''
			12fsdfg
		  '''

字符串的操作符：+、*、in

1
2
3
4
5
6
7
8
9
10
mystr = 'hello'
mystr1 = 'world'

print(mystr + ' ' + mystr1) #hello world
# 字符串不允许直接和其他类型进行拼接

print(mystr1 * 3) #worldworldworld

print('lo' in mystr) #True
# in 是查看是否是字符串的子串

字符串的索引和切片

1
2
3
4
mystr = 'bullet'

print(mystr[2]) #l
print(mystr[0:len(mystr):2]) #ble

字符串的基本函数

1
2
3
4
5
6
7
8
9
10
11
print(len('一二三456')) #6

print(str([1,2])) #[1, 2]

print(hex(125)) #0x7d

print(oct(125)) #0o175

print(ord('a')) #97

print(chr(97)) #a
  • len(s) 返回字符串s长度
  • str(x) 将任意类型转换成对应的字符串形式
  • hex(x) 将整数转成十六进制字符串
  • oct(x) 将整数x转成八进制字符串
  • ord(x) 返回字符x的Unicode编码
  • chr(x) 返回Unicode编码x对应的字符

字符串处理

  • str.find(sub)：检索str中是否存在子串sub，若不存在则返回-1，存在则返回首次出现时的索引。
  • str.startswith(prefix)：检查字符串是否是以prefix开头，是返回True，否则返回False
  • str.endswith(suffix)：检查字符串是否是以suffix结尾，是返回True，否则返回False

格式化字符串

字典

Python中的字典相当于Java或者C++中的Map。

Python中的字典与列表一样都是可变序列，但不同于列表，字典是无序的，它保存的内容都是以“键值对”的形式存放的。

字典的主要特征

  1. 字典通过键(key)来读取，但不能通过索引来读取。
  2. 字典是任意对象的无序集合，随机排列。
  3. 字典是可变的，可以任意嵌套，它的值(value)可以是其他列表或者字典。
  4. 字典的键(key)必须唯一且不可变，即可使用字符串、元组作为键但是不能使用列表、集合字典等其他可变值做为键。

字典的创建与删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 1. 使用{}方式创建
mydict0 = {} # 空字典

mydict1 = {"qq":"110110110","wechat":"hagsjhfaj"} #使用键值对形式创建

# 2. 使用dict()创建
mydict2 = dict() #空字典

mydict3 = dict(qq = "110110110",wechat = "hagsjhfaj")

list1 = ['qq','wechat']
list2 = ['110110110','hagsjhfaj']
mydict4 = dict(zip(list1,list2)) # 使用zip()函数将两列表对应位置的元素组合成元组返回成zip对象

# 3. 字典推导式
import random
mydict5 = {i:random.randint(10,100) for i in range(1,5)}

print(mydict5) # {1: 70, 2: 100, 3: 63, 4: 52}
# 4. 删除
mydict5.clear() # 清楚字典中的全部元素

del mydict #彻底删除字典

访问字典元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 1. 遍历字典元素
mydict = dict(qq = "110110110",wechat = "hagsjhfaj")
for item in mydict.items():
    print(item)         # ('qq', '110110110')
    print(type(item))   # <class 'tuple'>

# 分别获取具体的每个键与值
for key,value in mydict.items():
    print(key,':',value)

# 单独获取全部的key，value同理
for key in mydict.keys():
    print(key)
    
# 2. 通过键获得指定的值
mydict = dict(qq = "110110110",wechat = "hagsjhfaj")

print(mydict['qq']) #类似列表下标的方式

# 3. 使用get()方法获得指定键的值
mydict.get('qq') # 110110110
# 针对于get(key[,default])如果指定的key不存在，返回默认值，若默认值为空，则默认返回None
mydict.get('weibo','不存在') # 不存在

添加、修改与删除字典元素

1
2
3
4
5
6
7
8
9
10
11
12
13
# 添加与修改
mydict = dict(qq = "110110110",wechat = "hagsjhfaj")
mydict['weibo'] = 'shello' #添加一个元素，若键值存在，则变成修改元素

print(mydict) # {'qq': '110110110', 'wechat': 'hagsjhfaj', 'weibo': 'shello'}

mydict['weibo'] = 'nhello' #修改元素
print(mydict) # {'qq': '110110110', 'wechat': 'hagsjhfaj', 'weibo': 'nhello'}

# 删除
mydict.pop('qq') #删除指定键的元素，并返回键对应的value值

del mydict['qq'] #删除指定键的元素

集合

Python中的集合用于保存不重复的元素。

集合有可变集合set与不可变集合frozenset两种，这里主要介绍set。

set的主要特征

  1. set集合是无序可变序列，随机排列
  2. 形式上，集合中的所有元素都放在一对大括号之中{ }
  3. 集合的特性是元素唯一，常用于去重操作。

set集合的创建

1
2
3
4
5
6
7
8
9
10
11
12
# 1. 使用{}创建，元素可以是Python支持的任意数据类型
myset = {1,2,3,4,2}

print(type(myset)) 	#<class 'set'>
print(myset) 		#{1, 2, 3, 4} set会自动去重的

# 2. 使用set()函数创建
myset1 = set('此爱隔山海，山海皆可平')
print(myset1) #{'隔', '皆', '爱', '山', '海', '平', '可', '，', '此'}

myset2 = set([1,2,3,4,5,6])
print(myset2) #{1, 2, 3, 4, 5, 6}
  • 当创建空集合的时候只能使用set()函数，直接使用{}创建的是空字典。
  • set()函数可以将列表、元组、字符串、range对象等可迭代对象转换为集合，并且自动去重。

set集合元素的访问

由于set集合是无序可变序列，不能使用类似列表下标的方式访问元素，最好的方法是将set集合转成list再访问。

set集合的添加、删除与合并

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 1. 添加元素
myset = set([1,2,3,4,5,6])

myset.add('7')
print(myset) #{1, 2, 3, 4, 5, 6, '7'}

list1 = [8,9]	 #添加列表元组之类的元素会出错 
myset.add(list1) #TypeError: unhashable type: 'list'

# 2. 删除元素
if '7' in myset:
	myset.remove('7')
print(myset) #{1, 2, 3, 4, 5, 6}

print(myset.pop())  # 1
print(myset)        # {2, 3, 4, 5, 6}

del myset
print(myset)        # NameError: name 'myset' is not defined

# 3. 合并集合
myset1 = set([1,2,3,4,5,6])
myset2 = set(['hello','hi'])

myset1.update(myset2)
print(myset1) #{1, 2, 3, 4, 5, 6, 'hi', 'hello'}
  • set的add()方法添加元素时只能使用字符串、数字、布尔类型，不能使用列表、元组等可迭代对象。
  • 移除指定元素时最好使用in查看元素是否在集合之中。

set集合常用的交、并和差集的运算

1
2
3
4
5
6
7
8
9
pf = set(['邓肯','加内特','马龙'])
print('大前锋位置的球员有',pf)

cf = set(['邓肯','奥尼尔','姚明'])
print('中锋位置的球员有',cf)

print('交集运算',pf & cf) #交集运算 {'邓肯'}
print('并集运算',pf | cf) #并集运算 {'奥尼尔', '加内特', '邓肯', '姚明', '马龙'}
print('差集运算',pf - cf) #差集运算 {'马龙', '加内特'}

转化

将list中全部的字符串转成数字

1
2
3
4
5
list1 = ['1','2','3','4']
print(list1) #['1', '2', '3', '4']

list1 = list(map(int,list1))
print(list1) #[1, 2, 3, 4]

list转成字符串

1
2
3
4
5
6
list1 = ['1','2','3','4']
str1 = str(list1)

print(str1) #['1', '2', '3', '4']

print("".join(list1)) #1234

参考资料： Python字符串

Python序列结构（数据结构）