python中的数据结构
文章目录
- 字符串
-
- 字符串简介
- 转义字符
- 字符串格式化
- 字符串中相关方法
- 列表
-
- 列表简介
- 遍历列表元素
- 列表切片（子序列）
- 列表中相关方法
- 字典
-
- 字典简介
- 创建字典
- 字典的基本用法
- 字典中的常用方法
- 使用字典格式化字符串
字符串
字符串简介
字符串就是‘一串字符’，在python中使用单引号或者双引号括起来的一串字符，单引号和双引号字符串不能换行。使用三单引号，或者三双引号的字符串可以换行，即定义长字符串。
str1 = 'wenxinjin'
str2 = "wenxinjin"
str3 = """wenxin
jin"""
str4 = '''wenxin
jin'''
print(type(str1),type(str2),type(str3),type(str4))
#运行结果：
<class 'str'> <class 'str'> <class 'str'> <class 'str'>
Process finished with exit code 0
对于字符串本身包含单引号或者双引号的处理；
方式一：使用不同的引号将字符串括起来
str1 = "wenxin'jin"
print(str1)
方式二：使用转义字符，对引号进行转义
str2 = 'wenxin\'jin'
print(str2)
#运行结果：
wenxin'jin
wenxin'jin
Process finished with exit code 0
字符串拼接
python中使用（+）作为字符串的拼接运算符。
str1 = 'wen'
str2 = 'xin'
print(str1+str2)
#运行输出结果：
wenxin
Process finished with exit code 0
repr()和str()
使用str()和repr()函数可以将其他数据类型的数据转换成字符串。
在交互式解释器中输入一个变量或者一个表达式，python会自动使用repr()函数处理变量或表达式，因此会看到字符串带着双引号。
str1 = 'wenxinjin'
str11 = str(str1)
str12 = repr(str1)
print(str11,str12,sep='\n')
#运行输出结果：
wenxinjin
'wenxinjin'
Process finished with exit code 0
原始字符串
原始字符串以（r）开头，原始字符串不会把反斜杠当成特殊字符。
如果原始字符串中包含引号，程序同样需要使用反斜杠对引号进行转义，由于有原始字符串，反斜杠会成为字符串的一部分。
encode和decode
str_byte = '学习python真辛苦！'.encode('utf-8')
print(str_byte)
#运行输出结果：
b'\xe5\xad\xa6\xe4\xb9\xa0python\xe7\x9c\x9f\xe8\xbe\x9b\xe8\x8b\xa6\xef\xbc\x81'
Process finished with exit code 0
str_byte = '学习python真辛苦！'.encode('utf-8')
print(type(str_byte))
print(str_byte)
str1 = str_byte.decode('utf-8')
print(str1)
#运行输出结果：
<class 'bytes'>
b'\xe5\xad\xa6\xe4\xb9\xa0python\xe7\x9c\x9f\xe8\xbe\x9b\xe8\x8b\xa6\xef\xbc\x81'
学习python真辛苦！
Process finished with exit code 0
转义字符
python中常见的转义字符
| 转义字符 | 字符说明 |
|---|---|
| \b | 退格符 |
| \n | 换行符 |
| \r | 回车符 |
| \t | 制表符 |
| \" | 双引号 |
| \’ | 单引号 |
| \\ | 反斜杠 |
字符串格式化
str1 = 'wenxinjin'
print('%s正在学习python'%str1)
#运行输出结果：
wenxinjin正在学习python
Process finished with exit code 0
以%开头的转换说明符对各种类型的数据进行输出；格式化字符串中的“%s"被称为转换说明符（Conversion Specifier），相当于一个占位符，它会被后面表达式（变量、常量、数字、字符串、加减乘除等各种形式）的值代替。
python中提供的转换说明符
| 转换说明符 | 解释说明 |
|---|---|
| %d,%i | 转换为带符号的十进制整数 |
| %o | 转换为带符号的八进制整数 |
| %x，%X | 转换为大夫好的十六进制整数 |
| %e | 转换为科学计数法表示的浮点数（e小写） |
| %E | 转换为科学计数法表示的浮点数（E大写） |
| %f，%F | 转换为十进制的浮点数 |
| %g | 智能选择使用f或e格式 |
| %G | 智能选择F或E格式 |
| %c | 转换为单字符（只接受整数或单字符字符串） |
| %r | 使用repr()函数将变量或表达式转换为字符串 |
| %s | 使用str()函数将变量或表达式转换为字符串 |
格式化字符串可以包含多个转换说明符，这时需要提供多个变量或者表达式，且使用括号括起来，一一对应。
a = 'wenxinjin'
b = 18
c = '陕西'
print('%s今年%d,家是%s的'%(a,b,c))
#运行输出结果：
wenxinjin今年18,家是陕西的
Process finished with exit code 0
可以使用如下方式，对格式进行进一步控制：
%[(name)][flags][width].[precision]typecode
(name) 为命名；
flags 可以有+、-、0等，+表示在正数前加上正号，-表示右对齐，0表示用对齐是空的位置用0填充 ；
width 表示宽度；
precision 表示小数点后精度；
typecode 表示类型；
width和precision 为整数，我们可以使用*来动态的代入这两个量。
指定最小输出宽度
宽度不够时前面默认使用空格补足，当数值大于最小宽度时，将原数据输出，不增也不减。
num1 = 30
#指定最小宽度为6
print('宽度为6：%6d'%num1)
#指定最小宽度为1
print('宽度为1：%1d'%num1)
#运行输出结果：
宽度为6： 30
宽度为1：30
Process finished with exit code 0
指定对齐方式
python中支持如下方式：
-：指定左对齐
+：表示数值总要带着符号（正数带”+“，负数带”-“）
0：表示不补充空格，补充0
num1 = 123456.1
#宽度为10，左对齐，带符号
print('%-+10f'%num1)
#宽度为10，0补足,转换为整数
print('%010d'%num1)
str1 = 'wenxin'
#宽度为10，左对齐
print('%-10s..'%str1)
#运行输出结果：
+123456.100000
0000123456
wenxin ..
Process finished with exit code 0
指定小数精度
print() 还允许指定小数点后的数字位数，也即指定小数的输出精度。精度值需要放在最小宽度之后，中间用点号（.）隔开；也可以不写最小宽度，只写精度。
float1 = 123.456
#算上小数点，前面补齐的9个空格一共20位
print('%20.7f'%float1)
#只以0补齐小数位
print('%.7f'%float1)
#运行输出结果：
123.4560000
123.4560000
Process finished with exit code 0
字符串中相关方法
python字符串由内建的str类代表，可以使用dir()查看所包含的全部内容（函数、方法、类、变量等），其中以"__“开头和”__”结尾的方法是私有方法，不希望被外部直接调用。使用help()函数可以查看函数或方法的帮助文档。
print(dir(str))
#运行输出结果：
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
Process finished with exit code 0
print(help(str.count))
#运行输出结果：
Help on method_descriptor:
count(...)
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
None
Process finished with exit code 0
索引介绍
字符串本质上是由多个字符组成的，因此程序允许通过索引来操作字符串，索引即指字符在字符串中的位置编号；python中在（[]）中使用索引来获取对应的字符。
从左往右，第一个字符的索引为0，第二个为1，以此类推；从右往左，第一个字符的索引为-1，倒数第二个为-2，以此类推；
str1 = "wen"
#获取第一个字符
print(str1[0])
#获取第二个字符
print(str1[-1])
#运行输出结果：
w
n
Process finished with exit code 0
获取索引编号的方法是index()，输出的编号都是从左往右计算。
str1 = "wen"
print(str1.index('w'))
print(str1.index('n'))
#运行输出结果：
0
2
Process finished with exit code 0
字符串切片
字符串切片就是利用索引获取字符串中的片段；
语法格式：
[a:d:c] 其中a为起始索引默认从0开始，b为结束索引不会获取到b的字符默认以结尾结束（这里会包括结尾），c为步长
str1 = 'wenxinjin'
print(str1[1:5])
print(str1[:5])
print(str1[1:])
print(str1[1:6:2])
print(str1[-6:-2])
#运行输出结果：
enxi
wenxi
enxinjin
exn
xinj
Process finished with exit code 0
in运算符使用
#判断str1中是否包含子串
str1 = 'wenxinjin'
print('wen' in str1)
print('jinw' in str1)
#运行输出结果：
True
False
Process finished with exit code 0
len()函数的使用
#输出字符串的长度
str1 = 'wenxinjin'
print(len(str1))
#运行输出结果：
9
Process finished with exit code 0
min()和max()函数的使用
#获取字符串中的最小字符和最大字符，按照ASCII码表的先后顺序判断
str1 = 'wenxinjin'
print(min(str1))
print(max(str1))
#运行输出结果：
e
x
Process finished with exit code 0
字母大小写方法
title()：将每个单词的首字母改为大写
lower()：将整个字符串改为小写
upper()：将整个字符串改为大写
str1 = 'wen xin jin'
print(str1.title())
str2 = 'Wen xIN JIn'
print(str2.lower())
print(str2.upper())
#运行输出结果：
Wen Xin Jin
wen xin jin
WEN XIN JIN
Process finished with exit code 0
字符串前后空格处理
strip()：删除字符串前后的空格
lstrip()：删除字符串前面的（左边）的空格
rstrip()：删除字符串后面的（右边）的空格
python中str是不可变的，因此使用这三个方法返回的字符串是副本
str1 = ' wenxinjin '
a = ','
print(a,str1.strip(),a,sep='')
print(a,str1.lstrip(),a,sep='')
print(a,str1.rstrip(),a,sep='')
print(a,str1,a,sep='')
#运行输出结果：
,wenxinjin,
,wenxinjin ,
, wenxinjin,
, wenxinjin ,
Process finished with exit code 0
查找、替换方法
startswith()：判断字符串是否以指定子串开头；
endswith()：判断字符串是否以指定的子串结尾；
find()：查找指定子串在字符串中出现的位置，如果没有找到指定子串，则返回-1。
index()：查找指定子串在字符串中出现的位置，如果没有找到指定子串，引发ValueError错误；
replace()：使用指定子串替换字符串中的目标子串；
translate()：使用指定的翻译映射表对字符串执行替换； 有待考证
str1 = 'wenxinjin'
print(str1.startswith('wen'))
print(str1.endswith('jin'))
print(str1.find('x'))
print(str1.index('x'))
print(str1.replace('xin','new'))
#将字符串中的所有in替换成ing
print(str1.replace('in','jing'))
#将字符串中的1个in替换成ing
print(str1.replace('in','jing',1))
#运行输出结果：
True
True
3
3
wennewjin
wenxjingjjing
wenxjingjin
Process finished with exit code 0
join()和split()方法
split()：将字符串按指定分隔符分割成多个子串，并以列表的形式返回数据；
join()：将列表中的元素连接成字符串
str1 = 'wen,xin,jin'
list1 = ['I','LOVE','wenxinjin']
print(str1.split(','))
print(' '.join(list1))
print(str1,list1)
#运行输出结果：
['wen', 'xin', 'jin']
I LOVE wenxinjin
wen,xin,jin ['I', 'LOVE', 'wenxinjin']
Process finished with exit code 0
列表
列表简介
列表按顺序保存元素，每个元素都有自己的序列，可以通过索引访问元素，列表是可变的，程序可以修改列表所包含的元素。
（1）列表中的元素是定义在[]中
（2）元素和元素之间是用英文逗号(,)分隔的(不能用别的符号)
（3）列表当中的元素可以是任意数据类型
（4）列表是可变的,可以增删改查
#创建列表的语法格式：
list_exp = ['wen1','wen2','wen3','...']
print(type(list_exp))
list_exp1 = list(range(1,5))
print(list_exp1)
list_exp2 = list(range(1,9,2))
print(list_exp2)
#运行输出结果：
<class 'list'>
[1, 2, 3, 4]
[1, 3, 5, 7]
Process finished with exit code 0
遍历列表元素
列表的元素可以通过索引来访问，元素的索引都是从0开始的，第1个元素的索引为0，第二个元素的索引为1…依次类推；也支持使用负数索引，倒数第1个元素的索引为-1，倒数第2个元素的索引为-2…依次类推。
list_exp = ['wen','xin',66,'...',False,6.6]
print(list_exp)
for item in list_exp:
print(item)
print('*'*50)
for index in range(len(list_exp)):
print(list_exp[index])
print('*'*50)
print(list_exp[1])
print(list_exp[0])
print(list_exp[-1])
print(list_exp[-2])
#运行输出结果：
['wen', 'xin', 66, '...', False, 6.6]
wen
xin
66
...
False
6.6
**************************************************
wen
xin
66
...
False
6.6
**************************************************
xin
wen
6.6
False
Process finished with exit code 0
列表切片（子序列）
使用索引获取列表中元素的片段，这种方法就是切片（slice）。
切片的格式：
[start_index:end_index:step]
start_index、end_index两个索引值都可以使用正数或负数，其中负数表示从倒数开始。获取从star_index（包含）开始，到end_index（不包含）结束的列表片段；
step表示步长，是正数，默认值是1。
list_exp = ['wen','xin',66,'...',False,6.6,-9,'crazy']
list_slice1 = list_exp[1:4]
print(list_slice1)
print(list_exp[1:7:2])
print(list_exp[-6:-2])
print(list_exp[1:-2])
print(list_exp[-6:7])
#运行输出结果：
['xin', 66, '...']
['xin', '...', 6.6]
[66, '...', False, 6.6]
['xin', 66, '...', False, 6.6]
[66, '...', False, 6.6, -9]
Process finished with exit code 0
列表中相关方法
在解释器中输入dir(list)即可看到列表包含的所有方法
print(dir(list))
#运行输出结果：
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
Process finished with exit code 0
加法
两个列表相加获得的就是两个列表元素的总和。
list1 = [1,2,3,4]
list2 = [5,6,7,8]
list_sum = list1 + list2
print(list_sum)
print(list1,list2)
#运行输出结果：
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4] [5, 6, 7, 8]
Process finished with exit code 0
乘法
列表和整数相乘，列表元素就会重复乘数的倍数
list1 = [1,2,'wen']
list2 = list1 * 3
print(list2)
#运行输出结果：
[1, 2, 'wen', 1, 2, 'wen', 1, 2, 'wen']
Process finished with exit code 0
查询元素的索引：
list_exp = ['wen','xin',66,'...',False,6.6]
print(list_exp.index(66))
#运行输出结果：
2
Process finished with exit code 0
in运算符
in运算符用于判断列表或元组是否包含某个元素。
list1 = [1,2,'wen','xin','jin']
print('wen' in list1)
print('liu' in list1)
#运行输出结果：
True
False
Process finished with exit code 0
列表元素个数，最大值，最小值
len()函数用来获取列表中元素的个数；
max()、min()对列表中的元素比较大小，因此列表中的元素必须是相同的类型，且可以比较大小。
list1 = [1,2,'wen','xin','jin']
print(len(list1))
#运行输出结果：
6
Process finished with exit code 0
list1 = [1,2,6,0,-9,0.6]
print(max(list1))
print(min(list1))
list2 = ['wen','xin','jin']
print(max(list2))
print(min(list2))
list3 = [True,False,2,-1]
print(max(list3))
print(min(list3))
#运行输出结果：
6
-9
xin
jin
2
-1
Process finished with exit code 0
增加列表元素
增加列表元素方法有三个：
append()：将参数追加到列表的最后面，如果传入元组或者列表，会当成整个元素；
extend()：也是将元素追加到列表后面，如果是传入的参数是元组或者列表，只是将元素追加到列表后面；
insert()：需要指定元素插入列表的位置。
list1 = ['wen','xin','jin','jia','you']
list2 = ['wen','xin','jin','jia','you','good']
list1_return = list1.append('good')
print(list1)
print(list1_return)
list1.append((1,2,3))
print(list1)
list2.extend((1,2,3))
print(list2)
list1.append([6,7,8])
print(list1)
list2.extend([6,7,8])
print(list2)
print('----'*25)
list1.insert(3,999999)
print(list1)
list1.insert(0,('good','study'))
print(list1)
list1.insert(0,['love','study'])
print(list1)
#运行输出结果：
['wen', 'xin', 'jin', 'jia', 'you', 'good']
None
['wen', 'xin', 'jin', 'jia', 'you', 'good', (1, 2, 3)]
['wen', 'xin', 'jin', 'jia', 'you', 'good', 1, 2, 3]
['wen', 'xin', 'jin', 'jia', 'you', 'good', (1, 2, 3), [6, 7, 8]]
['wen', 'xin', 'jin', 'jia', 'you', 'good', 1, 2, 3, 6, 7, 8]
----------------------------------------------------------------------------------------------------
['wen', 'xin', 'jin', 999999, 'jia', 'you', 'good', (1, 2, 3), [6, 7, 8]]
[('good', 'study'), 'wen', 'xin', 'jin', 999999, 'jia', 'you', 'good', (1, 2, 3), [6, 7, 8]]
[['love', 'study'], ('good', 'study'), 'wen', 'xin', 'jin', 999999, 'jia', 'you', 'good', (1, 2, 3), [6, 7, 8]]
Process finished with exit code 0
删除列表元素
del语句：删除列表元素可以使用del语句，del在python中专门用于执行删除操作，不仅可以用于删除列表的元素，也可以用于删除变量等。del可以删除单个元素，也可以删除列表中间某一段元素。
list1 = ['yin','ni','shi','ci','sheng','de','wei','yi','tian','qi','zhen','hao']
#删除单个元素
del list1[2]
print(list1)
#删除第2到4（不包含）元素
del list1[2:4]
print(list1)
#删除第1到倒数第2（不包含）元素，间隔为2
del list1[1:-2:2]
print(list1)
#运行输出结果：
['yin', 'ni', 'ci', 'sheng', 'de', 'wei', 'yi', 'tian', 'qi', 'zhen', 'hao']
['yin', 'ni', 'de', 'wei', 'yi', 'tian', 'qi', 'zhen', 'hao']
['yin', 'de', 'yi', 'qi', 'zhen', 'hao']
Process finished with exit code 0
remove()：该方法不是根据索引来删除元素的，而是根据元素本身来执行删除操作的。该方法只删除第一个找到的元素，如果找不到元素就会引发ValueError错误。
list1 = [12,23,22,54,22,20]
list1.remove(22)
print(list1)
#运行输出结果：
[12, 23, 54, 22, 20]
Process finished with exit code 0
clear()：该方法用于清空列表中的所有元素。
list1 = [12,23,22,54,22,20]
list1.clear()
print(list1)
#运行输出结果：
[]
Process finished with exit code 0
count()：统计列表中某个元素出现的次数
list1 = [12,23,34,55,20,55,21,6,55]
print(list1.count(55))
#运行输出结果：
3
Process finished with exit code 0
index()：判断某个元素在列表中出现的位置,如果有多个相同元素，输出第一个出现的位置
list1 = [12,23,34,55,20,55,21,6,55]
print(list1.index(55))
#从索引4开始，定位元素55出现的位置
print(list1.index(55,4))
#从索引2到倒数第二个位置，定位元素55出现的位置
print(list1.index(55,2,-2))
#运行输出结果：
3
5
3
Process finished with exit code 0
pop()：弹出列表中最后一个元素，可以实现元素的出栈功能
list1 = ['wen','xin','jin','bang','bang','de']
print(list1.pop())
print(list1.pop())
print(list1)
print(list1.pop(2))
print(list1)
#运行输出结果：
de
bang
['wen', 'xin', 'jin', 'bang']
jin
['wen', 'xin', 'bang']
Process finished with exit code 0
reverse()：将列表中所有元素反转
list1 = list(range(1,9))
print(list1)
list1.reverse()
print(list1)
#运行输出结果：
[1, 2, 3, 4, 5, 6, 7, 8]
[8, 7, 6, 5, 4, 3, 2, 1]
Process finished with exit code 0
sort()：用于对列表元素进行排序，列表元素需要时同一数据类型，默认从小到大排序。
list1 = [2,5,4,3,0,2,-8,9,44]
list2 = ['wen','xin','WEN','gang']
list1.sort()
list2.sort()
print(list1)
print(list2)
#运行输出结果：
[-8, 0, 2, 2, 3, 4, 5, 9, 44]
['WEN', 'gang', 'wen', 'xin']
Process finished with exit code 0
sort()方法还可以出入key和reverse两个参数，key参数为每个元素都生成一个比较大小规则的’键‘；reverse的值为True时可改变排序由大到小
list1 = ['we','xin','hahaha','a','heiehei']
list2 = ['we','xin','hahaha','a','heiehei']
list1.sort(key=len,reverse=True)
list2.sort(key=len,reverse=False)
print(list1)
print(list2)
#运行输出结果：
['heiehei', 'hahaha', 'xin', 'we', 'a']
['a', 'we', 'xin', 'hahaha', 'heiehei']
Process finished with exit code 0
字典
字典简介
字典是用于存放具有映射关系的数据。在python中字典相当于保存了两组数据，其中一组数据是关键数据，被称为key；另一组数据可通过key来访问，被称为value。在字典中key是非常关键的数据，程序需要通过key来访问value，因此字典中的key不允许重复，也不允许改变。
创建字典
创建字典的方式：
1、使用花括号 {}；
2、使用dict()函数创建字典；
使用花括号创建字典
使用花括号创建字典时，花括号中包含多个key-value对，key与valuedu之间用英文冒号隔开；多个key-value对之间使用英文逗号隔开。
scores = {
'英语':90,'数学':100,'语文':99}
print(type(scores))
print(scores)
#创建一个空字典
empty_dict = {
}
print(type(empty_dict))
print(empty_dict)
#运行输出结果：
<class 'dict'>
{
'英语': 90, '数学': 100, '语文': 99}
<class 'dict'>
{
}
Process finished with exit code 0
字典的key可以使用元组作为key;
使用dict()函数创建字典
使用dict()函数创建字典时，可以传入多个列表或元组参数作为key-value对，每个列表或元组将被当成一个key-value对，因此这些列表或元组都只能包含两个元素。
book = [('语文',88),('数学',99),('英语',100)]
fruit = [['苹果',2.5],['桃子',3.8],['樱桃',2.0]]
book_dict = dict(book)
fruit_dict = dict(fruit)
print(book_dict)
print(fruit_dict)
#空字典
empty_dict = dict()
#关键参数创建字典
dict1 = dict(python=88,java=88,c=99)
print(dict1)
#运行输出结果：
{
'语文': 88, '数学': 99, '英语': 100}
{
'苹果': 2.5, '桃子': 3.8, '樱桃': 2.0}
{
'python': 88, 'java': 88, 'c': 99}
Process finished with exit code 0
字典的基本用法
字典的基本操作：
通过key访问value；
通过key添加key-value对；
通过key删除key-value对；
通过key修改key-value对；
通过key判断指定key-value对是否存在。
通过key访问value
使用方括号语法
dict1 = {
'苹果': 2.5, '桃子': 3.8, '樱桃': 2.0}
print(dict1['桃子'])
#运行输出结果：
3.8
Process finished with exit code 0
通过key添加key-value对
只需要为不存在的key赋值就可以了
dict1 = {
'苹果': 2.5, '桃子': 3.8, '樱桃': 2.0}
dict1['芒果'] = 5.6
print(dict1)
#运行输出结果：
{
'苹果': 2.5, '桃子': 3.8, '樱桃': 2.0, '芒果': 5.6}
Process finished with exit code 0
通过key删除key-value对
使用del语句
dict1 = {
'苹果': 2.5, '桃子': 3.8, '樱桃': 2.0}
del dict1['桃子']
print(dict1)
#运行输出结果：
{
'苹果': 2.5, '樱桃': 2.0}
Process finished with exit code 0
通过key修改key-value对
新赋的value值会覆盖原有的value
dict1 = {
'苹果': 2.5, '桃子': 3.8, '樱桃': 2.0}
dict1['桃子'] = 8.8
print(dict1)
#运行输出结果：
{
'苹果': 2.5, '桃子': 8.8, '樱桃': 2.0}
Process finished with exit code 0
使用key判断指定的key-value是否存在
使用 in 或 not in 运算符
dict1 = {
'苹果': 2.5, '桃子': 3.8, '樱桃': 2.0}
print('桃子' in dict1)
print('芒果' in dict1)
#运行输出结果：
True
False
Process finished with exit code 0
字典中的常用方法
字典由dict类代表，可以使用dir(dict)来查看该类包含哪些方法。
print(dir(dict))
#运行输出结果：
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
Process finished with exit code 0
clear()方法
清空字典中所有的key-value对
dict_fruit = {
'苹果':22,'梨子':33,'桃子':44}
print(dict_fruit)
dict_fruit.clear()
print(dict_fruit)
#运行输出结果
{
'苹果': 22, '梨子': 33, '桃子': 44}
{
}
Process finished with exit code 0
get()方法
该方法根据key来获取value，相当于方括号语法的增强版，当使用方括号语法访问并不存在的key时，字典会引发KeyError错误；但如果使用get()方法访问不存在的key，该方法会简单的返回None，不会导致错误。
dict_fruit = {
'苹果':22,'梨子':33,'桃子':44}
print(dict_fruit.get('梨子'))
print(dict_fruit.get('樱桃'))
#运行输出结果：
33
None
Process finished with exit code 0
update方法
执行update()方法时，如果被更新的字典中已经包含对应的key-value对，那么原来value会被覆盖；如果被更新的字典中不包含对应的key-value对，则该key-value被添加进去。
dict_fruit = {
'苹果':22,'梨子':33,'桃子':44}
print(dict_fruit.update({
'梨子':66,'樱桃':88}))
print(dict_fruit)
#运行输出结果：
None
{
'苹果': 22, '梨子': 66, '桃子': 44, '樱桃': 88}
Process finished with exit code 0
items()、keys()、values()
分别是获取字典中的所有key-value、所有key、所有value，这三个方法依次返回的是dict_items、dict_keys、dict_values对象，Python不希望用户直接操作这个方法，可以使用list()函数把它们转换成列表。
dict_fruit = {
'苹果':22,'梨子':33,'桃子':44}
#获取字典中所有key-value对，返回一个dict_items对象
d_items = dict_fruit.items()
print(d_items)
print(list(d_items))
#获取字典中所有的key,返回一个dict_keys对象
d_keys = dict_fruit.keys()
print(d_keys)
print(list(d_keys))
#获取字典中所有的value,返回一个dict_values对象
d_values = dict_fruit.values()
print(d_values)
print(list(d_values))
#运行输出结果：
dict_items([('苹果', 22), ('梨子', 33), ('桃子', 44)])
[('苹果', 22), ('梨子', 33), ('桃子', 44)]
dict_keys(['苹果', '梨子', '桃子'])
['苹果', '梨子', '桃子']
dict_values([22, 33, 44])
[22, 33, 44]
Process finished with exit code 0
pop()方法
获取指定的key对应的value，并删除这个key_value对。
dict_fruit = {
'苹果':22,'梨子':33,'桃子':44}
print(dict_fruit.pop('梨子'))
print(dict_fruit)
#执行输出结果：
33
{
'苹果': 22, '桃子': 44}
Process finished with exit code 0
popitem()方法
弹出字典中的最后一个key-value对
dict_fruit = {
'苹果':22,'梨子':33,'桃子':44,'樱桃':88}
print(dict_fruit.popitem())
print(dict_fruit)
#运行输出结果：
('樱桃', 88)
{
'苹果': 22, '梨子': 33, '桃子': 44}
Process finished with exit code 0
setdefault()方法
用于根据key来获取对应的value值。先为该key设置默认的value。然后判断key是否存在，如果key不存在返回设置的默认值，并将该键值对插入字典中；如果key存在返回key对应的value值，原来的值不会被改变。
dict_fruit = {
'苹果':22,'梨子':33,'桃子':44,'樱桃':88}
print(dict_fruit.setdefault('芒果',100))
print(dict_fruit)
print(dict_fruit.setdefault('梨子',99))
print(dict_fruit)
#运行输出结果：
100
{
'苹果': 22, '梨子': 33, '桃子': 44, '樱桃': 88, '芒果': 100}
33
{
'苹果': 22, '梨子': 33, '桃子': 44, '樱桃': 88, '芒果': 100}
Process finished with exit code 0
fromkeys()方法
使用给定的多个key创建字典，这些key对应的value默认都是None；也可以额外传入一个参数作为默认的value。该方法一般不会使用字典对象调用，通常会使用dict类直接调用。
#使用列表创建包含两个key的字典
dict_from = dict.fromkeys(['梨子','苹果'])
print(dict_from)
#使用元组创建包含两个key的字典
dict_from2 = dict.fromkeys(('香蕉','芒果'))
print(dict_from2)
#使用列表创建包含两个key的字典，指定默认的value
dict_from3 = dict.fromkeys(['梨子','苹果'],99)
print(dict_from3)
#运行输出结果：
{
'梨子': None, '苹果': None}
{
'香蕉': None, '芒果': None}
{
'梨子': 99, '苹果': 99}
Process finished with exit code 0
使用字典格式化字符串
在字符串模板中按key指定变量，然后通过字典为字符串模板中的key设置值。
test_str = '水果是：%(fruit)s,价格是：%(price).2f,供货商：%(man)s'
dict_fruit = {
'fruit':'苹果','price':99.9,'man':'果贩子'}
print(test_str % dict_fruit)
#运行输出结果：
水果是：苹果,价格是：99.90,供货商：果贩子
Process finished with exit code 0