Python中容器类型的数据

目录

序列

序列的索引操作

加和乘操作

切片操作

成员测试

列表

创建列表

追加元素

插入元素

替换元素

删除元素

元组

创建元组

元组拆包

集合

创建集合

修改集合

字典

创建字典

修改字典

访问字典视图

遍历字典

若我们想将多个数据打包并且统一管理，应该怎么办？ Python内置的数据类型如序列（列表、元组等）、集合和字典等可以容纳多项数据，我们称它们为容器类型的数据。

序列

序列是一种可迭代的、元素有序的容器类型的数据。序列包括列表（list）、字符串（str）、元组（tuple）和字节序列（bytes）等。

序列的索引操作

序列中的元素都是有序的，每一个元素都带有序号，这个序号叫作索引。索引有正值索引和负值索引之分。

序列示例：Hello字符串

>>>a='Hello'
>>>a[0]
'H'
>>>a[-5]
'H'
>>>max(a) # max()函数返回最后一个元素
'o'
>>>min(a) # min()函数返回第一个元素
'H'
>>>len(a) # len()函数用于获取序列的长度
5

加和乘操作

加（+）和乘（*）运算符也可以用于序列中的元素操作。加（+） 运算符可以将两个序列连接起来，乘（*）运算符可以将两个序列重复多次。

>>>a='Hello'
>>>a*2
'HelloHello'
>>>a='Hello'+','
'Hello,'
>>>a+='World'
>>>a
'Hello,World'

切片操作

序列的切片（Slicing）就是从序列中切分出小的子序列。切片运算符的语法形式为[start：end：step]。其中，start是开始索引 ，end是结束索引，step是步长（切片时获取的元素的间隔，可以为正整数，也可以为负整数）。

注意：切下的小切片包括start位置的元素，但不包括end位置的元素 ，start和end都可以省略。

>>>a='Hello'
>>>a[1:3]
'el'
>>>a[:3]//省略了开始索引，默认开始索引为0，所以a[:3]和a[0:3]的切片结果是一样的
'Hel'
>>>a[0:3]
'Hel'
>>>a[0:]//省略了结束索引，默认结束索引是序列的长度，即5.所以a[0:]与a[0:5]的切片结果是一样的
'Hello'
>>>a[0:5]
'Hello'
>>>a[:]//省略了开始索引和结束索引
'Hello'
>>>a[1:-1]//使用了负值索引
'ell'

当步长不为1时

>>>a='Hello'
>>>a[1:5]
'ello'
>>>a[1:5:2]
'el'
>>>a[0:3:2]
'Hl'
>>>a[0:3:3]
'H'

成员测试

成员测试运算符有两个：in和not in，in用于测试是否包含某一个元素，not in用于测试是否不包含某一个元素。

>>>a='Hello'
>>>'e' in a
True
>>>'E' not in a
True

列表

列表（list）是一种可变序列类型，我们可以追加、插入、删除和替换列表中的元素。

创建列表

创建列表有两种方法。

1 list（iterable）函数：参数iterable是可迭代对象（字符串、列表、 元组、集合和字典等）。

2 [元素1，元素2，元素3，⋯]：指定具体的列表元素，元素之间以逗号分隔，列表元素需要使用中括号括起来。

>>>[20,10,50,30]
[20,10,50,30]
>>>[] # 创建空列表
[]
>>>['Hello','World',1,2,3] # 创建一个字符串和整数混合的列表
['Hello','World',1,2,3]
>>>a=[10]
>>>a
[10]
>>>a[10,] # 列表的每一个元素后面都跟着一个逗号，但经常省略这个逗号
>>>a
[10]
>>>list('Hello')
['H','e','l','l','o']

追加元素

列表是可变的序列对象，列表可以追加元素。

1 在列表中追加单个元素时，可以使用列表的append（x）方法。

2 在列表中追加多个元素时，可以使用加（+）运算符或列表的extend(x)方法。

>>>list=[20,10,50,30]
>>>list.append(80)
>>>list
[20,10,50,30,80]
>>>list=[20,10,50,30]
>>>t=[1,2,3]
>>>list+=t
>>>list
[20,10,50,30,1,2,3]
>>>list=[20,10,50,30]
>>>list.extend(t)
>>>list
[20,10,50,30,1,2,3]

插入元素

想向列表中插入元素时，可以使用列表的list.insert（i，x）方法， 其中，i指定索引位置，x是要插入的元素。

>>>list=[20,10,50,30]
>>>list.insert(2,80)
>>>list
[20,10,80,50,30]

替换元素

想替换列表中的元素时，将列表下标索引元素放在赋值符号（=） 的左边，进行赋值即可。

>>>list=[20,10,50,30]
>>>list[1]=80
>>>list
[20,80,50,30]

删除元素

想在列表中删除元素时，可使用列表的list.remove（x）方法，如果找到匹配的元素x，则删除该元素，如果找到多个匹配的元素，则只删除第一个匹配的元素。

>>>list=[20,10,80,50,30]
>>>list.remove(80)
>>>list
[20,10,50,30]

元组

元组（tuple）是一种不可变序列类型。

创建元组

创建元组时有两种方法。

1 tuple（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）。

2 （元素1，元素2，元素3，⋯）：指定具体的元组元素，元素之间以逗号分隔。对于元组元素，可以使用小括号括起来，也可以省略小括号。

>>>21,32,43,45 # 创建一个有4个元素的元组，创建元组时使用小括号把元素括起来或省略
(21,32,43,45)
>>>('Hello','World') # 创建字符串元组
('Hello','World')
>>>('Hello','World',1,2,3) # 创建字符串和整数混合的元组
('Hello','World',1,2,3)
>>>tuple([21,32,43,45])
(21,32,43,45)
>>>t=1, # 创建只有一个元素的元组，元素后面的逗号不能省略
>>>t
(1,)
>>>type(t)
<class 'tuple')
>>>t=(1,)
>>>type(t)
<class 'tuple'>
>>>a=() # 通过()可以创建空元组
>>>type(a)
<class 'tuple'>

元组拆包

创建元组，并将多个数据放到元组中，这个过程被称为元组打包。与元组打包相反的操作是拆包，就是将元组中的元素取出，分别赋值给不同的变量。

>>>s_id,s_name=(102,'张三')
>>>s_id
102
>>>s_name
'张三'

集合

集合（set）是一种可迭代的、无序的、不能包含重复元素的容器类型的数据。

创建集合

序列中的元素是有序的，集合中的元素是无序的，但集合中的元素不能重复。

我们可以通过以下两种方式创建集合。

1 set（iterable）函数：参数iterable是可迭代对象（字符串、列表、 元组、集合和字典等）。

2 {元素1，元素2，元素3，⋯}：指定具体的集合元素，元素之间以逗号分隔。对于集合元素，需要使用大括号括起来。

>>>set('Hello')
{'o','H','e','l'}
>>>{20,15,10,30,20,15}
{10,20,30,15}
>>>b={}
>>>type(b)
<class 'set'>

修改集合

修改集合类似于修改列表，可以向其中插入和删除元素。修改可变集合有如下的常用方法。

add（elem）：添加元素，如果元素已经存在，则不能添加，不会抛出错误。

remove（elem）：删除元素，如果元素不存在，则抛出错误。

clear（）：清除集合。

>>>s_set={'张三','李四','王五'}
>>>s_set.add('董六')
>>>s_set
{'王五','张三','李四','董六'}
>>>s_set.remove('李四')
>>>'李四' in s_set
False
>>>s_set.clear()
>>>S_set
set()

字典

字典（dict）是可迭代的、通过键（key）来访问元素的可变的容器类型的数据。

字典由两部分视图构成：键视图和值视图。键视图不能包含重复的元素，值视图能。在键视图中，键和值是成对出现的。

创建字典

我们可以通过以下两种方法创建字典。

1 dict（）函数。

2 {key1：value1，key2：value2，...，key_n：value_n}：指定具体的字典键值对，键值对之间以逗号分隔，最后用大括号括起来。

>>>dict({102:'张三',105:'李四',109:'王五'}) # 通过dict()函数创建字典，参数是另外一个字典
{102:'张三',105:'李四',109:'王五'}
>>>dict(((102:'张三'),(105:'李四'),('109:'王五'))) # 通过dict()函数创建字典，参数是一个元组，在这个元组中包含三个只有两个元素的元组
{102:'张三',105:'李四',109:'王五'}
>>>dict([(102,'张三'),(105,'李四'),(109,'王五')]) # 通过dict()函数创建字典，参数是一个列表，在这个列表中包含三个只有两个元素的元组
{102:'张三',105:'李四',109:'王五'}
>>>dict(zip([102,105,109],['张三','李四','王五'])) # 通过zip()函数将两个可迭代对象打包成元组，第一个参数是字典的键，第二个参数是字典值，它们包含的元素个数相同，并且一一对应
{102:'张三',105:'李四',109:'王五'}
>>>dict1={102:'张三',105:'李四',109:'王五'}
>>>dict1
{102:'张三',105:'李四',109:'王五'}

修改字典

字典可以被修改，但都是针对键和值同时操作的，对字典的修改包括添加、替换和删除。

>>>dict1={102:'张三',105:'李四',109:'王五'}
>>>dict[109] # 通过字典键返回对应的值
'王五'
>>>dict[110]='董六' # 通过110键赋值，如果此时在字典中没有110键，则添加110:'董六'键值对
>>>dict1
{102:'张三',105:'李四',109:'王五',110:'董六'}
>>>dict1[109] # 将109键对应的值替换为'张三'
>>>dict1
{102:'张三',105:'李四',109:'张三',110:'董六'}
>>>dict1.pop(105) # 使用字典的pop(key)方法删除键值对，返回删除的值
'李四'
>>>dict1
{102:'张三',109:'张三',110:'董六'}

访问字典视图

我们可以通过字典中的三种方法访问字典视图。

items（）：返回字典的所有键值对视图。

keys（）：返回字典键视图。

values（）：返回字典值视图。

>>>dict1={102:'张三',105:'李四',109:'王五'}
>>>dict1.items()
dict_items([(102:'张三'),(105:'李四'),(109:'王五')])
>>>list(dict1.items())
[(102,'张三'),(105,'李四'),(109,'王五')]
>>>dict1.keys()
dict_keys([102,105,109])
>>>list(dict1.keys())
[102,1055,109]
>>>dict1.values()
dict_values(['张三','李四','王五'])
>>>list(dict1.values())
['张三','李四','王五']

遍历字典

遍历就是从容器中取出每一个元素的过程，在进行序列和集合遍历时使用for循环就可以。但字典有两个视图，在遍历时，可以只遍历值视图，也可以只遍历键视图，还可以同时遍历，这些便利都是通过for循环实现的。

s_dict={102:'张三',105:'李四',109:'王五'}
print('---遍历键---')
for s_id in s_dict.keys():
    print('学号：'+str(s_id))
print('---遍历值---')
for s_name in s_dict.values():
    print('学生：'+s_name)
print('---遍历键：值---')
for s_id,s_name in s_dict.items():
    print('学号：{0}-学生：{1}'.format(s_id,s_name))

输出

---遍历键---
学号：102
学号：105
学号：109
---遍历值---
学生：张三
学生：李四
学生：王五
---遍历键：值---
学号：102-学生：张三
学号：105-学生：李四
学号：109-学生：王五