python[4]

函数的嵌套调用

所谓函数的嵌套就是一个函数内调用了另外一个函数

def func_b():
    print("b")
def func_a():
    print("a")
    func_b()
    print("c")

func_a()

执行流程：函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容

变量在函数中的作用域

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）
主要分为两类：局部变量和全局变量

【1】所谓局部变量就是定义在函数体内部的变量，即只在函数体内部生效，在函数外部访问立即报错；
局部变量的作用：在函数内部，临时保存数据，即当函数调用完成后，即销毁局部变量
【2】所谓全局变量，指的是在函数体内、外都能生效的变量
【3】global关键字
在不写global关键字的时候，如果全局变量在函数体外定义，但如果只修改函数内的定义值，函数体外的值不变。
如果希望函数体内的值改变，导致函数体外的值也改变，那么只需要在函数体内定义num=500前面加global num语句。

num = 200
def func_a():
    global num
    num = 100
    print(num)
def func_b():
    num = 300
    print(num)
func_a()
func_b()
print(num)
--------------------结果------------------
100
300
100

函数综合案例

实现效果如下：

【1】主菜单效果
---------------------主菜单-------------------
周杰伦，您好，欢迎来到黑马银行ATM，请选择操作，
查询余额 【输入1】
存款 【输入2】
取款 【输入3】
退出 【输入4】
请输入您的选择：
【2】查询余额效果
---------------------查询余额----------------------
周杰伦，您好，您的余额剩余：5000000元
【3】存、取款效果
--------------------存款--------------------
周杰伦，您好，您存款50000元成功
周杰伦，您好，您的余额剩余：5050000元

--------------------取款---------------------

周杰伦，您好，您取款50000元成功
周杰伦，您好，您的余额剩余4950000元

步骤
【1】定义一个全局变量：money，用来记录银行卡余额（默认5000000）
【2】定义一个全局变量：money，用来记录客户姓名（启动程序时输入）
【3】定义如下函数：
查询余额函数
存款函数
取款函数
主菜单函数
【4】要求：
程序启动后要求输入客户姓名
查询余额、存款、取款后都会返回主菜单
存款、取款后，都应显示一下当前余额
客户选择退出或输入错误，程序会退出，否则一直运行

#定义全局变量
money = 5000000
name = None
#要求客户输入姓名
name = input("请输入您的姓名：")
#定义查询函数
def query(show_header):
 if show_header:
     print("--------------查询余额--------------")
 print(f"{name}您好,您的余额剩余:{money}元")
#定义存款函数
def saving(num):
    global money #money函数内部定义为全局变量
    money += num
    print("--------------存款--------------")
    print(f"{name},您好,您存款{num}元")

    #调用query函数查询余额
    query(False)
#定义取款函数
def get_money(num):
    global money
    money -= num
    print("--------------取款--------------")
    print(f"{name},您好,您取款{num}元")


    #调用query函数查询余额
    query(False)
#定义主菜单函数
def main():
    print("--------------主菜单--------------")
    print(f"{name},您好,欢迎来到黑马银行ATM。请选择操作")
    print("查询余额\t[输入1]")
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")
    print("退出\t\t[输入4]")     #通过\t制表符对齐输出
    return input("请输入您的选择：")

#设置无限循环，确保程序不退出
while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(True)
        continue  #通过continue继续下一次循环，一进来就是回到了主菜单
    elif keyboard_input =='2':
        num = int(input("你想要存多少钱？请输入："))
        saving(num)
        continue
    elif keyboard_input == '3':
        num = int(input("您想要取多少钱？请输入："))
        get_money(num)
        continue
    else:
        print("程序退出啦")
        break   #通过break退出循环

数据容器章节

python中的数据容器：
一个可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素。每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据类型根据特点不同，如：
【1】是否可支持重复元素
【2】是否可以修改
【3】是否有序等
python中有五类数据容器，分别是列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

列表

【1】列表的定义

基本语法：
[元素1，元素2，元素3，元素4，...]
变量名称 = [元素1，元素2，元素3，元素4，...]
定义空列表
变量名称 = [ ]
变量名称 = list()
列表内的每一个数据，称之为元素
以[  ]为标识。列表内每一个元素之间用逗号隔开
my_list = ["itheima","itcast","python"]
print(my_list)
print(type(my_list))
my_list1 = ["itheima",666,True]
print(my_list1)
print(type(my_list1))
my_list2 = [[1,2,3],[4,5,6]]
print(my_list2)
print(type(my_list2))
----------------------------------------结果------------------------------------------
['itheima', 'itcast', 'python']
<class 'list'>
['itheima', 666, True]
<class 'list'>
[[1, 2, 3], [4, 5, 6]]
<class 'list'>

【2】列表的下标索引

列表中的每一个元素，都有其位置下标索引，向前向后的方向，从0开始，依次递增
我们只需要按照下标索引，即可取得对应位置的元素
列表下标索引，从前向后是从0开始，每次+1，从后向前 -1开始，每次 -1
错误示范：通过下标索引取数据，一定不要超出范围
语法：列表[下标索引]

name_list = ['Tom','Lily','Rose']
print(name_list[0])
print(name_list[1])
print(name_list[2])
------------------------结果-----------------------
Tom
Lily
Rose

name_list = ['Tom','Lily','Rose']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
------------------------结果-------------------------
Rose
Lily
Tom

name_list = ['Tom','Lily','Rose']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
my_list=[[1,2,3],[4,5,6]]
print(my_list[1][1])
------------------------结果-------------------------
Rose
Lily
Tom
5

【3】列表的常用操作
插入元素
删除元素
清空列表
修改元素
统计元素个数
这些功能称为列表的方法

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同
def add(x，y):
return x+y
class Student:

		def add(self，x，y)：
				return x+y

函数的使用：num = add(1,2)
方法的使用：student = Student()
num = student.add(1,2)

my_list = ["itcast","itheima","python"]
# 1.1 查找某元素在列表内的下标索引
index = my_list.index("itheima")
print(f"iteheima在列表中的下标索引值是{index}")
# 1.2 如果被查找的元素不存在，会报错
#index = my_list.index("hello")
#print(f"iteheima在列表中的下标索引值是{hello}")
# 2 修改特定下标索引的值
my_list[0] = "传智教育"
print(f"列表被修改元素值后，结果是:{my_list}")
# 3 在指定下标位置插入新元素
my_list.insert(1,'best')
print(f"列表插入元素，结果是:{my_list}")
# 4 在列表的尾部追加```单个```新元素
my_list.append("黑马程序员")
print(f"列表在追加了元素后，结果是:{my_list}")
# 5 在列表尾部追加```一批```新元素
my_list2 = [1,2,3]
my_list.extend(my_list2)
print(f"列表在追加了一个新的列表后，结果是：{my_list}")
my_list = ["itcast","itheima","python"]
# 6 删除指定下标索引的元素（2种方式）
del my_list[2]
print(f"列表删除元素后的结果是:{my_list}")
# 6.1 方式1：del 列表[下标]
my_list = ["itcast","itheima","python"]
element = my_list.pop(2)
print(f"通过pop方法取出元素后列表内容：{my_list},取出的元素是:{element}")
# 7 删除某元素在列表中的第一个匹配项
my_list = ['itcast','itheima','itcast','itheima','python']
my_list.remove('itheima')
print(f"通过remove方法移除元素后，列表的结果是:{my_list}")

# 8 清空列表
my_list.clear()
print(f"列表被清空了，结果是:{my_list}")
# 9 统计列表内某元素的数量
my_list = ['itcast','itheima','itcast','itheima','python']
count = my_list.count('itheima')
print(f"列表中itheima的数量是:{count}")
# 10 统计列表中全部元素的数量
my_list = ['itcast','itheima','itcast','itheima','python']
count = len(my_list)
print(f"列表的元素数量总共有：{count}个")
---------------------------------------------结果----------------------------------------------
iteheima在列表中的下标索引值是1
列表被修改元素值后，结果是:['传智教育', 'itheima', 'python']
列表插入元素，结果是:['传智教育', 'best', 'itheima', 'python']
列表在追加了元素后，结果是:['传智教育', 'best', 'itheima', 'python', '黑马程序员']
列表在追加了一个新的列表后，结果是：['传智教育', 'best', 'itheima', 'python', '黑马程序员', 1, 2, 3]
列表删除元素后的结果是:['itcast', 'itheima']
通过pop方法取出元素后列表内容：['itcast', 'itheima'],取出的元素是:python
通过remove方法移除元素后，列表的结果是:['itcast', 'itcast', 'itheima', 'python']
列表被清空了，结果是:[]
列表中itheima的数量是:2
列表的元素数量总共有：5个

列表的常用操作

1.定义一个列表，并用变量去接收它，内容是[21，25，21，23，22，20]
2.追加一个数字31，到列表的尾部
3.追加一个新列表[29,33,30],到列表的尾部
4.取出第一个元素(应是21)
5.取出最后一个元素（应是30）
6.查找元素31，在列表中的下标位置

# 1.定义一个列表，并用变量去接收它，内容是[21，25，21，23，22，20]
my_list = [21,25,21,23,22,20]
print(f"新定义的列表是{my_list}")
# 2.追加一个数字31，到列表的尾部
my_list.append(31)
print(f"追加数字31后的列表是{my_list}")
# 3.追加一个新列表[29,33,30],到列表的尾部
p = [29,33,30]
my_list.extend(p)
print(f"追加新列表后的列表是{my_list}")
# 4.取出第一个元素(应是21)
num = my_list[0]
print(f"列表的第一个元素是{num}")
# 5.取出最后一个元素（应是30）
num1 = my_list.pop()
print(f"列表中最后一个元素是{num1}")
# 6.查找元素31，在列表中的下标位置
index = my_list.index(31)
print(f"元素31在列表中的下标位置是:{index}")
-------------------------------------------结果----------------------------------------------
新定义的列表是[21, 25, 21, 23, 22, 20]
追加数字31后的列表是[21, 25, 21, 23, 22, 20, 31]
追加新列表后的列表是[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]
列表的第一个元素是21
列表中最后一个元素是30
元素31在列表中的下标位置是:6

列表的循环遍历

1、什么是遍历？
将容器中的元素依次取出，并处理，称之为遍历操作
2、如何便历列表中的元素？
可以使用while或for循环
3、for循环的语法：
for 临时变量 in 数据容器：
对临时变量进行处理
4、for循环和while循环对比
for循环更简单，while更灵活
for 用于从容器内依次取出元素并处理，while用以任何需求循环的场景

#  使用 whiler 循环
def fun_a():
    my_list = ["传智教育","黑马程序员","python"]
    i = 0
    while i<len(my_list):
        element = my_list[i]
        print(f"列表中的元素是{element}")
        i += 1
fun_a()
#  使用for循环
def fun_a():
    my_list = ["传智教育","黑马程序员","python"]
    for i in my_list:
        print(f"列表中的元素是{i}")
fun_a()
------------------------------------结果------------------------------------
列表中的元素是传智教育
列表中的元素是黑马程序员
列表中的元素是python

元组的定义和操作

元组同列表一样，可以封装多个不同类型的元素在内。
但最大的不同点在于：元组一旦定义完成，就不可修改；

元组的定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
(元素，元素，元素，...，元素)
变量名称 = （元素，元素，...，元素）
变量名称 = （ ）                 #方式1
变量名称 = truple（）         #方式2

# 定义元组
# 定义元组
t1 = (1,'hello',True)
t2 = ()
t3 = tuple()
print(f"t1的类型是{type(t1)},内容是{t1}")
print(f"t2的类型是{type(t2)},内容是{t2}")
print(f"t3的类型是{type(t3)},内容是{t3}")
# 定义单个元素的元组
t4 = ('hello',)
print(f"t4的类型是{type(t4)},t4的内容是{t4}")
# 元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是{type(t5)},t4的内容是{t5}")
# 下标索引取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是{num}")
# 元组的操作：index查找方法
t6 = ("传智教育","黑马程序员","python")
index = t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员的下标是{index}")
# 元组的操作：count统计方法
t7 = ("传智教育","黑马程序员","黑马程序员","Python")
num = t7.count("黑马程序员")
print(f"黑马程序员在t7中出现的次数")
# 元组的操作：len函数统计元组元素数量
t8 = ("传智教育","黑马程序员","黑马程序员","Python")
num = len(t8)
print(f"t8元组中的元素有{num}个")
# 元组的便历：while
i = 0
while i<len(t8):
    print(f"while循环中元组的元素分别是{t8[i]}")
    #至关重要
    i += 1

#元组的便历：for
for i in t8:
    print(f"for循环中元组的元素分别是{i}")
#不能修改元组内容
#如果元组嵌套了一个列表，可以修改嵌套的列表的元素
#定义一个元组
t9 = (1,2,['itheima','itcast'])
print(f"t9的内容是{t9}")
t9[2][0]='黑马程序员'
t9[2][1]='传智教育'
print(f"修改后的内容是{t9}")
-----------------------------------------结果-------------------------------------------
t1的类型是<class 'tuple'>,内容是(1, 'hello', True)
t2的类型是<class 'tuple'>,内容是()
t3的类型是<class 'tuple'>,内容是()
t4的类型是<class 'tuple'>,t4的内容是('hello',)
t5的类型是<class 'tuple'>,t4的内容是((1, 2, 3), (4, 5, 6))
从嵌套元组中取出的数据是6
在元组t6中查找黑马程序员的下标是1
黑马程序员在t7中出现的次数
t8元组中的元素有4个
while循环中元组的元素分别是传智教育
while循环中元组的元素分别是黑马程序员
while循环中元组的元素分别是黑马程序员
while循环中元组的元素分别是Python
for循环中元组的元素分别是传智教育
for循环中元组的元素分别是黑马程序员
for循环中元组的元素分别是黑马程序员
for循环中元组的元素分别是Python
t9的内容是(1, 2, ['itheima', 'itcast'])
修改后的内容是(1, 2, ['黑马程序员', '传智教育'])

元组的特点：
1、可以容纳多个数据
2、可以容纳不同类型的数据（混装）
3、数据是有序存储的（下标索引）
4、允许重复数据存在
5、不可以修改（增加或删除元素等）
6、支持 for 循环

字符串的定义和操作

尽管字符串不像列表、元组那样是可以存储许多数据的容器
但不可否认的是，字符串同样也是数据容器的一员，字符串是字符的容器。
同元组一样，字符串是一个无法修改的数据容器。

作为数据容器，字符串有如下特点：
只可以存储字符串
长度任意（取决于内存大小）
支持下标索引
允许重复字符串存在
不可以修改（增加或删除元素等）
支持 for 循环

my_str = "itheima and itcast"
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素值是{value},取下标为-16的元素值是{value2}")
# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and,其起始下标是{value}")
# replace方法
new_my_str = my_str.replace('it','程序')
print(f"将字符串{my_str}进行替换后得到{new_my_str}")
#split方法
my_str = 'hello python itheima itcast'
my_str_list = my_str.split(" ") #不传入参数
print(f"将字符串{my_str}进行split切分后得到{my_str_list},类型是{type(my_str_list)}")
#strip方法
my_str = 'iteheima and itcast'
new_my_str = my_str.strip() #不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后,结果{new_my_str}")

my_str = '12itheima and itcast'
new_my_str = my_str.strip('12')
print(f"字符串{my_str}被strip('12')后结果是{new_my_str}")

#统计字符串中某字符串的出现次数,count
my_str = 'itheima and itcast'
count = my_str.count('it')
print(f"字符串{my_str}中it的个数为{count}")

#统计字符串的长度
num = len(my_str)
print(f"字符串{my_str}的长度是{num}")
------------------------------------------------------------结果----------------------------------------------------------
从字符串itheima and itcast取下标为2的元素值是h,取下标为-16的元素值是h
在字符串itheima and itcast中查找and,其起始下标是8
将字符串itheima and itcast进行替换后得到程序heima and 程序cast
将字符串hello python itheima itcast进行split切分后得到['hello', 'python', 'itheima', 'itcast'],类型是<class 'list'>
字符串iteheima and itcast被strip后,结果iteheima and itcast
字符串12itheima and itcast被strip('12')后结果是itheima and itcast
字符串itheima and itcast中it的个数为2
字符串itheima and itcast的长度是18

my_list = 'itheima itcast boxuegu'
count = my_list.count('it')
new_list = my_list.replace(' ','|')
new_list1 = new_list.split('|')
print(f"{new_list1}")
-------------------------结果-------------------------
['itheima', 'itcast', 'boxuegu']

什么是序列，序列的切片操作

序列是指：内容连续、有序、可使用下标索引的一类数据容器
列表、元组、字符串均可以视为序列
语法：序列[起始下标：结束下标：步长

# 对List进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4]
print(f"结果{result1}")
# 对tuple进行切片，从0开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result1 = my_tuple[:]
print(f"结果{result1}")
# 对str进行切片，从0开始，到最后结束，步长-1
my_str = [0,1,2,3,4,5,6]
result1 = my_str[::-1]
print(f"结果{result1}")
# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[3:1:-1]
print(f"结果{result1}")
# 对元组进行切片，从0开始，到最后结束，步长-2
my_tuple1 = [0,1,2,3,4,5,6]
result1 = my_tuple1[::-2]
print(f"结果{result1}")
---------------------------------------------------------结果--------------------------------------------------
结果[1, 2, 3]
结果(0, 1, 2, 3, 4, 5, 6)
结果[6, 5, 4, 3, 2, 1, 0]
结果[3, 2]
结果[6, 4, 2, 0]

序列的切片课后练习题

倒序字符串，切片取出或切片取出，然后倒序
split分隔“，”“replace替换"为空，倒序字符串

my_str = "月薪过万,就来黑马程序员"
#正序字符串，切片取出
result1 = my_str[::1][7:12]
print(result1)
#切片取出，然后倒序
result2 = my_str[-12:][-5:]
print(result2)

集合

集合是无序的，所以集合不支持下标索引访问。
但集合和列表一样，是允许修改的。

# 定义集合
# 添加新元素
# 移除元素
# 随机取出一个元素
# 清空集合
# 取2个集合的差集
# 清除2个集合的差集
# 2个集合合并为1个
# 统计集合元素数量


# 定义集合
my_set = {"传智教育","黑马程序员","itheima","传智教育","黑马程序员","itheima","传智教育","黑马程序员","itheima"}
my_set_empty = set()
print(f"my_set的内容是:{my_set}")
# 添加新元素
my_set.add("Python")
my_set.add("传智教育")
print(f"my_set添加元素后结果是{my_set}")
# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后，结果是{my_set}")
# 随机取出一个元素
my_set = {"传智教育","黑马程序员","itheima"}
element = my_set.pop()
print(f"集合被取出元素是{element},取出元素后:{my_set}")
# 清空集合
my_set.clear()
print(f"集合被清空了，结果是{my_set}")
# 取2个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是{set3}")
print(f"取差集后,原有set1的内容{set1}")
print(f"取差集后,原有set2的内容{set2}")

# 清除2个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(f"消除差集后,集合1的结果{set1}")
print(f"消除差集后,集合2的结果{set2}")
# 2个集合合并为1个
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"两个集合合并的结果是{set3}")
print(f"合并后集合1{set1}")
print(f"合并后集合2{set2}")
# 统计集合元素数量len()
set1 = {1,2,3,4,5,1,2,3,4,5}
num = len(set1)
print(f"集合内元素数量有{num}个")
# 集合的便历
set1 = {1,2,3,4,5}
print(f"集合set1中的元素依次是")
for i in set1:
    print(f"{i}",end=' ')

集合的课后练习

有如下列表对象：
my_list = [‘黑马程序员’，‘传智播客’，‘传智播客’，‘itheima’，‘itcast’，‘itheima’，‘itcast’，‘best’]
请：
定义一个空集合
通过for循环遍历列表
在for循环中将列表的元素添加至集合
最终得到元素去重后的集合对象，并打印输出

my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itcast','itheima','itcast','best']
my_set = set()
for i in my_list:
    my_set.add(i)
print(f"列表的内容是{my_list}")
print(f"通过for循环，得到的集合对象是{my_set}")
----------------------------------------------------------结果----------------------------------------------------------
列表的内容是['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itcast', 'itheima', 'itcast', 'best']
通过for循环，得到的集合对象是{'itcast', '黑马程序员', 'best', '传智播客', 'itheima'}

字典的定义

1、为什么使用字典
字典可以提供基于Key检索Value的场景实现，就像查字典一样
2、字典的定义语法
字典的定义同样使用{ }，不过存储的元素是一个个的：键值对，如下语法：
{key：value,key：value：key,…}
#定义字典变量
my_dict = {key：value，key：value，key：value}
#定义空字典
my_dict = { } #空字典定义方式1
my_dict = dict{ } #空字典定义方式2
3、字典的注意事项
python中字典的key不可重复，重复添加等同于覆盖原有数据；
Key可以是任意类型，但不可以是字典；
value可以是字典、元祖、列表、字符串、数字

hash ={
    "王力宏":99,
    "周杰伦":88,
    "林俊杰":77
}
print(f"字典1的内容是{hash},类型是{type(hash)}")
for i in hash:
    print(f"{i}对应的值为{hash[i]}")
score = hash["王力宏"]
print(f"王力宏的考试分数是{score}")
# 字典的嵌套 value可以是字典
stu_score_dict = {
    "王力宏":{
    "语文":77,
    "数学":66,
    "英语":33
},
    "周杰伦":{
    "语文":88,
    "数学":86,
    "英语":55
    },
    "林俊杰":{
        "语文":99,
        "数学":96,
        "英语":66
    }
}
print(f"学生的考试信息是{stu_score_dict}")
print(f"林俊杰学生的语文成绩是{stu_score_dict["林俊杰"]["语文"]}")
----------------------------------------------------结果--------------------------------------------------------
字典1的内容是{'王力宏': 99, '周杰伦': 88, '林俊杰': 77},类型是<class 'dict'>
王力宏对应的值为99
周杰伦对应的值为88
林俊杰对应的值为77
王力宏的考试分数是99
学生的考试信息是{'王力宏': {'语文': 77, '数学': 66, '英语': 33}, '周杰伦': {'语文': 88, '数学': 86, '英语': 55}, '林俊杰': {'语文': 99, '数学': 96, '英语': 66}}
林俊杰学生的语文成绩是99

字典的常用操作

1、

2、操作注意：
新增和更新元素的语法一致，如果Key不存在新增，如果Key存在即更新（key不可重复）
3、字典的特点：
可以容纳多个数据
可以容纳不同类型的数据
每一份数据是KeyValue键值对
可以通过Key获取到Value，key不可重复（重复会覆盖）
不支持下标索引
可以修改（增加或删除更新元素）
支持for循环，不支持while循环

# 演示字典的常用操作
my_dict = {"周杰伦":99,"林俊杰":88,"张学友":77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后,结果{my_dict}")
# 更新元素
my_dict["周杰伦"] = 33
print(f"字典经过更新后,结果{my_dict}")
# 删除元素
score = my_dict.pop("周杰伦")
print(f"字典中被移除了一个元素,结果是{my_dict},周杰伦的考试分数是{score}")
# 清空元素
my_dict.clear()
print(f"字典被清空了,内容是{my_dict}")
# 获取全部的key
my_dict = {"周杰伦":99,"林俊杰":88,"张学友":77}
keys = my_dict.keys()
print(f"字典的全部keys是{keys}")
# 便历字典
for key in keys:
    print(f"字典的key是{key}")
    print(f"字典的value是{my_dict[key]}")
for key in my_dict:
    print(f"字典的key是{key}")
    print(f"字典的value是{my_dict[value]}")
# 统计字典内的元素数量
n = len(my_dict)
print(f"字典中的元素数量是{n}")
---------------------------------------结果---------------------------------
字典经过新增元素后,结果{'周杰伦': 99, '林俊杰': 88, '张学友': 77, '张信哲': 66}
字典经过更新后,结果{'周杰伦': 33, '林俊杰': 88, '张学友': 77, '张信哲': 66}
字典中被移除了一个元素,结果是{'林俊杰': 88, '张学友': 77, '张信哲': 66},周杰伦的考试分数是33
字典被清空了,内容是{}
字典的全部keys是dict_keys(['周杰伦', '林俊杰', '张学友'])
字典的key是周杰伦
字典的value是99
字典的key是林俊杰
字典的value是88
字典的key是张学友
字典的value是77
字典的key是周杰伦
字典的value是99
字典的key是林俊杰
字典的value是88
字典的key是张学友
字典的value是77
字典中的元素数量是3

字典课后练习讲解

info_dict={
    "王力宏":{"部门":"科技部","工资":3000,"级别":1},
    "周杰伦":{"部门":"市场部","工资":5000,"级别":2},
    "林俊杰":{"部门":"市场部","工资":7000,"级别":3},
    "张学友":{"部门":"科技部","工资":4000,"级别":1},
    "刘德华":{"部门":"市场部","工资":6000,"级别":2}
}
print(f"字典的内容是{info_dict}")
#for循环遍历字典
for name in info_dict:
    if info_dict[name]["级别"] == 1:
        employee_info_dict_1 = info_dict[name]
        employee_info_dict_1["级别"] = 2
        employee_info_dict_1["工资"] += 1000
        info_dict[name] = employee_info_dict_1
print(f"对员工升职加薪后的结果是{info_dict}")
--------------------------------------结果-------------------------------------
字典的内容是{'王力宏': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}
对员工升职加薪后的结果是{'王力宏': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}