python操作_Python操作总结（一）

一：编译型vs解释型

编译型

优点：编译器⼀般会有预编译的过程对代码进⾏优化。因为编译只做⼀次，运⾏时不需要编

译，所以编译型语⾔的程序执⾏效率⾼。可以脱离语⾔环境独立运⾏。

缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运⾏环境⽣

成机器码，不同的操作系统之间移植就会有问题，需要根据运⾏的操作系统环境编译不同的

可执⾏⽂件。

解释型

优点：有良好的平台兼容性，在任何环境中都可以运⾏，前提是安装了解释器（虚拟机）。

灵活，修改代码的时候直接修改就可以，可以快速部署，不⽤停机维护。

缺点：每次运⾏的时候都要解释⼀遍，性能上不如编译型语⾔。

二：变量

（1）变量：变量是程序运行过程中产生的中间值. 供给后面程序使用

（2）变量的命名规则:

1, 变量由字⺟, 数字,下划线搭配组合⽽成

2, 不可以⽤数字开头,更不能是全数字

3,不能是pythond的关键字, 这些符号和字⺟已经被python占⽤, 不可以更改

4,不要⽤中⽂

5,名字要有意义

6,不要太⻓

7, 区分⼤⼩写

推荐⼤家使⽤驼峰体或者下划线命名

驼峰体: 除⾸字⺟外的其他每个单词⾸字⺟⼤写

下划线: 每个单词之间⽤下划线分开

三：常量

在python中不存在绝对的常量. 约定俗成, 所有字⺟⼤写就是常量

例如: PI = 3.141592653

BIRTH_OF_SYLAR = 1990

四：注释

有时候我们写的东⻄不⼀定都是给⽤户看的. 或者不希望解释器执⾏. 那我们可以使⽤#来

注释掉代码. 被注释的内容是不会执⾏的.可以⽅便后⾯的程序员来拜读你的代码

1）单⾏注释: # 被注释的内容

2）多⾏注释:''' 被注释的内容 ''', """这个也是多⾏注释"""

五：Python基本数据类型

1）整型(int)

常⻅的数字都是int类型. ⽤于计算或者⼤⼩的比较

在32位机器上int的范围是: -2**31～2**31-1，即-2147483648～2147483647

在64位机器上int的范围是: -2**63～2**63-1，即-9223372036854775808～9223372036854775807

2)字符串(str)

在Python中,凡是⽤引号引起来的,全是字符串.

字符串可以⽤单引号，双引号，或者三引号引起来，没有什么区别，只是⼀些特殊的格式需要不⽤的引号

⽐如：

msg = "My name is Alex , I'm 22 years old!" 这个就需要单双引号配合。

msg = """

今天我想写⾸⼩诗，

歌颂我的同桌，

你看他那乌⿊的短发，

好像⼀只炸⽑鸡。

"""

想多⾏赋值⼀个字符串，就需要三引号。

数字类型有 +-*/ .字符串只有 + *。

#字符串的拼接

s1 = 'a '

s2 = 'bc'

#print(s1 + s2)

#相乘 str*int

name = '坚强'

#print(name*8)

3)布尔值(bool)

真或者假, True和False

六：用户交互

使⽤input()函数,可以让我们和计算机互动起来

语法:

内容 = input(提⽰信息)

这⾥可以直接获取到⽤户输入的内容，输入的内容都是字符串类型

七：流程控制if语句

你在⽣活中是不是经常遇到各种选择，⽐如玩⾊⼦，猜⼤⼩，⽐如选择⾛那条路回家？Python程序中也会

遇到这种情况，这就⽤到了if语句。

if 条件:

代码块

当条件成立. 执行代码块

if 条件:

代码块1

else:

代码块2

当条件为真. 执行代码块1, 否则执行代码块2

if 条件1:

代码块1

elif 条件2:

代码块2

elif.....

else:

else代码块

嵌套: if..else可以无限的嵌套, 写的时候尽量控制在3-5以内

八：流程控制-while循环

while 条件:

结果

如果条件是真, 则直接执⾏结果. 然后再次判断条件. 直到条件是假. 停⽌循环

结束循环:

1,改变条件.

2,break

while循环.

while 条件:

循环体

else: 循环在正常情况跳出之后会执⾏这⾥

注意: 如果循环是通过break退出的. 那么while后⾯的else将不会被执⾏, 只有在while条件判断是假的时候才会执⾏这个else

九：流程控制-break和continue

1, break: 立刻跳出循环. 打断的意思

2, continue: 停⽌本次循环, 继续执⾏下⼀次循环.

补充：

in和not in

可以判断xxx字符串是否出现在xxxxx字符串中

pass: 不表⽰任何内容. 为了代码的完整性. 占位⽽已

十：格式化输出

见另一篇博客：格式化输出

十一：基本运算符

1）算数运算符

2）比较运算符

3）赋值运算符

4）逻辑运算符

1, 在没有()的情况下not 优先级⾼于 and，and优先级⾼于or，即优先级关系为( )>not>and>or，同⼀优先级从左往右计算。

() > not > and > or

2, x or y , x为真，值就是x，x为假，值是y；

x and y, x为真，值是y,x为假，值是x。

and 和or 的运算相反

十二：Python之再谈基本数据类型

1、Python基本数据类型

1. int ==> 整数. 主要⽤来进⾏数学运算

2. str ==> 字符串, 可以保存少量数据并进⾏相应的操作

3. bool==>判断真假, True, False

4. list==> 存储⼤量数据.⽤[ ]表⽰

5. tuple=> 元组, 不可以发⽣改变 ⽤( )表⽰

6. dict==> 字典, 保存键值对, ⼀样可以保存⼤量数据

7. set==> 集合, 保存⼤量数据. 不可以重复. 其实就是不保存value的dict

2、整型(int)

整数: 常见操作就那么几个 +-*/ // % **

bit_length() 一个数的二进制长度

3、布尔类型(bool)

没有操作

类型转换

字符串转换成整数 int(str)

结论1: 想要转化成什么类型就用这个类型括起来

结论2: True => 1 False => 0

结论3: 可以当做False来用的数据: 0 "" [] {} () None没有操作

4、字符串类型(str)

1. 字符: 单一文字符号

2. 字符串: 有序的字符序列

字符串由 ' " ''' """括起来的内容 字符串

索引 : 一排数字. 反应第某个位置的字符 索引的下标从0开始. 使用[]来获取数据

切片: [start: end: step]

顾头不顾尾

step:步长. 如果是+ 从左往右. 如果是- 从右往左 每n个取1个

3. 常用操作方法:

1. upper() 转化成大写. 忽略大小写的时候

2. strip() 去掉左右两端空白 用户输入的内容都要去空白

3. replace(old, new) 字符串替换

4. split() 切割 结果是list

5. startswith() 判断是否以xxx开头

6. find() 查找

7. isdigit() 判断是否是数字组成

8. len() 求长度. 内置函数

4. for循环

for 变量 in 可迭代对象:

循环体(break, continue)

else:

当循环结束的时候执行else

#-*- coding: utf-8 -*-#@Time : 18-9-9 上午11:27#@Author : Felix Wang

#字符串#########################################切片和索引#1. 索引. 索引就是下标. 切记, 下标从0开始#0123456 7 8

s1 = "python最⽜B"

print(s1[0]) #获取第0个

print(s1[1])print(s1[2])print(s1[3])print(s1[4])print(s1[5])print(s1[6])print(s1[7])print(s1[8])#print(s1[9]) # 没有9, 越界了. 会报错

print(s1[-1]) #-1 表示倒数.

print(s1[-2]) #倒数第⼆个

#2. 切片, 我们可以使⽤下标来截取部分字符串的内容#语法: str[start: end]#规则: 顾头不顾腚, 从start开始截取. 截取到end位置. 但不包括end

s2 = "python最⽜B"

print(s2[0:3]) #从0获取到3. 不包含3. 结果: pyt

print(s2[6:8]) #结果 最⽜

print(s2[6:9]) #最⼤是8. 但根据顾头不顾腚, 想要取到8必须给9

print(s2[6:10]) #如果右边已经过了最⼤值. 相当于获取到最后

print(s2[4:]) #如果想获取到最后. 那么最后⼀个值可以不给.

print(s2[-1:-5]) #从-1 获取到 -5 这样是获取不到任何结果的. 从-1向右数. 你怎么数也数不到-5

print(s2[-5:-1]) #⽜b, 取到数据了. 但是. 顾头不顾腚. 怎么取最后⼀个呢?

print(s2[-5:]) #什么都不写就是最后了

print(s2[:-1]) #这个是取到倒数第⼀个

print(s2[:]) #原样输出

#跳着截取#跳着取, 步⻓

print(s2[1:5:2]) #从第⼀个开始取, 取到第5个,每2个取1个, 结果: yh, 分析: 1:5=>ytho => yh

print(s2[:5:2]) #从头开始到第五个. 每两个取⼀个

print(s2[4::2]) #从4开始取到最后. 每两个取⼀个

print(s2[-5::2]) #从-5取到最后.每两个取⼀个

print(s2[-1:-5]) #-1:-5什么都没有. 因为是从左往右获取的.

print(s2[-1:-5:-1]) #步⻓是-1. 这时就从右往左取值了

print(s2[-5::-3]) #从倒数第5个开始. 到最开始. 每3个取⼀个, 结果oy

#步⻓: 如果是整数, 则从左往右取. 如果是负数. 则从右往左取. 默认是1#切片语法:#str[start:end:step]#start: 起始位置#end: 结束位置#step:步⻓##############################################

#字符串相关操作方法#切记, 字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的

#1、大小写转来转去

s1.capitalize() #首字母转换成大写

print(s1) #输出发现并没有任何的变化. 因为这⾥的字符串本身是不会发⽣改变的. 需要我们重新获取

ret1 =s1.capitalize()print(ret1)#⼤⼩写的转换

ret = s1.lower() #全部转换成⼩写

print(ret)

ret= s1.upper() #全部转换成⼤写

print(ret)#应⽤, 校验⽤户输⼊的验证码是否合法

verify_code = "abDe"user_verify_code= input("请输⼊验证码:")if verify_code.upper() ==user_verify_code.upper():print("验证成功")else:print("验证失败")

ret= s1.swapcase() #⼤⼩写互相转换

print(ret)#不常⽤

ret = s1.casefold() #转换成⼩写, 和lower的区别: lower()对某些字符⽀持不够好.casefold()对所有字⺟都有效. ⽐如东欧的⼀些字⺟

print(ret)

s2= "БBß" #俄美德

print(s2)print(s2.lower())print(s2.casefold())#每个被特殊字符隔开的字⺟⾸字⺟⼤写

s3 = "felix amy_dabing*dijia+神仙"ret= s3.title() #Felix Amy_Dabing*Dijia+神仙

print(ret)#中⽂也算是特殊字符

s4 = "felix喜欢beijing" #Felix喜欢Beijing

print(s4.title())#2、字符串切来切去#居中

s5 = "周杰伦"ret= s5.center(10, "*") #拉⻓成10, 把原字符串放中间.其余位置补*

print(ret)#更改tab的⻓度

s6 = "felix dajiang\tdijia"

print(s6)print(s6.expandtabs()) #可以改变\t的⻓度, 默认⻓度更改为8#去空格

s7 = "felix dijia haha"ret= s7.strip() #去掉左右两端的空格

print(ret)

ret= s7.lstrip() #去掉左边空格

print(ret)

ret= s7.rstrip() #去掉右边空格

print(ret)#应⽤, 模拟⽤户登录. 忽略⽤户输⼊的空格

username = input("请输⼊⽤户名:").strip()

password= input("请输⼊密码:").strip()if username == 'felix' and password == '123':print("登录成功")else:print("登录失败")

s7= "abcdefgabc"

print(s7.strip("abc")) #defg 也可以指定去掉的元素,#字符串替换

s8 = "felix_dijia_taibai_beijin_hangzhou"ret= s8.replace('felix', 'Python大佬') #把felix替换成Python大佬

print(s8) #felix_dijia_taibai_beijin_hangzhou切记, 字符串是不可变对象. 所有操作都是产⽣新字符串返回

print(ret) #Python大佬_dijia_taibai_beijin_hangzhou

ret = s8.replace('i', 'SB', 2) #把i替换成SB, 替换2个

print(ret) #felSBx_dSBjia_taibai_beijin_hangzhou#字符串切割

s9 = "felix_dijia_taibai_beijin_hangzhou"lst= s9.split(",") #字符串切割, 根据,进⾏切割

print(lst)

s10= """诗⼈

学者

感叹号

渣渣"""

print(s10.split("\n")) #⽤\n切割#坑

s11 = "银王哈哈银王呵呵银王吼吼银王"lst= s11.split("银王") #['', '哈哈', '呵呵', '吼吼', ''] 如果切割符在左右两端. 那么⼀定会出现空字符串.深坑请留意

print(lst)#3、查找

s13 = "我叫sylar, 我喜欢python, java, c等编程语⾔."ret1= s13.startswith("sylar") #判断是否以sylar开头

print(ret1)

ret2= s13.startswith("我叫sylar") #判断是否以我叫sylar开头

print(ret2)

ret3= s13.endswith("语⾔") #是否以'语⾔'结尾

print(ret3)

ret4= s13.endswith("语⾔.") #是否以'语⾔.'结尾

print(ret4)

ret7= s13.count("a") #查找"a"出现的次数

print(ret7)

ret5= s13.find("sylar") #查找'sylar'出现的位置

print(ret5)

ret6= s13.find("tory") #查找'tory'的位置, 如果没有返回-1

print(ret6)

ret7= s13.find("a", 8, 22) #切⽚找

print(ret7)

ret8= s13.index("sylar") #求索引位置. 注意. 如果找不到索引. 程序会报错

print(ret8)#4、条件判断#条件判断

s14 = "123.16"s15= "abc"s16= "_abc!@"

#是否由字⺟和数字组成

print(s14.isalnum())print(s15.isalnum())print(s16.isalnum())#是否由字⺟组成

print(s14.isalpha())print(s15.isalpha())print(s16.isalpha())#是否由数字组成, 不包括⼩数点

print(s14.isdigit())print(s14.isdecimal())print(s14.isnumeric()) #这个⽐较⽜B. 中⽂都识别.

print(s15.isdigit())print(s16.isdigit())#练习. ⽤算法判断某⼀个字符串是否是⼩数

s17 = "-123.12"s17= s17.replace("-", "") #替换掉负号

ifs17.isdigit():print("是整数")else:if s17.count(".") == 1 and not s17.startswith(".") and not s17.endswith("."):print("是⼩数")else:print("不是⼩数")#5、计算字符串的⻓度

s18 = "我是你的眼, 我也是a"ret= len(s18) #计算字符串的⻓度

print(ret)#6、迭代#我们可以使⽤for循环来便利(获取)字符串中的每⼀个字符#语法:#for 变量 in 可迭代对象:#pass#可迭代对象: 可以⼀个⼀个往外取值的对象

s19= "⼤家好, 我是VUE, 前端的⼩朋友们. 你们好么?"

#⽤while循环

index =0while index

index = index + 1

#for循环, 把s19中的每⼀个字符拿出来赋值给前⾯的c

for c ins19:print(c)'''in有两种⽤法:

1. 在for中. 是把每⼀个元素获取到赋值给前⾯的变量.

2. 不在for中. 判断xxx是否出现在str中.'''

print('VUE' ins19)#练习, 计算在字符串"I am sylar, I'm 14 years old, I have 2 dogs!"

s20 = "I am sylar, I'm 14 years old, I have 2 dogs!"count=0for c ins20:ifc.isdigit():

count= count + 1

print(count)#######################################################

字符串操作归纳

5、列表

1. 什么是列表(list)

能装东西的东西 列表中装的数据是没有限制的， 大小基本上是够用的

列表使用[]来表示。 在列表中每个元素与元素之间用逗号隔开

有索引和切片

[start, end, step]

2. 增删改查

1. 增加:

append(), insert(), extend()迭代增加

2. 删除:

remove(), pop(), clear(), del

3. 修改:

索引修改

4. 查询:

for el in list:

el

5. 操作:

1. count()

2. sort(reverse=True) 排序

3. reverse() 翻转

4. find()

5. index()

#-*- coding: utf-8 -*-#@Time : 18-9-9 上午11:27#@Author : Felix Wang

##############################################列表的索引

lst = ["麻花藤", "王剑林", "⻢芸", "周鸿医", "向华强"]print(lst[0]) #获取第⼀个元素

print(lst[1])print(lst[2])

lst[3] = "流动强" #注意. 列表是可以发⽣改变的. 这⾥和字符串不⼀样

print(lst) #['麻花藤', '王剑林', '⻢芸', '流动强', '向华强']

s0 = "向华强"

#s0[1] = "美" # TypeError: 'str' object does not support item assignment 不允许改变

print(s0)#列表的切片

lst = ["麻花藤", "王剑林", "⻢芸", "周鸿医", "向华强"]print(lst[0:3]) #['麻花藤', '王剑林', '⻢芸']

print(lst[:3]) #['麻花藤', '王剑林', '⻢芸']

print(lst[1::2]) #['王剑林', '周鸿医'] 也有步⻓

print(lst[2::-1]) #['⻢芸', '王剑林', '麻花藤'] 也可以倒着取

print(lst[-1:-3:-2]) #倒着带步⻓

#列表的增删改查#1、增, 注意, list和str是不⼀样的. lst可以发⽣改变. 所以直接就在原来的对象上进⾏了操作

lst = ["麻花藤", "林俊杰", "周润发", "周芷若"]print(lst)

lst.append("felix")print(lst)

lst=[]whileTrue:

content= input("请输⼊你要录⼊的员⼯信息, 输⼊Q退出:")if content.upper() == 'Q':breaklst.append(content)print(lst)

lst= ["麻花藤", "张德忠", "孔德福"]

lst.insert(1, "刘德华") #在1的位置插⼊刘德华. 原来的元素向后移动⼀位

print(lst)#迭代添加

lst = ["王志⽂", "张⼀⼭", "苦海⽆涯"]

lst.extend(["麻花藤", "麻花不疼"])print(lst)#2、删除，pop, remove, clear, del

lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"]print(lst)

deleted= lst.pop() #删除最后⼀个

print("被删除的", deleted)print(lst)

el= lst.pop(2) #删除2号元素

print(el)print(lst)

lst.remove("麻花藤") #删除指定元素

print(lst)#lst.remove("哈哈") # 删除不存在的元素会报错## print(lst)

lst.clear() #清空list

print(lst)#切⽚删除

del lst[1:3]print(lst)#修改，索引切片修改#修改

lst = ["太⽩", "太⿊", "五⾊", "银王", "⽇天"]

lst[1] = "太污" #把1号元素修改成太污

print(lst)

lst[1:4:3] = ["麻花藤", "哇靠"] #切⽚修改也OK. 如果步⻓不是1, 要注意. 元素的个

数print(lst)

lst[1:4] = ["李嘉诚和哈哈"] #如果切⽚没有步⻓或者步⻓是1. 则不⽤关⼼个数

print(lst)#查询, 列表是⼀个可迭代对象, 所以可以进⾏for循环

for el inlst:print(el)#其他操作

lst = ["太⽩", "太⿊", "五⾊", "银王", "⽇天", "太⽩"]

c= lst.count("太⽩") #查询太⽩出现的次数

print(c)

lst= [1, 11, 22, 2]

lst.sort()#排序. 默认升序

print(lst)

lst.sort(reverse=True) #降序

print(lst)

lst= ["太⽩", "太⿊", "五⾊", "银王", "⽇天", "太⽩"]print(lst)

lst.reverse()print(lst)

l= len(lst) #列表的⻓度

print(l)#列表的嵌套#采⽤降维操作.⼀层⼀层的看就好.

lst = [1, "太⽩", "felix", ["⻢⻁疼", ["可⼝可乐"], "王剑林"]]#找到felix

print(lst[2])#找到太⽩和felix

print(lst[1:3])#找到太⽩的⽩字

print(lst[1][1])#将felix拿到. 然后⾸字⺟⼤写. 再扔回去

s = lst[2]

s=s.capitalize()

lst[2] =sprint(lst)#简写

lst[2] = lst[2].capitalize()print(lst)#把太⽩换成太⿊

lst[1] = lst[1].replace("⽩", "⿊")print(lst)#把⻢⻁疼换成⻢化疼

lst[3][0] = lst[3][0].replace("⻁", "化")print(lst[3][0])

lst[3][1].append("雪碧")print(lst)#########################################

列表操作归纳

6、元组

元组: 俗称不可变的列表.⼜被成为只读列表, 元组也是python的基本数据类型之⼀, ⽤⼩括

号括起来, ⾥⾯可以放任何数据类型的数据, 查询可以. 循环也可以. 切片也可以. 但就是不能

改.

不可变的列表. 只读列表, 由小括号表示. 第一层不可变.第二层等其他看类型。

如果是空元祖: tuple()

一个元素 (1, )

#元组

tu = (1, "太⽩", "李⽩", "太⿊", "怎么⿊")print(tu)print(tu[0])print(tu[2])print(tu[2:5]) #切⽚之后还是元组#for循环遍历元组

for el intu:print(el)#尝试修改元组#tu[1] = "⻢⻁疼" # 报错 'tuple' object does not support item assignment

tu = (1, "哈哈", [], "呵呵")#tu[2] = ["fdsaf"] # 这么改不⾏

tu[2].append("麻花藤") #可以改了. 没报错

tu[2].append("王剑林")print(tu)#注意: 这⾥元组的不可变的意思是⼦元素不可变. ⽽⼦元素内部的⼦元素是可以变, 这取决于⼦元素是否是可变对象.

#元组中如果只有⼀个元素. ⼀定要添加⼀个逗号, 否则就不是元组

tu = (1,)print(type(tu))#元组也有count(), index(), len()等⽅法. 可以⾃⼰测试使⽤

元组操作归纳

7、range操作

range可以帮我们获取到⼀组数据. 通过for循环能够获取到这些数据.

range(边界) 从0到边界

range(start, end) 从start到end

range(start, end, step) 从start到end. 步长是step

遍历列表的时候可以使用range

for i in range(len(list)):

list[i]

#range操作

for num in range(10):print(num)for num in range(1, 10, 2):print(num)for num in range(10, 1, -2): #反着来, 和切⽚⼀样

print(num)

range操作

8、字典

1. 什么是字典

dict. 以{}表示. 每一项用逗号隔开, 内部元素用key:value的形式来保存数据

{"jj":"林俊杰", "jay":"周杰伦"}

查询的效率非常高, 通过key来查找元素

内部使用key来计算一个内存地址(暂时),hash算法. key必须是不可变的数据类型(key 必须是可哈希的数据类型)

可哈希就是不可变 已知的可哈希(不可变)的数据类型: int, str, tuple, bool。不可哈希(可变)的数据类型: list, dict, set

2. 字典的增删改查

1. 字典的新增:

dict[新key] = value

dict.setdefault()

2. 删除

pop(key)

popitem()

clear()

del dict[key]

3. 修改

dic[key] = 新值

update()

4. 查询

1. 用key直接查询 dict[key]

2. get(key, 如果key不存在返回的数据)

3. setdefault() 1. 执行新增流程. 2. 查询结果

5. 操作

1. keys() 获取所有键 这个返回的不是列表, 很像列表

2. values()获取所有的值

3. items() 获取所有的键值对. 返回的是元组

解构, 直接把元组或者列表中的数据拿出来.

a, b, c = (a1, b1, c1) 必须一一对应

6. 遍历字典

for key in dict:

dict[key]

for k, v in dict.items():

k , v

7. 字典嵌套.

#字典操作#1、字典的基本语法#合法

dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅哥', '美⼥'], (1, 2, 3): '麻花藤'}print(dic[123])print(dic[True])print(dic['id'])print(dic['stu'])print(dic[(1, 2, 3)])#不合法#dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key#dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key#dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key#dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. ⽽hash表不是连续的. 所以不能进⾏切片⼯作. 它只能通过key来获取dict中的数据

#2、字典的增删改查#1）增加

dic ={}

dic['name'] = '周润发' #如果dict中没有出现这个key, 就会新增⼀个key-value的组合进dict

dic['age'] = 18

print(dic)#如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值

dic.setdefault('李嘉诚') #也可以往⾥⾯设置值.

dic.setdefault("李嘉诚", "房地产") #如果dict中已经存在了. 那么setdefault将不会起作⽤

print(dic)#2）删除#ret = dic.pop("jay")#print(ret)#del dic["jay"]#print(dic)#随机删除.

ret =dic.popitem()#清空字典中的所有内容

dic.clear()#3）修改

dic = {"id": 123, "name": 'sylar', "age": 18}

dic1= {"id": 456, "name": "麻花藤", "ok": "wtf"}

dic.update(dic1)#把dic1中的内容更新到dic中. 如果key重名. 则修改替换. 如果不存在key, 则新增.

print(dic)print(dic1)#4）查询#查询⼀般⽤key来查找具体的数据.

print(dic['name'])#print(dic['sylar']) # 报错

print(dic.get("ok"))print(dic.get("sylar")) #None

print(dic.get("sylar", "⽜B")) #⽜B

#5）其他相关操作

dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科⽐"}print(dic.keys()) #dict_keys(['id', 'name', 'age', 'ok']) 不⽤管它是什么.当成list来⽤就⾏

for key indic.keys():print(key)print(dic.values()) #dict_values([123, 'sylar', 18, '科⽐']) ⼀样. 也当list来⽤

for value indic.values():print(value)print(

dic.items())#dict_items([('id', 123), ('name', 'sylar'), ('age',18), ('ok', '科⽐')]) 这个东⻄也是list. 只不过list中装的是tuple

for key, value in dic.items(): #?? 这个是解构

print(key, value)#解构 重要掌握

a, b = 1, 2

print(a, b)

(c, d)= 3, 4

print(c, d)#e, f = [1, 2, 3] # 解构的时候注意数量必须匹配#print(e, f)

#5）字典的嵌套#字典的嵌套

dic1 ={"name": "汪峰","age": 18,"wife": {"name": '章⼦怡',"age": 28},"children": ['第⼀个⽑孩⼦', '第⼆个⽑孩⼦'],"desc": '峰哥不会告我吧. 没关系. 我想上头条的'}print(dic1.get("wife").get("name"))print(dic1.get("children"))print(dic1.get("children")[1])

字典相关操作归纳