元组字典集合

元组 tuple

元组跟list非常相似，特点和区别是“不可修改”。所以元组需要在创建的时候就制定数据。
语法：小括号括起来，逗号分隔每一项

创建

tuple1 = (10,20,‘张三’)
(常用) tuple = (10,20,‘张三’)

场景

元组由于不可变，适合定义 常量、配置、不需要改变的值。
这样就在复杂代码中就不用害怕因为bug误修改值。
例如定义 中国所有的省份，一个注册登录表单中的下拉框选项

查询

有索引，通过下标访问
tuple[index]
tuple2 = (‘河南’，‘云南’)
tuple2[0] >>> ‘河南’

也支持切片

tuple2[0:1] >>> (‘河南’,)
注意的一个地方元组有时只有一项的时候，后面仍有一个逗号。

数组优势通过下标访问效率较高较快，但是插入修改元素较慢。

数据结构

#列表
###定义
原来的单值变量无法满足业务，需要一个“容器”来装内容。
列表储存一系列有序（有下标）数据。容器内可以保存整数、布尔、字符串、或其他容器。

###语法
中括号扩住，逗号分隔（对象item）元素。

###创建
1.通过内置关键字创建list()
demo_list = list()
2.(常用)中括号
demo_list2 = []
3.创建的时候赋值
demo_list3 = [‘小明’,‘小红’,‘小王’]
###添加 add

1. (常用)append() 方法，添加新项到列表的末尾。
   list实例.append(要增加的项)
   student_list = [‘小明’,‘小红’，‘小王’]
   sutdent_list.append(‘小李’)
   2.insert()方法，可以根据索引值插入指定数据。
   什么是索引？索引其实是一个编号，编号是从0开始的。目的为了方便操作数据。
   列表实例 .insert(索引，要增加的项)
2. for 循环
   list = [1,2,3,4]
   for i in range(5,8):
   list.append(i)
   print(list)
   4.两个列表拼接，用加号
   list1 = [1,2,3,4]
   list2 = [5,6,4,8]
   list3 = list1 + list2

###删除项目
1.pop()
列表.pop(索引)，根据索引删除列表中的某一个元素，返回删除成功的元素。
pop()不传索引参数的时候，默认删除列表最后一项。
pop()函数相当于append和insert函数的逆运算
2.remove()
列表.remove(想要删除的项目值) 根据项item的值value来删除而不通过索引操作。如果不存在的话，报错值不存在列表中。
list1 = [1,2,3,4]
list1.remove(2)
list1 >>> [1,3,4]

3 clear()清空列表
列表。clear() 清空所有项，返回空列表
list1 = [1,2,3,4]
list1.cleat()
list1

4. del 关键字删除，根据索引删除元素
   list1 = [1,2,3,4]
   del list1[1]
   list1 >>>[1,3,4]

###访问元素
通过索引（Index、下标）
列表[索引]
分清列表的中括号和索引中括号
访问不存在的索引时，会报索引越界错误。
student_list = [‘大明’,‘小红’,‘小李’]
stu1 = student_list[0]
stu2 = student_list[1]
stu3 = student_list[2]
print(stu1,stu2,stu3)
大明 小红 小李
student_list[4]
IndexError: list index out of range

修改

修改基于索引的。访问列表下标，然后等号赋值
列表[索引] = 新值
student_list = [‘小明’,‘小红’,‘小李’]
student_list[0] >>> ‘小明’
student_list[0] = ‘大明’
student_list >>> [‘大明’, ‘小红’, ‘小李’]

遍历

遍历、迭代，把一个sequence序列（可迭代的对象如列表）依次取出。
那些结构可以迭代？
sutdent_list = [‘大明’, ‘小红’, ‘小李’]
for i in student_list:
print(i)
大明
小红
小李

切片

列表[索引start: 索引end: 步进step] 切割截取出来的区间。
list = [1,2,3,4,5]
list[0:2] >>> [1, 2]
切片参数可以为负数，
list[-3,-1] >>> [3,4]
截取方向向右为正，步进为正时才能截取
start必须小于end,反的话截取出来的是空的。
list[3:1] >>> []
索引0可以省略
list[0:2] 等同于 list[:2]
反向reverse输出列表
list[::-1]
list[::-1] >>> [5,4,3,2,1]

链表的优势插入删除效率高，查询效率一般

(语法糖)for in 生产列表的单行写法

list1 = []
for i in range[1,5]
list1.append(i)

[i for i in range(1,5)]

字典 dict

跟list也是一种容器。特点：键值对（映射）存储。其他语言java中叫map。
没有索引，是无序的。靠键（key）来增删改查。
语法：大括号扩住。内容为键值对，键值对用冒号连接 冒号左边的是键（key）,
右边的是值（value）：每个键值对逗号分隔。
跟列表比较：列表一般存储一类东西，字典存储的是一个东西里的各个属性和描述。

创建

1.内置类实例化创建
dict1 = dict()
2.大括号，内容空
dict1 = {}
3. 创建是赋初始值
dict = {‘name’:‘小明’,‘age’:‘13’,‘sex’:‘male’}

查询 项的访问

1.（常用）dict[键key] >>> 值value
dict1 = {‘name’:‘小明’,‘age’:‘13’,‘sex’:‘male’}
dict1[‘name’] >>> ‘小明’
如果键不存在的话，报KeyError错误。
dict[‘aaa’] >>> KeyError：aaa
2.get(‘键’，默认值)
跟dict[键]非常相似，只不过多了个默认值。
dict.get(‘name’) >>> ‘小明’
dict.get(‘aaa’,None) >>> None

添加

字典[新键] = 新值
dict[‘new key’] = ‘new value’

修改

字典[键] = 新值
dict1 = {‘name’:‘小明’,‘age’:13,‘sex’:‘male’}

遍历

先 字典.items()转换为大列表套小列表的形式。
再用for循环遍历出来。
dict.items()
dict_items([(‘name’, ‘小红’), (‘age’, ‘13’), (‘sex’, ‘male’), (‘aaa’, ‘bbb’)])
k,v = (‘name’,‘小明’)
for k,v in dict.items():
print(k,v)

删除

1. 键访问，值设置为None,键还在
   dict1 = {‘name’:‘小明’,‘age’:13,‘sex’:‘male’}
   dict1[‘name’] = None
   dict1[‘name’] >>> None

2. pop(键) 根据键删除，返回删除成功的值，会把键和值都删除。
   dict1 = {‘name’:‘小明’,‘age’:13,‘sex’:‘male’}
   dict1.pop(‘name’) >>> ‘小明’
   dict1 >>> {‘age’:‘13’,‘sex’:‘male’}

3. del 字典[键]， del关键字删除，没有返回值，会把键和值都删除。

4. 字典 .clear() 删除所有内容
   dict1.clear()
   dict1 <<< {}

其他的常用方法

dict.items() 返回一个列表， 每一项都是 键值对
dict.keys() 返回一个列表，每一项是字典里的 键
dict.values() 返回一个列表,每一项是字典里的 值
dict__contains__(key) 键存在的话返回True,不存在返回

dict1 = {‘name’:‘小明’，‘age’:13,‘sex’:‘male’}
dict1.items() >>> [(‘name’:‘小明’)，(‘age’:13),(sex’:‘male’)}]
dict1.key() >>> [‘name’,‘age’,‘sex’]
dict1.value() >>> [‘小明’,‘13’,‘male’]
dict1.contains(‘name’) >>> True

容器列表、字典的嵌套

列表套列表

list = [1,2,3 [1,2].[3,4]]

(常用)列表套字典

student_list = [
{‘name’:‘小明’, ‘age’: ‘13’, ‘sex’: ‘male’},
{‘name’:‘懒懒’, ‘age’: ‘15’, ‘sex’: ‘male’},
{‘name’:‘勤勤’, ‘age’: ‘15’, ‘sex’: ‘male’},
…
…
]

散列表查询效率较高

集合

特点：无序的。元素不能重复。
使用场景：只关心元素是否出现，不管先出现顺序和次数；
常用来“去重”，检查元素是否出现过；求交，并，补集。
语法：大括号扩住，里面逗号分隔单个项，跟字典里面是键值对不同。

创建

1.类实例化
set1 = set()
2.带初始值
set1 = {‘a’,‘b’,‘c’,‘d’}

添加

set1 = {‘a’,‘b’,‘c’,‘d’}
add() 方法
set1.add(‘e’) >>> {‘a’,‘b’,‘c’,‘d’,‘e’}

删除

1.根据项内容删除
set1.remove(‘a’)
set1 >>> {‘b’,‘c’,‘d’}
2.全部删除
set1.clear() >>> set()
3.pop()
从集合里取出一个元素返回，如果集合为空的话会报错：
KeyError: ‘pop from an empty set’

求合，交，并集

两个集合参与运算
并集：所有属于集合A或属于集合B的元素组成的集合
交集：属于集合A又属于集合B。运算符 &
set1 = {3,4,5,6}
set2 = {5,6,7,8}
set1 & set2 >>> {3,4}
并集，所有集合属于集合A或属于集合B的元素组成的集合。运算符 | 。
set1 | set2 {3, 4, 5, 6, 7, 8}
补集差集
set2 - set1 >>> {5,6} 属于集合set2但不属于set1