前言
hi~欢迎点击我的Python系列学习笔记!
本篇呢主要介绍Python中的列表、元组、字典、集合这几大除开整数浮点数类型的数据类型。组合数据类型能将不同类型的数据组织在一起,实现更复杂的数据表示或数据处理功能。
组合数据类型可以分为三类:序列类型、映射类型、集合类型。序列类型包括列表、元组、字符串三种;映射类型中包含键值,典型的也就是字典;集合类型中元素无序,并且不允许有相同元素出现。
--------------------------------------------------------------------------------------------------------------------------------
嗨嘿嗨~来咯:
目录
一、序列类型
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)