Python基础学习第三天

目录

一、列表

1.列表的定义

2.列表常用操作

取值和取索引

​​​​​3.循环遍历

二、字符串

1.字符串的定义

2.字符串的切片操作

3.字符串的内建函数

（1）通用内建函数：

（2）大小写相关

 （3）查找、替换

 （4）字符串的编码和判断开头结尾

 （5）去除空白字符

（6）拆分和连接

 三、元组

1.元组的定义

2.元组常用操作

（1）元组和列表之间的转换

四、字典

1.字典的定义

如何把元组转换为字典？

2.字典常用操作

（1）修改字典

（2）删除字典元素

（3）字典键的特性

3.字典内置函数&方法

课后练习

---

一、列表

1.列表的定义

• List（列表） 是 Python 中使用 最频繁 的数据类型，在其他语言中通常叫做 数组
• 专门用于存储 一串 信息
• 列表用 [] 定义，数据 之间使用 , 分隔
• 列表的 索引 从 0 开始
  • 索引 就是数据在 列表 中的位置编号，索引 又可以被称为 下标

name_list = ["zhangsan", "lisi", "wangwu"] #注意：从列表中取值时，如果 超出索引范围，程序会报错

列表的取值

name_list = ["zhangsan", "lisi", "wangwu"]

name_list[1]
'lisi'

name_list[2]
'wangwu'

name_list[3]  # 索引超出了范围，会报错

Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    name_list[3]
IndexError: list index out of range
 

 

2.列表常用操作

• 定义一个 列表，例如：list = [] 

取值和取索引

name_list = ["zhangsan", "lisi", "wangwu"]
print(name_list[0])

#根据索引取值：
print(name_list.index("lisi"))

#根据值去索引/下标：
print(name_list.index("李四"))
Traceback (most recent call last):
  File "C:/Users/MSI-PC/Desktop/test/test.py", line 2, in <module>
    print(name_list.index("李四"))
ValueError: '李四' is not in list

#修改元素
name_list = ["zhangsan", "lisi", "wangwu"]
name_list[1] = "李四"
print(name_list)

#增加数据-列表.append（数据)
name_list
    ['张三', 'lisi', '王五']
name_list.append("王小二")
name_list
    ['张三', 'lisi', '王五', '王小二']

#增加数据-列表.insert（索引，数据）
name_list
    ['张三', 'lisi', '王五', '王小二']
name_list.insert(1,"小丽")
name_list
    ['张三', '小丽', 'lisi', '王五', '王小二']

#增加数据-列表.extend（列表2）/  +=
name_list
    ['张三', '小丽', 'lisi', '王五', '王小二']
name_list2=["小明","小红","小胖"]
name_list.extend(name_list2)
name_list
    ['张三', '小丽', 'lisi', '王五', '王小二', '小明', '小红', '小胖']

• 使用 del 关键字(delete) 同样可以删除列表中元素
• del 关键字本质上是用来 将一个变量从内存中删除的
• 如果使用 del 关键字将变量从内存中删除，后续的代码就不能再使用这个变量了

#删除数据-remove
name_list
    ['张三', '小丽', 'lisi', '王五', '王小二', '小明', '小红', '小胖’]
name_list.remove("lisi")
name_list
    ['张三', '小丽', '王五', '王小二', '小明', '小红', '小胖']

#删除数据-pop   ：默认把列表中最后一个元素删除
name_list
    ['张三', '小丽', '王五', '王小二', '小明', '小红', '小胖’]
name_list.pop()
    '小胖'
name_list
    ['张三', '小丽', '王五', '王小二', '小明', '小红']

#删除数据-pop（索引）
name_list
    ['张三', '小丽', '王五', '王小二', '小明', '小红’]
name_list.pop(4)
    '小明'
name_list
    ['张三', '小丽', '王五', '王小二', '小红']

#删除数据-clear
name_list
    ['张三', '小丽', '王五', '王小二', '小红’]
name_list.clear()
name_list
    []

#删除数据- del 列表[索引]
name_list2
    ['小明', '小红', '小胖']
del name_list2[1]
name_list2
    ['小明', '小胖']

#统计列表的元素-Len(列表)
name_list=["张三","李四","王五"]
len(name_list)
    3

#列表.count(数据)
name_list=["张三","李四","王五","张三"]
name_list.count("张三")
    2

#排序-列表.sort()-升序
num_list=[3,2,7,6,8,5,1,4]
num_list.sort()
num_list
    [1, 2, 3, 4, 5, 6, 7, 8]

#排序：列表. reverse（）-逆序
num_list
    [1, 2, 3, 4, 5, 6, 7, 8]
num_list.reverse()
num_list
    [8, 7, 6, 5, 4, 3, 2, 1]

#排序-列表. sort(reverse=True/False)
#True 代表 reverse 生效 将列表逆序排列， False 代表不生效
num_list
    [8, 7, 6, 5, 4, 3, 2, 1]
num_list.sort(reverse=True)
num_list
    [8, 7, 6, 5, 4, 3, 2, 1]
num_list.sort(reverse=False)
num_list
    [1, 2, 3, 4, 5, 6, 7, 8]

​​​​​3.循环遍历

• 遍历 就是 从头到尾 依次 从 列表 中获取数据

  • 在 循环体内部 针对 每一个元素，执行相同的操作

• 在 Python 中为了提高列表的遍历效率，专门提供的 迭代 iteration 遍历

• 使用 for 就能够实现迭代遍历,通过 迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

# for 循环内部使用的变量 in 列表
for name in name_list:

    循环内部针对列表元素进行操作
    print(name)

二、字符串

1.字符串的定义

• 字符串 就是 一串字符，是编程语言中表示文本的数据类型
• 在 Python 中可以使用 一对双引号 " 或者 一对单引号 ' 定义一个字符串
  • 虽然可以使用 \" 或者 \' 做字符串的转义，但在实际开发中：
    • 如果字符串内部需要使用 "，可以使用 ' 定义字符串
    • 如果字符串内部需要使用 '，可以使用 " 定义字符串
• 可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
• 也可以使用 for 循环遍历 字符串中每一个字符

string = "Hello Python"

for c in string:
    print(c)

2.字符串的切片操作

• 切片 使用 索引值 来限定范围，从一个大的 字符串 中 切出 小的 字符串
• 列表 和 元组 都是 有序 的集合，能够 通过索引值 获取到对应的数据
• 字典 是一个 无序 的集合，是使用 键值对 保存数据

"""
索引： 正索引 负索引
    正索引： 从0开始，正数第几个
    负索引： 倒数第几个

语法：
    str[start:end:方向(±)/步长]
    方向: 切片的时候，字符串的输出方向  +  正着输出  -反着输出 ； 默认是 正向输出
    步长: 输出切片值的时候，取值的间隔
"""

# 切片形式: 1 根据 索引取值
filename = "picture.png"
print(filename[5])

# 切片形式2: 截取部分字符串   filename[0:7]  顾前不顾后
print(filename[0:7])  # 取从0 到 7之前的一个元素
print("索引值为7对应的元素是: {}".format(filename[7]))

# 省略开头或结尾
print(filename[3:])  # 从3开始，一直取到最后
print(filename[:7])  # 从开头一直取值到 第7个元素 之前  等价于 filename[0:7]

# 取负数值
print(filename[8:-1])  # 从 第8个元素开始取值，一直取到 倒数第1个之前
print(filename[:-2])   # 从开头取值，一直取到 倒数第2个之前   picture.p
print(filename[-2:])   # 从倒数第二个值开始取值，一直取到结尾

# [::]  将这个字符串 取值，从前取到最后
print(filename[::])

# 方向/步长  步长默认为1
print(filename[::-1])   # gnp.erutcip

# 带有步长的切片
print(filename[0:8:2])  # picture.png
print(filename[-2:-5:-1])  #  -1 代表从右向左取值， [start:end:-1]

注意：

1. 指定的区间属于 左闭右开 型 [开始索引, 结束索引) => 开始索引 >= 范围 < 结束索引
   • 从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)
2. 从头开始，开始索引 数字可以省略，冒号不能省略
3. 到末尾结束，结束索引 数字可以省略，冒号不能省略
4. 步长默认为 1，如果连续切片，数字和冒号都可以省略

练习代码
"""
str1 = "hello world"
# 逆序输出 world
# 正向输出 hello
# 逆序输出 hello world
# 打印     llo wo
"""

str1 = "hello world"

# 逆序输出 world  dlrow
print(str1[-1:-6:-1])

# 正向输出 hello
print(str1[:5])

# 逆序输出 hello world
print(str1[::-1])

# 打印     llo wo
print(str1[2:8])

3.字符串的内建函数

（1）通用内建函数：

        id() 函数：查看对象的内存地址；

        help()函数：查看帮助信息；

        type()函数：查看对象的类型；不会认为子类是一种父类类型；

        isinstance()函数：查看对象类型；会认为子类是一种父类类型；

        dir()函数：查看对象中的属性、方法等；　

        ord():得到一个字符所对应的数字编码；

        chr():实现由数字编码向字符的转化；

（2）大小写相关

方法	说明
string.capitalize()	把字符串的第一个字符大写
string.title()	把字符串的每个单词首字母大写
string.lower()	转换 string 中所有大写字符为小写
string.upper()	转换 string 中的小写字母为大写
string.istitle()	若string 是标题化的(每个单词的首字母大写)则返回 True

"""
示例一
message = "andyis a beautiful girl !"
"""

# capitalize()  # 将字符串第一个字符转换成大写的表示形式
print(message.capitalize())

# title()       # 返回 每个单词的首字母 大写 的字符串
print(message.title())

# upper()  	  # 将字符串全部转成大写的形式
str_upper = message.upper()
print(str_upper)  # ANDYIS A BEAUTIFUL GIRL !

# lower()       #  将大写全部转成小写
print(str_upper.lower())  # andyis a beautiful girl !

# istitle()     # 返回的结果是bool类型的 True False  判断字符串是否符合 title的格式，
                #               # 如果是 ，返回True，如果不是，返回false

str2 = "Andyis A Beautiful Girl !"
print(str2.istitle())
print(message.istitle())  # "andyis a beautiful girl !" 不符合  title格式

"""
示例二
根据系统提示输入验证码，不用考虑大小写：
"""
# 1 随机生成字符串
# 1-1 创建一个 能够 提供 验证码的库
auth_code_lib = "1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"
print(len(auth_code_lib))  # 62
# 1-2 从这个库中，随机取值，生成验证码  长度是 5
import random  # 导入一个随机数的库，能够帮助我们随机提前 库中的 字符串

# 随机从 库中取一个值
auth_code = ''
# 随机取 5 次
for i in range(5):
    rand_str = auth_code_lib[random.randint(0, (len(auth_code_lib) - 1))]  # 在每次循环中，提供一个随机字符
    auth_code += rand_str  # 将随机字符进行拼接
print("当前系统输出的验证码是：",auth_code)

# 收集用户输入的验证码
user_input_code = input("请输入您看到的验证码：")

# 对这个验证码和  系统给的进行判断
# 将 系统给的验证码 和 用户输入的验证码 统一处理为 大写或者小写
if auth_code.upper() == user_input_code.upper():
    print("您输入的验证码是正确的！")
else:
    print("您输入的验证码有误！

 （3）查找、替换

语法如下：

        find(str, beg=0, end=len(string))        #find(要查找的字符，start，end)

         replace(old, new [, max])              #把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。

"""
find()
语法：find(str, beg=0, end=len(string))
说明：检测 str 是否包含在字符串中，
    如果指定范围 beg 和 end ，则检查是否包含在指定范围内，
    如果包含返回开始的索引值，否则返回-1
"""

s1 = "index lucy lucky goods"
p1 = s1.find("l")  # 在字符串中找到 l 的位置
print(p1)
p2 = s1.find("l", p1 + 1, len(s1))
print(p2)
result = s1.find("A")  # s1这个字符串中，没有"A",返回 -1
print(result)

"""
rfind 案例
案例2：获取链接中的文件名
"""
url = "https://www.baidu.com/img/bd_logo1.png"
# 需求： 将图片的文件名提出出来
# 分析： 文件名是 bd_logo1.png， 我们可以根据 / 来进行定位，最右面的 / 后面就是文件名

# 1 找到最右面的 / 的位置  ----》 返回一个索引值
p1 = url.rfind("/")
print(p1)

# 2 根据 / 的位置(索引值) 来进行切片
result = url[p1 + 1:]
print(result)

# 要提取文件的 扩展名 .png
# to be continued....  # todo

"""
replace(old, new [, max])   # [] 可选参数， max 默认最大替换/全部替换
把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
"""
s1 = "index lucy lucky goods"
# 需求，将 空格 换成 #
print(s1.replace(" ", "#"))

 （4）字符串的编码和判断开头结尾

 

方法	说明
编码 encode()	encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串， 如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
解码 secode()	m = result.decode("utf-8") print(m)
startswith()	判断是否以xxx开头的，endswith 判断是否以xxx 结尾的
endswith()	返回值都是布尔类型 True False

"""
encode()
decode()
"""
msg = "上课啦! 认真听课！"

# 对 msg进行编码
mesg_en = msg.encode("utf-8")  # 编码成二进制数据，以十六进制表示
print(mesg_en)
mesg_de = mesg_en.decode("utf-8")    # 对 编码后的字符进行解码
print(mesg_de)

"""
练习：
给定一个路径，上传文件(记事本txt或者是图片    jpg，png)
如果不是对应格式的，允许重新执行上传文件如果符合上传的规定则提示上传成功
"""
while True:
    path = input("请选择文件：")  # \c\pic\flower.png
    # 分析步骤 
    # 要上传的文件的路径 ---》文件名---》通过文件名再判断是否是图片类型
    p = path.rfind("\\")
    filename = path[p + 1:]  # 通过切片，截取出来文件名
# 判断是否是图片类型：
    if filename.endswith('jpg') or filename.endswith("png") or filename.endswith("txt"):
        print("是图片，上传成功！")
        break
 else:
       print("不是图片格式和记事本格式，上传错误！")

"""
isalpha() 是否是字母 
isdigit() 是否是数字
结果返回布尔值
"""
#判断输入的是否是纯数字，并计算出纯数字的和
sum = 0
i = 1
while i <= 3:
    num = input("请输入数字：")
    if num.isdigit():
        num = int(num)
        sum += num
        print("第{}个数字累加成功！".format(i))
        i += 1
   else:
        print("不是数字")
print("sum=", sum)

 （5）去除空白字符

方法	说明
string.lstrip()	截掉 string 左边（开始）的空白字符
string.rstrip()	截掉 string 右边（末尾）的空白字符
string.strip()	截掉 string 左右两边的空白字符

"""
strip  lstrip  rstrip
strip 能够去除 字符串 前 后 的space(空格)
lstrip
rstrip
"""
str1 = "   abcd  efg  "
str2 = str1.strip()
print(str1)
print(str2)

str3 = str1.lstrip()
print(str3)

str4 = str1.rstrip()
print(str4)

（6）拆分和连接

方法	说明
string.partition(str)	把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)	以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格
string.splitlines()	按照行(’\r’, ‘\n’, ‘\r\n’)分隔，返回一个包含各行作为元素的列表
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

# split 切割
# split 使用指定的字符（默认是空格），对字符串 进行切割， 将切割的结果，放到一个列表中
# split(str=" ", num=string.count(str))
str1 = "ab cd efg acke "
str2 = str1.split()  # str2 的类型是一个 列表
print(str2, "\n", type(str2))

str3 = "ab/cd/efg/acke "
str4 = str3.split("/", 2)
print(str4)

"""
str.count()  
对 字符串中出现 子字符串 次数的统计
"""
s = "sakflkasjflkajslfjwjeojas"
num = s.count("s")

s1 = "sakflkasajflkajsalfjwjeojas"
num1 = s1.count("sa")  # 子字符串

 三、元组

1.元组的定义

• Tuple（元组）与列表类似，区别：元组的 元素不能修改
  • 元组 表示多个元素组成的序列
  • 元组 在 Python 开发中，有特定的应用场景
• 用于存储 一串 信息，数据 之间使用 , 分隔
• 元组用 () 定义
• 元组的 索引 从 0 开始
  • 索引 就是数据在 元组 中的位置编号

元组中 只包含一个元素 时，需要 在元素后面添加逗号

# 定义一个元组
tuple_1 = ()  # 没有元素的元组 是一个空元组
print(type(tuple_1))

tuple_11 = tuple()  # 定义空元组的形式
print(type(tuple_11))

tuple_2 = (1,)  # 元组的表示方法，即使() 中只有一个元素，也要给这个 元素添加 一个","
print(type(tuple_2))

print(tuple_2.index(1))  # 元组也可以通过 值 取索引
print(tuple_2[0])  # 也可以通过索引 取值             元组是一个有序的数据集合

"""
交换变量
a = 1 
b = 2
---》 a=2,b=1

# 交换变量的第一种形式  
c = a  # c = 1  a=1
a = b  # a = 2
b = c  # b =1 

# 交换变量的第二种形式
a = a+b #a=3
b = a-b #b=1
a = a-b #a=2
"""
a = 1
b = 2
(a, b) = (b, a)  # 一行代码实现交换变量  两边的括号 是可以去掉的
# a, b = b, a
print(a, b)

2.元组常用操作

• 定义一个 元组，eg：info = ()

（1）元组和列表之间的转换

• 使用 list 函数可以把元组转换成列表

list(元组) 

• 使用 tuple 函数可以把列表转换成元组

tuple(列表)

# 从外形上看， 列表和元组 比较相似，可以进行类型转换

tuple_1 = (1, 2, 3, 45, 6)
list1 = list(tuple_1)
print(list1, "\n", type(list1))

"""
案例： 从1 到 20的范围，取10个值，生成一个元组
"""
import random

# 定义一个空列表
list1 = []
for i in range(10):
    list1.append(random.randint(1, 20))
print(list1)

# 将这个列表转换成 元组
tuple2 = tuple(list1)
print(tuple2)

#元组数据查询
print(t5[0])  # 通过下标查看元组中元素的值
print(t5[-1])
print(t5[2:-3])  # 通过切片取元组中元素的值
print(t5[::-1])
print(max(t5))    #元组最大值
print(min(t5))    #元组最小值
print(sum(t5))    #元组所有元素和
print(len(t5))    #元组元素个数
print(t5.count(4))  # 相同值元素的个数
print(t5.index(12))  # 从 t5这个元组中，没有元素就报错找出 4 的下标位置

# 元组拆包
t1 = (2, 5, 8, 9, 7)
a, *b, c = t1  # t1 = 2, 5, 8, 9, 7
# *b代表 能够被赋予 非固定数的元素
# 可以看到，表达式的左面没有括号，表达式的右面，是带括号的，t1不能直接对左面的表达式赋值
# 需要先将 t1的括号 去掉(拆包)，然后再给左面的变量进行赋值

# *b = 5,8,9 不属于任何类型， 如果要使用 *b,则对 *b进行装包:  b = [5,8,9]
print(type(b))

x, y, *z = "hello"
print(x, y, z)  # z不等于 "llo",而是一个列表["l","l","o"]
print(*z)

# 列表类型的拆包和装包
x, y, *z = ['aa', 6, 'hello', 'good', 'happy', 'lucky']
print(x,y,z)
print(*z)

四、字典

1.字典的定义

• dictionary（字典） 是 除列表以外 Python 之中 最灵活 的数据类型
• 字典同样可以用来 存储多个数据
  • 通常用于存储 描述一个 物体 的相关信息
• 和列表的区别
  • 列表 是 有序 的对象集合
  • 字典 是 无序 的对象集合
• 字典用 {} 定义
• 字典使用 键值对 存储数据，键值对之间使用 , 分隔
  • 键 key 是索引
  • 值 value 是数据
  • 键 和 值 之间使用 : 分隔
  • 键必须是唯一的
  • 值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组

dict1 = {}  # 定义空字典
dict2 = dict()  # 空字典 其他容器： list1 = list()  空列表  tuple = tuple()
dict3 = {"ID": '120220200011112222', 'name': "lucky", "age": 18}  # 有内容的字典的定义

如何把元组转换为字典？

dict4 = dict([("name", "lucy"), ("age", 18)])

可以这样写，其实是将列表强转成字典，这个列表的每个元素是元组，每个元组有2个元素，
第一个元素必须是 字符串、数字或者元组，只有符合固定格式的写法才能转换成字典

tuple_1 = ("name", "lucky")
# 能否转换成字典？
# dict1 = dict(tuple_1)


# 列表可以转字典，但是列表里面的值要成对出现，
# 元组不能直接转字典， 列表可以,但是，列表的元素，必须是成对的
lsit_1 = [("name", "lucky")]  # 这个列表 list1 只有1个元素，它的元素是一个元组，这个元组有2个元素
dict1 = dict(lsit_1)

list2 = [["age", 18]]  # list2是一个列表，这个列表有一个元素，它的 元素是一个列表，这个列表有2个元素
dict2 = dict(list2)
print(dict2)

2.字典常用操作

（1）修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8                   # 更新 Age
tinydict['School'] = "天津市软件学院"   # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

以上实例输出结果：
tinydict['Age']:  8
tinydict['School']:  天津市软件学院

（2）删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显式删除一个字典用del命令，如下实例

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

但这会引发一个异常，因为用执行 del 操作后字典不再存在：
Traceback (most recent call last):
  File "/runoob-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined

（3）字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

•         不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，
•         键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，

3.字典内置函数&方法

序号	函数及描述	实例
1	len(dict) 计算字典元素个数，即键的总数。	>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(tinydict) 3
2	str(dict) 输出字典，可以打印的字符串表示。	>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(tinydict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。	>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(tinydict) <class 'dict'>

Python字典包含了以下内置方法：

序号	函数及描述
1	dict.clear()                                删除字典内所有元素
2	dict.copy()                                返回一个字典的浅复制
3	dict.fromkeys()                          创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	dict.get(key, default=None)       返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict                                如果键在字典dict里返回true，否则返回false
6	dict.items()                                以列表返回一个视图对象
7	dict.keys()                                返回一个视图对象
8	dict.setdefault(key, default=None)        和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)                        把字典dict2的键/值对更新到dict里
10	dict.values()                                返回一个视图对象
11	pop(key[,default])                        删除字典给定键 key 所对应的值，返回值为被删除值。key值必须给出。 否则返回default值。
12	popitem()                                     返回并删除字典中的最后一对键和值。

课后练习

dict2 = {"张三": 100,
         "李四": 100,
         "王五": 89,
         "小赵": 99}

print(dict2["张三"])

# 遍历字典 , 结果是字典的键
for i in dict2:
    if dict2[i] > 90:  # 如果 取值大于 90，则将字典的键输出
        print(i)

"""
items()  字典的解封装 将字典拆包，生成一个dict_items 的一个结合，
             dict_items的每个元素都是一个元组，元组包含了键值对。
"""
result = dict2.items()  # 数据类型是 class 'dict_items'
print(result, type(result))

for i in result:
    print(i)

for (key, value) in dict2.items():
    if value > 90:
        print(key)

# values() 和 key() 是字典的属性，而不是 字典解封装的属性
print(dict2.keys())
print(dict2.values())

"""
删除  del  
pop(key[,default]) 
"""
dict1 = {"张三": 100, "李四": 100, "王五": 89, "小赵": 99}

del dict1["王五"]  # 删除 王五的键值对
print(dict1)

print(dict1.pop("王五", "没有这个键值对"))  # pop("王五","没有王五这个键值对")  王五：是我要删掉的键，  "没有王五这个键值对"  如果字典中没有 王五这个键，提示的信息
print(dict1)

"""
update() 将两个字典合并成1 个
"""

dict1 = {0: 'tom', 1: "jack", 2: "lucy"}  # 字典中不能出现相同的键，如果在合并字典的时候，有相同的键，则保留 后面字典键对应的值
dict2 = {0: "lily", "4": "ruby"}

dict1.update(dict2)
print(dict1)

"""
fromkeys(seq,[])  # seq 是一个 序列， dict.fromkeys()这个函数 会根据这个序列，来生成一个新字典，
                    会以序列中的元素作为字典的键，可以不赋值，如果没有赋值，则 每个键对应的值为 None 
"""

list1 = ["alex", "box", "alice", "tom"]

# 创建一个新字典，使用 list1的元素作为字典的键
new_dict = dict.fromkeys(list1)  # 以列表的每个元素作为字典的键，每有给字典的键 赋值，为 None, 空
print(new_dict)

new_dict2 = dict.fromkeys(list1, 100)
print(new_dict2)

"""
案例：
用户注册功能,用户填写如下信息，完成用户注册
username
password  输入密码，需要进行确认
email
phone

将以上的信息，存储到一个数据库，在数据库中，存放多个人的信息
注册完一个信息之后，是否还要继续注册，如果否，退出系统
"""

# 欢迎语
print("欢迎使用用户信息注册软件：")

# 创建一个数据库 形式是 列表
datebase = []

# 能够进行多个用户的注册：
while True:
    # 收集信息
    username = input("请输入用户名：")
    password = input("请输入密码：")
    re_passwd = input("请再次输入密码: ")  # 输入密码的时候，需要进行确认，如果两个密码不一样，则提示，密码不一致，重新输入信息
    if password == re_passwd:
        email = input("请输入邮箱号：")
        phone = input("请输入手机号：")
        dict_1 = {}  # 在输入信息之前，先定义一个字典，可以是空字典
        # 将这些信息填写到一个字典中，用于储存这个人的信息
        dict_1["username"] = username
        dict_1["passwd"] = password
        dict_1["email"] = email
        dict_1["phone"] = phone
        print(f"注册成功，信息为：{dict_1}")
        # 当成功的注册了一个信息之后，将这个信息，添加到 数据库中
        datebase.append(dict_1)

        # 是否需要继续注册？如果否，请按 exit(),退出系统
        ask = input("是否继续注册，如果 不继续注册，请输入 exit()  :  ")
        if ask == "exit()":
            break
    else:
        print("两次输入的密码不一致，请重新输入！")
print(f"当前的用户注册信息是：{datebase}")