Python学习-5.组合数据类型

一、组合数据类型的基本概念

• 常用的组合数据类型
  ①集合类型：集合（set）是一个元素集合，元素之间无序，相同元素在集合中唯一存在。
  ②序列类型：序列类型的典型代表是字符串（str）、列表（list）、元组（tuple），是一个元素向量，元素之间有先后关系，通过序号访问，元素之间不排他。
  ③映射类型：典型代表是字典（dict），是“键-值”数据项的组合，每个元素是一个键值对，表示为（key，value）。

二、集合类型

• 集合概念

Python中的集合和数学中的集合概念一致，包含0个或多个数据项的无序组合。用大括号{}表示，没有索引和位置的概念，集合中的元素可以动态增加或删除。
由于集合元素独一无二，可以使用集合删除重复元素

a={'www',223,223.6,'www'}
print(type(a))
print(a)
--输出
<class 'set'>
{223.6, 'www', 223}//重复元素www被删除，并且无序排列

• 操作符
  集合有4个操作符，交集&，并集|，差集-，补集^
  
  示例

s={1010,'python',78.9}
t={1010,'set',12.3,1010,1010}
print(s-t)
print(s&t)
print(s^t)
print(s|t)
--输出
{'python', 78.9}//差集
{1010}//交集
{12.3, 78.9, 'set', 'python'}//补集
{1010, 'set', 'python', 12.3, 78.9}//并集

• 操作函数或方法
  集合类型有一些常用的操作函数或方法
  注：set()函数可以将其他组合数据类型变成集合类型，返回结果是一个无重复且排序任意的集合。set()函数也可以生产空集合变量。
  示例

s={1010,'python',78.9}
print(s)
s.add('AI')
print(s)
s.remove(1010)
print(s)
s.clear()
print(s)
print(len(s))
print(1010 in s)
print(1010 not in s)
--输出
{1010, 78.9, 'python'}//s集合
{'AI', 1010, 78.9, 'python'}//增加'AI'元素
{'AI', 78.9, 'python'}//删除1010元素
set()//执行clear后，s集合变为空集合
0//空集合长度为空
False//1010不在s中，返回false
True//1010不在s中，返回True


//set()函数示例
a=set()
s='知之为知之，不知为不知'
a=set(s)
print(a)
--输出
{'知', '，', '为', '之', '不'}

三、列表类型

• 列表概念
  列表类型用中括号[]表示，列表没有长度限制，元素类型可以不同。通过list(x)函数将集合或字符串类型转换为列表类型。
  列表类型属于序列类型，所以列表类型支持序列类型对应的操作。

s=[1010,'python',78.9,1010]
print(s,type(s))
--输出
[1010, 'python', 78.9, 1010] <class 'list'>//列表不会删除重复元素，并且有序

注：序列类型的操作符和函数

• 列表的索引
  索引是列表的基本操作，用于获得列表的一个元素。使用中括号作为索引操作符。

s=[1010,'python',78.9,1010,[22,'33']]
print(s[4])
--输出
[22, '33']

还可以使用遍历循环对列表类型的元素进行遍历操作：

s=[1010,'python',78.9,1010,[22,'33']]
for i in s:
    print(i*2)
--输出
2020
pythonpython
157.8
2020
[22, '33', 22, '33']

• 列表的切片
  列表切片和字符串切片是基本一致的，用于获得列表的一个片段，即获得一个或多个元素。切片后的结果也是列表类型。

s=[1010,'python',78.9,1010,[22,'33']]
print(s[1:3])
print(s[0:4:2])
--输出
['python', 78.9]
[1010, 78.9]

四、列表类型的操作

• append()函数

ls.append(x)仅用于在列表中增加一个元素，如果希望增加多个元素，可以使用+直接将两个列表合并。

s=[1,2,3,4,5,6,7]
s.append(8)
print(s)
t=[9,10,11,12]
print(s+t)
--输出
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

• 其他函数示例

//insert(i,x)函数用于在列表中第i个位置增加一个元素。
s=[1,2,3,4,5,6,7]
s.insert(4,10)
print(s)
--输出
[1, 2, 3, 4, 10, 5, 6, 7]

//pop(i)函数用于将列表中第i个元素取出并删除
s=[1,2,3,4,5,6,7]
s.pop(4)
print(s)
--输出
[1, 2, 3, 4, 6, 7]

//remove(x)函数用于将列表中出现的第一个x元素删除
s=[1,2,3,4,5,6,7,5]
s.remove(5)
print(s)
--输出
[1, 2, 3, 4, 6, 7, 5]

//reverse()函数用于将元素顺序翻转
s=[1,2,3,4,5,6,7]
s.reverse()
print(s)
--输出
[7, 6, 5, 4, 3, 2, 1]

• del删除
  可以使用Python保留字del对列表元素或片段进行删除：
  示例

s=[1,2,3,4,5,6,7]
del s[1:3]
print(s)
--输出
[1, 4, 5, 6, 7]

• copy函数
  直接使用=进行复制的话，当原列表被删除，则新列表也为空，因此需要使用copy函数生成一个新列表，复制ls中所有元素。

//使用=复制
//示例一
s=[1,2,3,4,5,6,7]
t=s
s.clear()
print(t)
--输出
[]//当s被删除，则t也为空
//示例二
s=[1,2,3,4,5,6,7]
t=s
s.pop(2)
print(t)
--输出
[1, 2, 4, 5, 6, 7]//当s被删除某个元素，则t也被删除


//使用copy函数复制
s=[1,2,3,4,5,6,7]
t=s.copy()
s.clear()
print(t)
--输出
[1, 2, 3, 4, 5, 6, 7]//当s被删除，t依旧存在

原因是当计算机保存列表时，保存的是地址，当使用=进行复制时，只是复制了计算机保存旧列表的地址，而不是复制的旧列表值。因此若对旧列表有操作，会影响新列表的值

• 修改元素
  使用索引配合等号=对列表元素进行修改

s=[1,2,3,4,5,6,7]
s[2]='三'
print(s)
--输出
[1, 2, '三', 4, 5, 6, 7]

四、元组类型

Python的元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组使用小括号()，列表使用方括号[]。

• 函数

因为元组的元素无法修改，其方法只有count()和index()两种，因此，元组适合保存保密要求较高的数据。
s.count(x)函数可用于查询s元组中包含x元素的个数。
s.index(x)函数可用于查询s元组中x元素的第一个位置。
tuple()函数可以将其他数据类型转为元组。

• 定位及切片
  元组元素的定位及切片也是通过[m:n[:step]]进行的

五、字典类型

• 概念
  Python语言中的 字典使用大括号{}建立，每个元素是一个键值对。键和值通过冒号连接，不同键值对通过逗号隔开。
  
  大括号同时可以表示集合，因此字典类型也具有和集合类似的性质，即键值对之间没有顺序且不能重复。

s= {1:'A',2:'B',3:'C',4:'D',2:'E'}
print(s,type(s))
t= {1:'A',2:'B',3:'C',4:'D',5:'B'}
print(t,type(t))
--输出
{1: 'A', 2: 'E', 3: 'C', 4: 'D'} <class 'dict'>//键重复，删除
{1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'B'} <class 'dict'>//值重复，保留

• 赋值方式
  可以通过d={}的方式，或者dict()的方式定义一个空字典（空集合则只能以set()的方式定义）。
  可以通过d[键]=‘值’的方式直接赋值键值对，或者修改某个键的值。

• 操作函数
  
  示例

d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
s=dict()
print(len(d))
print(min(d))
print(max(d))
print(s,type(s))
--输出
5
1
5
{} <class 'dict'>

• 操作方法
  
  ①d.key()返回字典中所有键信息。返回结果是Python的一种内部数据类型dict_keys，专用于表示字典的键。如果希望更好的使用返回结果，可以将其转为列表类型。
  ②d.values()返回字典中的所有值信息。返回结果是Python的一种内部数据类型dict_values，如果希望更好的使用返回结果，可以将其转为列表类型。
  ③d.itmes()返回字典中的所有键值对信息。返回结果是Python的一种内部数据类型dict_items。可以将其转为列表类型，但列表中每个元素是一个元组，不可修改。

d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
print(d.keys())
print(list(d.keys()))
print(d.values())
print(list(d.values()))
print(d.items())
print(list(d.items()))
--输出
dict_keys([1, 2, 3, 4, 5])
[1, 2, 3, 4, 5]//将键转为列表
dict_values(['A', 'B', 'C', 'D', 'E'])
['A', 'B', 'C', 'D', 'E']//将值转为列表
dict_items([(1, 'A'), (2, 'B'), (3, 'C'), (4, 'D'), (5, 'E')])
[(1, 'A'), (2, 'B'), (3, 'C'), (4, 'D'), (5, 'E')]//将键值对转为列表，每个元素为元组()

④d.get(key,default)根据键信息查找并返回值信息。如果key存在则返回相应值，否则返回默认值，第二个元素默认值default可以省略为空。
⑤d.popt(key,default)根据键信息查找并取出值信息。如果key存在则返回相应值，否则返回默认值，第二个元素默认值default可以省略为空。pop()在取出相应值后，将从字典中删除对应的键值对。

d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
print(d.get(2))
print(d.get(6,'不存在'))
print(d.pop(2))
print(d)
--输出
B
不存在//不存在6键值，返回默认值‘不存在’
B
{1: 'A', 3: 'C', 4: 'D', 5: 'E'}//2键值对已被pop删除

⑥d.popitem()将随机从字典中取出一个键值对，以元组(key,value)形式返回。取出后从字典中删除这个键值对。

d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
print(d.popitem())
print(d)
--输出
(5, 'E')
{1: 'A', 2: 'B', 3: 'C', 4: 'D'}

⑦d.clear()删除字典中所有键值对。如果希望删除字典中某一个元素，可以使用Python保留字del。

d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
del d[1]
print(d)
d.clear()
print(d)
--输出
{2: 'B', 3: 'C', 4: 'D', 5: 'E'}
{}

⑧ 字典也支持保留字in，用来判断一个键是否存在字典中。如果在则返回True，否则返回False
for循环返回的变量名是字典的索引值（int型）。如果需要获得键对应的值，可以使用get()，或者使用[]直接取值。

d= {1:'A',2:'B',3:'C',4:'D',5:'E'}
for i in d:
    print('字典的键为{}，值为{}'.format(i,d[i]))#也可写作d.get(i)
# 输出
字典的键为1，值为A
字典的键为2，值为B
字典的键为3，值为C
字典的键为4，值为D
字典的键为5，值为E