- 学习：知识的初次邂逅
- 复习：知识的温故知新
- 练习：知识的实践应用
目录
4.2,通过get方法获取值.如果键不存在,返回None,也可以返回指定值
1.3,remove()删除指定元素；clear()清空整个集合
2,如何创建列表[10,20,30,40,50,60,70,80,90] ?
4,如何删除 a = [10,20,30,40,50] 最后一个元素50?
5,如何判断 a = [10,20,30,40,50,20,30,20,30] 是否包含元素 20?
6,如下代码[10,20,30,40][1:3] ，执行结果的是
7,如下代码[10,20,30,40,50,60,70][::-1]，执行结果的是
8,画出代码 a = [100,200,300] 的内存存储示意图
9,使用 range 生成序列： [30,40,50,60,70,80] {30,40,50,60,70,80}
10,推导式生成列表： a = [x*2 for x in range(100) if x%9==0] ，手写出结果
12,创建一个字典对象，包含如下信息： 支出金额：300.15，支出日期：2018.10.18，支出人：小七
16,请问：修改和添加字典元素时，都可以采用【变量名[键] = 值】，这句话对吗？
19,字典的内部元素形式是键值对，且键是唯一的，这句话正确吗
20,元组的内容可以查询，但不能添加、不能删除、也不能修改，这句话正确吗？
21,如果要判断列表中是否存在某元素值，可以使用什么 关键字?
22,如果要修改列表的元素，可以通过索引值来操作，这句话正确吗？
24,如果要在for循环中获取列表的索引值，可以引入一个计数器，这句话正确吗？
27,切片操作适用于所有序列的操作，比如对字符串、列表、元组等，这句话正确吗？
28,实操，6班的学生有：张三、李四、王五、钱六，从键盘上录入一个学生姓名，检验是否是6班的学生。若是6班的学生，就输出：6班学生，欢迎你；否则，输出：非6班学生，非诚勿扰。
29,定义一个列表，用于存放手机品牌信息，例如小米、华为、OPPO、苹果、荣耀等，要求：
30,请使用字典类型来表示一台电脑的信息，例如有电脑品牌、价格、电脑屏幕尺寸、系统版本等，并单独获取品牌值、价格值。并给电脑信息字典做如下操作：
一,本章知识简介
主线A:字典
主线B:集合
回顾前面知识
pyhthon学习路线:
- 前置:
- pyhton的概述
- pyhton环境安装;
- 基础:
- 注释
- 标识符
- 关键字
- 变量
- 数据类型
- 输入
- 输出
- 运算符
- 控制语句
- 选择分支
- 循环结构
- 序列(容器)
- 字符串
- 列表
- 元组
一,邂逅Python,搭建python环境,基础语法介绍:python注释,关键字,标识符,变量,数据类型,print()输出,input()输入,数据类型转换等-CSDN博客
二,PyCharm软件的使用,Python运算符,变量的介绍与运用,以及本章综合测试-CSDN博客
三,python控制语句 (条件分支与循环结构)-CSDN博客
四,python之字符串. [字符串的特点,操作,常用方法,遍历,综合测试]-CSDN博客
五,Python之列表与元组 [列表和元组的特点,操作,常用方法,遍历]-CSDN博客
二,字典
1,什么是字典?
先来看看现实生活中的字典。我们知道，可以应用字典来查找汉字。
接着，来看看Python中的字典。比如，定义一个本书：
{"name":"新华字典","page":568,"price":46.5}仔细观察，会发现Python字典需要使用{ }引起来，且元素形式为键值对。
键值对，可以理解为一一对应的关系，即可以通过键找到值。
字典是 “ 键值对 ” 的无序可变序列，字典中的每个元素都是一个 “ 键值对” ，包含： “ 键对象 ” 和 “ 值对象 ” 。可以通过 “ 键对象 ” 实现快速获取、删除、更新对应的“ 值对象 ” 。
列表中我们通过 “ 下标数字 ” 找到对应的对象。字典中通过 “ 键对象 ” 找到对应的“ 值对象 ” 。
2,字典的特点
1 “键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。2 但是：列表、字典、集合这些可变对象，不能作为“键”。3 并且“键”不可重复。4 “值”可以是任意的数据，并且可重复5 键、值组合在一起，形成了字典的元素；
6 字典元素的键是唯一的；
7 可以使用字典存储大量数据。
3,字典的创建
语法:
变量名 = {键1: 值1, 键2: 值2, ...}3.1,我们可以通过{}、dict()来创建字典对象
dict1 = {}
print(type(dict1)) #<class 'dict'>
dict2= dict()
print(type(dict2)) #<class 'dict'>3.2,通过zip()创建字典对象
key1=[1,2,3]
value1=['一', '二', '三']
dict3=dict(zip(key1,value1))
print(type(dict3)) #<class 'dict'>3.3,通过fromkeys创建值为空的字典
dict4=dict.fromkeys(['a','b','c'],1)
print(dict4) #{'a': 1, 'b': 1, 'c': 1}
print(type(dict4)) #<class 'dict'>完成：
（1）定义一个字典变量，存放一个学生的信息：姓名、性别、住址、年龄等；
（2）输出并查看字典变量值与类型；
（3）思考1：若给字典变量存放两个性别信息，会怎样？
（4）思考2：若给字典变量再存放一个薪酬，与年龄值相同，会怎样？
# 1.定义字典变量
student = {"name":"欧阳芝","sex":"女","address":"广东广州","age":16}
# 2.查看类型和变量值
# print(type(student)) # <class 'dict'>
# print(student)
# 3.存放两个性别? sex 键唯一?
# student = {"name":"欧阳芝","sex":"女","address":"广东广州","age":16,"sex":"Female"}
# print(student) # 键是唯一的,如果有多个相同的键, 最后的键会把前面的键所对应的值都给覆盖了
# 4.value多个
# student = {"name":"欧阳芝","sex":"女","address":"广东广州","age":16,"salary":16}
# print(student) # 值可以重复=总结：==
（1）字典与列表类似，都属于可变数据类型，即当添加元素后，长度也跟着变化；
（2）注意：字典的内部元素形式是键值对，且键是唯一的，这句话正确吗？==A、正确==；
4,字典元素的访问
为了测试各种访问方法，我们这里设定一个字典对象：
4.1,通过 [键] 获得“值”。若键不存在，则抛出异常。
a={'乔峰':80,'段誉':90,'虚竹':85}
b=a['乔峰']
print(b) # 80
c=a[80]
print(c) #报错 键不存在 KeyError: 804.2,通过get方法获取值.如果键不存在,返回None,也可以返回指定值
通过 get() 方法获得 “ 值 ” 。 ❤️ 推荐使用。优点是：指定键不存在， 返回None ；也可以设定指定键不存在时默认返回的对象。推荐 使用get() 获取 “ 值对象 ”
a={'乔峰':80,'段誉':90,'虚竹':85}
# b=a['乔峰']
# print(b) # 80
# c=a[80]
# print(c) #报错 键不存在 KeyError: 80
print(a.get('虚竹'))
print(a.get('虚竹1',90)) #如果键不存在 则返回第二个参数
4.3,列出所有的键值对
a={'乔峰':80,'段誉':90,'虚竹':85}
print(a.keys()) # dict_keys(['乔峰', '段誉', '虚竹'])
print(a.values()) # dict_values([80, 90, 85])
print(a.items()) # dict_items([('乔峰', 80), ('段誉', 90), ('虚竹', 85)])
4.4,len() 键值对的个数
a={'乔峰':80,'段誉':90,'虚竹':85}
print(len(a)) # 34.5,检测一个“键”是否在字典中
a={'乔峰':80,'段誉':90,'虚竹':85}
print(a.keys()) # dict_keys(['乔峰', '段誉', '虚竹'])
print(a.values()) # dict_values([80, 90, 85])
print(a.items()) # dict_items([('乔峰', 80), ('段誉', 90), ('虚竹', 85)])
a={'乔峰':80,'段誉':90,'虚竹':85}
print(len(a)) # 3
print('虚竹' in a) # True5,字典元素添加、修改、删除
5.1,给字典新增“键值对”
a={'乔峰':80,'段誉':90,'虚竹':85}
a['王语嫣']=85 # 添加 如果键不存在 则添加
print(a) #{'乔峰': 80, '段誉': 90, '虚竹': 85, '王语嫣': 85}
a['乔峰']= 100 #如果键存在 则修改
print(a) #{'乔峰': 100, '段誉': 90, '虚竹': 85, '王语嫣': 85}5.2,字典的update方法
a={'乔峰':80,'段誉':90,'虚竹':85}
b={'乔峰': 120, '段誉': 90, '虚竹': 85, '王语嫣': 85}
a.update(b) # 更新
print(a) #{'乔峰': 120, '段誉': 90, '虚竹': 85, '王语嫣': 85}5.3,字典的删除
字典中元素的删除，可以使用 del() 方法；或者 clear() 删除所有键值对； pop() 删除指定键值对，并返回对应的 “ 值对象 ”
a={'乔峰': 120, '段誉': 90, '虚竹': 85, '王语嫣': 85}
del(a['乔峰'])
print(a) #{'段誉': 90, '虚竹': 85, '王语嫣': 85}
print(a.pop('王语嫣')) #85 pop删除指定的键值对 并返回对应的值对象
clear(a)
print(a) #{} 直接清空列表5.4,随机删除和返回该键值对
随机删除和返回该键值对。字典是 “ 无序可变序列 ” ， 因此没有第一个元素、最后一个元素的概念； popitem 弹出随机的项，因为字典并没有" 最后的元素 " 或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）
从 Python 3.7 开始，字典会记住元素的插入顺序，所以在这个版本及之后，
popitem()通常会删除并返回字典中的最后一个插入的键值对。但在 Python 3.7 之前，popitem()的删除顺序是不确定的，它可能随机删除并返回任意一个键值对。对于你给出的例子，在 Python 3.7 及以后版本中，看起来像是固定删除最后一个，但这只是因为你的代码中字典的创建和操作顺序导致的，并不是普遍的确定性规则。
所以，不能认为
popitem()是固定删除最后一个元素
a={'乔峰': 120, '段誉': 90, '虚竹': 85, '王语嫣': 85,'ss':20}
print(a.popitem()) #('ss', 20)
print(a.popitem()) #('王语嫣', 85)
print(a.popitem()) #('虚竹', 85)
print(a)6,字典的序列解包
序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。
x,y,z=(20,30,1)
(a,b,c)=(9,8,10)
[m,n,p]=[10,20,30]
序列解包用于字典时，默认是对 “ 键 ” 进行操作； 如果需要对键值对操作，则需要使用items() ；如果需要对 “ 值 ” 进行操作，则需要使用values()；
a={'name': '张三', 'age': 20,'job': '程序员'}
name,age,job=a.values()
print(name,age,job) #张三 20 程序员
name,age,job=a.items()
print(name,age,job) #('name', '张三') ('age', 20) ('job', '程序员')
name,age,job=a
print(name,age,job) #name age job
z,x,c=a
print(z,x,c) #name age job
7,表格数据使用字典和列表存储和访问
r1 = {"name":"一","age":18,"salary":30000,"city":"北京"}
r2 = {"name":"二","age":19,"salary":20000,"city":"上海"}
r3 = {"name":"五","age":20,"salary":10000,"city":"深圳"}
tb = [r1,r2,r3]
#获得第二行的人的薪资
print(tb[1].get("salary"))
#打印表中所有的的薪资
for i in range(len(tb)): # i -->0,1,2
print(tb[i].get("salary"))
#打印表的所有数据
for i in range(len(tb)):
print(tb[i].get("name"),tb[i].get("age"),tb[i].get("salary"),tb[i].get("city"))
8,字典的核心原理
字典对象的核心是散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的每个单元叫做 bucket 。每个 bucket 有两部分：一个是键对象的引用，一个是值对象的引用。由于，所有 bucket 结构和大小一致，我们可以通过偏移量来读取指定 bucket 。
一、计算键的哈希值
- 当你要将一个键值对放入字典时，Python 首先会计算键的哈希值。哈希值是一个整数，它是根据键的内容通过特定的哈希算法计算得出的。例如，如果键是一个字符串，Python 会使用其内部的哈希算法来计算该字符串的哈希值。
- 这个哈希值在后续的操作中用于确定键值对在字典中的存储位置。
二、确定存储位置
- 有了哈希值后，Python 会根据字典的大小和哈希值来确定键值对在内存中的存储位置。具体的计算方式通常是将哈希值对字典的大小取模，得到一个索引值。这个索引值指向字典内部的一个存储位置。
- 如果该位置为空，那么可以直接将键值对存储在这个位置。
三、处理冲突
- 但是，可能会出现不同的键具有相同的哈希值，或者多个键在取模后得到相同的索引值的情况，这被称为冲突。
- Python 通常使用开放寻址法或链表法来处理冲突。
- 开放寻址法：如果发生冲突，Python 会尝试在字典内部的其他位置寻找空闲位置来存储键值对。它会按照一定的顺序（例如线性探测、二次探测等）逐个检查其他位置，直到找到一个空闲位置。
- 链表法：在每个存储位置上，可以是一个链表或其他数据结构，当发生冲突时，新的键值对会被添加到链表中。
四、存储键值对
- 一旦找到合适的存储位置，Python 就会将键值对存储在该位置。
- 同时，字典会记录一些额外的信息，如字典的大小、已使用的存储位置数量等，以便在后续的操作中进行管理和调整。
字典在内存中开销巨大，典型的空间换时间。键查询速度很快往字典里面添加新键值对可能导致扩容，导致散列表中键的 序变化。因此，不要在遍历字典的同时进行字典的修改键必须可散列 --- 数字、字符串、元组，都是可散列的自定义对象需要支持下面三点:1 支持 hash() 函数2 支持通过 __eq__() 方法检测相等性3 若 a==b 为真，则 hash(a)==hash(b) 也为真
三,集合
集合是无序可变，元素不能重复。实际上，集合底层是字典实现， 集合的所有元素都是字典中的“ 键对象 ” ，因此是不能重复的且唯一的。
1,集合创建和删除
1.1,使用{}创建集合对象，并使用add()方法添加元素
a = {3,5,7}
a.add(9) #{9, 3, 5, 7}1.2 使用set()
将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个
a = ['a','b','c','b']
b = set(a) #{'b', 'a', 'c'}1.3,remove()删除指定元素；clear()清空整个集合
a = {10,20,30,40,50}
a.remove(20) #{10, 50, 40,30}2,集合相关操作
>>> a = {1,3,'fm'}
>>> b = {'he','it','fm'}
>>> a|b #并集
{1, 3, 'fm', 'he', 'it'}
>>> a&b #交集
{'fm'}
>>> a-b #差集
{1, 3}
>>> a.union(b) #并集
{1, 3, 'fm', 'he', 'it'}
>>> a.intersection(b) #交集
{'fm'}
>>> a.difference(b) #差集
{1, 3}四,序列综合测试
1,python中，关于序列(容器)的简述?
内存中，序列就是一块用来存放多个值的连续的内存空间
字符串和列表都是序列类型
列表：用于存储任意数目、任意类型的数据集合
2,如何创建列表[10,20,30,40,50,60,70,80,90] ?
a = [10,20,30,40,50,60,70,80,90]
或者
b = [x*10 for x in range(1,10)]
或者
c = [x*10 for x in range(10) if x>0]
3,如何在在列表[10,20,30]后添加元素40?
[10,20,30]+[40]或者[10,20,30].append(40)或者[10,20,30].insert(2,40)
4,如何删除 a = [10,20,30,40,50] 最后一个元素50?
a.pop()或a.remove(50)或a.pop(4)
5,如何判断 a = [10,20,30,40,50,20,30,20,30] 是否包含元素 20?
20 in a或0<=a.index(20)<=len(a) - 1或a.count(20)==0
6,如下代码[10,20,30,40][1:3] ，执行结果的是
[20, 30]
7,如下代码[10,20,30,40,50,60,70][::-1]，执行结果的是
[70, 60, 50, 40, 30, 20, 10]
8,画出代码 a = [100,200,300] 的内存存储示意图
9,使用 range 生成序列： [30,40,50,60,70,80] {30,40,50,60,70,80}
a=[i*10 for i in range(3,9)]
b=(i*10 for i in range(3,9))
print(a) #[30, 40, 50, 60, 70, 80]
print(set(b)) #{70, 40, 80, 50, 60, 30}10,推导式生成列表： a = [x*2 for x in range(100) if x%9==0] ，手写出结果
[0*2,9*2,18*2,27*2,36*2,45*2,54*2,63*2,72*2,81*2,90*2,99*2]
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
11,元组和列表有哪些共同点？有哪些不同点？
相同的:
都是序列类型
都支持切片操作
都可以进行迭代
不同的:
列表是可变类型,元组是不可变类型
列表可以增删改,元组不支持增删改
语法不同 列表是中括号,元组是小括号
12,创建一个字典对象，包含如下信息： 支出金额：300.15，支出日期：2018.10.18，支出人：小七
a={'支出金额':300.15,'支出日期':'2018-10-18','支出人':'小七'}
13,集合和字典有什么关系？
底层数据结构相同,集合和字典的底层都实现了使用哈希表这种数据结构,这使他们在查找元素的时候都非常高效;
唯一性:集合保证其中的元素都是唯一的,字典中的键也是唯一的;从某种意义上来说,他们都可以用来存储不重复的数据
都是使用{}
14,生成验证码案例
1）请生成一个由数字、字母组成的6位数的验证码；
2）文本内容：【XX】验证码2943AD，用于手机验证码登录，5分钟内有效。验证码提供给他人可能导致账号被盗，请勿泄露，谨防被骗。
import random
# 1.先要有批量文本内容 数字、字母
strs = "0123456789ABCDECGHIJKLMNOPQRSTUVWXYZabcdecghijklmnopqrstuvwxyz"
code = ""
# 2.for循环
for temp in range(6):
# 3.动态获取字母或数字 + 拼接
index = random.randint(0,len(strs)-1)
text = strs[index]
# print(text)
# 4.生成了验证码
code += text
# print(code)
message = f"【XX】验证码{code}，用于手机验证码登录，5分钟内有效。验证码提供给他人可能导致账号被盗，请勿泄露，谨防被骗。"
print(message)15,请问：字符串只能与字符串内容拼接，这句话正确吗？
正确
16,请问：修改和添加字典元素时，都可以采用【变量名[键] = 值】，这句话对吗？
正确
17,当直接给变量内容定义为{ }时，表示是?
字典 .集合需要用set()定义
18,当通过键访问字典的值出错时，可以考虑使用?
get(键)
19,字典的内部元素形式是键值对，且键是唯一的，这句话正确吗
正确
20,元组的内容可以查询，但不能添加、不能删除、也不能修改，这句话正确吗？
正确
21,如果要判断列表中是否存在某元素值，可以使用什么 关键字?
in
22,如果要修改列表的元素，可以通过索引值来操作，这句话正确吗？
正确
23,当要给列表添加元素时，首先应该想到方法?
append()
24,如果要在for循环中获取列表的索引值，可以引入一个计数器，这句话正确吗？
正确
25,如果要定义一个列表变量，可以使用什么符号?
[]
26,当要查找字符串的某元素时，可以使用?
find() 或者 index()
27,切片操作适用于所有序列的操作，比如对字符串、列表、元组等，这句话正确吗？
正确
28,实操，6班的学生有：张三、李四、王五、钱六，从键盘上录入一个学生姓名，检验是否是6班的学生。若是6班的学生，就输出：6班学生，欢迎你；否则，输出：非6班学生，非诚勿扰。
# 学生信息
student_lists = ["张三","李四","王五","钱六"]
# input()
name = input("请输入学生姓名:")
# 判断 in
if name in student_lists:
print(f"6班学生【{name}】,欢迎你.")
else:
print("非6班学生,非诚勿扰!")29,定义一个列表，用于存放手机品牌信息，例如小米、华为、OPPO、苹果、荣耀等，要求：
（1）访问元素华为，获取列表总长度；
（2）使用for循环遍历手机品牌列表，并输出所有元素；
（3）使用while循环遍历手机品牌列表，并输出所有元素。
# 定义列表
brand_list = ["小米","华为","OPPO","苹果","荣耀"]
# 查询数据
print(f"访问元素:{brand_list[1]}")
print(f"列表总长度:{len(brand_list)}")
print("-----------------")
# for遍历元素
for brand in brand_list:
print(f"for遍历的元素:{brand}")
print("-----------------")
# while遍历
index = 0
while index < len(brand_list):
print(f"while获取元素:{brand_list[index]}")
index += 130,请使用字典类型来表示一台电脑的信息，例如有电脑品牌、价格、电脑屏幕尺寸、系统版本等，并单独获取品牌值、价格值。并给电脑信息字典做如下操作：
（1）查看字典的屏幕尺寸值；
（2）修改价格值为8999；
（3）给字典添加电脑所属类型，如游戏本、或商务本、或轻薄本等；
（4）删除电脑的系统版本元素。
#电脑信息
computers = {
"brand":"华硕",
"price":12899,
"screensize":15.6,
"system":"Windows 10",
}
print(f"电脑信息:{computers}")
print("-"*30)
# 查看
print(f"屏幕尺寸:{computers['screensize']}")
print("-"*30)
# 修改价格
computers["price"] = 8999
print(f"修改价格后,电脑信息:{computers}")
print("-"*30)
# 添加元素
computers["kind"] = "商务本"
print(f"添加元素后,电脑信息:{computers}")
print("-"*30)
# 删除元素
del computers["system"]
print(f"删除系统元素后,电脑信息:{computers}")
- 学习：知识的初次邂逅
- 复习：知识的温故知新
- 练习：知识的实践应用
1352
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
