python容器,字符串，列表，元组，字典介绍和常规操作

在Python中，常见容器有：

（1）字符串：str

（2）列表：list

（3）元组：tuple

（4）字典：dict

# 容器
# 列表[]
# list1=[1,2,3,4,5,6,7,8,9] 可以增删改查
# 元组()
# tuple1=(1,2,3,4,5,6,7,8,9)  只能查，不能改
# 字典{}
# dict1={1:1,2:2,3:3,4:4,5:5,6:6,7:7}
# 集合{}
# set1={1,2,3,4,5,6,7,8,9}  不能放重复的，会去掉重复的数据

（1）字符串：使用双引号引起来的内容；
（2）列表：使用[ ]表示的内容；
（3）元组：使用( )表示的内容；
（4）字典：使用{ }表示，内部元素是键值对。

# 1.字符串变量
a = "itheima"
print(a)  # itheima
print(type(a))  # <class 'str'>

# 2.列表
b = ["it","heima"]
print(b)  # ['it', 'heima']
print(type(b))  # <class 'list'>

# 3.元组
c = ("it","heima",)
print(c)  # ('it', 'heima')
print(type(c))  # <class 'tuple'>

# 4.字典
d = {"name":"itheima","age":17}
print(d)
print(type(d))  # <class 'dict'>

（1）常用的Python容器有：（==字符串==）、列表、元组、字典；

（2）注意：Python容器有很多操作方法，但都是使用【变量名.函数(x)】形式完成调用。

例如，一起来完成：

（1）使用双引号表示一个公司名称；

（2）使用单引号表示公司名称；

（3）分别输出变量的类型结果；

（4）思考1：使用字符串与一个数值拼接，会怎样？

（5）思考2：一段使用引号表示的字符串中，还有引号，该怎么处理？

# 1.双引号
strs1 = "最佳程序员"
print(strs1)
print(type(strs1))  # <class 'str'>

# 2.单引号 -扩展
# strs2 = 'itheima'
# print(strs2)
# print(type(strs2))  # <class 'str'>

# 1.字符串拼接
a. + 字符串连接符
b. 字符串只能和字符串数据拼接
s1 = "hello"+"world"
print(s1)

s2 = "hello"+666  # 报错
s2 = "hello"+"666"
s2 = "hello"+str(666)  # 指定数据类型名(变量)
print(s2)   # A.hello666   B、其他的

# 2.引号? -扩展
东升说: "我是一班最帅的男人."
a = '东升说: "我是一班最帅的男人."'
a = "东升说: \"我是一班最帅的男人.\""
a = "东升说: '我是一班最帅的男人.'"
a = """东升说: "我是一班最最帅的男人."
"""   # 参考
print(a)

索引

索引有时也称为下标、编号

获取字符串元素语法：

变量名[索引值]

说明：

索引值是从0开始计算的。

接着，来看一下字符串长度的表示方式。

函数名	含义
len(s)	返回变量s的长度或元素个数。

说明：

（1）长度值是从1开始计算的；

（2）索引与长度的关系可表示为：【最大索引值 = 长度 - 1】。

例如，一起来完成：

（1）定义一个存有HelloWorld的字符串变量；

（2）获取变量中的H和W；

（3）获取变量的总长度；

（4）思考：如何获取变量的最后一个元素d。

# 1.定义变量
strs = "HelloWorldABCDE"
# 2.获取元素
 print(strs[0])
 print(strs[5])

# 3.长度
 print(len(strs))

# 4.访问最后一个元素
# 正常
 print(strs[9])
print(strs[len(strs)-1])  # 灵活 = 更好维护

# 逆向
print(strs[-1])

（1）当使用超出最大索引的值去访问字符串的元素，会报错；

（2）注意：索引与长度的关系是：【最大索引值 = （长度 - 1）】

切片

切片指的是：截取字符串中的一部分内容。

切片语法：

[起始:结束]

另外的，当需要每隔几个字符来截取内容时，可以加入步长，语法：

[起始:结束:步长]

说明：

（1）切片语法选取的范围是左闭右开型，即[起始, 结束)；

（2）注意：截取内容时，包含起始位，但不包含结束位。

例如，一起来完成：

（1）定义一个字符串变量，内容为：HelloITHEIMA；

（2）截取索引值1到5之间的内容；

（3）截取索引值2到结尾的内容；

（4）截取索引值2到倒数第2个的内容；

（5）截取起始处到索引值为3的内容；

（6）截取索引1到8且每隔2个字母截取一下内容；

（7）截取索引2到10且每隔3个截取一下内容。

# 1.定义变量
strs = "HelloITHEIMA"
# 2.1-5
 print(strs[1:5])
# 3.2-
 print(strs[2:12])
# 4.2 - 倒数第2
 print(strs[2:10])
# 5. -3
 print(strs[0:3])
# 6 1 8 2
 print(strs[1:8:2])
# 7. 2 10 3
print(strs[2:10:3])


strs = "HelloITHEIMA"
# 3.2-
 print(strs[2:12])
 print(strs[2:100])
 print(strs[2:])

# 4.2 - 倒数第2
 print(strs[2:10])
 print(strs[2:-2])

# 5. -3
 print(strs[0:3])
 print(strs[:3])

# 从后往前数数,可以使用负数表示;  当从开始处截取时,可以省略起始位; 当截取到结尾处时,可以省略结束位.

# 升级: 记住   若要对字符串反转，该怎么做?
print(strs[::-1])

切片最简单的语法是：[起始:结束]，且默认步长为1

字符串的遍历

for 临时变量 in 序列:
    满足条件时，执行的代码1
    满足条件时，执行的代码2
    ……
[else:
    当for循环正常执行结束后，执行代码]

例如，一起来完成：

（1）定义一个字符串变量，内容为：ABCDEF；

（2）使用for循环来遍历元素；

（3）执行程序，观察效果。

# 1.定义字符串
strs = "ABCDEF"
# 2.使用for遍历
for temp in strs:  # 疑问: 元素对应索引值?
    print(temp)

# 3.扩展 -else
 for temp in strs:
     print(temp)
 else:
     print("所有字符串元素已遍历结束!!")

==总结：==

（1）如果想快速获取字符串的所有元素，可以直接使用for循环；

（2）注意：使用for语句遍历字符串时，无法直接显示索引值。

使用while遍历字符串

初始化变量语句
while 循环条件:
    循环体语句
    改变循环条件的语句  # 先写

接着，再来看看获取长度。

函数名	含义
len(s)	返回变量s的长度或元素个数。

获取元素值的语法：

变量名[索引值]

例如，一起来完成：

（1）定义一个字符串变量，内容为：ABCDEF；

（2）使用while循环来遍历元素；

（3）执行程序，观察效果。

# 1.定义字符串变量
strs = "ABCDEF"
# 2.写循环
i = 0
# while i < len(strs):
while i <= (len(strs)-1):
    # 3.访问元素
    print(strs[i])
    i += 1

查找元素

字符串的查找方法指的是查找元素（或子串）在字符串内容的索引位置。

查找方法有：

函数名	含义
find(sub)	检测sub是否包含在字符串中，如果是，则返回sub所在开始的索引，否则返回-1。
index(sub)	与find()类似，只不过当sub在字符串中不存在时，会报错误。
rfind(sub)	从右往左找子串在字符串的某个索引。
count(sub)	计算sub在字符串中出现的总次数。

例如，一起来完成：

（1）定义一个字符串变量，内容为：hello world and itcast and itheima and Python；

（2）分别使用find()和index()函数来查看and所在位置；

（3）思考1：如果查找不存在的内容666，效果如何？

（4）思考2：若要从右往左查找and，该怎么做？若还要获取and出现的总次数呢？

（5）扩展：字符串的操作方法那么多，该怎么记忆呢？

# 1.定义字符串
name = "hello world and itcast and itheima and Python"

# 2.and -find()  index()
 print(name.find("and"))
 print(name.index("and"))

# 3.对比find  index
 print(name.find("666"))  # 稳定
 print(name.index("666"))  # 报错

# 4.从右往左    right
 print(name.rfind("and"))
 print(name.rindex("and"))
# 总次数
 print(name.count("and"))

# 5.如何记忆
# a.大佬发
# b.技巧: 看快捷提示
# name.

（1）当要查找字符串的某元素时，可以使用find()、index()；

（2）注意：实际应用中，优先使用（==find()==）方法查找字符串元素，因为这个方法更稳定。

修改元素

字符串的修改方法，指的是修改字符串中的数据。

函数名	含义
replace(old, new)	用于将字符串中的old内容替换成new内容。
split(sep)	使用指定内容sep来对字符串进行切割。
strip()	用于去掉字符串前后的空白内容。

说明：

修改字符串，就是将字符串原有内容修改为其他结果。

例如，一起来完成：

（1）定义一个字符串变量，内容有： hello itheima big data ；

（2）将变量中的空格替换为666；

（3）使用空格、字符a来分别分割字符串；

（4）去掉字符串的前后空白内容。

# 1.定义字符串
 strs = "hello itheima big data"
# 2.替换
 ret1 = strs.replace(" ","666")
 print(ret1)   #" "  -暂无数据
# 3.分割  -切割
 ret2 = strs.split("a")
 print(ret2)
# 4.去掉空白
strs = "  hello itheima big data    "
# print(strs.strip())
result1 = strs.lstrip()
result2 = result1.rstrip()
print(result2)

（1）当要对字符串文本内容进行替换数据时，可以使用（replace()）方法；

（2）注意：split()常应用与分割字符串数据内容。

列表的定义

列表类型为list，是Python中的一种常见类型。

列表可以存放各种数据类型的数据，且列表的长度会随着添加数据的变化而变化。

列表语法：

变量名 = [元素1,元素2,元素3,...]

说明：

列表的多个元素之间使用,逗号分隔。

例如，一起来完成：

（1）定义一个列表变量1，用于存放几个知名大学名称；

（2）定义一个列表变量2，用于存放某学生的姓名、年龄、存款、是否男生等信息；

（3）思考：要把字符串Python转换为列表list类型的值，该怎么做？

# 1.定义列表变量：相同类型
 lists = ["南京大学","南开大学","南昌大学","东南大学"]  # 数组
 print(type(lists))

# 2.不同类型的数据元素
 data = ["汪致诚",38,0,True]
 print(type(data))   # 列表中可以存放多种不同类型的数据

# 3.思考: list()
strs = "Python"
result = list(strs)
print(result)   # A.[python]  B.[P   y   t  h  o  n]

列表就是一个Python容器，可以用于存放任意类型的数据；

访问列表元素和长度

获取列表的元素和长度的方式与字符串一样。

获取列表元素语法：

变量名[索引值]

说明：索引值是从0开始计算的。

再来看一下列表长度的表示方式。

函数名	含义
len(s)	返回变量s的长度或元素个数。

说明：

（1）长度值是从1开始计算的；

（2）索引与长度的关系可表示为：【最大索引值 = 长度 - 1】。

例如，一起来完成：

（1）获取知名大学名称列表变量的元素总个数；

（2）获取列表变量的第1个和第3个位置对应的元素值；

（3）思考：若直接访问不存在的第100个元素值，会怎样？

lists = ["南京大学","南开大学","南昌大学","东南大学"]
# 获取总个数
 print(len(lists))
# 访问元素
 print(lists[0])
 print(lists[2])

# 问题
print(lists[100])
# 注意: 当直接通过 变量名[索引值] 访问元素时, 记得索引值不允许超过最大索引值。  -报错！

（1）当给列表变量添加新内容后，列表的长度也会变化；

（2）注意：如果要获取列表元素的总个数，可以使用（len(xx)）方法。

使用for遍历列表

先来看看，for循环语法：

for 临时变量 in 序列:
    满足条件时，执行的代码1
    满足条件时，执行的代码2
    ……
[else:
    当for循环正常执行结束后，执行代码]

例如，一起来完成：

（1）定义一个列表变量，用于存放水果信息，内容为：苹果、香蕉、西瓜、菠萝等；

（2）使用for循环来遍历元素；

（3）执行程序，观察效果。

# 1.定义列表变量
datas = ["苹果","香蕉","西瓜","菠萝"]
# 2.遍历
 for temp in datas:
     print(temp)

# 3.查看到索引？    索引值 --> 元素
index = 0  # 引入一个计数器
for temp in datas:
    # print(temp)
    print(f"{index} --> {temp}")
    index += 1

使用while遍历列表

while循环语法：

初始化变量语句
while 循环条件:
    循环体语句
    改变循环条件的语句  # 先写

获取长度

函数名	含义
len(s)	返回变量s的长度或元素个数。

获取元素值的语法：

变量名[索引值]

例如，一起来完成：

（1）定义一个列表变量，用于存放水果信息，内容为：苹果、香蕉、西瓜、菠萝等；

（2）使用while循环来遍历元素；

（3）执行程序，观察效果。

datas = ["苹果","香蕉","西瓜","菠萝"]
# 遍历
i = 0
while i < len(datas):
    print(datas[i])
    i += 1

 i = len(datas)-1
 while i >= 0:
     print(datas[i])
     i -= 1

# 扩展: 切片
 datas = ["苹果","香蕉","西瓜","菠萝"]
 # 获取除最后一个元素外的其他元素内容
 print(datas[0:-1])
 print(datas[:-1])
 # 获取第2-3个元素内容
 print(datas[1:3])

操作列表

添加元素

==目标：==掌握如何给列表添加元素。

给列表添加元素表示的是：在列表变量的基础上，再添加新元素内容。

添加元素的方法：

函数名	含义
append(x)	用于在列表结尾处，添加数据内容x。
insert(index, x)	用于在列表索引index处，新增一个元素x。
extend(x)	用于给列表添加另一个列表的所有元素内容，并形成一个完整列表。

例如，一起来完成：

（1）定义一个列表变量，存放内容：中国、美国、英国、俄罗斯；

（2）在列表结尾处添加元素：德国；

（3）在元素美国后添加元素：日本；

（4）思考：若要在列表变量的结尾处，再新增元素：100、200、300，该怎么做？

# 1.定义列表的变量
country_list = ["中国","美国","英国","俄罗斯"]  # 可变类型
print(f"原始数据:{country_list}")

# 2.添加1个元素到结尾
country_list.append("德国")
print(country_list)

# 3.在某元素后添加
 country_list.insert(1, "日本")
 print(country_list)

# 4.批量添加
 lists = [100,200,300]
 country_list.extend(lists)
 print(country_list)

# 5.扩展?
 lists = [100,200,300]   # append添加一个元素
 country_list.append(lists)
 print(country_list)

（1）当要给列表添加元素时，首先应该想到方法：（append()）；

（2）注意：当给列表添加一个元素后，列表的长度也会增加1。

删除元素

删除列表元素指的是：删除列表变量的某元素内容。

删除元素的方法：

函数名	含义
remove(x)	删除列表元素值x。
del 变量名[索引]	根据索引值，删除列表的某个元素。

例如，一起来完成：

（1）定义一个列表变量，存放内容：中国、美国、英国、俄罗斯；

（2）使用remove()删除元素：英国；

（3）使用del删除元素：美国；

（4）执行程序，观察效果。

# 1.定义列表的变量
country_list = ["中国","美国","英国","俄罗斯"]
print(country_list)
print(f"原始长度:{len(country_list)}")

# remove()删除
country_list.remove("英国")
print(country_list)
print(f"删除后的长度:{len(country_list)}")

# del 删除
 del country_list[1]
 print(country_list)

# 扩展？
 country_list = ["中国","美国","英国","俄罗斯"]
  country_list.pop()
  print(country_list)
 print(country_list[:-1])

（1）当要删除列表中的元素时，可以使用方法：A、remove()；B、delete()；

（2）注意：当删除列表中的一个元素后，列表的长度也会减1。

修改元素

修改列表元素指的是：修改列表变量的某元素内容。

修改元素的方法：

函数名	含义
变量名[索引] = 值	根据索引值，来修改列表中的某个元素值。

例如，一起来完成：

（1）定义一个列表变量，存放内容：中国、美国、英国、俄罗斯；

（2）将中国修改为中华人民共和国；

（3）修改俄罗斯为Russia；

（4）执行程序，观察效果。

# 1.定义列表的变量
country_list = ["中国","美国","英国","俄罗斯"]
# 2.修改中国
 country_list[0] = "中华人民共和国"
 print(country_list)

# 3.修改俄罗斯
# country_list[3] = "Russia"
country_list[-1] = "Russia"
print(country_list)

查找元素

查找列表元素指的是：查找列表变量的某元素内容是否存在？

查找元素的方法：

函数名	含义
len(s)	返回s的长度或元素个数。
in	判断指定数据是否在某个列表序列中。如果在就返回True，否则返回False。

例如，一起来完成：

（1）因["192.168.1.15", "10.1.1.100", "172.35.46.128","172.32.24.99"]等IP地址存在恶意访问黑马程序员官网，被列为访问黑名单；

（2）获取黑名单IP列表的长度；

（3）从键盘上输入一个IP地址，并用于判断是否是黑名单IP地址？

# 1.定义ip列表
ip_lists = ["192.168.1.15", "10.1.1.100", "172.35.46.128","172.32.24.99"]
# 2.获取长度
# print(len(ip_lists))
# 3.判断是否是黑名单
temp_ip = input("请输入IP地址:")
if temp_ip in ip_lists:
    print("Forbidden 403, 你的行为不检点!!!")
else:
    print("欢迎你!!")

（1）如果要判断列表中是否存在某元素值，可以使用（）关键字：A、and；==B、in==；

（2）当查找列表元素时，有两种情况，比如：遍历列表中的所有元素、查找某元素是否存在列表中。

排序操作

排序通常指按从小到大、从大到小的顺序排列。

操作方法有：

函数名	含义
reverse()	将列表进行倒序，即输入顺序与输出顺序相互倒过来。
sort([reverse=False])	对列表进行从小到大排序。当设置reverse=True可改为由大到小排序。

例如，一起来完成：

（1）定义一个列表变量，存放数据：10、200、20、100、30、0；

（2）将列表数据进行倒序输出；

（3）将列表进行从小到大排序；

（4）思考：若要将列表元素进行从大到小排序，该怎么做呢？

# 1.定义变量
data = [10,200,20,100,30,0]
# 2.倒序
# data.reverse()
# print(data)
# 3.从小到大排序
data.sort()
print(data)
# 4.从大到小排序
# ?? 切片   -先从小到大、倒序
# data.sort()
# data.reverse()
# print(data)
# sort(=True)

# data.sort(reverse=True)   # 参数??
# print(data)

（1）当要对一批数值型数据做从小到大排序时，可以使用（sort()）方法

定义元组

定义元组时，需要使用()小括号，用,逗号隔开各个元素，并且，元组的元素可以是不同类型的数据。

虽然元组从表面上看与列表类似，比如：

列表: [1, 2, 3, 4]
元组: (1, 2, 3, 4)

特别注意，元组的元素只能用来查询，且元素不可以修改、不可以删除、也不可以添加。

元组语法：

变量名 = (元素1,元素2,元素3,...)

说明：

（1）元组元素需要使用()小括号引起来；

（2）元组变量中可以存放不同类型的数据。

例如，一起来完成：

（1）定义一个元组变量1，用来存放多个数值；

（2）定义一个元组变量2，并存放不同类型的数据；

（3）查看变量类型，执行程序，观察效果。

# 1.定义变量1
ts1 = (1,2,3,8,90,)
# 2.定义变量2
ts2 = (True,"男","itheima",)
# 查看类型
print(ts1)
print(type(ts1))
print(type(ts2))

# 扩展?
# ts = (24)  # <class 'int'>
ts = (24,)
print(type(ts))

常见操作

我们已知道，元组数据只支持查找，且不支持修改、删除和添加。

操作方法有：

函数名	含义
元组变量名[索引]	按索引值查找数据。
index(x)	查找某个数据，当数据不存在时会报错，语法和列表、字符串的index()方法相同。
len(x)	表示元组中元素的总个数。
in	用于判断元素是否出现在元组中。

例如，一起来完成：

（1）定义一个元组变量，内容有：Python、MySQL、Linux、Hadoop；

（2）试着给元组变量添加、删除、修改元素，观察效果；

（3）查找元组中的元素：Python、Linux；

（4）查看元组中的元素总个数；

（5）判断Hello是否存在元组变量中？

# 1.定义变量
source = ("Python","Linux","MySQL","Hadoop",)
# 2.思考: 添加、删除、修改
# source[0] = "黑马"  # 不支持修改
# source.ap  # 不支持添加
# del source[0]  # 不支持删除
# 3.查找
print(source[0])
print(source[1])
# 4.个数
# print(len(source))
# 5.是否存在
print("Hello" in source)

（1）如果要获取元组的元素总个数，可以使用（len()）方法；

（2）注意：元组的数据内容常用于查找，比如是否存在元组中、元素所在索引值等。

使用for和while遍历元组

先来看看for循环语法：

for 临时变量 in 序列:
    满足条件时，执行的代码1
    满足条件时，执行的代码2
    ……

接着，看一下while循环语法：

初始化变量语句
while 循环条件:
    循环体语句
    改变循环条件的语句  # 先写

例如，一起来完成：

（1）定义一个元组变量，存放几个知名的手机品牌；

（2）分别使用for和while循环遍历元组数据；

（3）执行程序，观察效果。

# 1.定义元组变量
phone_lists = ("三星","苹果","OPPO","传音","Mi",)
# 2.遍历元组数据
# for
 for temp in phone_lists:
     print(temp)


# while
index = len(phone_lists)-1
while index >= 0:
    print(phone_lists[index])
    index -= 1

元组的应用场景

元组的应用场景较多，但都离不开格式【(元素1, 元素2, ...)】。

常见应用场景有：

（1）当要存放一些固定值和内容时，优先考虑使用元组，比如存储黑马程序员、www.itheima.com、法人、注册地址等；
（2）格式化符号后使用%百分号连接的（）内容，本质上就是一个元组；
（3）元组就是：让列表的数据不可以修改、删除、添加，这样可以保护数据安全；
（4）Python函数后面的任意多个参数，也是元组形式。

例如，一起来完成：

（1）定义3个变量：姓名、年龄、身高，并使用格式化符号拼接后再输出；

（2）对两个变量a和b进行互换顺序；

（3）执行程序，观察效果。

# 1.定义元组变量
# 2.拼接
# name = "金臻韬"
# age = 23
# height = 175.00
# print("姓名:%s, 年龄:%d, 身高:%fcm"%(name,age,height))

# 3.互换位置
a = 18
b = 99
# 元组
# a,b = b,a
(a,b) = (b,a)

# 其他语言: 引入第3方变量
# temp = a
# a = b
# b = temp

# 按位异或
# a = a ^ b  # 位运算  -先把数据转换二进制
# b = a ^ b
# a = a ^ b

print(f"a = {a}")
print(f"ab = {b}")

（1）元组的主要用途有存储数据、传递元组数据；

（2）注意：在后期使用中，当看到类似【(元素1, 元素2, ...)】的形式时，可以当成是（元组）类型的数据。

字典介绍

字典语法：

变量名 = {键1: 值1, 键2: 值2, ...}

说明：

（1）键、值组合在一起，形成了字典的元素；

（2）字典元素的键是唯一的；

（3）字典元素的值可以重复；

（4）可以使用字典存储大量数据。

例如，一起来完成：

（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：

函数名	含义
get(key[, default])	返回指定键key对应的值，若值不在字典中，则返回默认值。

例如，一起来完成：

（1）定义一个字典变量，存放一个学生的信息：姓名、住址、年龄等；

（2）分别使用不同方式去获取字典的姓名、住址值；

（3）思考：当访问不存在的性别信息时，会怎样？

# 1.定义变量
student = {"name":"欧阳芝","address":"广东广州","age":16,"sex":"Female"}
# 2.获取值
print(student["name"])
print(student["address"])  # 可以通过键来访问值

# 3.访问不存在的值
# print(student["sex"])
 print(student.get("sex"))   # 1. None   2.不报错
 print(student.get("sex","女"))

使用字典时，可以通过键访问值，优先使用【变量名[键]】来访问；

字典的常见操作

添加元素

添加元素指的是：给字典添加新元素内容。

添加元素语法：

变量名[键] = 值

说明：当要添加多个元素时，则执行多次添加元素的操作。

例如，一起来完成：

（1）定义一个字典变量，存放老师信息：姓名、体重、年龄等；

（2）给老师变量添加一个兴趣爱好；

（3）思考：若给一个空字典添加2个元素，该怎么做？

（4）执行程序，观察效果。

# 1.定义变量
teacher = {"name":"涛哥","weight":95,"age":40}
print(teacher)
# 2.添加一个元素
teacher["gender"] = "男"
print(teacher)

# 3.空字典添加2个元素
# teacher = {}
# teacher["name"] = "方哥"
# teacher["like"] = "爱好工作"
 print(teacher)
 print(type(teacher))

注意：字典中的元素不分先后顺序，可任意存储字典的数据

删除元素

删除元素指的是：删除字典的某元素，或者清空字典的所有数据。

删除元素方法：

函数名	含义
del 变量名[键]	删除指定元素。
clear()	清空字典的所有元素内容。

清空数据的操作，简要来了解一下。

说明：

（1）当要添加新的纯净数据前，要先把原有数据做清空处理；

（2）比如，先搜索酒店、再搜索美食，观察效果链接：百度地图。

例如，一起来完成：

（1）定义一个字典变量，存放老师信息：姓名、体重、年龄等；

（2）试着删除字典的体重元素；

（3）思考：当要给字典变量重新添加数据时，该怎么办？

teacher = {"name":"涛哥","weight":95,"age":40}
# 1.删除体重
del teacher["weight"]
print(teacher)
​
# 2.重新添加数据
# teacher.clear()
 print(teacher)

（1）对于删除字典的元素数据，使用较少，了解即可；

（2）注意：在实际应用中，若需要重新给字典变量添加新数据，建议先使用clear()清空数据。

修改元素

修改元素指的是：对已有元素进行修改，当成功修改后，则会用最新修改的值替换原有值。

修改元素语法：

变量名[键] = 值

例如，一起来完成：

（1）定义一个字典变量，存放老师信息：姓名、体重、年龄等；

（2）修改字典变量的姓名、体重值。

teacher = {"name":"涛哥","weight":95,"age":40}
# 修改姓名
teacher["name"] = "健哥"
# 修改体重
teacher["weight"] = 110
print(teacher)

注意：修改与添加字典元素的语法一样，要多理解一下应用场景。

查找元素

查找元素指的是：通过键来访问值。

比如，访问值的方式有两种：

变量名[键]

函数名	含义
get(key[, default])	返回指定键key对应的值，若值不在字典中，则返回默认值。

例如，一起来完成：

（1）定义一个字典变量，存放老师信息：姓名、体重、年龄等；

（2）使用两种方式来查看老师的姓名、年龄。

teacher = {"name":"涛哥","weight":95,"age":40}
print(teacher["name"])
print(teacher.get("age"))   # 若报错,则优先考虑使用get()

生成验证码案例

例如，一起来完成：

（1）请生成一个由数字、字母组成的6位数的验证码；

（2）文本内容：【抖音】验证码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"【抖音】验证码{code}，用于手机验证码登录，5分钟内有效。验证码提供给他人可能导致账号被盗，请勿泄露，谨防被骗。"
print(message)