【Python3】组合数据类型

前言   

        hi~欢迎点击我的Python系列学习笔记！

         本篇呢主要介绍Python中的列表、元组、字典、集合这几大除开整数浮点数类型的数据类型。组合数据类型能将不同类型的数据组织在一起，实现更复杂的数据表示或数据处理功能。

        组合数据类型可以分为三类：序列类型、映射类型、集合类型。序列类型包括列表、元组、字符串三种；映射类型中包含键值，典型的也就是字典；集合类型中元素无序，并且不允许有相同元素出现。

--------------------------------------------------------------------------------------------------------------------------------

嗨嘿嗨~来咯：

目录

 一、序列类型 

1.总体概况 

2.列表&&元组

二、映射类型(字典)

1.字典的基本操作：

2.字典的常用方法

三、集合类型

1.集合的基本操作

2.集合运算

---

 一、序列类型 

1.总体概况 

        序列类型（列表、元组、字符串）就是单纯的数据组合。元素之间存在先后关系，因此可以使用索引进行访问（[i]）。

        当然，序列元素中也可以出现序列类型。

        Python中典型的序列类型包括：字符串(str)、列表(list)、元组(tuple)。字符串是单一字符的有序集合，所以可以视作基本数据类型。无论哪种序列类型，都可以使用相同的索引体系，从左到右序列号递增（下标，第一个为0），从右到左序列号递减（下标，第一个为-1）。

        序列类型常用的操作符和方法如下表所示，这些均是学习序列类型中具体类型的基础：

（x为序列中的某一元素，s和t为序列，ijk为序列的索引）

操作符和方法	功能
x in s	x是s的元素就返回True
x not in s	x不是s的元素就返回True
s + t	将s和t序列连接起来（s和t必须是相同的数据类型）
s * n	将s复制n次
s[i]	返回s序列第i下标的元素
s[i:j]	返回s中[i,j)的子序列
s[i:j:k]	返回s中[i,j)以k为步长的子序列
len(s)	返回s序列的元素总数
max(s)	返回s序列中最大元素
min(s)	返回s序列中最小元素
s.index(x[,i[,j]])	返回序列s在区域[i, j)第一次出现x的位置
s.count(x)	返回序列s中出现x的总数

        根据上述表格，如下代码进行举例：

s = [1, 2, "Yu"]
print(s)
print(s * 2)
t = (3, 4)
print(t + t)
print(s[0:2])  # 1 2
print(s[0:2:2])  # 1  上面的就类似于步长为1
# print(max(s)) #注意，此序列之间必须只存在一种可比的数据类型，像这里这个str类型和int类型就不可比
s[2] = 3
print(max(s))
print(s.index(3))
# print(s.index(3, 0, 2))  # 返回异常 s的[0, 2)区域里没有3这个元素
print(s.count(3))

         那么，先前我已经简单介绍了序列类型里的字符串数据类型啦（str），没看过的可以前去观看哦~【Python3】Python中的字符串_柒海啦的博客-CSDN博客

        现在，我们就重点看一下列表类型和元组类型的相关操作吧：

2.列表&&元组

        列表，作为Python中比较常用的一种序列类型。列表中的元素不需要相同类型，并且可变。通过[]符号就可以创建列表。

        列表的相关操作中和上面的序列操作类似，需要注意的是使用+和max以及min的时候一个需要同种列表类型，一个需要列表里面均为可比较的数据类型（比如整数类型就是单一的整数类型，其他的就是其他的）。用户可以在列表上进行随意的增加元素和删除元素，还能进行遍历、排序、反转等基本操作。

        下面表用来介绍列表相关常用的操作符和方法作为参考：ls和lst均为列表类型，x为列表中的元素，ijk为索引。

操作符或方法	功能
del ls[i]	删除列表ls中第i项元素
del ls[i:j[:k]]	删除列表ls[i,j)中以k步长走的元素，默认为1
ls += lst	将列表lst中的元素追加到ls中去(lst只能是列表哦)
ls.extend(lst)	同+=
ls*=n	将ls复制n次，然后更新ls
ls.append(x)	列表ls尾插x数据
ls.clear()	清空列表ls全部数据
ls.copy()	复制生成一个包括ls中所有元素的新列表
ls.insert(i, x)	在ls列表第i位置增加x元素
ls.pop(i)	返回ls列表i下标元素并且删除
ls.remove(x)	删除列表ls出现的第一个x元素
ls.reverse()	反转列表中的元素
ls.sort()	排序列表ls中的元素

        下面进行测试代码：

ls = [1, 2, 3]
lls = ls  # 注意这里的赋值没有拷贝赋值 -- 单纯的共享一块区域，类似于C++的引用
lls[0] = 0
print(lls, ls)
lls2 = ls.copy()  # 此时才是拷贝，开辟的一个新的空间
lls2[0] = 1
print(ls, lls2)
ls.reverse()  # 反转
print(ls)
ls.sort()  # 排序
print(ls)
ls.clear()
print(ls)

 

         遍历列表就可以用到for和while进行遍历了：

        for就之间利用in进行遍历即可：

lis = [1, 2, "Yu"]
for tmp in lis:
    print(tmp, end=" ")

        while就需要使用下标进行访问：

i = 0
while i < len(lis):
    print(lis[i], end=" ")
    i += 1

 

        元组（tuple）则就是包含0个或者多个元素的不可变序列类型。元组生成后是固定的，也就是说对此类型里的数据只能进行只读操作，不可修改替换和删除。

        元组的创建和列表类似，只不过是圆括号()。同样的基本操作也可以使用总体概况里面表格里的操作符和方法。

        由于元组的特殊性质，当有的时候我们想对其进行修改的时候，可以将元组类型转换为列表类型，使用函数tuple(lst)和list(tup)就可以进行相互转换啦。

二、映射类型(字典)

         字典是Python中内置的映射类型。映射是通过键值查找一组数据值信息的过程，由key-value的键值对组成。通过key就可以找到相关的值value。

        字典是一种特殊的类型，里面结构相当于由键值构成的列表，只不过一个键值对算一个元素。类似于现实里的字典，每次通过字典中的键就可以找到对应的值(定义)，键可以是数字、字符串、元组等。字典内的元素是无序的，每次添加一个键值对Python会自动修改字典的排列顺序，以提高搜索效率。

1.字典的基本操作：

        字典类型可以通过{}进行创建，只不过一个元素由键和值组成，之间用:隔开，不同元素之间用，进行隔开：

dict1 = {1: "Yu", 2: "shen", '三': 3}
print(dict1)

 

        当然，创建字典类型还有一种方法就是使用dict方法进行创建：

dict()方法有两种途径进行创建字典类型：

1.通过关键字参数创建字典（关键字就默认为字符串了，所以不需要加''）：

        dict(键=值,键=值,.......)

2.通过键值对序列进行创建：

        dict([(键,值), (键, 值), ......]) 

dict2 = dict(一="YU", 二="shen", 三=3)  # 关键字进行构造字典，键均为字符串
print(dict2)
dict3 = dict([(1, "Yu"), (2, "shen"), ('三', 3)])  # 利用序列进行创建字典对象
print(dict3)

 

        创建完字典对象后，如果想对其进行查看是否存在对应的键(key)同样可以使用in操作符：

key in dicts

如果字典对象dicts中存在key这个键就返回True，否则就是False 

         想检索即访问对应键下面的值可以使用dict[key]进行访问。

dict3 = dict([(1, "Yu"), (2, "shen"), ('三', 3)])  # 利用序列进行创建字典对象
print(dict3)
print(1 in dict3)  # True
print(dict3[2], dict3["三"])

        由于字典也是可变的，所以也可以进行随时的添加和修改字典中的元素：

 添加和修改字典元素：

        dict[key] = value

        添加：如果原本字典不存在key键，那么就新增此键值(key,value)

        修改：如果原本字典存在此key键，那么就修改此key对应的值(value)

dict1 = {1: "Yu", 2: "shen", '三': 3}
# 将'三'对应的值修改为"special"，然后添加3键，对应值为"666"
dict1['三'] = "special"  # 修改
dict1[3] = "666"  # 添加
print(dict1)

2.字典的常用方法

        首先，常用方法或者操作用如下表格进行展示：（dicts为字典对象，key为键，value为值）

方法或操作	功能
dicts.keys()	返回所有键信息
dicts.values()	返回所有值信息
dicts.items()	返回所有键值对
dicts.get(key,default)	键存在返回相应值，否则返回默认值(空值),default可以指定值哦
dicts.pop(key,default)	键存在就返回相应值，并且删掉此键值对，否则返回默认值
dicts.popitem()	随机从字典取出一个键值对，以元组形式返回(key, value)
dicts.clear()	删除所有的键值对
del dicts[key]	删除字典中的某个键值对
dicts.copy()	复制拷贝一个新的字典对象
dicts.update(dicts2)	更新字典，dicts2的值（类似于追加dicts中没有的元素）

        如下就是代码例子：

dicts = dict([(1, "Yu"), (2, "shen"), ('三', 3)])
print(dicts.keys())  # 返回所有键信息
print(dicts.values())  # 返回所有值信息
print(dicts.items())  # 返回所有键值对
print("----------------------")

print(dicts.get(2))  # 返回对应值
print(dicts.get(3, "不存在"))  # 键存在返回相应值，否则返回默认值
print(dicts.pop('三'))
print(dicts)
print("----------------------")

print(dicts.popitem())  # 随机从字典取出一个键值对，以元组形式返回(key, value)
print(dicts)
dicts.clear()  # 删除所有的键值对
print(dicts)
print("----------------------")

dicts[1] = "Yu"
dicts[2] = "shen"
dicts['三'] = 3
print(dicts)
del dicts['三']  # 删除'三'这个键对应的键值对
print(dicts)
print("----------------------")

dicts1 = dicts  # 此时dicts1不是全新的空间，而是dicts的别名而已
print(dicts1)
dicts['三'] = 3
print(dicts1)  # dicts发生变化dicts1也会发生变化
dicts1 = dicts.copy()  # 此时就是全新的空间了
del dicts['三']
print(dicts, dicts1)
print("----------------------")

# 此时将dicts1换成dicts的值，并且不是共享
dicts[3] = "666"
dicts1.update(dicts)  # 更新内容,即添加dicts1里没有dicts里的元素
print(dicts1)
del dicts1[2]
print(dicts, dicts1)  # 证明不是同一个空间

 

         查看类似于地址即储存空间不同的话可以使用id()方法进行查看哦~

三、集合类型

        集合的特点：

集合是0个或多个元素的无序组合。

1.集合是可变的。

        可以任意对集合进行添加和移除元素。

2.集合是无序的。

        无序就不存在索引的概念，和字典类似。

3.集合是不重复的。

        每个元素均不相等，这是集合的一个重要特点。

4.集合内元素只能是基本数据类型。

        整数、浮点数、字符串等基本数据类型。

1.集合的基本操作

        首先，需要了解到的是可迭代对象。

        在Python中，可迭代对象有：字符串、列表、元组、字典、集合。它们都有着一个共同的特点：那就是支持索引访问。

        相较于之前的列表使用[],元组使用(),字典使用{}。创建集合没有类似的快捷方式，只能利用set()函数进行创建。而set()函数的功能就是创建一个集合。

        但是，当创建的{}里面没有键值对的话，就会创建成集合哦~

set(iterate)

        iterate是指可迭代对象，即传入此对象进行创建集合

        如果不传参，那么创建的就是一个空的集合

        在创建的时候重复元素会进行自动过滤

        如下代码例子进行创建集合：

set1 = set()  # 空集合
set2 = set("abcde")  # 以字符串可迭代对象进行创建集合
set3 = set([1, 2, 3, '四'])
print(set1, set2, set3)

        也可以发现执行结果中的顺序不一样，这也进一步说明在集合里面的元素的无序。

        同样，Python也为集合提供了许多内置进行操作集合的方法：添加元素、删除元素、复制集合等：S、E为集合，x为集合中的元素：

方法	功能
S.add(x)	添加元素，不在集合S中就进行添加
S.clear()	消除S中的所有元素
S.copy()	复制拷贝一个新的集合
S.pop()	随机输出一个集合里的元素，并且消除（如果为空报异常）
S.discard(x)	如果x在集合内移除该元素，不存在不报异常
S.remove(x)	同上，只不过不存在时产生异常
S.isdisjoint(E)	判断S和E集合是否存在相同元素，不存在返回True
len(S)	返回集合S的元素个数

        参考代码如下：

set1 = set()  # 空集合
set1.add(1)  # 添加1这个元素
print(set1)
set1.add(1)  # 添加重复元素
set1.add(2)  # 添加不重复元素
print(set1)
print("----------------------")

set2 = set1.copy()  # 复制拷贝一个新的集合
set1.clear()  # 对set1进行清空操作
print(set1, set2)
print("----------------------")

print(set2.pop(), set2)  # 随机输出一个集合里面的元素，并且消除
print("----------------------")

set2.add(1)
set2.add(3)
set2.discard(1)  # 有此元素就进行移除
print(set2)
set2.discard(6)  # 无此元素 不报异常
# set2.remove(6)  # 无此元素，报异常
print("----------------------")

print(set2.isdisjoint(set1))  # 不存在相同元素
set1.add(2)
print(set2.isdisjoint(set1))  # 存在相同元素
print(len(set1), len(set2))
print("----------------------")

         集合没有下标索引，那么集合的遍历可以通过for循环完成：

set1 = set("abcdea")
for tmp in set1:
    print(tmp, end=",")
print()

        集合类型一般用于三个场景中：成员关系测试、元素去重和删除数据项。因此，如果需要对一维数据进行去重或数据重复处理时，一般可通过集合来进行完成。

        比如如下代码进行去重处理：

lis = [1, 1, 2, 2, 3, 4, 4]
for i in lis:
    print(i, end=" ")
print()
set1 = set(lis)
lis.clear()
lis = list(set1)
for i in lis:
    print(i, end=" ")

 

2.集合运算

        Python中的集合和数学中的集合概念是一致的，因此，两个集合可以做数学意义上的交、并、补、差集计算等，相关方法如下表所示：

方法	功能
S&E 或 S.intersaction(E)	交集，返回新集合
S|E 或 S.union(E)	并集，返回新集合
S-E 或 S.difference(E)	差集，返回新集合
S^E 或 S.symmetric_differrnce_update(E)	补集，返回新集合（即返回S和E中的元素，但不包括同时在的元素）
S<=E 或 S.issubset(E)	子集测试，如果S是E本身或者子集，那么就返回True（<就是验证真子集）
S>=E 或 S.issuperset(E)	超集测试，类似于上

        集合运算代码实例：

# Python中的set进行数学中的运算
set1 = set([1, 2, 4, 5, 6, 7])
set2 = set([1, 2, 4, 8])

set3 = set1 & set2  # 计算交集1 2 4
print(set3)
set4 = set1 | set2  # 计算并集1 2 4 5 6 7 8
print(set4)
set5 = set1 ^ set2  # 计算补集5 6 7 8
print(set5)
set6 = set1 - set2  # 计算差集 5 6 7
print(set6)
set2.remove(8)
print(set2 <= set1)  # 测试set2是否为set1的子集
print(set1 >= set2)