文章目录

掌握知识点
- 1. 元组
- - 1.1 元组概述
  - 1.2 语法格式
  - 1.3 元组场景使用
- 2. 字典
- - 2.1 概述
  - 2.2 字典的语法结构与注意
  - 2.3 字典CURD
  - - 2.3.1 字典获取
    - 2.3.2 字典添加和修改
    - 2.3.3 字典删除
    - 2.3.4 字典遍历
  - 2.4 enumerate 函数
  - 2.5 扩展练习
  - - 2.5.1 判断是否能全部购买
    - 2.5.2 学生信息的排序
    - 2.5.3 WordCount 输出字典
    - 2.5.4 统计字符串数字出现次数

掌握知识点

什么是元组 ?
如何创建元组的一个元素 ?
元组和列表的区别?
字典的定义
掌握字典的CURD 操作
掌握字典的遍历
- 遍历整个字典有2种方式
掌握公共方法的操作

1. 元组

1.1 元组概述

在Python中，元组是一种 不可变的有序序列,即一旦创建不能被修改，可以用来存储一组 有序的数据。
和列表相似，元组中的 数据可以是多个,并且可以是任意类型的。
- 包括 数字、字符串、列表、元组等。
- 元组和列表的语法非常相似， 不同的是 元组使用圆括号()进行定义，而不是方括.
- 理解记忆, 所谓“元”组，就是用“圆”括号

1.2 语法格式

因为元组的创建方式和列表极其相似,定义方式也相差不多,

但是元组是一旦创建,就无法改变.,一般可以存储不变的元素,如日期, 坐标等

'''
1.元组和列表很相似, 都可以存放多个元素,可以存放不同的类型
    一旦创建就不可改变,
    列表的定义方式 []
    元组定义方式 ()
'''
my_list = [1, "字符串", 3.14, True]  # 列表的创建
my_tuple = (1, "字符串", 3.14, True)  # 创建元组

# 输出  <class 'list'> <class 'tuple'>
print(type(my_list), type(my_tuple))
# 输出 [1, '字符串', 3.14, True] (1, '字符串', 3.14, True)
print(my_list, my_tuple)

#2.改变元组会异常 'tuple' object does not support item assignment
my_tuple[0] = 2

在这里插入图片描述

在创建元组时,需要注意事项

如何创建单个元组元素 ?

'''
1. 列表创建单个元素与元组创建单个元素的不同.
'''

my_list =[1]
print(type(my_list))
#1.1 创建元组
my_tuple = (1)
print(my_tuple) # 输出是1
print(type(my_tuple)) #类型是 <class 'int'>

#1.2 创建时需要注意
my_tuple2=(1,) #在后面 必须要留一个逗号
print(type(my_tuple2),my_tuple2)

元组是Python中的不可变序列，相较于列表，其所拥有的方法较少。

count(x)：返回元组中x元素出现的次数。
index(x)：返回元组中第一次出现x元素的索引位置。
len() ：计算元组的个数.

# 定义元组
my_tuple = (1, 2, 3, 4, 5, 3, 2, 1)

# count()方法
print(my_tuple.count(3)) # 2
print(my_tuple.count(6)) # 0

# index()方法
print(my_tuple.index(3))  # 2
print(my_tuple.index(6))  # ValueError: tuple.index(x): x not in tuple

#len() 计算元组的个数
print(len(my_tuple))

在这里插入图片描述

# 创建元组
my_tuple = ("字符串", 5, True)  
print(my_tuple[-1]) #True

需要注意的是，元组是不可变序列，因此元组的方法不会修改元组本身。这些方法会返回一个新的元组，且不对原有元组进行任何修改。

1.3 元组场景使用

一般认为,tuple有这类特点,并且也是它使用的情景:
Tuple 比 list 操作速度快。
- 如果定义了一个值的常量集，并且唯一要用它做的是不断地遍历它，请使用 tuple 代替 list。
  3, 如果对不需要修改的数据进行 “写保护”，可以使代码更安全。 使用 tuple 而不是 list
Tuples 可以在 dictionary（字典，后面要讲述）中被用做 key，但是 list 不行。
- Dictionary key 必须是不可变的。Tuple 本身是不可改变的，但是如果您有一个 list 的 tuple，那就认为是可变的了，用做 dictionary key 就是不安全的。
- 只有字符串、整数或其它对 dictionary 安全的 tuple 才可以用作 dictionary key。

2. 字典

2.1 概述

首先思考一个问题,在学习列表时, 假如,因为列表中的第一个元素发生了错误, 数据发生了错误,想修改它.
- 直接修改即可. 列表名[0] = new_value
- 但是它的顺序又发生了改变 ,我需要再通过改变索引才能找到它在修改它,这时我还需要修改索引.
```
list_1 = ["小明","小红","小绿"]
#1. 修改第一个元素,将小明该为 小黄
list_1[0] = "小黄"
print(list_1)
# 1.1 如果列表中的顺序发生了变化, 我还需要修改索引
list_2 = ["小红","小明","小绿"]
list_2[1] ="小黄"
print(list_2)
```
问题来了,有没有一种类型,即可以存储多个数据,又能快速定位某个元素.
- 字典的产生,以键值对的方式存在
字典是一种 可变容器类型，可以存储键值对,字典中的键和值可以是任意类型，不能是列表。字典的特点是：
- 无序性：字典中的键值对没有固定的顺序，每次访问可能返回不同的顺序。
- 键具有唯一性：在一个字典中，键是唯一的。如果有相同的键出现，则后面的键值对会覆盖前面的键值对。
- 可变性：可以在字典中添加、删除、修改任意键值对。
- 可迭代性：可以通过for循环遍历字典中的所有键值对。

2.2 字典的语法结构与注意

通过 key 和 value 组成 键值对的形式

my_dict = {'key1': value1, 'key2': value2, ...}

# 定义一个空字典
my_dict3={}
print(my_dict3)
#定义有键值对的字典
my_dict={"name":"孙悟空","age":500,"address":"花果山","like":["取经","打妖精","收拾二师兄"]}
print(type(my_dict)) #<class 'dict'>
print(my_dict)

键具有唯一性.

# 到底会输出谁 ?
dict_1  = {"name": "孙悟空", "name":"六耳猕猴"}

print(dict_1)

键具有唯一性. 为什么不能是列表 ?

为什么元组可以?

# 不能是列表, 但可以是元组
#dict_2 = {"name": "孙悟空", [1,2]:"六耳猕猴"}
#print(dict_2) # TypeError: unhashable type: 'list' 不支持,因为列表可变.

dict_3 = {"name": "孙悟空", (1,2):"六耳猕猴"} #因为元组是不可以改变
print(dict_3) #{'name': '孙悟空', (1, 2): '六耳猕猴'}

值可以是任意类型.

#值可以是任意类型
dict_4 ={"name":['孙悟空',"齐天大圣","美猴王"],"address":("花果山","水帘洞")}
print(dict_4)

2.3 字典CURD

2.3.1 字典获取

第一种, 通过get("key")值的方式来获取.

第二种, 也可以使用 字典名["key"] 方式获取.

#1. 创建字典
my_dict={"name":"孙悟空","age":500,"address":"花果山","like":["取经","打妖精","收拾二师兄"]}

#1.1 获取key值 使用 字典名.get(key) 方法
print(my_dict.get("like"))
print(my_dict.get("age"))
print(my_dict.get("salary")) #获取一个没有的key值 None

# 1.2 也可以通过字典名["key"]值方式,但是注意如果key值不存在, 则抛出异常.
print(my_dict["like"])
print(my_dict["salary"]) # KeyError: 'salary'

2.3.2 字典添加和修改

既然能通过索引获取,那么就能添加数据

如果键存在,就是修改, 如果不存在, 就是添加.
整数,浮点,布尔 可以直接写, 不用加双引号.

#1.3 字典的添加
#1.3.1 key值存在 就是修改 ,key值不存在,就是添加.

my_dict1={"name":"孙悟空","age":500,"address":"花果山","like":["取经","打妖精","收拾二师兄"]}
#如果存在brother 就是修改,如果不存在就是添加
my_dict1["brother"] = ["猪八戒","沙悟净"] #可以添加列表
my_dict1[10] =100 #整数 小数 布尔 ,可以直接写.  key值不需要加双引号.
print(my_dict1)

#如果存在就是修改
my_dict1["name"] ="六耳猕猴"
print(my_dict1)

2.3.3 字典删除

键值对,所有的操作都是通过key去操作, 那么删除也是 通过键删除键值对…

第一种,使用的方法 pop(key)
第二种,使用 del 字典名[key] 或者 del(字典名[key])
第三种使用 clear() 可以 清空所有元素.


'''
1. 字典的三种删除方式
    1.1 pop(key)
    1.2 del 字典名[key] 或者  del(字典名[key])
    1.3 全部清空   字典名.clear()

'''
my_dict={"name":"孙悟空","age":500,"address":"花果山","like":["取经","打妖精","收拾二师兄"]}

#第一种 pop()删除
my_dict.pop("like")
#my_dict.pop("likes") #没有key 就会抛出异常 KeyError: 'likes'
print(my_dict)

#第二种 del 字典名[key]删除 或者 写成  del(字典名[key])
del(my_dict["age"])
print(my_dict)

#第三种清空 clear()
my_dict.clear()
print(my_dict)

2.3.4 字典遍历

遍历键 , 遍历值

获取键视图 字典名.keys()
获取值视图字典名.values()
获取字典元素视图 字典名.items()

'''
1. 遍历的进化
1.1 字典 就一种思路, 通过key获取value
    遍历就需要使用循环
'''
# 1.遍历
my_dict = {"name": [1, 2, 3], "age": 500, "adress": "花果山"}
for key in my_dict:
    print(key)

print("-"*20) #华丽分割线

#1.1 获取key值
keys = my_dict.keys()
print(keys)#dict_keys(['name', 'age', 'adress'])
print(type(keys))#<class 'dict_keys'>

print("-"*20)#华丽分割线

#1.2  相当于将 1和1.1 结合
for key in my_dict.keys():
    print(key)

print("-"*20)#华丽分割线

#1.3  通过 1.2 退到出 .
# 能遍历key就肯定能遍历value
for value in my_dict.values():
    print(value)

如何遍历字典 获取键和值, 2 种方式

第一种通过 遍历key值, 获取value
第二种 遍历键值对 ,然后再获取key和value

'''
1.字典如何遍历
    1.1 通过key 在找到value
                理解为: 通过key找到对应的value
    1.2 通过遍历键值对, 获取 key 和value
                理解为: 先找到地址, 然后找key和value
'''

# 创建列表
dict_1 = {"name": "孙悟空", "age": 500, "address": "花果山",
                "like": ["取经", "打妖精", "收拾二师兄"]}

# 1.1  第一种方式  通过key 找到value
for key in dict_1.keys():
    # 通过拼接 format字符串输出格式
    # print(f'{key} = {dict_1[key]}')
    print(f'{key} = {dict_1.get(key)}')

print("-"*40)

# 第二种方式 ,通过遍历键值对 ,然后再获取key 和value

items = dict_1.items()
#返回的是元组的形式
print(items)#dict_items([('name', '孙悟空'), ('age', 500), ('address', '花果山'), ('like', ['取经', '打妖精', '收拾二师兄'])])

print("-"*30)
#第二种方式升级
for a,b in dict_1.items():
    print(f"{a} = {b}")

2.4 enumerate 函数

enumerate() 是 Python 内置函数之一，在遍历一个可迭代对象时，同时返回迭代对象的 索引和对应的元素。

enumerate(iterable, start=0)

iterable： 必需，表示可迭代对象。
start： 可选，表示计数开始的值，默认为0。

'''
1.使用enumerate枚举使用
    返回列表索引对应的值

'''
list_1 = ["张飞", ",刘备", "关羽","赵云","黄钟"]

for i  in  enumerate(list_1):
    print(i,type(i)) #返回一个元组

print("-"*30) #华丽分割线

#计数开始值  将2计为开始索引
for i  in  enumerate(list_1,start=2):
    print(i,type(i)) #返回一个元组

(0, '张飞') <class 'tuple'>
(1, ',刘备') <class 'tuple'>
(2, '关羽') <class 'tuple'>
(3, '赵云') <class 'tuple'>
(4, '黄钟') <class 'tuple'>
------------------------------
(2, '张飞') <class 'tuple'>
(3, ',刘备') <class 'tuple'>
(4, '关羽') <class 'tuple'>
(5, '赵云') <class 'tuple'>
(6, '黄钟') <class 'tuple'>

2.5 扩展练习

2.5.1 判断是否能全部购买

一个列表,保存商品以及单价, 假如客户手里有500元是否能全部买下

如果能请输出 “可以”,如果不能请输出 “不可以”.

'''
1. 使用到的知识点
    遍历列表
    通过key值获取value
        字典[key] 或者 字典.get()
    分支结构
    累计求和
'''

product = [
    {"name": "鞋子", "price": 300},
    {"name": "衣服", "price": 80},
    {"name": "裤子", "price": 20},
    {"name": "帽子", "price": 100},
]
#1.需要获取所有的商品的价格并进行判断,
# 1.1 注意这是一个列表,嵌套元组
money = 500 #一共有500元
cash =0
for i in product:
    #print(i)#相当于获取内部元素
    #通过key值寻找value并求和
    cash += i.get("price")

#商品的总价格
print("商品总价格 %d元 "%cash)
#进行判断是否满足
if cash>money:
    print("不能购买")
else:
    print("可以购买")

2.5.2 学生信息的排序

使用字典保存学生的信息
- 学号
- 姓名

将学生的信息按照学号由小到大排列, 排序后进行输出

提示: sort() 默认升序参数 reverse=True 是降序.

'''
1. 使用**字典** 保存学生的信息
	- **学号**
	- **姓名**
2. 将学生的信息按照**学号由大到小排列**, 排序后进行输出
'''

# 1. 创建字典保存学号, 姓名
dict = {"学号": [101, 102, 103, 104], "姓名": ["刘备", "关羽", "张飞", "赵云"]}

#通过遍历, 字典获取值 dict.values() .
for i in dict.values():
    #通过列表内置方法,sort(reverse = True)
    i.sort(reverse=True) # 列表排序
    #print(i)


# 遍历输出结果
for key,value in dict.items():
    print(key,value)

2.5.3 WordCount 输出字典

编写一个程序, 用于统计字符串每个字母出现次数(字母忽略大小写) ,统计出的结果,

最后按照 字典的格式输出
{"a":2,"b":3}
提示: 是否需要忽略 大小写 可以先统一转换为小写或者大写.

# 1.1 创建字符串
s = "HellO,world" 
#1.2 创建空字典
dict_1 = {}
#首先遍历 字符串中所有数.
#for i in s: # 如果不忽略就不需要转换.
for i in s.lower():#忽略大小写统一转小写
    #在进行判断 列表中的查找 in 如果存在就累加
    if i in dict_1:
        dict_1[i] += 1
    else:
        dict_1[i] = 1
print(dict_1)

{'h': 1, 'e': 1, 'l': 3, 'o': 2, ',': 1, 'w': 1, 'r': 1, 'd': 1}

2.5.4 统计字符串数字出现次数

计算一个字符串中含有数字的数量,
- s="a1b2c3d4"
- 方法使用 字符串名. isdigit()

将数据存储到字典中. 最后结果输出为 {“num”:几个数字}

'''
1. 计算一个字符串中含有数字的数量,
    s="a1b2c3d4"
    方法使用 is
2. 将数据存储到字典中.
    {"num":几个数字}
'''

# 1.创建一个字符串使用
s = "a1b2c3d4"
# 1.1 创建一个字典
dict = {"num": 0}  # 创建一个空字典
# 遍历字符串
for i in s:
    # 查看输出
    # print(i,end=" ")
    # 判断是否存在
    if i.isdigit():
        # 如果有从1开始,每次累加
        dict["num"] += 1
        # print(i)

print(dict.get("num"))