字典的使用

1.字典的内置方法

#1. 字典的声明方式
dict0 = dict()  #创建出来的是空字典  {}
print(dict0)
​
dict0 = dict({"A":15, "B":17})
print(dict0)
​
#如果传递序列的话 传递的是嵌套的序列
dict0 = dict([[12, 34],[22, 34]])
print(dict0)
​
#变量=值
dict0 = dict(姓名="小沐", age=18)
print(dict0)
​
dict0 = {"语文":87, "数学":22}
​
#是没有索引
# item = dict0[0] #KeyError: 0
# print(item)
​
#获取value的方式 根据键来获取的  字典名[key]
value = dict0["数学"]
print(value)
​
#如果key不存在 这种获取方式会报错
# value = dict0["英语"]  #KeyError: '英语'
# print(value)
​
#另外一种获取方式 如果键不存在 会返回None
value = dict0.get("英语")
print(value)
​
#设置值的方式
#修改值 前提键存在的情况下修改[新值覆盖旧值] 如果不存在会添加为新的键值对
dict0["数学"] = 45
print(dict0)
​
dict0["英语"] = 60
print(dict0)
​
#提供了set方法
dict0.setdefault("政治", 55)
print(dict0)
​
#提供了set方法 注意: 如果键不存在与键值对中 才会将值赋予给对应键  如果存在就不会赋值了
#D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
dict0.setdefault("政治", 75)
print(dict0)
​
#update的方法 合并字典 不会新生成一个字典 而是直接影响当前字典
dict1 = {"历史":55, "地理":78}
dict0.update(dict1)
print(dict0)
​
#获得字典中键值对的个数
length = len(dict0)
print(length)
​
​
#关于字典的遍历
#直接遍历字典 -- 其实遍历的是键
for k in dict0:
    print(k)
​
#只遍历值
#获得字典中所有的值
values = dict0.values()
print(values)
​
for v in dict0.values():
    print(v)
​
​
#遍历字典的键值对
#获得所有的键值对  将键和值成对存放于元组中
items = dict0.items()
print(items)
for item in dict0.items():
    print(item)
​
k, v = (10, 12)
print(k, v)
​
for k, v in dict0.items():
    print(k, v)
​
#删除元素 : 根据键删除键值对
print(dict0)
​
dict0.pop("英语")
print(dict0)
​
# KeyError: '英语' 如果不存在报错
# dict0.pop("英语")
# print(dict0)
​
#直接删除键值对 删除的是确定位置后最后一个
# dict0.popitem()
# print(dict0)
​
#清空字典
dict0.clear()
print(dict0)

2.字典的例子

content = input("请输入一句英语 每个单词之间使用空格隔开:")
print(content)
print(type(content))
​
#切割 切割符是空白
word_list = content.split()
print(word_list)
​
#声明一个空的字典 来存放单词和数量成对的数据
word_dict = {}  #key是单词 value是单词数量
​
for word in word_list:
    if word not in word_dict:
        #第一次进来
        word_dict[word] = 1
    else:
        #这种情况表示不是第一次来 需要在原有的次数上加1
        #获得原有次数
        value = word_dict[word] + 1
        word_dict[word] = value
print(word_dict)
​
for item in word_dict.items():
    print(item)

3.二分法

list0 = [12, 34, 57, 81, 96, 108]
list0.sort()
#设定待查找元素
key_item = 109
#设置初始查找区间
min_index = 0
max_index = len(list0) - 1
#获得中间索引
mid_index = (min_index + max_index) // 2
#重复查找操作
while list0[mid_index] != key_item:
    if key_item > list0[mid_index]:
        min_index = mid_index + 1
    elif key_item < list0[mid_index]:
        max_index = mid_index - 1
    #区间发生变化 盘判断区间是否合理
    if max_index >= min_index:
        #更新中间索引 再去重新查找
        mid_index = (min_index + max_index) // 2
    else:
        #区间不合理
        print("对不起, 没有该元素")
        break  # 不用再继续查找
else:
    #找到了
    print("%d在列表的%d位置处" % (key_item, mid_index))
​
#函数方法
def half_search_desc(src_list, key):
    src_list.sort(reverse=True) # 大 ---> 小
    min_index = 0
    max_index = len(src_list) - 1
    mid_index = (min_index + max_index) // 2
​
    #判定区间是否合理进行查找
    while max_index >= min_index:
​
        if key > src_list[mid_index]:
            max_index = mid_index - 1
        elif key < src_list[mid_index]:
            min_index = mid_index + 1
        else:
            #代表找到了
            return mid_index
​
        #区间更改之后 更新中间索引
        mid_index = (min_index + max_index) // 2
​
    else:
        #区间不合理
        return -1

4.集合

#声明集合的方式
set0 = set()  #空集合  这个设置空集合的唯一方式
print(set0)
​
set0 = set("abcdefg")
print(set0)
​
#集合有数据的时候是使用大括号包含的 但是没有数据的时候不能直接使用{}表示空集合 因为{}表示的是空字典
​
set0 = {12, 34, 56}
​
#象集合中添加元素
set0.add(72)
print(set0)
​
#移除  任意一个
# set0.pop()
# print(set0)
​
#删除指定元素
# set0.discard(13)
# print(set0)
​
#KeyError: 13  删除存在就直接删除 如果不存在报错
# set0.remove(13)
# print(set0)
​
​
#运算符的使用
set1 = {12, 34, 77}
new_set = set0 - set1
print(new_set)  #在前者中去除掉与后者的交集部分
​
​
#合并两个集合
set2 = {12, 34, 56}
set3 = {12, 77, 65}
#合并完成之后生成一个新的集合
new_set = set2.union(set3)
print(new_set)
​
#在原有集合的基础上 合并其他集合
set2.update(set3)
print(set2)
​
#判断一个集合是否另外一个集合的子集
set4 = {13}
set5 = {12, 56, 71}
res = set4.issubset(set5)
print(res)
​
#判断一个集合是否包含另外一个集合
res = set5.issuperset(set4)
print(res)
​
#判断两个集合是否没有交集
res = set4.isdisjoint(set5)
print(res)
​
#在一个集合中移除另外一个集合与自己的交集
set0 = {43, 67, 81, 29}
set1 = {43, 22, 67}
set0.difference_update(set1)
print(set0)
​
#清空集合
set0.clear()
print(set0)

5.元组

#1.声明方式
tuple1 = tuple() # 声明的是一个空元祖  ()
print(tuple1)
​
#可以放置序列 元组中的内容是序列中的每一个元素
tuple1 = tuple("abcdefg")
print(tuple1)
​
tuple1 = tuple([12])
print(tuple1)  #(12,)
​
a = (10,)
print(a)
print(type(a))
​
#2.运算符的操作  与列表中类似
'''
+   将两个元组的内容拼接在一起 生成一个新的元组
*  乘以数值 将元组的中复制n倍  生成一个新的元组
==  比较的是元组中的内容是否相等
!=
>=
<=
>
<
'''
tuple2 = (12, 34, 56)
tuple3 = (22, 71, 19)
new_tuple = tuple2 + tuple3
print(new_tuple)
​
new_tuple = tuple2 * 2
print(new_tuple)
​
tuple4 = (12, 34, 56)
print(id(tuple2))
print(id(tuple4))
​
print(tuple2 == tuple4)
​
tuple5 = (12, 34, ["a", "b"])
#操作元组中的元素
#只能获取  不能直接修改元素的地址
# 0-len(tuple5)- 1     [-len(tuple5), -1]
value = tuple5[0]
print(value)
​
#tuple5[0] = 13
print(tuple5) #TypeError: 'tuple' object does not support item assignment
​
#这个可以 因为脚标2的位置地址没有发生变化
tuple5[2][0] = "m"
print(tuple5)
​
tuple0 = (12, 56, 78, 91, 12, 45, 72, 12)
#获得元组指定元素出现的次数
num = tuple0.count(12)
print(num)
​
#获得元组元素的个数
length = len(tuple0)
print(length)
​
#获得最值
max_value = max(tuple0)
print(max_value)
min_value = min(tuple0)
print(min_value)
​
#遍历
for item in tuple0:
    print(item)
​
for i in range(length):
    print(tuple0[i])
​
​
#查找某个元素第一次出现的位置
index = tuple0.index(12)
print(index)
#从指定位置开始查找
index = tuple0.index(12, 1)
print(index)
​
#从指定区间进行查找[1, 3)
index = tuple0.index(12, 1, 5)
print(index) #找到返回索引  找不到报错