Python：六、字典dict，元组tuple与集合set的使用

本文链接：https://blog.youkuaiyun.com/weixin_44180787/article/details/107627805

一、字典dict【重要】

1.1 字典概念

语法： {键1: 值1, 键2: 值2, 键3: 值3, …, 键n: 值n}
说明：键值对: key-value

字典和列表类似，都可以用来存储多个数据
在列表中查找某个元素时，是根据下标进行的；字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
字典中的每个元素都由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
键可以使用数字、布尔值、元组，字符串等不可变数据类型，但是一般习惯使用字符串，切记不能使用列表等可变数据类型
每个字典里的key都是唯一的，如果出现了多个相同的key,后面的value会覆盖之前的value

习惯使用场景：

列表更适合保存相似数据，比如多个商品、多个姓名、多个时间
字典更适合保存不同数据，比如一个商品的不同信息、一个人的不同信息。

1.2 字典的使用

1.2.1 创建字典

语法：字典名 = {key1:value1,key2:value2…}
创建空字典：d = {}
创建非空字典：

方式一：

dict21 = {"name":"张三","age":18}

方式二：dict(key=value),key是一个变量名，value是一个值

dict22 = dict(a="avvv",b="2353")
print(dict22)
dict22 = dict(a=200,b=33)
print(dict22)

方式三：
dict()和zip(序列)，zip表示映射
dict(zip([key1,key2,key3…],[value1,value2,value3…]))
注意：key的数量和value的数量可以不一致，以少的作为参考

dict23 = dict(zip(("name","age"),("aaa",10)))
print(dict23)

d = dict(zip("123", "abc"))
print(d)		---> 结果为{'1': 'a', '2': 'b', '3': 'c'}

方式四：[(key1,value1), (key2,value2)…] => {key1:value1, key2:value2…}

dict24 = dict([("a",10),("b",20),("c",30)])
print(dict24)		---> {'a': 10, 'b': 20, 'c': 30}

1.2.2 dict查询：通过key值查询

字典名[“key”]：

print(d["name"])         查询没有的key值则报错

字典名.get(“key”)：

print(d.get("name"))    	 查询没有的key值不报错，会返回None
print(d.get("sex", "男"))    没有key值不报错，会返回默认值：男

1.2.3 遍历字典

方式一：直接遍历字典的key

d = {"name":"哈哈", "age":24, "height":174}
for k in d:
    print(k)

方式二：通过 dict.keys() 得到所有的key值

for k in d.keys():
    print(k)

方式三：通过 dict.values() 得到所有的元素值

for v in d.values():
    print(v)

k = d.values()
print(k, list(k))	--->结果为：dict_values(['哈哈', 24, 174]) ['哈哈', 24, 174]

方式四：通过 dict.items() 得到key、元素值

for k, v in d.items():
    print(k, v)

1.2.4 合并

字典合并不能简单的通过“+”把两个字典合并起来，而是要使用 dict1.update(dict2) ：将字典dict2合并到字典dict1里面。

代码演示：

d1 = {1:2}
d2 = {3:4}
d1.update(d2)    update更新
print(d1)   --->结果为 {1: 2, 3: 4}

1.2.5 字典的增删改查

增加元素：字典名[“key”] = “元素值”，在末尾增加

d = {"name":"哈哈", "age":24, "height":174}
d["sex"] = "男"
print(d)

修改字典：字典名[“key”] = “元素值”
修改和增加的方式一样，若修改的key不存在，则会增加该值到字典。

d["name"] = "呵呵"
print(d)

查询：如 1.2.2节
删除元素：dict.pop(“key”)，通过key删除指定的元素。

d.pop("sex")
# d.clear()   # 清空字典
# d.popitem() # 删除最后一项，理解为随机删除一项
print(d)

1.2.6 其他使用

字典长度获取：len(字典名)

d = {"name":"哈哈", "age":24, "height":174}
print(len(d))

成员判断：判断的是key值，输出结果为bool值

print("age" in d)
print("age" not in d)

1.3 列表和字典的区别

list：

1、定义方式不同：列表[]，一般存放相同类型的数据；
2、内存相对字典较小；
3、数据量较大时，查找所需时间越久；

dict：

1、定义方式：{}，一般存放同一个事物的不同的属性；
2、内存消耗较大；
3、数据量大小对查询速度影响不大；
4、字典无下标。

二、元组tuple

特点：

元组元素不可改变，元素一旦被初始化，将不能发生改变。
可存不同类型数据。
和列表相似，本质上是一种有序的集合。

2.1 创建元组

创建空元组：t = ()
创建一个元素的元组 t = (1, )，不能用t=(1),否则是int类型数据：

t = (1,) 
print(t)	---> 结果为 （1，）
t = (1)
print(t)	---> 结果为 1

2.2 元组的下标

下标的获取：i = tuple.index(元素)
通过下标获取元素值：

t = (1, 2, 3, 4)
print(t[0])
print(t[-1])

2.3 合并，原元组不变，生成新元组

print((1, 2) + (3, 4))

2.4 重复

print((1,2) * 3)

2.5 长度len()

t = (1, 2, 3, 4)
print(len(t))

2.6 成员判断

t = (1, 2, 3, 4)
print(3 in t)

2.7 切片，和列表一样

t = (1,2,3,4,5)
print(t[2:5])

2.8 遍历

遍历元素

t = (1,2,3,4,5)
for n in t:
    print(n)

遍历下标

for i in range(len(t)):
    print(i)

同时得到下标和元素

for i, n in enumerate(t):
    print(i ,n)

2.9 排序，返回的是列表，不是元组

sorted(元组）：升序

t = (3,1,5,7,4)
t2 = sorted(t)

sorted(元组, reverse = True)：降序

t = (3,1,5,7,4)
t3 = sorted(t, reverse=True)

reversed(元组)：反转/倒序，要用list强制转换类型

t2 = reversed(t)        
print(t, list(t2))

2.10 列表与元组的转换

print(list((1,2,3)))
print(tuple([1,2,3]))

2.11 元组、列表可以快速取值

x, y = (2, 3)
print(x, y)
x, y = [2, 3]
print(x, y)

2.12 元组中有列表：列表依然可以修改

t = (1,2,[3,4])
t[-1][1] = 2
print(t)		--->结果为 (1,2,[3,2])

2.13 其他功能

增删改查：元组是不能改变的列表，所以无增删改功能。
查：如遍历

三、集合set【了解】

特点：

无序
唯一：不重复

3.1 创建集合

注意：

set的创建需要借助于list、tuple、字典；
set中会自动将重复元素过滤掉；
set跟dict类似，都使用{}表示，但是与dict之间的区别在于：set中相当于只存储了一组key，没有value。

1、通过列表创建集合
list1 = [432,5,5,46,65]
s1 = set(list1)

2、通过元组创建集合
tuple1 = (235,45,5,656,5)
s2 = set(tuple1)

3、通过字典创建集合，只转换key
dict1 = {1:"hello",2:"good"}
s3 = set(dict1)
print(s3)   #{1, 2}

3.2 集合的使用

3.2.1 列表去重

因集合是不重合的列表，可将列表转换为集合去除重复值后再转换为列表。

l = [1,2,4,4,4,3,2,1,6]
l2 = list(set(l))
print(l2)

3.2.2 遍历

set是没有索引的，所以不能通过s[2]获取元素，原因：set是无序的。

s = {1,2,3,4}
for n in s:
    print(n)

枚举获取的是编号和元素值：

for i,num in enumerate(s4):
 print(i,num)

3.2.3 增加元素

（1）set.add()：在set的末尾进行追加

语法：set.add(元素）
注意：

如果元素已经存在，则添加失败；
list是可变的，set中的元素不能是list类型，不能用add()添加列表元素进集合；
dict中的键值对可以改变，set中的元素不能是dict类型，不能用add()添加字典进集合。

s = {1,2,3,4}
s.add(44)
print(s)

（2）update() 插入【末尾添加】

语法：set.update(列表/元组/字符串)
注意：

打碎插入：直接将元组，列表中的元素添加到set中，将字符串中的字母作为小的字符串添加到set中；
不能添加整型，因为整型不能使用for循环遍历。

s2 = set([1,2,3,4,5])
print(s2)
s2.update([6,7,8])	---> {1, 2, 3, 4, 5, 6, 7, 8}
s2.update((9,10))	---> {1, 2, 3, 4, 5, 9, 10}
s2.update("good")	---> {1, 2, 3, 4, 5, 'd', 'g', 'o'}

3.2.4 删除元素

语法：set.remove(元素)

s3 = set([1,2,3,4,5])
print(s3)
s3.remove(3)
print(s3)		---> {1, 2, 4, 5}

3.2.5 交集、并集

s1 = {1,2,3,4}
s2 = {3,4,5,6}
1.按位与
print(s1 & s2)		---> {3, 4}
2.按位异或
print(s1 | s2)		---> {1, 2, 3, 4, 5, 6}
3.差集，s1中有，s2中没有的元素
print(s1 - s2) 		---> {1, 2}
4.对称差集，s1、s2中互相没有的元素
print(s1 ^ s2)		---> {1, 2, 5, 6}
5.s1包含s2
print(s1 > s2)		---> False
6.s2包含s1
print(s1 < s2)		---> False

四、排序算法

4.1 冒泡排序

思路：比较两个相邻下标对应的元素，如果以升序为例的话，则最大值出现在最右边。
原理：
[9,7,6,8,5,4,3,2,1]
第1次：[9,7,6,8,5,4,3,2,1] =>[7,6,8,5,4,3,2,1,9]
第2次：[7,6,8,5,4,3,2,1,9] =>[7,6,5,4,3,2,1,8,9]
第3次：[7,6,5,4,3,2,1,8,9] =>[6,5,4,3,2,1,7,8,9]
第4次：[6,5,4,3,2,1,7,8,9] =>[5,4,3,2,1,6,7,8,9]
第5次：[5,4,3,2,1,6,7,8,9] =>[4,3,2,1,5,6,7,8,9]
第6次：[4,3,2,1,5,6,7,8,9] =>[3,2,1,4,5,6,7,8,9]
……
代码演示

nums = [9,7,6,8,5,4,3,2,1]

外层循环：控制比较的轮数
for i in range(len(nums)-1):
	内层循环：控制每一轮比较的次数，兼顾参与比较的下标
    for j in range(len(nums)-1-i):
        if nums[j] > nums[j+1]:
            nums[j], nums[j+1] = nums[j+1], nums[j]
print(nums)

4.2 选择排序

思路：固定一个下标，然后拿这个下标对应的元素和其他的元素依次进行比较，最小值出现在最左边。找到最小数后先不交换，遍历完一次后再把最小数直接和左边数交换。
原理：
[9,7,6,8,5,4,3,2,1]
第1次：[9,7,6,8,5,4,3,2,1] => [1,7,6,8,5,4,3,2,9]
第2次：[1,7,6,8,5,4,3,2,9] => [1,2,6,8,5,4,3,7,9]
第3次：[1,2,6,8,5,4,3,7,9] => [1,2,3,8,5,4,6,7,9]
第4次：[1,2,3,8,5,4,6,7,9] => [1,2,3,4,5,8,6,7,9]
……
代码演示：

nums = [9,7,6,8,5,4,3,2,1]
for i in range(len(nums)-1):

    求剩下数中最小数的下标
    min_index = i
    for j in range(i, len(nums)):
        if nums[j] < nums[min_index]:
            min_index = j
            
     将最小数与左边未排序的数交换
    nums[i], nums[min_index] = nums[min_index], nums[i]
print(nums)