组合数据类型

组合数据类型

1 集合类型(两判断+246)

​ 判断集合与集合之间关系与判断元素与集合之间关系，两个操作函数，四个操作符，六个操作方法（其中一个增加集合元素方法，一个复制集合元素方法和四个集合元素删除方法）

1.1 集合的定义

集合是多个元素的无序组合
1.集合用大括号{}表示，元素之间用逗号分隔
2.建立集合类型用{} / set()
3.若建立空集合类型，必须使用set()¹

• 集合类型与数学中的集合概念一致
• 集合元素之间无序，每个元素唯一，不存在相同元素
• 要求放入集合中的元素均为不可变数据类型，也就是说集合中的元素一旦被放到集合中，这个元素是不能被修改的
  **注:**非可变数据类型:整数，浮点数，复数，字符串类型，元组类型等

a={
     ''python'',123,(''python'',123)}  #使用{}建立集合
print(a)
b=set("pypy123")    #使用set()建立集合
print(b)
c={
     'python',123,'python',123}   #证明集合中不存在相同元素
print(c)

输出:

{
     ('python', 123), 123, 'python'}
{
     'p', 'y', '1', '3', '2'}
{
     123, 'python'}

1.2 集合的操作符(4+一个判断)

数学语言	操作符	描述
并	S|T	返回一个新集合，包括在集合S和T中的所有元素
差	S-T	返回一个新集合，包括在集合S中但不在T中的元素
交	S&T	返回一个新集合，包括同时在在集合S和T中的元素
补	S^T	返回一个新集合，包括在集合S和T中的非相同元素
子集	S<= /	返回True则表示,S为T的子集，返回False,则不是
子集	S>= / >T	返回True则表示,T为S的子集，返回False,则不是

增强操作符(4)

通过四种操作符与赋值符号的组合来实现对集合S的更新

增强操作符	要表达的意思
S|=T	S=S|T
S-=T	S=S-T
S&=T	S=S&T
S^=T	S=S^T

a={
     'p','y',123}
b=set("py123")
a-b
b-a
a&b
a^b
a|b

输出:

{
     123}
{
     '2', '1', '3'}
{
     'p', 'y'}
{
     '1', '3', '2', 123}
{
     'p', 'y', '1', '3', '2', 123}

1.3 集合处理方法及函数 (一个判断+26)

操作方法	描述
S.add(x)	如果x不在集合S中，则将X增加到S(增加元素)
S.discard(x)	删除集合S中的元素x，如果x不在集合S中，不会报错(删除元素)
S.remove(x)	删除集合S中的元素x，如果x不在集合S中，则产生KeyError异常(删除元素)
S.clear()	删除集合S中的所有元素(删除元素)
S.pop()	随机取出2S的一个元素，若S为空，则产生KeyError异常(删除元素)
S.copy	返回集合S的一个副本(复制元素)

a={
     'p','y',123,'1','2','3'}
a.add('123')
print(a)
a.discard('1')
print(a)
a.remove(1)    #因为集合a中没有元素1，这里会直接报错，出现KeyError异常
a.pop()        #首先会随机打印出一个集合a中的元素，然后打印集合a时发现集合中前面打印的元素已被删除#
print(a)
a.clear()     #此时集合a中元素全被删除，接下来打印的集合a为空集合
print(a)

输出：

{
     '2', '123', '1', 'p', '3', 'y', 123}
{
     '2', '123', 'p', '3', 'y', 123}
#下面四行是.remove()引起的异常
Traceback (most recent call last):
  File "", line 1, in <module>
    a.remove(1)
KeyError: 1
'2'     #随机返回的元素
{
     '123', 'p', '3', 'y', 123}
set()   #空集合

操作函数	描述
len(S)	返回集合S的元素个数
set(x)	将其他类型变量x转变为集合类型

判断元素与集合关系的操作符	描述
X in S	判断S中元素x，x在集合中，返回True，否则返回False
X not in S	判断S中元素x，x不在集合中，返回True，否则返回False

1.4 集合类型应用场景

1.4.1 包含关系的比较

集合与集合包含关系的比较与集合与元素包含关系的比较

'p' in {
     'p','y',123}

输出:
True

{
     'p','y'}>={
     'p','y',123}

输出:

False

1.4.2 数据去重

利用集合数据类型中所有元素不能重复的特点，对一组数据中的重复元素进行删除，留下不重复/不相同的元素

ls=['p','y','p','y',123]
s=set(ls)     #利用集合元素不能重复的特点，进行数据去重
print(s)
lt=list(s)    #将集合转换成列表
print(lt)

输出:

{
     123, 'p', 'y'}
[123, 'p', 'y']

2 序列类型(基本6+6 列表的1234 元组的不变)

序列基本的六个操作符和六个操作函数(方法)

访问与修改列表元素的一种操作，两个增加列表元素的方法，三个改变列表元素排序的方法(函数)，四个删除列表元素的方法(函数)

定义:具有先后关系的一组元素(说明元素之间是有序的)

• 序列是一维元素向量，元素类型可以不同

• 由于元素之间存在先后关系，所以元素之间可以相同

• 类似于数学元素序列：S₀ , S₁ , … , S_N-1

• 元素之间有序号引导，通过下标访问序列的特定元素

• 在序列类型中，元素存在正向递增序号的索引关系和反向递减序号的索引关系

我们一般使用的时候，不会直接使用序列类型，而是使用序列类型衍生出的几种数据类型:

1. 字符串类型
2. 列表类型
3. 元组类型
   注:序列类型的所有操作在衍生出的几种类型中都是适用的，同时各种衍生类型又有各自独特的操作能力

序列通用函数及方法(6+6)

此处用列表来表示序列,所以此处序列用[]表示

操作符(6)

操作符	描述
x in s	判断
x not in s	判断
s+t	连接两个序列s和t
s * n / n * s	将序列s复制n次
s[i]	索引，与字符串索引相同
s[i:j:k]	切片，与字符串切片相同

ls=['python',123,'.io']
ls=[::-1]
['.io',123,'python']

注:,当要返回序列s中的第几个元素时，此时索引的序号为:元素位置-1

函数和方法(6)

函数和方法	描述
len(s)	返回序列s的长度
min(s) /max (s)	返回序列s的最小 / 最大 元素，当序列中元素可比较时
s.index(x) / s.index(x,i,j)	返回序列s从索引i开始，到索引j中第一次出现元素x的索引序号
s.count(x)	返回序列s中出现元素x的总次数

s=[2,3,466,78,-5.35,2,45,2,9,72,2]
len(s)
11
min(s)
-5.35
s.index(2,2,9)
5  #返回为在索引2和9之间第一次出现元素2的索引序号
s.count(2)
4

2.1 列表类型(1+2+3+4)

• 列表是一种序列类型，十分常用
• 使用[] / list()创建，元素之间用逗号分隔
• 列表会随着每次运算发生改变，与元组不同
• 只有[] / list()才是真正创建了一个列表，赋值仅表示传递引用

ls=[2,3,467,466,44,1]
print(ls)
[2,3,467,466,44,1]
lt=is  #此处并未创建一个新列表，只是将列表ls的值赋给了变量lt
print(lt)
[2,3,467,466,44,1]

2.1.1 访问列表元素

方法与字符串中索引相同
格式:list[i]
注:访问列表元素时，要注意列表元素顺序与索引的关系，索引=列表元素顺序-1
例如，访问列表的第三个元素就是访问索引(位置)为2处的元素，应使用list[2]

2.1.2 修改及复制列表元素(2种操作)

操作	描述
lt=ls[:]	通过切片的方式产生列表ls的一个副本，即产生了一个新列表，这与列表赋值不同
ls[i]=x	用x(任意数据类型)替换列表ls索引为i的元素
ls[i:j:k]=x	用x(任意数据类型)替换ls切片后所对应的元素子列表

ls=['one','two','three',3,2,1]
ls[3]='three'
print(ls)
['one','two','three','three',2,1]
ls[2:4]=[1,2,3,4,5,6]
print(ls)
['one','two',1,2,3,4,5,6,2,1]

**注:**通过上述程序可知，列表是动态的，随着程序的运行，列表会发生相应的改变。

2.1.3 添加列表元素(2个方法)

函数/方法	描述
ls.append(x)	在列表最后增加一个元素x
ls.insert(i,x)	在列表索引为i处增加元素x，即在索引i处插入x，原来索引i处元素向后退一位。

1.在列表末尾添加元素

利用.append()方法在列表末尾添加元素

ls=[1,2]
ls.append('end')
print(ls)
[1, 2, 'end']
ls.append(4)
print(ls)
[1, 2, 'end', 4]

2.在列表中插入元素

利用.insert()方法在列表中插入元素

ls=['cat','dog','tiger',1024]
ls.insert(3,'human')
print(ls)
['cat', 'dog', 'tiger', 'human', 1024]

2.1.4 删除列表元素(3个方法和1个操作符)

操作符及方法	描述
del ls[i]	删除列表ls中索引为i的元素
del ls[i:j:k]	删除列表ls中切片的元素
ls.pop(i)	将列表ls中索引为i的元素从列表ls中取出,返回为被取出的元素，i默认为-1
ls.remove(x)	删除列表ls中第一次出现的元素x
ls.clear()	删除列表ls中所有元素

注:

• 将元素删除后，不使用已删除元素：del语句
• 将元素删除后，需要使用已删除元素:.pop(),.remove(),需要先给被删除的元素赋值，再使用被删除元素,这两种方法的赋值还有点不一样，具体看下方代码

ls=[1,2,3,4,5]
poped_ls=ls.pop() #ls.pop()就是被删除的元素，现在把被删除的元素赋值给poped_ls
print(ls)
print(poped_ls)
[1, 2, 3, 4]
5
shan=4    #我们先给要删除的元素赋值，此时的4是元素值，不是索引，需要注意
ls.remove(shan) #删除赋值后的变量
print(ls)
[1, 2, 3]

适用情况	方法
知道删除元素的值时	.remove()
知道删除元素的索引	del语句，.pop()

1.使用del语句删除列表元素

ls=[2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2]
del ls[2]
print(ls)
[2, 3, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]
del ls[2:12:3]
print(ls)
[2, 3, 6, 7, 9, 10, 8, 7, 5, 4, 3, 2]

2.使用.pop()方法取出列表元素

ls=[1,2,3,4,5]
ls.pop()
5
print(ls)
[1, 2, 3, 4]
ls.pop(3)
4
print(ls)
[1, 2, 3]

3.使用.remove()方法删除列表元素

ls=['one','two','three','four','five']
lll='four'
ls.remove(lll)
print(ls)
['one', 'two', 'three', 'five']

4.使用.clear()方法删除列表中所有元素

ls=[1,2,3,4,5]
ls.clear()
print(ls)
[]

2.1.5 列表元素排序(两个方法和一个函数)

方法	描述
ls.sort()	使列表元素按首字母顺序排序显示列表**(永久)**
sorted(ls)	使列表元素按首字母顺序排序显示列表**(临时)**
ls.reverse()	使列表元素倒序

注:.sort()方法与sorted()函数中可加参数reverse=True,表示按元素首字母顺序逆序显示列表

1.使用.sort()方法对列表元素进行永久排序

ls=['cba','nbc','abc','dbc']
ls.sort()
print(ls)  
['abc', 'cba', 'dbc', 'nbc']  #证明了.sort()方法的永久性
ls.sort(reverse=True)  #使用参数reverse=True使列表ls按元素首字母顺序逆序
print(ls)
['nbc', 'dbc', 'cba', 'abc']

2.使用sorted()函数对列表元素进行临时排序

ls=['cba','nbc','abc','dbc']
print(sorted(ls))
['abc', 'cba', 'dbc', 'nbc']
print(ls)
['cba', 'nbc', 'abc', 'dbc'] #证明sorted()函数的排序是临时的

3.使用.reverse()方法对列表元素进行逆序

ls=['cba','nbc','abc','dbc']
ls.reverse()
print(ls)  #证明.reverse()方法的永久性
['dbc', 'abc', 'nbc', 'cba']
ls.reverse()
print(ls) 
['cba', 'nbc', 'abc', 'dbc'] #证明了.reverse()方法永久性的可逆性

**注:**虽然.reverse()方法也是永久性的，但是我们可以再次使用.reverse()方法让列表元素变会原序列

2.2 元组类型

2.2.1 对于元组的介绍

元组是序列类型的一种扩展,就是将元素进行有序的排列，用()来组织。
元组是一种序列类型，一旦创建就不能被修改
使用() / tuple()创建，元素之间用逗号分隔
在使用的时候，元组可以有圆括号，也可以不用圆括号
比如:

creature='cat','dog','tiger','human' #建立元组时未使用圆括号
print(creature)
('cat', 'dog', 'tiger', 'human')
color=(0x001100,'blue',creature)    #用圆括号建立元组
print(color)
(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))

2.2.2 元组类型的操作

元组继承序列类型的全部通用操作，即六个操作符和六个处理函数及方法
元组类型因为创建后不能修改，因此没有特殊操作
**注:**在对元组进行切片时，并不改变原有元组的值，而是生成了一个新的元组值
比如:

#继上例
creature[::-1]
('human', 'tiger', 'dog', 'cat')  #生成的新元组
color[-1][2]  #[-1]使索引到creature这个元素上，由于该元素是元组，所以还可以使用索引
'tiger'  #说明creature[::-1]未改变原来元祖的值

2.3 序列类型应用场景

2.3.1 数据表示

数据表示指的是我们要用元组 / 列表来表达一组有序数据，通过这样的类型表达有序数据，进而操作他们

• 元组用于表示元素不改变的应用场景，更多用于固定搭配场景
• 列表用于需要处理数据且需要处理功能比较多样的场景

2.3.2 元素遍历

#列表元素遍历:
for item in ls:
    #语句块

#元组元素遍历
for item in tuple:
    #语句块

2.3.3 数据保护

如果不希望数据被程序所改变，将数据转换成元组

ls=['cat','dog','tiger',1024]
lt=tuple(ls)
print(lt)
('cat', 'dog', 'tiger', 1024)

3 字典数据类型

3.1 字典类型的定义

• 理解映射
  1 映射是一种键(索引)和值(数据)的对应关系
  2 映射表达某一个属性跟他对应的值
  3 映射本身就是一种索引/属性与数据的之间的对应关系
  **注:**序列类型由0…N整数作为数据的默认索引，映射类型则由用户为数据定义索引
• 字典类型是映射的体现
  1 字典是一系列键值对可以使用键来访问与之相关联的值，与键相关联的值可以是数字，字符串，列表，乃至字典。
  2 字典是放在{}中的一系列键值对，键和值之间用冒号分隔，而键值对之间用逗号分隔，键值对之间无序
  字典：{<键1>:<值1>,<键2>:<值2>,…,.<键N>:<值N>}

3.2 字典的建立

采用大括号{}和dict()来创建字典，空{}可以创建空字典
**注:**python不关心键值对的存储顺序，而只跟踪键和值之间的关联关系

#用dict()函数建立一个空字典
d=dict()
print(d)
{
     }
#用{}创建一个字典类型
de={
     '中国':'北京','美国':'华盛顿','英国':'伦敦'}
#另一种字典的建立(键值对前四个空格)
de={
     
    1:'一',
    2:'二',
    3:'三',
    }
print(de)
{
     1: '一', 2: '二', 3: '三'}

3.3 访问,添加与修改字典中键值对

通用格式:<字典变量>[<键>]=<值>
**访问字典中的值:**指定字典名和放在方括号中的键
**添加键值对:**指定字典名，用方括号括起来的新建和相关联的值
**修改字典中值:**指定字典名，用方括号括起的键以及与该键相关联的新值
比如

#创建了一个字典类型
de={
     '中国':'北京','美国':'华盛顿','英国':'伦敦'}
#访问字典中的值
de['中国']
'北京'
#向字典中添加键值对
de["法国"]="巴黎"
print(de)
{
     '中国': '北京', '美国': '华盛顿', '英国': '伦敦', '法国': '巴黎'}
#修改字典中的值
de['美国']='洛杉矶'
print(de)
{
     '中国': '北京', '美国': '洛杉矶', '英国': '伦敦', '法国': '巴黎'}

3.4 删除键值对

**格式:**del <字典变量>[<键>]
使用del语句删除的是语句中的键与相对应的值

de={
     '中国':'北京','美国':'华盛顿','英国':'伦敦'}
del de['英国']
print(de)
{
     '中国': '北京', '美国': '华盛顿'}

3.5 遍历字典

方法	描述
<字典变量名>.items()	返回字典中所有键值对的信息
<字典变量名>.keys()	返回字典中所有的键信息
<字典变量名>.values()	返回字典中所有的值信息

de={
     '中国':'北京','美国':'华盛顿','英国':'伦敦'}
#返回字典de中的所有键值对的信息
de.items()
dict_items([('中国', '北京'), ('美国', '华盛顿'), ('英国', '伦敦')])
#返回字典de中的所有键的信息
de.keys()
dict_keys(['中国', '美国', '英国'])
#返回字典de中的所有值的信息
de.values()
dict_values(['北京', '华盛顿', '伦敦'])

**注:**dict_items,dict_keys和dict_values并不返回列表类型，他返回的是一种字典的items/keys/values类型，可以用for…in的方式做遍历，但是不能当列表类型来操作

3.5.1 遍历字典中所有的键值对

**遍历语句:**for <键变量>,<值变量> in <字典变量>.items():

de={
     'one':'java','two':'python','three':'hip'}
for key,value in de.items():
    print("\nkey:" + key)
    print("value:" + value)
#输出结果如下
key:one
value:java

key:two
value:python

key:three
value:hip

3.5.2 遍历字典中的所有键

**遍历语句:**for <键变量> in <字典变量>.keys():

de={
     'one':'java','two':'python','three':'hip'}
for key in de.keys():
    print("key:" + key)
#输出结果如下
key:one
key:two
key:three

3.5.3 按顺序遍历字典中的所有键

**遍历语句:**for <键变量> in sorted(<字典变量>.keys()):

de={
     'one':'java','two':'python','three':'hip'}
for key in sorted(de.keys()):
    print("key:" + key)
#输出结果如下
key:one
key:three
key:two

3.5.4 遍历字典中的所有值

**遍历语句:**for <值变量> in <字典变量>.values():

de={
     'one':'java','two':'python','three':'hip'}
for value in de.values():
    print("value:" + value)
#输出结果如下
value:java
value:python
value:hip

3.6 嵌套

3.6.1 嵌套的定义

将一系列字典储存在列表中，或将列表作为值储存在字典中

3.6.2 在列表中储存字典

将每个字典作为列表的元素(所有字典的结构要相同)

3.6.3在字典中储存列表

将列表作为值放入字典中
**适用范围:**每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表

---

3.6.4 在字典中储存字典

将一系列字典作为值放入一个新的字典中

3.7 对字典的处理(1+1+4)

一种操作符，一个处理函数，四个处理方法
操作符/方法/函数|描述
:-:-:
<键名> in <字典变量名>|判断键是否在字典中，如果在返回True,否则False
len(<字典变量名>)|返回字典中键值对的个数
<字典变量名>.get(<键名>,)|若键存在，则返回相应值，反之则返回值
<字典变量名>.pop(<键名>,)|若键存在，则取出相应值，反之则返回值
<字典变量名>.popitem()|随机从字典中取出一个键值对，以(<键>,<值>)元组形式返回
<字典变量名>.clear()|删除字典中所有的键值对

de={
     '中国':'北京','美国':'华盛顿','英国':'伦敦'}
'one' in de     #判断键one是否在字典de中
len(de)         #返回字典de中键值对的个数
de.get('英国','巴黎')
de.pop('法国','巴黎')
de.popitem()    #以元组形式随机返回一个键值对
de.clear()
print(de)       #用来验证.clear方法是否将键值对全部删除
#输出结果为
False
3
'伦敦'
'巴黎'
('英国', '伦敦')
{
     }

---

de={
     '中国':'北京','美国':'华盛顿','英国':'伦敦'}
'one' in de     #判断键one是否在字典de中
len(de)         #返回字典de中键值对的个数
de.get('英国','巴黎')
de.pop('法国','巴黎')
de.popitem()    #以元组形式随机返回一个键值对
de.clear()
print(de)       #用来验证.clear方法是否将键值对全部删除
#输出结果为
False
3
'伦敦'
'巴黎'
('英国', '伦敦')
{
     }

---

---

1. 因为{}生成的是空字典，所以空集合只能用set()生成 ↩︎

2. 取出是指除了返回给用户，同时在集合中将这个元素删除 ↩︎