元组&字典

一、元组【掌握】

1.概念

和列表相似，本质上是一种有序的集合

元组和列表的不同之处：

​ a.列表:[] 元组：()

​ b.列表中的元素可以进行增加和删除操作，但是，元组中的元素不能修改【元素：一旦被初始化，将不能发生改变】

2.元组基本操作

创建列表:

​ 创建空列表：list1 = []

​ 创建有元素的列表：list1 = [元素1，元素2，。。。。。]

创建元组

​ 创建空元组：tuple1 = ()

​ 创建有的元组：tuple1 = (元素1，元素2，。。。。)

# 1.概念
"""
列表：是一种有序的，可变的，可以存储重复元素的，可以存储不同类型数据的集合
元组：是一种有序的，不可变的，可以存储重复元素的，可以存储不同类型数据的集合

元组和列表的不同之处：
	a.数据类型的表示形式不同：列表:[]     元组：()
	b.列表中的元素可以进行增加和删除操作，但是，元组中的元素不能修改【元素：一旦被初始化，将不能发生改变】
"""

# 2.定义
# 元组：tuple    列表：list
# a.命名格式：尽量不要直接使用tuple或list
list1 = [34,5,6,6,6,6,6,"abc"]
print(list1,type(list1))
tuple1 = (34,6,7,7,7,7,7,"abc")
print(tuple1,type(tuple1))

# b.当元组中只有一个元素时，则需要在元素的后面添加逗号，以消除歧义
list2 = [45]
print(list2,type(list2))
tuple2 = (45,)
print(tuple2,type(tuple2))

# c.列表是可变的，元组是不可变的
list1[1] = 100
print(list1)
# tuple1[1] = 100   # TypeError: 'tuple' object does not support item assignment

# 【面试题】
t1 = (34,4,5,[45,5,78])
t1[-1][0] = 100
print(t1)  # (34, 4, 5, [100, 5, 78])

# 3.操作
# a.+
t1 = (1,2)
t2 = (3,4)
print(t1 + t2)

# b.*
print(t1 * 3)

# c.in和not in
print(2 in t1)
print(23 not in t1)

# d.切片
t1 = (11,22,33,44,55,66,77,88,99)
print(t1[100:])   # ()
print(t1[0:-1])   # (11.....88)

print(t1[1:5:-1])  # ()
print(t1[-1:-5:-1]) # (99,88....66)

print(t1[-5:-1:-1])  # ()
print(t1[3::-1])     # (44...11)

# 4.遍历
for ele in t1:
    print(ele)

for i in range(len(t1)):
    print(t1[i])

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

# 5.系统功能
# a.
print(len(t1))

# b
i = t1.index(22)


# c.
c = t1.count(22)

# d.
print(max(t1))
print(min(t1))

# e.list()和tuple()
l1 = [34,6]
print(l1,type(l1))

t1 = tuple(l1)
print(t1,type(t1))

l2 = list(t1)
print(l2,type(l2))

二、字典【重点掌握】

1.概念

列表和元组的使用缺点：当存储的数据要动态添加、删除的时候，我们一般使用列表，但是列表有时会遇到一些麻烦,

解决方案：既能存储多个数据，还能在访问元素的很方便的定位到需要的元素，采用字典

如，

一个列表保存5个学生的成绩，score_list = [66,100,70,78,99]

一个字典保存5个学生的成绩，score_dict = {“小明”:66,“小花”:100,“jack”:70,“tom”:78,“bob”:99}

2.定义字典

语法：{键1:值1, 键2:值2, 键3:值3, …, 键n:值n}

说明：

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

习惯使用场景：

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

# 【面试题】创建字典有几种方式，请举例说明

# 方式一
dict1 = {"name":"张三","age":18}
print(dict1)

# 方式二
dict2 = {}
dict2["aaa"] = 10
dict2["bbb"] = 20
print(dict2)

# 方式三,dict(key1=value1,key2=value2.....)
# 弊端：字典的key只能是字符串形式
dict3 = dict(x=10,y=20,z=30)
print(dict3)  # {'x': 10, 'y': 20, 'z': 30}
"""
{1:10,2:20,3:30}
"""
# dict3 = dict(1=10,2=20,3=30)
# print(dict3)

# 方式四：dict([(key1,value1),(key2,value2).....])
dict4 = dict([("one",10),("two",20),("three",30)])
print(dict4)

# 方式五：dict(zip([key1，key2,key3....],[value1,value2,value3....]))
dict5 = dict(zip(['11','22','33'],[1,2,3]))
print(dict5)

dict5 = dict(zip(['11','22','33','44'],[1,2,3]))
print(dict5)

dict5 = dict(zip(['11','22','33'],[1,2,3,4]))
print(dict5)

dict5 = dict(zip(('11','22','33'),(1,2,3)))
print(dict5)

3.字典的使用

"""
【面试题】列表，元组和字典的区别
列表：是一种有序的，可变的，可以存储重复元素的，可以存储不同类型数据的集合
元组：是一种有序的，不可变的，可以存储重复元素的，可以存储不同类型数据的集合
字典：是一种有序的，可变的，key不允许重复，value可以重复，key只能是不可变的数据类型，存储键值对的集合
"""

# 1.
score_list = [66,100,70,78,99]
print(score_list)
score_dict = {"小明":66,"小花":100,"jack":70,"tom":78,"bob":99}
print(score_dict)

# 2.定义字典
# a.定义一个空字典
dict1 = {}
print(type(dict1))

# b.定义一个非空字典
# Python3.7之前字典是无序的，Python3.7之后字典是有序的
score_dict = {"小明":66,"小花":100,"jack":70,"tom":78,"bob":99}
print(score_dict)

# 3.字典中的值的访问
# a.获取
# 语法形式一:字典[key],如果key存在，则获取对应的value，如果不存在，则直接报错
score1 = score_dict["小花"]
print(score1)
# score2 = score_dict["张三"]  # KeyError: '张三'

# 语法形式二：字典.get(key)，如果key存在，则获取对应的value，如果不存在，则返回None
score1 = score_dict.get("小花")
print(score1)
score2 = score_dict.get("张三")  # None
print(score2)

# b.修改
# 语法：字典[key] = 值
# 情况一：如果key存在，则表示修改值
print(score_dict)
score_dict["jack"] = 40
print(score_dict)

# 情况二：如果key不存在，则表示添加键值对
score_dict["李四"] = 88
print(score_dict)

# 4.
score_dict = {"小明":66,"小花":100,"小明":70,"tom":70,"bob":99}
print(score_dict)

4.遍历字典

dict1 = {"name":"张三","age":18}
print(dict1)

print(dict1.keys())
print(dict1.values())
print(dict1.items())


# 方式一：默认遍历key           *****
for key  in dict1:
    print(key,dict1[key])

# 方式二：keys()
for key in dict1.keys():
    print(key,dict1[key])

# 方式三：values()
for value in dict1.values():
    print(value)

# 方式四：items()                      *****
for key,value in dict1.items():
    print(key,value)

5.练习

# 1.从控制台输入一段文本，统计每个字符出现的次数
# 思路：定义一个空字典，将字符串中的每个字符判断在字典中是否存在，
# 如果不存在，则向字典中添加一对键值对，键为字符，值为1，如果存在，则将指定字符对应的值获取出来，递增1
# data = input("请输入一段文本：")
# count_dict = {}
# for ch in data:
#     if ch not in count_dict:    # if xx  in  字典，判断xx是否为字典中的key
#         count_dict[ch] = 1      # 添加键值对
#     else:
#         count_dict[ch] += 1     # 修改指定键对应的值
# print(count_dict)


# 2.统计一个列表中出现次数最多的元素
list1 = [34,4,6,6,67,778,9,24,35,9,4]
# 统计每个元素出现的次数
count_dict = {}
for num in list1:
    if num not in count_dict:
        count_dict[num] = 1
    else:
        count_dict[num] += 1
print(count_dict)
#获取字典中value的最大值
max_value = max(count_dict.values())
# 遍历字典，获取出现次数最多的元素
numlist = []
for key,value in count_dict.items():
    if value == max_value:
        numlist.append(key)
print(f"列表中出现的最多次数为：{max_value},对应的元素为：{numlist}")

# 3.已知列表list1 = [1,2,3,4,5],list2 = ['a','b','c','d','e'],
# 以list1中的元素作为key，list2中的元素作为value，生成一个字典dict3
list1 = [1,2,3,4,5,6]
list2 = ['a','b','c','d','e']

# 方式一：
dict3 = {}
if len(list2) >= len(list1):
    for i in range(len(list1)):
        dict3[list1[i]] = list2[i]
    print(dict3)
else:
    for i in range(len(list2)):
        dict3[list1[i]] = list2[i]
    print(dict3)

# 方式二
dict3 = dict(zip(list1,list2))
print(dict3)