1.列表，字典，元祖，集合之间的区别
| 容器类型 |
符号 |
可变/不可变 （是否可以增删改查） |
有序/无序（是否可以通过下标获取元素） |
| 常用 |
| 列表 |
[ ] |
可变 |
有序 |
| 字典 |
{key:value } |
可变 |
无序 |
| 偶尔用 |
| 元祖 |
( ) |
不可变 |
有序 |
| 集合 |
{ } |
可变 |
无序 |
1.列表的相关功能和方法：列表(list), 符号[ ]:
可变，有序，元素可以是任何类型的数据 -->整数、浮点数、布尔、字符串、列表、字典、元祖、集合、函数、类的对象等
a.增删改查：
| 功能 |
增 |
| 列表.append(元素) |
把元素增加到列表最后 |
| 列表.insert(下标，元素） |
把元素添加到指定下标前 |
| 功能 |
删 |
| del 列表[下标] |
删除指定下标对应的元素 |
| 列表.remove(元素) |
删除指定元素(多个只删第一个) |
| 列表.pop( ) |
取出最后一个元素(可保存) |
| 列表.pop(下标) |
取出下标对应的元素(可保存) |
| 列表.clear( ) |
清空列表中的内容 |
| 功能 |
改 |
| 列表[下标] = 新值 |
修改指定下标对应的元素 |
| 功能 |
查 |
| 列表[下标] |
查下标对应的元素 |
| 列表[起始下标：结束下标：步长] |
拿到对应元素组成的列表(切片) |
| for 变量 in 列表 |
获取到列表元素 |
| *变量名1，变量名2 =[元素1，元素2，元素3..] |
可以通过在变量前加*来获取部分的元素 |
b.列表的相关方法：
| 使用方法 |
解释方法 |
|
1. 元素 in 列表 |
判断元素是否在列表中 |
| 元素 not in列表 |
判断元素是否不在列表中 |
|
2. len(列表) |
获取指定元素的长度 |
|
3. max(列表) |
获取列表中的最大元素 |
元素类型一致，支持>操作 |
| min(列表) |
获取列表中最小元素 |
元素类型一致，支持>操作 |
|
4. list(序列) |
将指定序列转换成列表 |
字符，range,容器，迭代器 |
|
5. 列表.count(元素) |
获取指定元素在列表中的个数 |
|
6.列表.extend(序列) |
将序列中的元素添加到列表中 |
|
7. 列表.index(元素) |
获取指定元素在列表中的下标 |
如果多个，取第一个下标 |
|
8. 列表.reverse( ) |
将列表中的元素倒序 |
|
9. 列表.sort( ) |
将列表中元素升序排列 |
| 列表.sort(reverse = True) |
将列表中的元素降序排列 |
| sorted(列表) |
将列表中升序后产生一个新的列表，不会改变原列表 |
列表中的元素要一致，元素支持>操作 |
| sorted(列表,reverse = True) |
将列表降序排列，不会改变原列表 |
列表中的元素要一致，元素支持>操作 |
c.列表的赋值：
总结:直接赋值，可以回改变一个列表而影响另一个列表，所以赋值时切片或者拷贝
d.列表的运算：
| 列表1+列表2 |
将列表1和列表2的元素合并，产生一个新的列表 |
| 列表*n |
将列表中元素重复n次，产生一个新的列表 |
| 列表1 == 列表2 |
判断元素是否相等 |
| 列表1 is 列表2 |
判断列表位置是否相等 |
| 列表1>列表2 |
比较每个元素的大小 |
元素符合>操作 |
2.字典的功能和方法(dict),符号{key:value}：
可变，无序，元素：键(key): 用来定位值的。要求只能是不可变的数据类型(数字，字符串，元祖...)。是唯一的
值(value): 存储的数据。可以是任何类型的数据
a.字典的增删改查：
| 功能 |
增 |
| 字典[key] = 值 |
key值不在时就是增加 |
| 字典.setdefault(key) |
添加键值对，键是key，值是None |
key存在的时候，对字典不会有任何操作 |
| 字典.setdefault(key,value) |
添加键值对，键是key，值是value |
key存在的时候，对字典不会有任何操作 |
| 功能 |
删 |
| del 字典[key] |
通过key删除键值对 |
| 字典.pop(key) |
取出key对应的值(实质还是删除key对应的键值对) |
| .字典.clear() |
清空字典 |
| 功能 |
改 |
| 字典[key] = 新值 |
key存在，修改key值对应的value值 |
| 功能 |
查 |
| 字典[key] |
获取key对应的值 key值必须是存在的，否则会报KeyError |
| 字典.get(key) |
通过key获取值 |
key值不存在的时候不会报错，结果是None |
| for 变量 in 字典 |
遍历字典拿到key值 |
| for 变量 in 字典.values( ) |
遍历字典拿到value值 |
| for key, value in 字典.items( ) |
编历拿到key值和value值 |
确定key一定存在就是使用[ ]语法，key可能不存在的时候使用get语法
b.字典相关的方法：
| 使用方法 |
方法解释 |
|
1. len(字典) |
获取键值对的个数 |
|
2.字典.copy( ) |
将字典中的键值对复制一份产生一个新的字典 |
|
3..dict.fromkeys(序列,值) |
创建一个字典，将序列中的每个元素作为key，值作为value |
|
4. 字典.get(key,默认值) |
key不存在取默认值 |
|
5.字典.keys( ) |
返回所有key键对应的序列 |
转换成必须在前面加list（） |
| 字典.values( ) |
返回所有value值对应的序列 |
转换成列表必须在前面加list( ) |
| 字典.items( ) |
将键值对转换成元祖，作为一个序列的元素 |
转换成列表必须在前面加list( ) |
|
6. 字典1.update(字典2) |
使用字典2中(key,value)去更新字典1 |
已经存在的key就更新，不存在就添加 |
c.字典相关运算：
| 符号 |
解释 |
| == |
判断两个字典的键和值是否相等 |
| is |
判断两个字典的地址是否相等 |
| key in 字典 |
判断key值是否存在 |
| key not in 字典 |
判断key值是否不存在 |
3.元祖的功能和方法(tuple), 符号：（）;
不可变，有序，元素可以是任何类型的数据
如果元祖的元素只有一个的时候，必须在元素的后面加逗号
多个数据直接用逗号隔开，也表示是一个元祖 num = 1,2,3
a.查
| 功能 |
查 |
| 元祖[下标] |
查下标对应的元素 |
| 元祖[起始下标：结束下标：步长] |
拿到对应元素组成的元祖(切片) |
| for 变量 in 列表 |
获取到元祖元素 |
| 变量1，变量2 = （元素1，元素2） |
可以通过相同的变量个数，来一一获取元祖中的元素 |
| *变量名1，变量名2 =(元素1，元素2，元素3..) |
可以通过在变量前加*来获取部分的元素 |
可以通过在列表或者元祖前加*,来展开列表中的元素
b.元祖的相关方法:
len(), max(), min()也适用于元祖
| tuple() |
所有的序列都可以转换成元祖 |
字典只能将key值作为元祖元素 |
| sorted() |
对元祖进行升序排序 |
产生一个新的列表 |
c.元祖的运算：
| +, *, ==, is, in, not in |
和列表一样 |
4.集合的功能和方法(set), 符号:{元素1,元素2}
可变，无序 元素只能是不可变的数据，唯一 ： 自带去重的功能
a.集合的增删改查：
| 功能 |
增 |
| 集合.add(元素) |
在集合中添加一个元素 |
| 集合.update(序列) |
将序列中的元素添加到集合中 |
| 功能 |
删 |
| 集合.remove(元素) |
删除指定的元素 |
| 功能 |
查 |
| for 变量 in 集合 |
集合不能单独的获取一个元素，也不能切片，只能用for- in |
b.集合相关的运算: 是否包含，交集、并集、差集、补集
| 功能 |
包含 |
| 集合1 >= 集合2 |
判断集合1之中是否包含集合2 |
| 功能 |
差集 |
| 集合1- 集合2 |
求集合1中除了集合2以外的部分 |
| 功能 |
补集 |
| 补集^ |
求两个集合除了公共部分以外的部分 |
5.容器之间的相互转换：
| 类型 |
列表 |
| list(序列) |
序列才能转换成列表 |
字典转换成列表，将字典的key作为列表的元素 |
| 类型 |
字典 |
| dict(序列) |
序列的每个元素有两个元素的数据才能转换成字典 |
| 类型 |
元祖 |
| tuple(序列) |
只能将序列转换成元祖 |
字典转换成列表，将字典的key作为列表的元素 |
| 类型 |
集合 |
| set(序列) |
序列可以转换成集合，有去重的功能 |
字典转换成列表，将字典的key作为列表的元素 |
网友评论