格式化输出（模板化）
用% ；s； d；
“%”为占位符；“s”为替换符（用于替换字符串）；“d”也是替换符（可用于替换数字）；当需要单纯地使用%（百分号）时，那就在它的前或后再加一个%，用来表示它不是占位符。
例如：
name = input("你的名字：")
age = input("你的年龄：")
cool = input("帅or丑：")
mgs = '''
------%s的信息表------
我的名字是%s：
我的年龄是%d
我很%s
我的学习进度是5%%
----------END---------''' %(name,name,int(age),cool)
print(mgs)
输出结果为：
你的名字：Aires
你的年龄：18
帅or丑：帅
------Aires的信息表------
我的名字是Aires：
我的年龄是18
我很帅
我的学习进度是5%
----------END---------
编码
数据的传输和储存，实际上都是010101形式的二进制文件；通过各种形式的编码方式，转换成各种文字符号。
美国：ASCII码：创造之初有8位（bit）二进制数字，每个8位二进制数字代表一个字节（byte），但当时实际只使用了7位，共表示出了177个字符，留出的那一位是为了未来的拓展
所以ASCII码最左边的那一位数字全都是0
8bit==1byte（字节） 1024byte==1KB 1024KB==1MB 1024MB==1GB 1024GB==1TB 4个字节（byte）==32位（bit）
虽然177个字符在美国足够了，但面对中国这个拥有9万多文字的国家来说还是远远不够的，所以为了解决这个全球化的文字问题，美国有创建了万国码：Unicode
Unicode 最开始的格式：用16位（bit）2个字节（byte）表示所有的英文字母、特殊字符、数字；4个字节（32bit）表示汉字，但是位数过多导致了浪费，所以有了它的升级版：utf-8；
utf-8：最少用一个字节也就是8位（bit）表示一个英文。欧洲文字使用16位（bit）2个字节。中文使用24位（bit）3个字节（byte）表示;
国产国内使用的编码：gbk（GBK） ASCII码升级得来 只能表示中文和英文 一个中文使用2个字节，英文用1个字节；
gbk和utf-8需要通过unicode转译
运算符：
+（加）、-（减）、*（乘）、/（除）、**（幂、乘方）、//（整除）、==（相等）、！=（不等）
运算简写：a+=1 == a=a+1
a-=1 ==a=a-1
a*=1 ==a=a*1
a/=1 == a=a/1
逻辑运算：and（并且；而且） 、 or （或；或者） 、 not（不）
优先级：（）> not > and > or #有括号先算括号，然后算not ，然后算and（两边条件都为真），然后再算or（两边条件有一边条件为真，就是真）
相同优先级的情况下，从左往右算
or： x or y x为非零 就返回x的值，否则返回y的值 例如：0 or 2 得到的值为2； 2 or 6 得到的值为2.
and：与or相反 例如： 0 and 2 返回的值为0 2 and 6 返回的值为6
print(0 or 2 and 3 and 4 or 6 and 0 or 3)
输出结果为4 #过程：按优先级从左往右2 and 3 -> 3 3 and 4 -> 4 6 and 0 -> 0 0 or 4 -> 4 后面的就不执行了
print( 6 or 2 > 1)
输出结果为6 #过程：6 or 2 > 1 --> 6
print(2 > 1 or 6)
输出结果为 True #过程：2 > 1 为真（True）
print(3 and 2 > 1)
输出结果为 True #过程： 2 > 1为真（True）
print(0 and 3 > 1)
输出结果为0 #过程：x and y若x==0 就返回x的值
print(3 < 1 and 0)
输出结果为 False #过程： x and y 若x为假（False）就返回x的值 反之 若x为真则返回y的值。
布尔值（bool）与数字（int）可以互相转换：所有非零的数字（不管多大，不管正负）转换为布尔值都是True；数字0转换为布尔值是False；
而布尔值转换为数字只有两种结果：True转换为1 False转换为0
数据类型整体分析：
int：（整数；数字）用于计算。
数字主要是用于计算用的，使用方法并不是很多，就记住一种就可以：
bit_length()
#bit_length() 当十进制用二进制表示时，最少使用的位数
v = 11
data = v.bit_length()
print(data)
bool：True，False，用于判断。
str：字符串，用引号引起来的都是字符串。用于储存少量数据进行操作。
ps：循环：while 1比while true 的效率高。
int转换为str-->无条件，想咋转换就咋转换。--> i = 1； s = str（i）
str转换为int-->字符串里只能是数字。-->s = “1”；i = int（s）
int转换为bool-->若int为0，那么返回的结果就是False，反之，如果int为非零，那么返回的结果就是True。
bool转换为int-->只有两种结果：True就是1，False就是0.
str转换为bool-->空字符串，例如s = “” 中间什么都没有，就是False，反之，若字符串非空，就是True。
字符串的索引与切片。
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串，原字符串不作任何改变（原则就是顾头不顾尾，意思就是从设定的头开始到设定的尾的前一位数据）。
a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[0:5:2]) #加步长，步长指在设定的切片首位之间，每间隔步长-1，取一个数据。这段代码意为在ABCDE中每隔一个数据取一个数据，所以输出位ACE。
print(a[5:0:-2]) #反向加步长；意为从F开始到A之间，每隔一个数据，取一个数据，所以输出的数据是FDB
ps：
若要取全部值可用【：】冒号两边都为空，若【0：0】输出为空，不会报错
要取的数据之间的步长必须相等
list：列表，用中括号括起来的数据或字符串 例如【1，2，3，“asd”】每个元素以逗号隔开，而且他里面可以存放各种数据类型。列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。。
元组（tuple）：可以储存成千上万的各种类型的数据，与列表的区别是：它是只读版本的列表，只能读取，不能更改。
dict（dictionary）：字典，｛“name”：“姓名”，“age”：16｝
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
集合set。
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
字符串的常用方法：
1、首字母大写：capitalize()
1 s = "aires"
2 s1 = s.capitalize()
3 print(s1)
输出结果为：
Aires
2、字符串所有字母大写：upper()
s = "aires"
s2 = s.upper()
print(s2)
输出结果为：
AIRES
3、字符串所有字母小写：lower()
s = "AIRES"
s3 = s.lower()
print(s3)
输出结果为：
aires
4、字符串中字母大小写反转：swapcase()
（1）大写转小写
s = "AIRES"
s4 = s.swapcase()
print(s4)
输出结果为：
aires
（2）小写转大写
a = "aires"
s41 = a.swapcase()
print(s41)
输出结果为：
AIRES
5、在单词中间隔着空格、特殊字符或数字的情况下首字母大写：title()
s = "air;es asd-fg fj2fj"
s5 = s.title()
print(s5) #只要字符串中有除了英文以外的字符，那么那个字符后面的那一个英文字母转换为大写。
输出结果为：
Air;Es Asd-Fg Fj2Fj
6、字符串内容居中，字符串总长度，空白处填充其他字符：center() （长度，填充）
s = "Aires"
s6 = s.center(40,"-") #（长度，填充）若使用此方法，长度必须填，若想保持不变可以填0，不可为空。填充符可不填，默认为空格。
print(s6)
输出结果为：
-----------------Aires------------------
7、位数补齐（不常用）：exoandtabs()
s = "Air\tes" #\t
s = "Air\tes" #\t==Tab键 若字符串中有“\t”键 那便与它前面的字符加空格补齐八位，若前面的字符已够八位那便补齐16位，然后是24位...32位
s7 = s.expandtabs()
print(s7)
输出结果为：
Air es
8、公共方法（字符串，元组，列表，字典等皆可用的方法）len() （变量名）
s = "Aires"
s8 = len(s)
print(s8)
输出结果为：
5 #用于字符串输出有多少字符，用于元组输出有多少元素，用于列表输出有多少元素，用于字典输出有多少键值对；
9、判断一组字符串的开头或结尾（可切片）：
开头：startswith()
s = "Aires"
s9 = s.startswith("Air",0,4) #（需要判定的开头，设定切片首，设定切片尾）（顾头不顾尾）
print(s9)
输出结果为：
True 返回的值为bool（布尔值）
结尾：endswith()
s = "Aires"
s91 = s.endswith("re",0,4) #（需要判定的结尾，设定切片首，设定切片尾）（顾头不顾尾）
print(s91)
输出结果为：
True
10、寻找字符串中是否有某个字符：find() index()与find()差不多，但找不到会报错，所以一般选择用find()
s = "Aires"
s10 = s.find("re",0,4) #用find通过元素（字符）寻找索引，找到的情况下返回第一个元素（字符）的索引，找不到返回-1.
print(s10)
输出结果为：
2
11、删除字符串前后的空格或字符：strip() 删除左侧的空格或字符：lstrip() 删除右侧的空格或字符：rstrip()
s = "**Ai*res**"
s11 = s.strip("*A") #括号不填默认删除空格，括号里填什么字符就前后删除什么字符，可多填，中间不用逗号分开。不能删字符串中间的字符，只能删两边的
print(s11)
输出结果为：
i*res
从左删lstrip() 意为只删左面的，右面的不懂，反之，从右删rstrip() 意为只删右边的，左边的不动。
12、分割 字符串转换为列表：split()
s = "Ai;re;s"
s12 = s.split(";") 括号中不写默认为以空格分割字符串为列表。括号里填什么符号就以什么符号分割字符串为列表。
print(s12)
输出结果为：
['Ai', 're', 's'] #结果为列表
13、格式化输出的三种玩法：format（尽量用这种格式化输出方法）
s13='我叫{}，我{}岁了，我的爱好是{}'.format('aires',18,'play computergame') #顺序输入
s131='我叫{0}，我{1}岁了，我的爱好是{2}'.format('aires',18,'play computergame') #索引
s132='我叫{name}，我{age}岁了，我的爱好是{hobby}'.format(hobby='play computergame',name='aires',age=18) #字典（键值对）
print(s13)
print(s131)
print(s132)
输出结果为：
我叫aires，我18岁了，我的爱好是play computergame
我叫aires，我18岁了，我的爱好是play computergame
我叫aires，我18岁了，我的爱好是play computergame
14、替换：repalce()（需要替换的字符，新的字符，替换次数）替换次数为空默认全部替换
s = "123666aaaaad"
ls = s.replace("a","q")
print(ls)
输出结果为：
123666qqqqqd
15、判断字符串是否由（数字，字母，数字或字母）组成：
数字：isdigit() ； 字母：isalpha() ； 数字或字母：isalnum()
只返回两个结果（True，False）
ps：括号里不写参数
name = "aires132546"
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成
输出结果为：
True
False
False
16、计算一个元素在字符串里出现了多少次（计数）：count()
ps：与“len（）”一样可用于列表
s = "123666aaaaad"
ls = s.count("6")
print(ls)
输出结果为：
3
for循环：用户按照顺序循环可迭代对象的内容。
ps：由多个元素组成的字符串，元组，列表，字典等，都是可迭代对象
字符串：
he = '呵呵哒！'
for play in he:
print(play)
输出结果为：
呵
呵
哒
！
列表：
li = ['aires','内存','ssd','cpu','显卡']
for computer in li:
print(computer)
输出结果为：
aires
内存
ssd
cpu
显卡
字典：
dic = {'name':'aires','age':18,'hobby':'girl'}
for k,v in dic.items():
print(k,v)
输出结果为：
name aires
age 18
hobby girl
列表的操作方法： 四种：增、删、改、查
ps：直接对原列表进行操作，不生成新列表。
1、增：
（1）append：在列表末尾追加
li = ["aires","oython"] #定义列表
while 1 : #开始循环
name = input(">>>") #用户输入
if name.strip().upper() == "Q" : #对用户输入的内容去空格，全部改为大写
break #若用户输入内容为q（Q）则退出循环
else :
li.append(name) #否则就将用户输入的内容添加到列表的末尾
print(li)
输出结果为：
>>>Aires
>>>hdaukd
>>>132
>>>q
['aires', 'oython', 'Aires', 'hdaukd', '132']
（2）insert：在列表中间插入，（需要索引，添加的元素将添加到索引元素的前面）
li = ["aires","oython","打我发发发"] #定义列表
while 1 : #开始循环
name = input(">>>") #用户输入
if name.strip().upper() == "Q" : #对用户输入的内容去空格，全部改为大写
break #若用户输入内容为q（Q）则退出循环
else :
li.insert(2,name) #否则就将用户输入的内容添加索引元素的前面
print(li)
输出结果为：
>>>AIRES
>>>q
['aires', 'oython', 'AIRES', '打我发发发']
（3）extend：将可迭代对象的每一个最小元素追加至末尾
li = ["aires","oython","打我发发发"] #定义列表
while 1 : #开始循环
name = input(">>>") #用户输入
if name.strip().upper() == "Q" : #对用户输入的内容去空格，全部改为大写
break #若用户输入内容为q（Q）则退出循环
else :
li.extend(name) #否则就将用户输入的内容分解为最小元素并追加到列表末尾
print(li)
输出结果为：
>>>AIRES
>>>q
['aires', 'oython', '打我发发发', 'A', 'I', 'R', 'E', 'S']
2、删
（1）pop：根据索引删除列表中的元素。
ps：若索引为空默认删除最后一位元素，可返回删除的元素
li = ["aires","oython","打我发发发"] #定义列表
s = li.pop(1) #输入需要删除的索引
print(s,li) #打印删除的元素，和修改后的列表
输出结果为：
oython ['aires', '打我发发发']
（2）remove：按元素删除。
li = ["aires","oython","打我发发发"] #定义列表
li.remove("打我发发发") #输入需要删除的元素
print(li) #打印修改后的列表
输出结果为：
['aires', 'oython']
（3）clear：清空列表（不是删除）
li = ["aires","oython","打我发发发"] #定义列表
li.clear() #清空
print(li) #打印修改后的列表
输出结果为：
[]
（4）del（）；（列表名称）：直接删除列表
li = ["aires","oython","打我发发发"] #定义列表
del(li) #删除列表
print(li) #打印修改后的列表
输出结果为：（因为已经删除，所以打印不出来，直接报错）
Traceback (most recent call last):
File "C:/Users/Administrator/PycharmProjects/untitled/Aires/笔记暂存区.py", line 13, in <module>
print(li) #打印修改后的列表
NameError: name 'li' is not defined
（5）del【：】（切片删除）
li = ["aires","oython","打我发发发","gdajgd"] #定义列表
del li [1:3] #删除索引切片的元素
print(li) #打印修改后的列表
输出结果为：
['aires', 'gdajgd']
3、改：
（1）直接索引，然后对索引元素重新赋值
li = ["aires","oython","打我发发发","gdajgd"] #定义列表
li[2] = "呵呵哒" #索引列表中想要更改的元素，重新赋值
print(li) #打印修改后的列表
输出结果为：
['aires', 'oython', '呵呵哒', 'gdajgd']
（2）切片改
ps：可迭代对戏指的是由多个元素或字符组成的对象，迭代指的是将可迭代对象拆分为基本元素。
li = ["aires","oython","打我发发发","gdajgd"] #定义列表
li[1:3] = [1,2,3,"aires","嘻嘻"] #用索引切片删除列表中想要更改的元素，迭代式地在原位置添加新元素
print(li) #打印修改后的列表
输出结果为：
['aires', 1, 2, 3, 'aires', '嘻嘻', 'gdajgd']
4、查
（1）for in 循环打印：
li = ["aires","oython","打我发发发","gdajgd"] #定义列表
for s in li: #将列表里的每一个元素循环地赋值给s
print(s) #打印每一次循环时s的值
输出的结果为：
aires
oython
打我发发发
gdajgd
（2）切片索引查询：
li = ["aires","oython","打我发发发","gdajgd"] #定义列表
print(li[1]) #索引查询的结果为元素
print(li[1:3]) #切片查询的结果为列表
输出结果为：
oython
['oython', '打我发发发']
len：计算列表的长度
li = ["aires","oython","打我发发发","gdajgd"] #定义列表
l = len(li) #计算列表li的长度
print(l)
输出结果为：
4
count：计算一个元素在列表中的出现次数
li = ["aires","oython","打我发发发","gdajgd","aires"] #定义列表
num = li.count("aires") #计算一个元素在列表中出现几次
print(num)
输出结果为：
2
index：查找一个元素在列表中的第一索引
li = ["aires","oython","打我发发发","gdajgd","aires"] #定义列表
num = li.index("打我发发发") #查找元素在列表中的索引
print(num)
输出结果为：
2
sort：将列表中的元素从小到大或从大到小排序
li = [5,6,2,15,48,641,]
li.sort() #使列表中的数字从小到大排序 括号中默认为（reverse=False）将False改为True可实现从大到小排序
print(li)
li = [5,6,2,15,48,641,]
li.sort(reverse=True) #使列表中的数字从大到小排序
print(li)
输出结果为：
[2, 5, 6, 15, 48, 641] #从小到大
[641, 48, 15, 6, 5, 2] #从大到小
reverse：将列表中的元素反转排序
li = [5,6,2,15,48,641,]
li.reverse() #将列表的元素反转排序
print(li)
输出结果为：
[641, 48, 15, 2, 6, 5]
嵌套列表：
与列表的操作方法基本相同，可结合字符串的操作方法。
li =["嗨喽","呵呵哒","fire",["aires","Python pycharm","打我发发发"],123] #定义列表
li[2] = li[2].upper() #在列表中将索引的元素全部大写
li[3][0] = li[3][0].upper() #在嵌套列表中索引第3个元素（嵌套列表）中的第0个元素，并将其首字母改为大写
li[3][2]="打我piapiapia" #在嵌套列表中将索引的元素更改
li[3][1] = li[3][1].replace("pycharm","编程") #用字符串的操作方法将嵌套列表中的元素替换
print(li) #打印经过以上操作后修改的列表
输出结果为：
['嗨喽', '呵呵哒', 'FIRE', ['AIRES', 'Python 编程', '打我piapiapia'], 123]
元组：
创建元组的方法很简单，用逗号分开一些值就会自动创建元组
"hello","world"
>>>("hello","world")
元组不可更改，但可以索引查找，循环（for in）查找，切片查找。
虽然元组中的元素不能修改，但是若其中那个元素是一个列表，那便可以对列表进行修改。
tu =("嗨喽","呵呵哒","fire",["aires","Python pycharm","打我发发发"],123) #定义元组
tu[3][1]=tu[3][1].upper() #对元祖中的元素内的子元素进行修改
print(tu)
输出结果为：
('嗨喽', '呵呵哒', 'fire', ['aires', 'PYTHON PYCHARM', '打我发发发'], 123)
"".join()
将任何可迭代对象（包括但不限于字符串、列表、元组）转化为字符串，并自定义中间连接符（若连接符为空，字符之间会连在一起）
tu =("aires","Python pycharm","打我发发发") #定义元组
a = "-*-链接123-*-".join(tu) #对元祖中的元素迭代拆分并转化为字符串，元素之间用引号内的内容进行连接（引号内可以是任何内容）
print(a)
输出结果为：
aires-*-链接123-*-Python pycharm-*-链接123-*-打我发发发
range 内置无限大的整数，可直接调用，可设定取值范围（同切片）
for i in range(3,10): #循环打印range，取值范围为3，10
print(i)
输出结果为：
3
4
5
6
7
8
9
若从0开始取值，可省略0
for i in range(10): #循环打印range，取值范围为0，10（0可省略）
print(i)
输出结果为：
0
1
2
3
4
5
6
7
8
9
按步长取值 每个要取的数据之间的步长必须相同
for i in range(0,10,3): #循环打印range，范围为0，10，每隔3步长（也就是两个数）取值
print(i)
输出结果为：
0
3
6
9
倒着取值:
ps：倒着取值也同切片，且倒着取时步长不可为0，否则报错，不可为空，否则输出也为空，必须是负数，不可为正数，否则同样为空。
for i in range(10,0,-1): #循环打印range，范围为10，0，每隔-1步长（也就是0）取值 (顾首不顾尾)
print(i)
输出结果为：
10
9
8
7
6
5
4
3
2
1
当需要倒取数据的尾（也就是0）时，可将尾数取值范围设定为-1
for i in range(10,-1,-2): #循环打印range，范围为10，0，每隔-1步长（也就是0）取值 (顾首不顾尾)
print(i)
输出结果为：
10
8
6
4
2
0
结合条件语句可以打印嵌套列表内的所有元素：
li = ["aires","god","boy",["hello","world"],"you","给老子","out"] #定义列表
for i in li: #循环打印li列表并赋值给i
if type(i) == list: #如果i的类型为列表
for k in i : #那就把列表循环打印并赋值给k，然后打印
print(k)
else:
print(i) #否则就继续循环打印列表li并赋值给i
输出结果为：
aires
god
boy
hello
world
you
给老子
out
或者结合索引和range和len 打印索引所对应的元素
li = ["aires","god","boy",["hello","world"],"you","给老子","out"] #定义列表
for i in range(len(li)): #检测li列表的长度，并作为range的取值范围，并循环打印赋值给i，用作下一行代码的索引
if type(li[i]) == list: #如果li列表索引所对应的元素是列表
for k in li[i]: #那就把列表索引所对应的元素循环打印并赋值给k，然后打印k
print(k)
else:
print(li[i]) #否则就继续循环打印li列表索引所对应的元素
输出结果为：
aires
god
boy
hello
world
you
给老子
out
数据类型的分类：可变数据类型（不可哈希），不可变数据类型（可哈希）
可哈希（不可变）的数据类型：bool，元组，int，str
不可哈希（可变）的数据类型：list，dict，set（集合）
字典：
字典由键值对组成，键（key）必须是不可变数据类型；值（value）可以是任何数据类型
优点：查询使用二分查找，查询速度快。可以储存大量的关系型数据类型。
特点：3.5版本之前，字典是无序的，不可索引。可以通过key查找对应的值。
字典的值可以是列表，元组，也可以是字典（嵌套）
增：
（1）用若原本有键，就将新的值将原有的值覆盖，若没有键，就添加新的值。
dic = {
"name":"aires",
"age":18,
"hobby":"play computergame",
"high":163,
"weight":"52kg",
}
dic["game"] = "聚爆" #没有键就将键值对追加于字典末尾，若原本有键，那就将其值覆盖
print(dic)
输出结果为：
{'name': 'aires', 'age': 18, 'hobby': 'play computergame', 'high': 163, 'weight': '52kg', 'game': '聚爆'}
（2）setdefault（） （k，v）没有键就将键值对追加于字典末尾，若原本有键，不作任何改变
dic = {
"name":"aires",
"age":18,
"hobby":"play computergame",
"high":163,
"weight":"52kg",
}
dic.setdefault("game","聚爆") #没有键就将键值对追加于字典末尾，若原本有键，不作任何改变
print(dic)
输出结果为：
{'name': 'aires', 'age': 18, 'hobby': 'play computergame', 'high': 163, 'weight': '52kg', 'game': '聚爆'}
删：
（1）pop（） （k） 删除k所对应的v
若要删除的字典中没有要删除的键，就会报错。而当不确定是否有这个键时，可以先对其值进行自定义，通常定为None，也可以是别的。
dic = {
"name":"aires",
"age":18,
"hobby":"play computergame",
"high":163,
"weight":"52kg",
}
a = dic.pop("game","没有这个键") #可打印删除的键所对应的值，若不确定是否有这个键，可先对其值进行自定义，通常为None
print(a)
输出结果为：
没有这个键
（2）popitem（） 删除字典的最后一位键值对。有返回值，返回的是元组。
dic = {
"name":"aires",
"age":18,
"hobby":"play computergame",
"high":163,
"weight":"52kg",
}
dic.popitem() #删除最后一位键值对
print(dic)
输出结果为：
{'name': 'aires', 'age': 18, 'hobby': 'play computergame', 'high': 163}
（3）clear（） 清空字典
dic = {
"name":"aires",
"age":18,
"hobby":"play computergame",
"high":163,
"weight":"52kg",
}
dic.clear() #清空，但不是删除
print(dic)
输出结果为：
{}
（4）del 删除字典
dic = {
"name":"aires",
"age":18,
"hobby":"play computergame",
"high":163,
"weight":"52kg",
}
del dic #删除
print(dic)
输出结果为： 没有结果，因为已删除，所以报错
Traceback (most recent call last):
File "C:/Users/Administrator/PycharmProjects/untitled/Aires/练习区.py", line 9, in <module>
print(dic)
NameError: name 'dic' is not defined
（5）del dic["k"] 删除键所对应的键值对，若字典中没有要删除的键，则报错。
dic = {
"name":"aires",
"age":18,
"hobby":"play computergame",
"high":163,
"weight":"52kg",
}
del dic["name"] #删除键所对应的键值对，若字典中没有要删除的键，则报错。
print(dic)
输出结果为：
{'age': 18, 'hobby': 'play computergame', 'high': 163, 'weight': '52kg'}
改：
（1）将键原有的值，用新的值覆盖（同增的方法）
dic = {
"name":"aires",
"age":18,
"hobby":"play computergame",
"high":163,
"weight":"52kg",
}
dic["name"] = "聚爆" #将键原有的值，用新的值覆盖
print(dic)
输出结果为：
{'name': '聚爆', 'age': 18, 'hobby': 'play computergame', 'high': 163, 'weight': '52kg'}
（2）dic.updata(dic2) 将dic2的值更新到dic里（已有的键覆盖，没有的增加）
dic = {
"name":"aires",
"age":18,
}
dic2 = {"game":"聚爆",
"name":"python"
}
dic.update(dic2) #将dic2的值更新到dic里
print(dic)
输出结果为：
{'name': 'python', 'age': 18, 'game': '聚爆'}
查：
（1）keys（）：查询字典中的键（k）。输出类型为字典的键（dict_keys）（字典独有类型） 数据类型为列表
（2）values（）：查询字典中的值（v）。输出类型为字典的值（dict_values）（字典独有类型）数据类型同为列表
（3）items（）：查询字典中的键和值（k，v）。输出类型为字典的键和值（dict_items）（字典独有类型）数据类型同为列表，但列表内为元组
dic = {
"name":"aires",
"age":18,
}
a = dic.keys() #查询字典中的键
print(a,type(a))
dic = {
"name":"aires",
"age":18,
}
a = dic.values() #查询字典中的值
print(a,type(a))
dic = {
"name":"aires",
"age":18,
}
a = dic.items() #查询字典中的键和值
print(a,type(a))
输出结果为：
dict_keys(['name', 'age']) <class 'dict_keys'> #查询到的键及其类型
dict_values(['aires', 18]) <class 'dict_values'> #查询到的值及其类型
dict_items([('name', 'aires'), ('age', 18)]) <class 'dict_items'> #查询到的键和值及其类型
（4）get（）（key，返回的值）可查找打印键所对应的值，若不确定是否有这个键，可对其值进行自定义，通常为None 可常用这种方法。
dic = {
"name":"aires",
"age":18,
"hobby":"play computergame",
"high":163,
"weight":"52kg",
}
s = dic.get("game","没有此键") #可查找打印键所对应的值，若不确定是否有这个键，可对其值进行自定义，通常为None
print(s)
输出结果为：
没有此键
（5）for in 循环打印
1）循环打印键
dic = {
"name":"aires",
"age":18,
"hobby": "play computergame",
"high": 163,
"weight": "52kg",
}
for i in dic: #循环打印键，同for i in dic.keys： 不写默认为循环打印键
print(i)
输出结果为：
name
age
hobby
high
weight
2）循环打印值
dic = {
"name":"aires",
"age":18,
"hobby": "play computergame",
"high": 163,
"weight": "52kg",
}
for i in dic.values(): #循环打印值
print(i)
输出结果为：
aires
18
play computergame
163
52kg
3）循环打印键和值（结果为元组）
dic = {
"name":"aires",
"age":18,
"hobby": "play computergame",
"high": 163,
"weight": "52kg",
}
for i in dic.items(): #循环打印键和值
print(i)
输出结果为：
('name', 'aires')
('age', 18)
('hobby', 'play computergame')
('high', 163)
('weight', '52kg')
对应关系
a,b = 1,2
print(a,b)
a,b = [1,2],[3,4]
print(a,b)
a,b = (1,2),(3,4)
print(a,b)
a,b = "name","age"
print(a,b)
a,b = 1,2
a,b = b,a #关系互换
print(a,b)
输出结果为：
1 2
[1, 2] [3, 4]
(1, 2) (3, 4)
name age
2 1 #关系互换
for循环打印也可以关系对应地打印键和值，输出为字符串类型
dic = {
"name":"aires",
"age":18,
"hobby": "play computergame",
"high": 163,
"weight": "52kg",
}
for k,v in dic.items(): #用对应关系循环打印键和值，输出为字符串类型
print(k,v)
输出结果为：
name aires
age 18
hobby play computergame
high 163
weight 52kg
若字典的值为列表，修改字典的值
若字典中键值对中的值为列表，可按修改列表的方法修改其值，其他de类型数据同理
例如： 追加dic["k"].apeend（"v"） v为需要追加的值
dic = {
"name":"aires",
"age":18,
"hobby": ["play computergame","play"],
"high": 163,
"weight": "52kg",
}
dic["hobby"].append("编程") #hobby所对应的值为列表，可按修改列表的方式修改值
print(dic)
输出结果为：
{'name': 'aires', 'age': 18, 'hobby': ['play computergame', 'play', '编程'], 'high': 163, 'weight': '52kg'}
按索引，将索引所对应的元素作为字符串修改 例如：首字母大写
dic = {
"name":["aires","zhang"],
"age":18,
"hobby": ["play computergame","play"],
"high": 163,
"weight": "52kg",
}
dic["name"][1] = dic["name"][1].capitalize() #索引修改，将索引所对应的元素首字母大写
print(dic)
输出结果为：
{'name': ['aires', 'Zhang'], 'age': 18, 'hobby': ['play computergame', 'play'], 'high': 163, 'weight': '52kg'}
嵌套中根据键修改值，也可添加或别的各种操作
dic = {
"name":["aires","zhang"],
"age":18,
"hobby": ["play computergame","play"],
"game":{"单机":"聚爆","网络":"王者"}
}
dic["game"]["网络"] = "无" #嵌套中根据键修改值，也可添加或别的各种操作
print(dic)
输出结果为：
{'name': ['aires', 'zhang'], 'age': 18, 'hobby': ['play computergame', 'play'], 'game': {'单机': '聚爆', '网络': '无'}}
