4种内置数据结构(容器类型)
文章目录
- 4种内置数据结构(容器类型)
- 概述
- 列表list
- 概述
- 定义
- 切片
- 增加
- 删除
- 修改
- 统计
- 遍历:依次取出对象中的每一项数据
- 元组tuple
- 定义
- 列表list与元组tuple
- 字典dict
- 定义
- 查找
- 修改
- 新增
- 删除
- 合并
- 成员关系
- 遍历
- 集合set
- 定义
- 添加
- 删除
- 并集
- 交集
- 差集
- 对称差集
概述
- 列表 list = [val1,val2,val3,val4]
- 元组 tuple = (val1,val2,val3,val4)
- 字典 dict = {key1:val1,key2:val2}
- 集合 set = {key1,key2,key3,key4}
列表list
概述
- 是处理一组 有序 的项目的数据结构,是 有序 集合对象类型
- 列表可以包含 任何类型 的对象:字符串、数字甚至其他列表
- 列表是 可变 的数据类型,这种类型的值是可以被修改的
定义
- 使用[]定义
my_list1 = [1,'abc',2.36,True,None]
print(my_list1)
[1, 'abc', 2.36, True, None]
- 使用工厂函数list
my_list = []
my_list = list("abc")
print(my_list)
['a', 'b', 'c']
- 列表可装入python的任何对象(不可放入关键字)
my_list = list("abc")
my_list1 = [1,'abc',2.36,True,None,my_list]
print(my_list1)
[1, 'abc', 2.36, True, None, ['a', 'b', 'c']]
切片
sample[strat: end:step] 默认step=1
my_list = ["a","b","c","d"]
print(my_list[0:3])
s1 = slice(0,3,1)
print(my_list[s1])
['a', 'b', 'c']
['a', 'b', 'c']
增加
- append:在末尾增加,作为整体追加,类型不限
my_list = [1,'a',True]
my_list.append('haha')
print(my_list)
[1, 'a', True, 'haha']
- insert:在index位置插入元素,a.insert(索引,内容)
my_list = [1,'a',True]
my_list.insert(0,1.5)
print(my_list)
[1.5, 1, 'a', True]
- extend:扩展列表,只限可转为list的类型(str,list,tuple)
my_list = [1,'a',True]
my_list.extend("123456")
print(my_list)
[1, 'a', True, '1', '2', '3', '4', '5', '6']
删除
- pop:删除元素,默认删除最后一个,也可以指定下标删除(指定index删除,超出下标会报错)
my_list = [1,'a',True]
my_list.pop()
print(my_list)
[1, 'a']
my_list = [1,'a',True]
my_list.pop(0)
print(my_list)
['a', True]
- remove:指定删除的数据(若需要删除的数据不存在会报错)
my_list = [1,'a',True]
my_list.remove(True)
print(my_list)
['a', True]
my_list = [1,'a',True,'a']
my_list.remove('a')
print(my_list)
[1, True, 'a'] 相同的元素将从左到右删除第一个
- del:del关键字根据下标删除
切片能做出来的,del都能删除掉
del是python的一个关键字,用于删除变量的引用
my_list = [1,'a',True]
del my_list[0]
print(my_list)
['a', True]
my_list = [1,'a',True]
del my_list[1:3]
print(my_list)
[1]
my_list = [1,'a',True]
a = 2
del my_list[a]
print(my_list)
[1, 'a']
- clear:清空
my_list = [1,'a',True]
my_list.clear()
print(my_list)
[]
修改
- 主要是利用下标和切片来修改或增加删除
- 根据索引
my_list = [1,'a',True]
my_list[1] = 'abc'
print(my_list)
[1, 'abc', True]
- 根据切片:与start值有关
若为空值,则插入
my_list = [1,'a',True]
print(my_list[2:2])
my_list[2:2] = [5,6]
print(my_list)
[]
[1, 'a', 5, 6, True]
若不为空值,则替换
my_list = [1,'a',True]
my_list[1:3] = ['x','y']
print(my_list)
- 反转reverse
my_list = [1,'a',True]
my_list.reverse()
print(my_list)
统计
- len统计长度
my_list = [1,'a',True]
print(len(my_list))
3
- count统计元素出现的次数
my_list = [1,'a',True,'a']
print(my_list.count('a'))
2
- index返回元素所在的下标、索引
my_list = [1,'a',True,'x','y']
print(my_list.index('x'))
3
遍历:依次取出对象中的每一项数据
- list是一个可迭代对象(iterable),可以直接用for循环遍历
my_list = [1,'a',True]
for i in my_list:
print(i)
1
a
True
- 返回各个值
my_list = [1,'a',True]
for i in enumerate(my_list):
print(i)
(0, 1)
(1, 'a')
(2, True)
- 返回的是一个个元组
my_list = [1,'a',True]
for i,j in enumerate(my_list):
print(f"{i}---->{j}")
0---->1
1---->a
2---->True
元组tuple
- 有序;
- 可以包含 任意类型;
- 不可变
定义
- 使用圆括号
my_tuple = (1,3,5,'abc',8,'x')
print(my_tuple)
(1, 3, 5, 'abc', 8, 'x')
只有一个元素时候,需要加,区别结合运算
my_tuple = (1)
print(type(my_tuple))
<class 'int'>
my_tuple = (1,)
print(type(my_tuple))
<class 'tuple'>’
- 工厂函数tuple
a = [1,2,3]
my_tuple = tuple(a)
print(type(my_tuple))
print(my_tuple)
<class 'tuple'>
(1, 2, 3)
列表list与元组tuple
- 相同点
序列的两个主要特点是索引操作符和切片操作符
索引操作符让我们可以从序列中抓取一个特定项目
切片操作符让我们能够获取序列的一个切片,即一部分序列 - 不同点
list:可变对象
tuple:不可变对象,不能增加修改删除
tuple中嵌套list,list可修改
字典dict
- 字典是python中一个 键值映射 的数据结构 key-value
- 字典是 无序 的,字典是 可变对象 ,但是 key必须是唯一 的
定义
- 使用{}
dict = {key1:value,key2:value,…}
my_dict = {1:'a',2:'b',3:'c'}
print(my_dict)
{1: 'a', 2: 'b', 3: 'c'}
- 字典的key必须是 可hash对象 (不可变对象;list、dict等可变数据类型都不能作为key)
- python中所有字符串、数字、元组、布尔值、None都是可hash对象
字典的value可以是任何值
查找
- 通过key获取value
my_dict = {1:'a',2:'b',3:'c'}
print(my_dict[2])
b
若未查找到,便会抛出异常
my_dict = {1:'a',2:'b',3:'c'}
print(my_dict.get(5,0))
0
推荐使用这种方式获取,可以设置默认值,当找不到key到时候不会抛出异常
修改
- 当key存在时,表示修改
dicts[key]=value
my_dict = {1:'a',2:'b',3:'c'}
my_dict[2] = 'c'
print(my_dict)
{1: 'a', 2: 'c', 3: 'c'}
新增
- 当key不存在时,表示新增
my_dict = {1:'a',2:'b',3:'c'}
my_dict['haha'] = 'd'
print(my_dict)
{1: 'a', 2: 'b', 3: 'c', 'haha': 'd'}
删除
- dicts.pop(key)删除指定元素
my_dict = {1:'a',2:'b',3:'c'}
my_dict.pop(2)
print(my_dict)
{1: 'a', 3: 'c'}
- dicts.popitem()删除最后一个
my_dict = {1:'a',2:'b',3:'c'}
my_dict.popitem()
print(my_dict)
{1: 'a', 2: 'b'}
合并
- dict1.update(dicat2) 将dict2合并到dict1
my_dict = {1:'a',2:'b',3:'c'}
my_dict2 = {'e':0,'f':9}
my_dict.update(my_dict2)
print(my_dict)
print(dict(my_dict,**my_dict2))
print(dict(dict(my_dict, e=0, f=9)))
{1: 'a', 2: 'b', 3: 'c', 'e': 0, 'f': 9}
{1: 'a', 2: 'b', 3: 'c', 'e': 0, 'f': 9}
{1: 'a', 2: 'b', 3: 'c', 'e': 0, 'f': 9}
成员关系
my_dict = {1:'a',2:'b',3:'c'}
print('a' in my_dict)
False
print('a' in my_dict.values())
True
遍历
- 遍历key
my_dict = {1:'a',2:'b',3:'c'}
for i in my_dict:
print(i)
1
2
3
- 遍历value
my_dict = {1:'a',2:'b',3:'c'}
for i in my_dict.values():
print(i)
a
b
c
- 遍历字典
my_dict = {1:'a',2:'b',3:'c'}
for i in my_dict.items():
print(i)
(1, 'a')
(2, 'b')
(3, 'c')
- 遍历键值对
my_dict = {1:'a',2:'b',3:'c'}
for i,j in my_dict.items():
print(i,"--->",j)
1 ---> a
2 ---> b
3 ---> c
集合set
- 集合是一个 无序的, 不重复 的数据类型
- 集合是一个只有key的字典
定义
- 使用{}
my_set = {val1,val2,val3...}
my_set = {1,'a','xyz',90}
print(my_set)
{1, 90, 'a', 'xyz'}
- 工厂函数set
my_set = set("abc")
print(my_set)
{'c', 'b', 'a'}
添加
- add
my_set = {1,'a','xyz',90}
my_set.add(5)
print(my_set)
- update
my_set = {1,'a','xyz',90}
my_set.update("abc")
print(my_set)
{1, 'c', 'a', 'xyz', 'b', 90}
删除
- remove
my_set = {1,'a','xyz',90}
my_set.remove('xyz')
print(my_set)
{1, 90, 'a'}
- discard :元素不存在异常不抛出错误
my_set = {1,'a','xyz',90}
my_set.discard('xyz')
print(my_set)
{1, 'a', 90}
并集
- 符号表示|
my_set = {1,'a','xyz',90}
my_set1 = {2,'abc',90,'a'}
print(my_set1|my_set)
{1, 2, 'a', 'abc', 'xyz', 90}
- union
my_set = {1,'a','xyz',90}
my_set1 = {2,'abc',90,'a'}
print(my_set.union(my_set1))
{1, 2, 'abc', 'a', 90, 'xyz'}
交集
- 符号表示&
my_set = {1,'a','xyz',90}
my_set1 = {2,'abc',90,'a'}
print(my_set & my_set1)
{'a', 90}
差集
- 符号表示-
my_set = {1,'a','xyz',90}
my_set1 = {2,'abc',90,'a'}
print(my_set - my_set1)
{'xyz', 1}
对称差集
- 符号^
my_set = {1, 'a', 'xyz', 90}
my_set1 = {2, 'abc', 90, 'a'}
print(my_set ^ my_set1)
{1, 2, 'abc', 'xyz'}
print((my_set1 | my_set) -( my_set&my_set1))
{1, 2, 'abc', 'xyz'}