容器类型

4种内置数据结构（容器类型）

概述

• 列表 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'}