Python（1） 6种基本数据类型
1.数值型
（1）整型 int
a. Python 中的整数没有长度限制，不像其他编程语言有 int，smallint，short，long，longint，long 等
不信来试试：
print(9 ** 999)
运行结果为：
上面 9 ** 999 的意思是：9 的 999 次方，这么大的数据都能输出，换作其他语言基本都报错了吧
b. Python 的整数有十进制，十六进制，八进制，二进制
十进制就不说了，正常的写法
十六进制写法：加前缀 0x，出现 0-9 和 A-F 的数字和字母组合
八进制写法：加前缀 0o，出现 0-7 数字组合
二进制写法：加前缀 0b，只有 0 和 1 数字组合
运行时，他们会自动转换为十进制输出：
print(0x10)
print(0o10)
print(0b10)运行结果为：
（2）浮点数 float
a. 浮点数只能以十进制表示，不能加前缀，否则会报语法错误
b. 浮点数有长度限制 边界值为：
max=1.7976931348623157e+308 min=2.2250738585072014e-308
（3）布尔值 bool
布尔值就是我们常说的逻辑，可以理解为对或错
print(100 == 100.0)运行结果：
注意：Python 中 100 == 100.0 的布尔值是 True，这里只是比较两个值是否相等，只是精度不一样
（4）复数 complex
# Python 中的复数这样来表示： 1 + 1j 虚部为 1，仍不可省略
print((1 + 2j).real) # 输出实部 float 类型
print((1 + 2j).imag) # 输出虚部 float 类型 运行结果：
2. 字符串 str
（1）字符串的组成
通俗来说，字符串就是字符组成的一串内容，Python 中用成对的单引号或双引号括起来，用三个单引号或双引号可以使字符串内容保持原样输出，可以包含回车等特殊字符，在 Python 中字符串是不可变对象
（2）转义
转义转义，顾名思义，转换含义
Python 中用反斜杠 “\” 来转义字符
| 转义字符 | 描述 |
|---|---|
| \\ | 反斜杠 |
| \' | 单引号 |
| \" | 双引号 |
| \b | 退格（删除前面1个字符） |
| \n | 换行 |
| \t | 制表符（4个空格） |
如何使转义不生效：
a. 在字符串前面加 ’r‘ 可以使整个字符串原样输出，即不会被转义
print(r'hello world\t\n\b') 运行结果：
b. 再加一个反斜杠
print('hello\\t\\n\\b world') 运行结果：
（3）常见字符串操作
a. 字符串长度
用 len() 函数，可以查看字符串长度
print(len('hello world')) 运行结果：
注意：字符串中的空格也占 1 个长度，中文，字母，数字，符号占 1 个长度，空字符串长度为 0，转义字符的字符长度是把每个转义字符当成 1 个字符，故占 1 个长度，而不是看上去的 2 个，如：\t，\n
b. 字符串连接
通过加号连接字符串
print('hello' + ' ' + 'world') 运行结果：
c. 字符串索引
Python 有 2 种索引方式：
从前向后的正向索引：有 m 个字符长度的字符串，索引值是 0 ~ m-1
从后向前的反向索引：有 m 个字符长度的字符串，索引值是 -1 ~ -m
string = 'python'
print(string[0], string[5])
print(string[-1], string[-6]) 运行结果：
如果下标索引越界了，则会报错：
string = 'python'
print(string[7]) 运行结果：
d. 字符串切片
切片：即取出字符串中的子字符串
切片最标准的写法是用 2 个冒号分割 3 个数字，如：string[0:-1:2]
第 1 个数字表示切片的起始位置（可省略不写，则从第 1 个字符开始）
第 2 个数字表示切片的终止位置（切出的子串不包含这个字符，可省略不写，则以最后个字符结尾且包含该字符）
第 3 个数字表示切片的步长（步长为 1 时，可省略不写第 2 个冒号及步长）如：string[0:-1]
string = 'python'
print(string[0:-1]) # 切出除最后个字符外的所有字符
print(string[:-1]) # 切出除最后个字符外的所有字符
print(string[0:]) # 切出所有字符
print(string[:]) # 切出所有字符
print(string[::]) # 切出所有字符
print(string[0:-1:2]) # 按步长为2，切出除最后个字符外的字符
print(string[::-1]) # 逆序切出所有字符 运行结果：
注意：切片越界，不会报错
string = 'python'
print('运行结果：', string[7:])
print('运行结果：', string[:7]) 运行结果：
3. 列表 list
列表是 Python 特有的数据类型，Java 中的数据跟它有一点点类似，Python 提供了列表这种数据类型来存储由多个值构成的序列，可以同时存储多种数据类型，也可以嵌套其他列表
（1）创建列表
不同数据项之间由逗号分隔，整体放在一个方括号里，这就是列表
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
print(ls) 运行结果：
那么，如何定义一个空列表呢？
ls = [] 是不是很简单？
（2）列表的基本操作
a. 通过索引取出列表的元素
方法：列表名[索引] （索引从 0 开始计数）
那我们来取出一下上个例子中的嵌套索引及嵌套索引的元素
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
print(ls[6], ls[6][0]) 运行结果：
那我们再试试，取出不存在的索引会是怎样的结果呢？
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
print(ls[7]) 运行结果：
直接抛出错误
与字符串相同，当我们想取出最后一个时，可以直接取索引为 -1 的值
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
print(ls[-1]) 运行结果：
b.使用加号连接列表
ls1 = [1, 2, 3]
ls2 = ['a', 'b', 'c']
print(ls1 + ls2) 运行结果：
直接使用加号将两个列表相加，会产生一个新列表，包含列表 1 和列表 2 的元素
c. 列表元素复制
ls = [1, 2, 3]
print(ls*3) 运行结果：
列表 * 复制次数，将生成一个新列表，元素为前一个列表的元素复制次数
d. 求列表长度
ls = [1, 2, 3, [8, 5, 7]]
print(len(ls)) 运行结果：
求列表长度将用到 len() 函数
e. 遍历列表元素
通过循环的方式进行遍历：
ls = [1, 2, 3, [8, 5, 7]]
for i in ls:
print(i) 运行结果：
f. 检查列表中是否存在某个元素
使用 in 关键字，返回值为布尔值
ls = [1, 2, 3, [8, 5, 7]]
print(8 in ls)
print([8, 5, 7] in ls) 运行结果：
g. 删除列表
使用 del 关键字，手动删除列表（亦可等系统自动回收）
ls = [1, 2, 3, [8, 5, 7]]
del ls
print(ls)运行结果：
删除之后，就无法使用了
h. 删除列表中索引为 i 的元素
也是使用 del 关键字来删除，指定下标的元素
ls = [1, 2, 3, [8, 5, 7]]
print(ls[0])
del ls[0]
print(ls[0])
print(ls) 运行结果：
删除过后，会将后续元素下标往前挪一位
i. 返回列表中最大值与最小值
ls = [1, 2, 3]
print(max(ls))
print(min(ls)) 运行结果：
只能适用于元素只存在 int、bool、float 或 只存在字符串且都没有嵌套列表的情形
ls = [1, 2, 3, [8, 5, 7]]
print(max(ls))
print(min(ls)) 否则，会直接报错：
（3）列表切片
列表切片指的是将列表的一部分切出来，有点像字符串切片
列表切片的形式：list[起始索引:终止索引（不包含）:步长]（1. 省略起始索引，默认为 0 2. 省略索引位置，默认为最后一个且包含 3. 省略步长，默认为 1）
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
print(ls[:])
print(ls[::])
print(ls[1:5:2]) 运行结果：
逆序切片，也与字符串相似
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
print(ls[:-1])
print(ls[::])
print(ls[-5:-1:2]) 运行结果：
我们再试一下骚操作，正向切片起始索引大于终止索引，逆向切片起始索引小于终止索引：
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
print(ls[-1:-5:2])
print(ls[5:1]) 运行结果：
不会报错哦，只是没有切出内容
（4）修改列表元素
列表是一种可变的数据类型，所以可以修改其元素
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
print(ls)
ls[1] = 'Python'
print(ls) 运行结果：
除了通过索引修改，还能通过切片的方式进行修改
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
print(ls)
ls[1:3] = 'a'
print(ls) 运行结果：
新插入的元素数量小于切片的元素数量，列表长度会变短，那如果插入的是字符串或是列表会是什么结果呢？
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
ls[-3:-1] = ['n', 'e', 'w']
print(ls) 运行结果：
没想到吧，对于列表，并不是单纯的修改并使列表长度变短，而是把元素插入进去
（5）列表的一些方法
就是操作列表的一些函数
| 方法 | 描述 |
|---|---|
| list.append(obj) | 在列表末尾添加新对象 |
| list.count(obj) | 返回某个元素在列表中出现的次数 |
| list.extend(seq) | 在列表末尾添加另一个列表的所有元素 |
| list.index(obj) | 返回第一个匹配元素的索引值 |
| list.insert(index, obj) | 在指定索引插入对象 |
| list.pop(index) | 移除指定索引的值，并返回该值 |
| list.remove(obj) | 移除第一个匹配的某对象 |
| list.sort() | 对原列表进行排序 |
| list.reverse() | 反转列表元素 |
接下来，依次进行演示：
a. list.append(obj) 在列表末尾添加新对象
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
ls.append(['a', 'p', 'p'])
print(ls) 运行结果：
b. list.count(obj) 返回某个元素在列表中出现的次数
ls = [1, 2, 3, 4, 1, 'a', 'b', [1, 2, 3]]
print(ls.count(1)) 运行结果：
c. list.extend(seq) 在列表末尾添加另一个序列的所有元素
ls = [1, 2, 3, 4, 1, 'a', 'b', [1, 2, 3]]
ls2 = ['a', 'p', 'p']
ls.extend(ls2)
print(ls) 运行结果：
d. list.index(obj) 返回第一个匹配元素的索引值
ls = [1, 2, 3, 4, 1, 'a', 'b', [1, 2, 3]]
print(ls.index(1)) 运行结果：
若不存在则会报错：
ls = [2, 3, 4, 'a', 'b', [1, 2, 3]]
print(ls.index(1)) 运行结果：
e. list.insert(index, obj) 在指定索引之前插入对象
ls = [1, 2, 3, 4, 1, 'a', 'b', [1, 2, 3]]
ls.insert(0, ['a', 'p', 'p'])
print(ls) 运行结果：
那我们指定的索引不存在呢？
ls = [1, 2, 3, 4, 1, 'a', 'b', [1, 2, 3]]
ls.insert(20, ['a', 'p', 'p'])
print(ls)运行结果：
超过最大索引，则会插入在最后一个位置上
f. list.pop(index) 移除指定索引的值，并返回该值
ls = [1, 2, 3, 4, 1, 'a', 'b', [1, 2, 3]]
value = ls.pop(-1)
print(ls)
print(value) 运行结果：
g. list.remove(obj) 移除第一个匹配的某对象
ls = [1, 2, 3, 4, 1, 'a', 'b', [1, 2, 3]]
ls.remove(1)
print(ls) 运行结果：
h. list.sort() 对原列表进行排序
ls = [8, 5, 7, -1, 9, 0, -1]
ls.sort()
print(ls) 运行结果：
默认升序排列，如果要降序，该怎么实现呢？
ls = [8, 5, 7, -1, 9, 0, -1]
ls.sort(reverse=True)
print(ls) 运行结果：
另外，只能对纯字符或纯数字排序，否则会报错哦
ls = [8, 5, 7, -1, 9, 0, -1, 'a', 'b', 'c']
ls.sort()
print(ls) 运行结果：
i. list.reverse() 反转列表元素
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
ls.reverse()
print(ls) 运行结果：
（6）删除列表中的元素
a. del 关键字可以删除整个列表或者列表中的元素
删除指定索引元素：
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
del ls[0]
print(ls) 运行结果：
切片删除：
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
del ls[:3]
print(ls) 运行结果：
删除整个列表：
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
del ls
print(ls) 直接报错：
（7）列表生成式
在 Python 中，列表生成式体现了 Python 优雅的特色
直接上例子，创建一个元素是 1 - 10 的平方的列表：
ls = [i*i for i in range(11)]
print(ls) 运行结果：
一行代码就可以优雅的搞定啦！
对于双重或多重循环使用列表生成式，该如何生成列表呢？
将九九乘法口诀表放入列表：
ls = [f'{i} x {j} = {i*j}' for i in range(1, 10) for j in range(1, 10) if i <= j]
print(ls) 运行结果：
4. 元组 tuple
元组是 Python 中的另一种特色的数据类型，和列表很相似，同样可以存储不同的数据类型，但是它是不可变对象，即：创建后就不可进行任何元素修改操作
（1）创建元组
用逗号对元素进行分隔就是元组，但是为了美观以及代码的可读性，一般还会加上小括号
a = 1, 2, 3
b = (1, 2, 3)
print(type(a))
print(type(b))
print(a == b) 运行结果：
那我们看看修改不可变对象元素会报什么错：
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
tp[0] = 100
print(tp) 运行结果：
如果元组里的元素有可变对象，则这个可变的元素是可以被修改的，例如，元组嵌套列表：
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
print(tp)
tp[6][0] = 100
print(tp) 运行结果：
特殊情况：
a. 创建一个元素的元组时，需要加逗号（加括号只是为了习惯写法，更加美观，易理解）
tp = (1, )
print(type(tp)) 运行结果：
b. 创建空元组
tp = tuple()
tp2 = ()
print(type(tp))
print(type(tp2))
print(tp)
print(tp2)
print(tp == tp2) 运行结果：
创建空元组有两种方式，直接使用空的小括号或者使用 tuple()方法
（2）元组的基本操作
和列表类似，元组也有很多基本操作：索引、切片、连接、复制、对内部元素循环、查找元组中是否存在某元素、删除元组、返回元组中最大值及最小值等等
a. 索引
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
print(tp[0])
print(tp[-1]) 运行结果：
b. 切片
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
print(tp[4:6])
print(tp[::-1]) 运行结果：
c. 连接
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
tp2 = (['a', 'p', 'p'], )
print(tp + tp2) 运行结果：
d. 复制
tp2 = (['a', 'p', 'p'], )
print(tp2 * 2) 运行结果：
e. 对内部元素循环
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
for i in tp:
print(i) 运行结果：
f. 查找元组中是否存在某元素
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
tp2 = (['a', 'p', 'p'], )
print('a' in tp)
print('a' in tp2) 运行结果：
g. 删除元组
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
del tp
print(tp) 删除后，报错 tp 变量未定义：
那如果删除元素会怎样呢？
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
del tp[0]
print(tp) 由于元组是不可变对象，所以不能删除元素，直接报错：
h. 返回元组中最大值及最小值
tp = (1, 2, 3, 4, -1)
print(max(tp))
print(min(tp)) 运行结果：
同样，只能适用于元素只存在 int、bool、float 或 只存在字符串且都没有嵌套列表的情形，否则就会报错
tp = ('a', 'b', 'c', ['d', 'e'])
print(max(tp))
print(min(tp)) 运行结果：
最后再试试，修改元组元素：
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
tp[0] = 4 运行结果：
由于元组是不可变对象，所有元素不可修改，并且列表中的这些方法均不可对元组使用：
pop()、append()、extend()、remove()、index()
(3)元组和列表相互转化
tp = (1, 2, 3, 4, 'a', 'b', [8, 5, 7])
ls = list(tp)
print(ls)
tp2 = tuple(ls)
print(tp2) 运行结果：
元组转换成列表，只需要使用 list() 函数即可，同样，列表转换成元组，也只需要使用 tuple() 函数
再演示一个元组和列表生成式的配合使用：
ls = [(a, b) for a in 'ABC' for b in 'abc']
print(ls) 运行结果：
如果我们只想要配对的大小写，该怎么操作？
ls = [(a, b) for a in 'ABC' for b in 'abc' if a.lower() == b]
print(ls) 运行结果：
其中，lower() 函数，用于将字符串转换为小写字符，同样转换大写字符的函数是 upper()
(4)元组解包
其实，我们在创建元组的时候，是在对其进行打包，即：把元素放进元组里
那解包，就是把元组的元素依次赋值给单个变量
tp = 1, 2, 3, 4 # 打包
print(tp)
a, b, c, d = tp # 解包
print(a, b, c, d) 运行结果：
如果左边元素个数多写了会怎样呢？
tp = 1, 2, 3, 4 # 打包
a, b, c, d, e = tp # 解包
print(a, b, c, d) 运行结果：
有多就有少，那少了呢？
tp = 1, 2, 3, 4 # 打包
a, b, c = tp # 解包
print(a, b, c) 运行结果：
多与少都会报错哦，所以元组拆包，数量必须一一对应哦
那列表和元组如此类似，但是元组的方法比列表少，那元组与列表相比的优势又是什么呢？
1. 元组的运算速度比列表快，如果你经常要遍历一个序列，且不需要修改内容，用元组比列表好
2. 元组相当于给数据加了保护（不可修改），有些场合需要这种特性
5. 集合 set
集合是一种不重复的无序集，用花括号{}来定义
集合的元素是无序的、不可重复的、必须是不可变类型
集合的元素是无序的：
st = {1, 2, 3}
st2 = {3, 2, 1}
print(st == st2) 运行结果：
集合的元素是不可重复的：
st = {1, 1}
print(st) 创建集合时，有重复的元素不会报错，只会保留1个，运行结果：
集合的元素必须是不可变类型：
st = {1, [1, 2, 3]}
print(st) 运行结果：
集合的的元素必须是不可变类型，和字典中的键一样，集合可以理解为，只有键的字典
（1）集合的创建
a. 直接使用大括号创建
集合的元素可以是，数字、字符串、元组
st = {1, 2, 3, 'python', ('a', 1)}
print(st)
print(type(st)) 运行结果：
创建空集合
使用 set() 函数，而不是{}（空字典）
st = set()
dt = {}
print(type(st))
print(type(dt)) 运行结果：
b. 使用列表或元组创建
可以使用 set() 函数，将不包含可变对象元素的列表或元组转换成集合
ls = [1, 2, 3, 4]
st = set(ls)
print(st)
print(type(st)) 运行结果：
那包含可变对象会是什么结果呢？
ls = [1, 2, 3, 4, [1, 2, 3]]
st = set(ls)
print(st)
print(type(st)) 运行结果：
c. 使用字符串创建
st = set('Python')
print(st)
print(type(st)) 字符串得到的集合，元素是所有不重复的字符，可以很直观的看出，集合的元素是无序的：
（2）集合的常用方法
a. set.add(x) 向集合添加元素
st = {1, 2, 3, 4}
print(st)
st.add(0)
print(st) 运行结果：
同样，set.add() 函数，参数不能是可变对象
st = {1, 2, 3, 4}
print(st)
st.add([0, 5, 6])
print(st) 运行结果：
b. set.update(iterable) 将一个可迭代对象的元素添加到集合
st = {1, 2, 3, 4}
iterable = ['a', 'b', 'c']
st.update(iterable)
print(st) 运行结果：
c. set.pop() 将集合的第一个元素删除，并返回被删除元素的值
st = {1, 2, 3, 4}
iterable = ['a', 'b', 'c']
st.update(iterable)
print(st)
p = st.pop()
print(st, p) 运行结果：
d. set.remove(x) 删除集合中的指定元素
st = {1, 2, 3, 4}
st.remove(1)
print(st) 运行结果：
若被删除的元素不存在，则会报错：
st = {1, 2, 3, 4}
st.remove(0)
print(st) 运行结果：
e. set.discard(x) 与 set.remove() 函数的作用一样，删除集合中的指定元素
st = {1, 2, 3, 4}
st.discard(1)
print(st) 运行结果：
set.discard() 与 set.remove() 函数的不同点在于，若被删除的元素不存在，不会报错：
st = {1, 2, 3, 4}
st.discard(0)
print(st) 运行结果：
f. set.clear() 清空集合
st = {1, 2, 3, 4}
st.clear()
print(st) 运行结果，打印一个空集合：
（3）集合的数学运算
高中我们就学过集合的在数学中的运算——文氏图
Python 集合常用运算有：交集、并集、差集
a. set1.intersection(set2) 两个集合的交集
st1 = {1, 2, 3, 4}
st2 = {0, 2, 4, 6}
print(st1.intersection(st2)) 运行结果：
b. set1.union(set2) 两个集合的并集
st1 = {1, 2, 3, 4}
st2 = {0, 2, 4, 6}
print(st1.union(st2)) 运行结果：
c. set1 - set2 两个集合的差集
st1 = {1, 2, 3, 4}
st2 = {0, 2, 4, 6}
print(st1 - st2) 运行结果：
d. 集合的其他数学运算
判断集合是否在集合中，使用 in 关键字：
st = {1, 2, 3}
print(1 in st)
print(0 in st) 运行结果：
set2.issubse(set1) t判断集合 set2 是否是集合 set1 的子集：
st1 = {1, 2, 3}
st2 = {2, 3}
print(st2.issubset(st1)) 运行结果：
6. 字典 dict
（1）创建字典
字典，即键值对，一个键，对应着一个值
形式：{键1:值1, 键2:值2}，每个键值对用冒号隔开，每对键值对用逗号隔开
dict1 = {'name': 'zhangsan', 'age': 18}
print(dict1) 运行结果：
注意：键必须是唯一的，且必须是不可变的。如：字符串，数字，元组，但是值可以是任意数据类型
我们试一下这三个键：
dt = {'name': 'zhangsan', 1: 123, (1, ): [1, 2, 3]}
print(dt) 运行结果：
那存在相同的键会怎样呢？
dt = {'name': 'zhangsan', 'name': 'lisi'}
print(dt) 然而，它并没有报错，只是后面的值覆盖了前面的值：
那如果键是可变对象呢？
dt = {[1, 2, 3]: 'zhangsan'}
print(dt) 这就必然会报错了哦
那如何创建空字典呢？
dt1 = {}
dt2 = dict()
print(dt1)
print(dt2)
print(dt1 == dt2) 同样的，与列表和元组相似，两种方法都可以创建
第一种，直接通过空的大括号创建，第二种，借助 dic() 函数来创建
dict() 函数同样可以创建非空字典（列表或元组，嵌套列表或元组）：
dt = dict([['name', 'zhangsan'], ['age', 18]])
print(dt) 运行结果：
使用 dict() 函数还可以这样来创建：
dt = dict(name='zhangsan', age=18)
print(dt) 运行结果：
这种情况下，键只能为字符串，并且创建的时候作为键的字符串不用加引号
（2）访问字典中的值
和列表、元组索引类似，字典可以通过键来访问对应值
dt = dict(name='zhangsan', age=18)
print(dt['name']) 运行结果：
那如果被访问的键不存在会怎样呢？
dt = dict(name='zhangsan', age=18)
print(dt['gender']) 会直接报错：
同样，可以通过 in 关键字来判断字典是否存在某个键：
dt = dict(name='zhangsan', age=18)
print('name' in dt)
print('gender' in dt) 运行结果：
（3）更新字典
添加、删除、修改字典中的键值对：
dt = dict(name='zhangsan', age=18)
dt['gender'] = '男' # 增加键值对
print(dt)
del dt['age'] # 删除键值对
print(dt)
dt['name'] = 'zhang3' # 修改键值对
print(dt) 运行结果：
（4）字典的操作
Python 对于字典这个数据类型，提供了很多函数：
a. dict.keys() 返回包含所有键的列表的dict_keys对象，该对象可以直接转换成列表、元组、集合
dt = dict(name='zhangsan', age=18, gender='男')
print(dt.keys())
print(list(dt.keys())) 运行结果：
b. dict.values() 返回包含所有值的列表的dict_values对象，该对象可以直接转换成列表、元组、集合
dt = dict(name='zhangsan', age=18, gender='男', a=18)
temp = dt.values()
print(temp)
print(list(temp)) 运行结果：
c.dict.items() 返回包含所有键值对元组的列表的dict_values对象，该对象可以直接转换成列表、元组、集合、字典
dt = dict(name='zhangsan', age=18, gender='男', a=18)
temp = dt.items()
print(temp)
print(list(temp)) 运行结果：
d. dict.clear() 清空字典，即删除字典中的所有元素，无返回值
dt = dict(name='zhangsan', age=18, gender='男', a=18)
dt.clear()
print(dt) 元素清空后，运行不会报错，打印一个空字典：
e. dict.get(key, default=None) 返回字典中的指定 key 的 value 值，若 key 值不存在，则返回default值（default 默认为 None）
dt = dict(name='zhangsan', age=18, gender='男', a=18)
print(dt.get('name'))
print(dt.get('size', '默认值')) 运行结果：
f. dict.pop(key[, default]) 删除字典中的指定 key 值并返回其 value 值，若 key 值不存在，则返回 default 值
dt = dict(name='zhangsan', age=18, gender='男', a=18)
print(dt.pop('name'))
print(dt.pop('size', '默认值'))
print(dt) 运行结果：
若未指定 default 值，则报错：
dt = dict(name='zhangsan', age=18, gender='男', a=18)
print(dt.pop('name'))
print(dt.pop('size'))
print(dt) 运行结果：
g. dict.update(dict_obj) 将字典 dict_obj 的所有键值对添加到 dict 中，相同的 key 值会更新其 value 值
dt = dict(name='zhangsan', age=18, gender='男', a=18)
dt2 = dict(name='lisi', b=18)
dt.update(dt2)
print(dt) 运行结果：
（5）字典的遍历
a. 通过 key 值遍历
dt = dict(name='zhangsan', age=18, gender='男', a=18)
for key in dt.keys():
print(key, dt[key]) 运行结果：
b. 通过对 dict.items() 拆包，直接遍历
dt = dict(name='zhangsan', age=18, gender='男', a=18)
for key, value in dt.items():
print(key, value) 运行结果：
（6）字典的复制
当我们需要复制一份相同的字典，应该怎么操作呢？
dt = dict(name='zhangsan', age=18, gender='男', a=18)
dt2 = dt
dt2['name'] = 'lisi'
print(dt)
print(dt2)
print(id(dt))
print(id(dt2)) 运行结果：
用赋值号来实现复制，修改新的列表，会影响到旧的列表，并且 id 都是一样的，说明它们其实是同一个，这称为浅复制，只是复制了一个引用
相应的，可以引入 copy 模块来实现深拷贝
import copy
dt = dict(name='zhangsan', age=18, gender='男')
dt2 = copy.deepcopy(dt)
dt2['name'] = 'lisi'
print(dt)
print(dt2)
print(id(dt))
print(id(dt2)) 运行结果：
