一、列表list

**
1. append() 在末尾插入一个内容
2. insert(index,data) 指定位置插入
 如：a.insert(3,11)在第四个位置插入113. del() 删除
4. pop()拿出最后一个元素，经常有赋值操作如：a=x.pop()
5. remove()在列表中删除指定值的元素，列表中必须有这个值，否则会报错，应使用try或先进行判断
6. clear()清空，但列表的地址不变也就是说仍存在空间
7. reverse()翻转，列表地址不变
8. extend()扩展列表，a.attend(b)把b加到a上
9. count()查找列表中指定元素的个数
10. copy()浅拷贝传值不传址且只传一层即二层列表传址
 【注】list操作中直接赋值相当于传址操作**

二、元组-tuple（不可更改）

**
创建：
1. t=()
 print(type(t))2. t = 1,2,3,4
 print(type(t))3. l = [1,2,3,4]
 t = tuple(l)
 list所有的特性，除了可以修改，元组都有
 索引，分片，序相加，相乘，成员操作一模一样
 关于元组的函数4. len()获取长度
5. min()max()最大最小值
6. 元组变量交换法
 a=1
 b=2
 a,b=b,a
 print(a,b)
 结果：2 1**

三、集合-set

**
 一堆确定的无序的唯一的数据，集合中每一个数据成为一个元素
 定义：s=set() s={1,2,3,4,5}
 l = [1,2,3,5,5,5,5]
 s = set(l)
 特征：集合内数据无序，无法索引和分片
 集合内数据元素具有唯一性，不能有重复数据
 内部只能放可哈希的数据
 集合序列操作： in , not in
 集合的遍历操作：for i in s:
 ##带有元组的集合遍历
 s = {(1,2,3),(‘i’,‘love’,‘you’),(4,5,6)}
 for k,m,n in s:
 print(k," “,m,” ",n)
 for k in s:
 print(k)
 结果：4 5 6
 i love you
 1 2 3
 (4, 5, 6)
 (‘i’, ‘love’, ‘you’)
 (1, 2, 3)
 集合的内涵：
 ##普通集合的内涵,以下初始化后自动过滤掉重复的元素
 s = {1,1,222,3,6,8,3}
 print(s)
 ss = {i for i in s}
 print(ss)
 结果：
 {1, 3, 6, 8, 222}
 {1, 3, 6, 8, 222}
 ##带条件的集合内涵
 s = {1,2,333,453,2,1,776}
 ss = {i for i in s if i%2 == 0}
 print(ss)
 结果：{776, 2}
 ##多循环的集合内涵
 s1 = {1,2,3,4}
 s2 = {“i”,“love”,“you”}
 s = {m*n for m in s2 for n in s1 if n==2}
 print(s)
 结果：{‘youyou’, ‘lovelove’, ‘ii’}
 关于集合的函数：
 len(),max(),min()跟其他函数基本一致1. add()向集合内添加元素，向末尾添加
2. clear清空,原地清空
3. copy()函数，浅拷贝s1=s2.copy()
4. remove()移除指定的值，直接改变原有值，如果要删除的值不存在会报错
5. discard()移除集合中指定值，根remove()一样，但是元素不存在不会报错
 6.pop()随机移除一个元素6. intersection()交集
7. difference()差集
8. union()并集
9. issubset()检查一个集合是否为另一个集合的子集
10. issuperset()检查一个集合是否为另一个集合的超集
 s1 = {1,2,3,4,5}
 s2 = {4,5,6,7,8}
 s_1 = s1.intersection(s2)
 print(s_1)
 s_2 = s1.difference(s2)
 print(s_2)
 s_3 = s1.union(s2)
 print(s_3)
 s_4 = s1.issubset(s2)
 print(s_4)
 结果：{4, 5}
 {1, 2, 3}
 {1, 2, 3, 4, 5, 6, 7, 8}
 False11. frozenset冰冻集合,冰冻就是不可以任何修改的集合
 ##创建
 s = frozenset()**

四、dict字典

**
 ##创建空字典 d = {} 或d = dict{}
 ##创建有值的字典，每一组用冒号分开，每一对键值对用逗号隔开
 d = {“one”:1,“two”:2,“three”:3}
 ##用元组创建一个字典
 d=dict([(“one”,1),(“two”,2),(“three”,3)])
 print(d)
 结果：{‘one’: 1, ‘two’: 2, ‘three’: 3}
 ##用关键字创建一个字典
 d=dict(one=1,two=2,three=3)
 print(d)
 结果：{‘one’: 1, ‘two’: 2, ‘three’: 3}
 ##字典的特征
 ##字典是序列类型，但是是无序序列，所以没有分片和索引
 ##字典中的数据是每一个键值对组成，即没有kv对
 ##key：必须是可哈希的值，如int,char,float,但是list,set,dict不行
 ##value：任何值
 ##常见操作
 ##访问数据
 d={“one”:1,“two”:2,“three”:3}
 print(d[“one”])
 d={“one”:1,“two”:2,“three”:3}
 d[“one”]=“一”##修改
 print(d)
 del d[“one”]##删除
 print(d)
 结果：1
 {‘one’: ‘一’, ‘two’: 2, ‘three’: 3}
 {‘two’: 2, ‘three’: 3}
 ##成员检测in , not in
 ##检测的不是值，也不是键值对，是键
 d={“one”:1,“two”:2,“three”:3}
 if 2 in d:
 print(“值”)
 if “two” in d:
 print(“键”)
 if (“two”,2) in d:
 print(“键值对”)
 结果：键
 ##遍历
 d={“one”:1,“two”:2,“three”:3}
 for k in d.keys():
 print(k, d[k])
 结果：one 1
 two 2
 three 3
 ##字典生成式
 d={“one”:1,“two”:2,“three”:3}
 dd={k:v for k,v in d.items() if v%2==0}
 print(dd)
 结果：{‘two’: 2}
 ##str(字典)返回字典的字符串格式
 ##items返回字典对应组成的元组格式
 d={“one”:1,“two”:2,“three”:3}
 i=d.items()
 print(type(i))
 print(i)
 结果：<class ‘dict_items’>
 dict_items([(‘one’, 1), (‘two’, 2), (‘three’, 3)])
 ##get:根据指定键返回相应的值，好处是可以返回默认值
 d={“one”:1,“two”:2,“three”:3}
 print(d.get(“aaa”))##会输出none，并且默认值是可设置的如print(d.get(“aaa”,100))此时会返回100
 print(d[“aaa”])##会报错
 ##fromkeys 使用指定的序列做为键，使用一个值作为字典的所有的键的值
 s=[“一”,“二”,“三”]
 d=dict.fromkeys(s,1)
 print(d)
 结果：{‘一’: 1, ‘二’: 1, ‘三’: 1}