Python第二节：列表、元组、集合、字典等数据类型的详解

本章概要

本节将介绍列表、元组、字典，三个数据类类型的使用方法

一、列表

列表是由一系列特定顺序排列的元素组成的，它的元素可以是任何数据类型即数字、字符串、列表、元组、字典、布尔值等等，同时其元素也是可修改的。

列表的基础操作：
list_01 = [2,3,43,2,5,34,321,23]
list_02 = [9,9,8,7,56]

1、查询，列表是有序排列的，可以通过其索引进行查询
print(list_01[1])         >>>>3
2、修改，通过索引值进行定位修改
list_01[0] = 1
print(list_01[0]，list_01)      >>>>1,[1,3,43,2,5,34,321,23]
3、增加，直接在列表的最后添加值
list_01.append(55)
print(list_01)    >>>>[1,3,43,2,5,34,321,23,55]
4、插入添加，通过索引添加，原有的索引值后退位
list_01.insert(2,10)
print(list_01)    >>>>[1,3,10,43,2,5,34,321,23,55]
5、删除，通过索引删除
list_01.pop（3）
print(list_01)    >>>>[1,3,10,2,5,34,321,23,55]
6、通过值直接删除，有重复，就删除列表最左边的
list_01.remove(321)
print(list_01)    >>>>[1,3,10,2,5,34,23,55]
7、清空列表
list_01.clear（）
print(list_01)    >>>>[ ]
8、查找索引值，通过值查询索引，有重复，就查询列表最左边的
print(list_02.index(9))   >>>>0
9、统计，通过列表中的值统计其个数
print(list_02.count(9))   >>>>2
10、两个列表进行合并，把一个列表并入另一个列表的后面
list_01.extend(list_02)
print(list_01)    >>>>[1,3,10,2,5,34,23,55,9,9,8,7,56]
print（list_01+list_02)）    >>>>[1,3,10,2,5,34,23,55,9,9,8,7,56]
11、列表倒序来排列
list_01.reverse()
print(list_01)    >>>>[56,55,34,23,10,9,9,8,7,5,3,2,1]
12、列表正序来排列
list_01.sort（）
print(list_01)    >>>>[1,2,3,5,7,8,9,9,10,23,34,55,56]
13、复制一个新的列表
list_03=list_01.copy()
print(list_03)    >>>>[1,2,3,5,7,8,9,9,10,23,34,55,56]

列表的切片：

list_04 = [1,2,3,5,7,8,9,9,10,23,34,55,56]
1、切取开始的一部分，从索引值0开始正向切
print(list_04[ : 4])     #取索引 [ 0,4 )之间的值，不包括4     >>>>[1,2,3,5]
2、切取中间一部分，从索引值非0开始正向切
print(list_04[ 3:6])     #取索引 [ 3,6 )之间的值，不包括6    >>>>[5,7,8]
3、切取最后的一部分，从索引值0开始逆向切，从0开始放过来数
print(list_04[-3 : 0])     #取索引 [-3 : 0 )之间的值，不包括0     >>>>[34,55,56]
4、切取中间一部分，从索引值非0开始逆向切
print(list_04[-5 : -2])     #取索引 [-5 : -2 )之间的值，不包括-2     >>>>[10,23,34]
5、按规定区间提取，就是按一定规格跳着取
print(list_04[::2])    #从索引值0开始，累加2的提取    >>>>[1, 3, 7, 9, 10, 34, 56]
print(list_04[:6:3])    #从索引值0开始，累加3的提取,最大到索引6,不包括6        >>>>[1, 5]
print(list_04[-8::3])  #从索引值-8开始，累加3的提取,最大到索引0,不包括0       >>>>[8, 10, 55]

二、集合

m = [1, 2, 3, 3, 5, 4333, 7, 288]
n={2, 3, 5，66}

jihe=set(m)     #python是个强转化的语言，列表可以直接转化为集合，没有排列顺序
print（jihe）   #集合是没有重复的值的，列表转化时就去重了        >>>>{288, 1, 2, 3, 5, 7, 4333}
print（list（jihe））  #集合也可强转化为列表    >>>>[288, 1, 2, 3, 5, 7, 4333]
1、添加元素
n.add(66)       n.add(5)
print(n)   #添加已有的元素，直接覆盖原有的                  >>>>{66, 2, 3, 5}
2、删除，通过值指定删除
n.remove(3)                          
print（n）                          >>>>{66, 2, 5}
3、随机删除一个值
print（n. pop()）            >>>>{2,5}
4、差集：一个集合减去另一个集合与之共有的元素，且剩下的元素为之差集
print(set(m).difference(n))                              >>>>｛1,4333, 7, 288｝
print(set(m) - n)    # “-” 减号为之简写格式      >>>>｛1,4333, 7, 288｝
5、交集：取出两个集合共有的元素
print(set(m).intersection(n))                           >>>>{2,3,5}
print(set(m) & n)    # “&” 符号为之简写格式      >>>>{2,3,5}
6、子集：一个集合的元素在另一个集合内全部都有
print（n.issubset(set(m))）                          >>>>False
print（n <= set(m)）        #   “<= ” 符号为之简写格式                   >>>>False
7、父集：一个集合包括了另一个集合内所有元素
print（set(m).issubset(n)）                          >>>>False
print（ set(m) >= n）        #   “>= ” 符号为之简写格式                   >>>>False
8、并集：把两个集合合并在一起，且出重
print（set(m).union(n)）                              >>>>{288, 1, 2, 3, 5, 7,66, 4333}
print（ set(m) | n）    #   “| ” 符号为之简写格式         >>>>{288, 1, 2, 3, 5, 7,66, 4333}
9、对称差集：把两集合的公有部分去掉，剩余的进行合并
print（set(m).symmetric_difference(n)）                              >>>>{288, 1, 7,66, 4333}
print（ set(m) ^ n）        #   “^ ” 符号为之简写格式                   >>>>{288, 1, 7,66, 4333}

三、元组

元组元组与列表类似，不同之处在于元组的元素不能修改、删除、添加

tuple=(1,2,4,5,7,9,33)       #元组是以小括号形式显示的

1、元素的查看：通过索引进行查看，类似列表，人家也是有序排列的
print(tuple[4])                              >>>>7
2、元组不能进行元素删除，单能删除整个元组
del tuple      #不会打印出任何东西
3、元组不能添加元素，但两元组能合并
print（tuple+（0，8，12，44））        >>>>(1,2,4,5,7,9,33,0,8,12,44)    
4、元组也能进行切片，形式跟列表一样
print(tuple[ : 3])                 >>>>(1,2,4)

四、字典

字典是一个容器模型，且可存储任意类型对象，是无序排列的。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的

info = {  'M001':"sanxing" , 'M002':"pingguo", 'M003':"xiaomi"}
info1 = {"M006":'lianxiang', 'M007':'bubugao', 'M003':'guge'}

1、查询：通过键查询其值
print(info["M001"])                                             >>>>sanxing
print(info.get("M001"))     #  这种查找，即使找不到，也不会报错的              >>>>sanxing
2、修改：通过键修改其值
info["M002"] = "huawei"
print(info["M002"] ,info)                   >>>>huawei, {  'M001':"sanxing" , 'M002':"huawei", 'M003':"xiaomi"}
3、新增：通过键新增其值，类似于修改，修改不了，就添加
info["M004"] = "pingguo"
print(info)                   >>>>{  'M001':"sanxing" , 'M002':"huawei", 'M003':"xiaomi","M004": "pingguo"}
4、删除
info.pop("M002")
del info["M001"]
print(info)                   >>>>{ 'M003':"xiaomi","M004": "pingguo"}
5、清空
info.clear() 
print(info)                   >>>>{ }
6、创建字典，浅一层创建
A = info.fromkeys([5,6,7])
print(A)                          >>>>{5: None, 6: None, 7: None}
7、字典转成列表
print(info.items())       >>>>dict_items([('M001', 'sanxing'), ('M002', 'pingguo'), ('M003', 'xiaomi')])
8、以列表的形式，打印键（keys）
print(info.keys())           >>>>dict_keys(['M001', 'M002', 'M003'])
9、通过键进行查询，找到就输出其值，找不到就添加到字典中
print（info.setdefault("M003")）          >>>>xiaomi
info.setdefault("M005")
print(info)                   >>>>{ 'M001':"sanxing" , 'M002':"pingguo", 'M003':"xiaomi","M005":None}
10、把字典dict2的键/值对更新到dict里，有同键的话，dict2的直接覆盖
info1.update(info)
print(info1)            >>>>{'M006': 'lianxiang', 'M007': 'bubugao', 'M003': 'xiaomi', 'M001': 'sanxing', 'M002': 'huawei' }
11、以列表返回字典中的所有值（values）
print(info.values())                  >>>>dict_values(['sanxing', 'pingguo', 'xiaomi'])
12、通过索引来对比，是否在字典中
print("M001" in info)                         >>>>True
13、两个列表合并成字典
print(dict(zip([1,2,3,4],['ab','ac','ad'])))                    >>>>{1: 'ab', 2: 'ac', 3: 'ad'}