Python基础
python基础
Python基础语法涵盖字符串格式化、运算符、编码原理和数据类型等核心内容。字符串格式化支持%操作符、format方法和f-string三种方式，用于灵活构建字符串。运算符包括算术、比较、逻辑、赋值等类型，支持各种运算操作。编码部分主要讲解Unicode字符集和UTF-8编码格式的实现原理。数据类型包含数字、字符串、列表、元组、字典和集合等基础结构，每种类型都具有特定的特性和使用场景。这些基础知识构成了Python编程的核心要素，是掌握更高级编程技能的必要前提。
字符串格式化
实现字符串的拼接。
1.%+变量名
text = "%s" % "小猫"
text = "%s,%d" % ("小猫",123)
print(text)
#小猫,123
text1= "%(name)s %(this)s" % {"name":"亲爱的","this":"小猫"}
print(text1)
#亲爱的 小猫
输出%, %%
2. format
text = "{0},{1}。".format("aaa","bbb")
print(text)
#aaa,bbb。
#不添加索引从前开始匹配，但不能复用
#0,1数字可用变量名替换。(name="xxx")
text = "{0},{1}"
data=text.format("123","456")
print(data)
#123,456
3. f (python3.6 version)
i have 3 + 2 = 5 catanimal="cat"
text=f"{animal} is cute"
print(text)
#cat is cute
text=f"i have {3 + 2} cat"
print(text)
#i have 5 cat
#python3.8
text=f"i have {3 + 2 = } cat"
print(text)
#i have 3 + 2 = 5 cat
#进制转换
text=f"i have {12:#b} cat"
print(text)
#i have 0b1100 cat
运算符
# **幂次
# //取整除
#成员运算
in #返回true
not in #返回false
#逻辑运算
and
or
not
v2 = "wupeiqi" and "alex"
# 第一步：将and前后的只转换为布尔值 True and True
# 第二步：判断本次操作取悦于谁？由于前面的是True，所以本次逻辑判断取决于后面的值。
# 所以，后面的只等于多少最终结果就是多少。 v2 = "alex"
v3 = "" and "alex"
# 第一步：将and前后的只转换为布尔值 False and True
# 第二步：判断本次操作取悦于谁？由于前面的是False，所以本次逻辑判断取决于前面的值。
# 所以，前面的只等于多少最终结果就是多少。 v2 = ""
v4 = 1 or 8
# 第一步：将and前后的只转换为布尔值 True or True
# 第二步：判断本次操作取悦于谁？由于前面的是True，所以本次逻辑判断取决于前面的值。
# v4 = 1
v5 = 0 or 8
# 第一步：将and前后的只转换为布尔值 False or True
# 第二步：判断本次操作取悦于谁？由于前面的是False，所以本次逻辑判断取决于后面的值。
# v5 = 8
#如果多个and 和or的情况，先计算and再计算or.
编码
1.unicode
unicode也被称为万国码，为全球的每个文字都分配了一个码位（二进制表示）。
ucs2和ucs4指的是使用多少个字节来表示unicode字符集的码位。
unicode的应用：在文件存储和网络传输时，不会直接使用unicode，而在内存中会unicode。
2. utf-8编码
包含所有文字和二进制的对应关系，全球应用最为广泛的一种编码（站在巨人的肩膀上功成名就）。
本质上：utf-8是对unicode的压缩，用尽量少的二进制去与文字进行对应。
unicode码位范围 utf-8
0000 ~ 007F 用1个字节表示
0080 ~ 07FF 用2个字节表示
0800 ~ FFFF 用3个字节表示
10000 ~ 10FFFF 用4个字节表示
具体压缩的流程：
-
第一步：选择转换模板
码位范围（十六进制） 转换模板 0000 ~ 007F 0XXXXXXX 0080 ~ 07FF 110XXXXX 10XXXXXX 0800 ~ FFFF 1110XXXX 10XXXXXX 10XXXXXX 10000 ~ 10FFFF 11110XXX 10XXXXXX 10XXXXXX 10XXXXXX 例如： "B" 对应的unicode码位为 0042，那么他应该选择的一个模板。 "ǣ" 对应的unicode码位为 01E3，则应该选择第二个模板。 "武" 对应的unicode码位为 6B66，则应该选择第三个模板。 "沛" 对应的unicode码位为 6C9B，则应该选择第三个模板。 "齐" 对应的unicode码位为 9F50，则应该选择第三个模板。 😆 对应的unicode码位为 1F606，则应该选择第四个模板。 注意：一般中文都使用第三个模板（3个字节），这也就是平时大家说中文在utf-8中会占3个字节的原因了。 -
第二步：在模板中填入数据
- "武" -> 6B66 -> 110 101101 100110 - 根据模板去套入数据 1110XXXX 10XXXXXX 10XXXXXX 1110XXXX 10XXXXXX 10100110 1110XXXX 10101101 10100110 11100110 10101101 10100110 在UTF-8编码中 ”武“ 11100110 10101101 10100110 - 😆 -> 1F606 -> 11111 011000 000110 - 根据模板去套入数据 11110000 10011111 10011000 10000110Python相关的编码
字符串（str） "alex媳妇叫铁锤" unicode处理 一般在内存
字节（byte） b"alexfdsfdsdfskdfsd" utf-8编码 or gbk编码 一般用于文件或网络处理
数据类型
int
#转换
v1 = int("186",base=10) # 把字符串换成十进制的值，然后在转换为 十进制整数
bool
整数0、空字符串、空列表、空元组、空字典转换为布尔值时均为False
其他均为True
字符串
独有功能
#判断字符串是否以 XX 开头/结尾？得到一个布尔值
v1 = "i love you"
result1 = v1.startswith("i")
print(result1)
v2 = "you love me"
result2 = v2.endswith("me")
print(result2)
# true true
#判断字符串是否为十进制数？得到一个布尔值
v1 = "1238871"
result = v1.isdecimal()
print(result) # True
#去除字符串两边的 空格、换行符、制表符，得到一个新字符串
v4 = " cat is cute "
print(v4.strip()) #cat is cute
data = msg.lstrip()
data = msg.rstrip()
#去除字符串两边指定的内容
v5 = "cat love cat"
print(v5.strip("cat"))
print(v5.rstrip("cat"))
print(v5.lstrip("cat"))
# love
#cat love
# love cat
#字符串变大写，得到一个新字符串
v1 = "my heart is shaken"
print(v1.upper()) #MY HEART IS SHAKEN
print(v2.lower())
#字符串内容替换，得到一个新的字符串
v1 = "i love you,you love me"
v2 = v1.replace("me", "her")
print(v2) #i love you,you love her
#字符串切割，得到一个列表
data = "abc|root|wupeiqi@qq.com"
result = data.split('|') # ["abc","root","wupeiqi@qq.com"]
print(data) # "abc|root|wupeiqi@qq.com"
print(result) # 输出 ["abc","root","wupeiqi@qq.com"] 根据特定字符切开之后保存在列表中，方便以后的操作
#字符串拼接，得到一个新的字符串
v3 = ["he","is","my","lover"]
v4 = "**".join(v3)
print(v4) #he**is**my**lover
#将字符串内容居中、居左、居右展示
v1 = "i love you,you love me"
print(v1.center(40,"*"))
print(v1.ljust(40,"*"))
print(v1.rjust(40,"*"))
#*********i love you,you love me*********
#i love you,you love me******************
#******************i love you,you love me
#填充0
v1 = "2025"
print(v1.zfill(20))
#00000000000000002025
公共功能
相加：字符串 + 字符串
-
相加：字符串 + 字符串
v1 = "alex" + "大sb" print(v1) -
相乘：字符串 * 整数
data = "亲爱的" * 3 print(data) # 亲爱的亲爱的亲爱的 -
长度
data = "世界灿烂盛大" value = len(data) print(value) # 6 -
获取字符串中的字符，索引
message = "一朵花只有一个夏天" # 0 12 3 4 56 7 8 # ... -3 -2 -1 print(message[0]) # "一" print(message[1]) # "朵" print(message[2]) # "花" print(message[-1]) # 天 print(message[-2]) # 夏 print(message[-3]) # 个注意：字符串中是能通过索引取值，无法修改值。【字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。】
message = "一朵花只有一个夏天" index = 0 while index < len(message): value = message[index] print(value) index += 1message = "一朵花只有一个夏天" index = len(message) - 1 while index >=0: value = message[index] print(value) index -= 1 -
获取字符串中的子序列，切片
message = "一朵花只有一个夏天" print(message[0:2]) # "一朵" print(message[3:7]) # "只有一个" print( message[3:] ) # "只有一个夏天" print( message[:5] ) # "一朵花只有" print(message[4:-1]) # "有一个夏" print(message[4:-2]) # "有一个" print( message[4:len(message)] ) # "有一个夏天"注意：字符串中的切片只能读取数据，无法修改数据。【字符串在内部存储时不允许对内部元素修改，想要修改只能重新创建】
message = "一朵花只有一个夏天" value = message[:3] + "Python" + message[5:] print(value) #一朵花Python一个夏天 -
步长，跳着去字符串的内容
name = "生活不是电影，生活比电影苦" print( name[ 0:5:2 ] ) # 输出：生不电 【前两个值表示区间范围，最有一个值表示步长】 print( name[ :8:2 ] ) # 输出：生不电， 【区间范围的前面不写则表示起始范围为0开始】、 # 此处老师讲解时，错把 name[ 2::3 ]看成了name[ 2::2 ]，更正下。（感谢 B站 放酱啊噗啊噗 同学的反馈） # print( name[ 2::2 ] ) # 输出：不电，活电苦 # print( name[ 2::3 ] ) # 输出：不影活影 print( name[ 2::3 ] ) # 输出：不电，活电苦 【区间范围的后面不写则表示结束范围为最后】 print( name[ ::2 ] ) # 输出：生不电，活电苦 【区间范围不写表示整个字符串】 print( name[ 8:1:-1 ] ) # 输出：活生，影电是不 【倒序】name = "生活不是电影，生活比电影苦" print(name[8:1:-1]) # 输出：活生，影电是不 【倒序】 print(name[-1:1:-1]) # 输出：苦影电比活生，影电是不 【倒序】 # 面试题：给你一个字符串，请将这个字符串翻转。 value = name[-1::-1] print(value) # 苦影电比活生，影电是不活生 -
循环
-
while循环
message = "一朵花只有一个夏天" index = 0 while index < len(message): value = message[index] print(value) index += 1 -
for循环
message = "一朵花只有一个夏天" for char in message: print(char) -
range，帮助我们创建一系列的数字
range(10) # [0,1,2,3,4,5,6,7,8,9] range(1,10) # [1,2,3,4,5,6,7,8,9] range(1,10,2) # [1,3,5,7,9] range(10,1,-1) # [10,9,8,7,6,5,4,3,2] -
For + range
for i in range(10): print(i)message = "一朵花只有一个夏天" for i in range(5): # [0,1,2,3,4] print(message[i])message = "一朵花只有一个夏天" for i in range( len(message) ): # [0,1,2,3,4,5,6,7] print(message[i])
一般应用场景：
-
while，一般在做无限制（未知）循环此处时使用。
while True: ...# 用户输入一个值，如果不是整数则一直输入，直到是整数了才结束。 num = 0 while True: data = input("请输入内容:") if data.isdecimal(): num = int(data) break else: print("输入错误，请重新输入！") -
for循环，一般应用在已知的循环数量的场景。
message = "一朵花只有一个夏天" for char in message: print(char)for i in range(30): print(message[i]) -
break和continue关键字
message = "foreverfo" for char in message: if char == "f": continue print(char) # 输出： o r e v e r omessage = "foreverfo" for char in message: if char == "e": break print(char) # 输出： f o rfor i in range(5): print(i)# 0 1 2 3 4 for j in range(3): break print(j) # 0 1 2 # 0 1 2 # 0 1 2 # 0 1 2 # 0 1 2
-
转换
num = 999
data = str(sum)
print(data) #"999"
列表
独有功能
#追加
data_list.append(v1)
#批量追加，将一个列表中的元素逐一添加另外一个列表
tools = ["搬砖","菜刀","榔头"]
tools.extend( [11,22,33] ) # weapon中的值逐一追加到tools中
print(tools) # ["搬砖","菜刀","榔头",11,22,33]
#插入，在原列表的指定索引位置插入值
user_list=["cat","dog","cattle"]
user_list.insert(0,"pigeon")
print(user_list)
#['pigeon', 'cat', 'dog', 'cattle']
#在原列表中根据值删除(从左到右找第一个删除，慎用，里面没有会报错)
user_list.removw("cat")
#在原列表中根据索引踢出某个元素（根据索引位置删除）
user_list.pop() #无数字删除最后一个值
user_list.pop(1) #删除索引为1的值
#清空原列表
user_list.clear()
#根据值获取索引
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
# 0 1 2 3 4
user_list.index("Alex") #2
#列表元素排序(不能同时存在整型和字符串)
num_list = [11, 22, 4, 5, 11, 99, 88]
print(num_list)
num_list.sort() # 让num_list从小到大排序
num_list.sort(reverse=True) # # 让num_list从大到小排序
print(num_list)
#反转原列表
user_reverse()
获取unicode编码
v = ord("李")
print(v) #26446(十进制表示)
print(hex(v)) #0x674e(十六进制)
公共功能
#相加，两个列表相加获取生成一个新的列表。
v1 = ["good","large"]
v2 = ["well","nice"]
v3 = v1 + v2
print(v3) # ["good","large","well","nice"]
#相乘，列表*整型 将列表中的元素再创建N份并生成一个新的列表。
data = ["小猫","咪咪"] * 2
print(data) # ['小猫', '咪咪', '小猫', '咪咪']
#运算符in包含，由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。
user_list = ["咪咪","小狗","鹦鹉","月亮"]
result = "小狗" in user_list
# result = "小狗" not in user_list
print(result) # True
#获取长度
user_list = ["咪咪","小狗",'我的月亮你的心']
print( len(user_list) ) #3
#索引，一个元素的操作
user_list = ["cat","rubbit","panda"]
#读
print(user_list[0])
#改
user_list[0] = "goat"
#删
del user_list[1]
user_list.remove("xxx")
user_list.pop(1) #可以获取值
#切片，多个元素的操作（很少用）
#读
user_list = ["cat","rubbit","panda"]
print( user_list[0:2] ) #['cat', 'rabbit']
#改
user_list[0:2]= {21,23,43}
print(user_list) #[43, 21, 23, 'panda']
#删
del user_list[1:]
#步长
user_list = ["小明","小白",'巴啦啦小魔仙',"咪咪","亲爱的"]
# 0 1 2 3 4
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] )
#['小白', '咪咪']
#['小明', '巴啦啦小魔仙', '亲爱的']
#['小白', '咪咪']
#['亲爱的', '咪咪', '巴啦啦小魔仙']
#列表反转
user_list[::-1]
#循环的过程中对数据进行删除会踩坑
# 错误方式， 有坑，结果不是你想要的。
user_list = ["小明","小白",'巴啦啦小魔仙',"咪咪","亲爱的"]
for item in user_list:
if item.startswith("小"):
user_list.remove(item)
print(user_list)
# 正确方式，倒着删除。
user_list = ["小明","小白",'巴啦啦小魔仙',"咪咪","亲爱的"]
for index in range(len(user_list) - 1, -1, -1):
item = user_list[index]
if item.startswith("小"):
user_list.remove(item)
print(user_list)
转换
int、bool无法转换成列表
v1 = (11,22,33,44) # 元组
vv1 = list(v1) # 列表 [11,22,33,44]
v2 = {"alex","eric","dsb"} # 集合
vv2 = list(v2) # 列表 ["alex","eric","dsb"]
嵌套
列表属于容器，内部可以存放各种数据，所以他也支持列表的嵌套，如：
data = [ "小白",["巴啦啦小魔仙","小明"],True,[11,22,[999,123],33,44],"亲爱的" ]
对于嵌套的值，可以根据之前学习的索引知识点来进行学习，例如：
data = [ "小白呀",["巴啦啦小魔仙","小明"],True,[11,22,33,44],"亲爱的" ]
print( data[0] ) # "小白呀"
print( data[1] ) #['巴啦啦小魔仙', '小明']
print( data[0][2] ) # "呀"
print( data[1][-1] ) # "小明"
data.append(666)
print(data) # ['小白呀', ['巴啦啦小魔仙', '小明'], True, [11, 22, 33, 44], '亲爱的', 666]
data[1].append("abc")
print(data) # ['小白呀', ['巴啦啦小魔仙', '小明', 'abc'], True, [11, 22, 33, 44], '亲爱的', 666]
del data[-2]
print(data) #['小白呀', ['巴啦啦小魔仙', '小明', 'abc'], True, [11, 22, 33, 44], 666]
data[-2][1] = "alex"
print(data) # ['小白呀', ['巴啦啦小魔仙', '小明', 'abc'], True, [11, 'alex', 33, 44], 666]
data[1][0:2] = [999,666]
print(data) # ['小白呀', [999, 666, 'abc'], True, [11, 'alex', 33, 44], 666]
元组
列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。
元组（tuple），是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。
v1=(11,22,33)
# 建议：议在元组的最后多加一个逗号，用于标识他是一个元组。
d1 = (1) # 1,编译器会当成整型
d2 = (1,) # (1,)
公共功能
#相加，两个列表相加获取生成一个新的列表。
v1=("1","2")
v2=("3","4")
print(v1+v2)
#('1', '2', '3', '4')
#相乘，列表*整型 将列表中的元素再创建N份并生成一个新的列表。
#获取长度
print( len(user_list) )
#只能读不能更改
#翻转
元组: user_list[::-1]
列表: user_list[::-1]
user_list.reserve
转换
其他类型转换为元组，使用tuple(其他类型)，目前只有字符串和列表可以转换为元组。
data = tuple(其他)
# str / list
v1="moon"
print(tuple(v1))
v2=["cat","moon"]
print(tuple(v2))
#('m', 'o', 'o', 'n')
#('cat', 'moon')
嵌套
由于元组和列表都可以充当容器，他们内部可以放很多元素，并且也支持元素内的各种嵌套。
元组不可修改，但元组中嵌套的列表可以修改。
其他
以下哪些数据类型转换为布尔值为False
1
"" #false
-19
[] #false
[11,22]
(1)
(1,2,3)
() #false
集合
集合是一个 无序 、可变、不允许数据重复的容器。
v1={11,22,33,"cat"} #不支持索引操作
#定义空列表
v1 = []
v1 = list()
#定义空元组
v1 = ()
v1 = tuple()
#定义空集合
v1 = set ()
#定义空字典
v1 = set {}
v1 = dict()
一般什么时候用集合呢？
就是想要维护一大堆不重复的数据时，就可以用它。比如：做爬虫去网上找图片的链接，为了避免链接重复，可以选择用集合去存储链接地址。
独有功能
#添加元素
v1=set()
v1.add(1)
v1.add(2)
print(v1) #{1, 2}
#删除元素
v1.discard(1)
print(v1) #{2}
#交集
v1 = {"cat","rabbit","goat","dog"}
v2 = {"horse","cattle","pigeon","dog"}
v3 = v1 & v2
print(v3)
v4 = v1.intersection(v2)
print(v4)
#{'dog'}
#{'dog'}
#并集
v1 = {"cat","rabbit","goat","dog"}
v2 = {"horse","cattle","pigeon","dog"}
v3 = v1 | v2
print(v3)
v4 = v1.union(v2)
print(v4)
#{'dog', 'horse', 'cattle', 'cat', 'rabbit', 'goat', 'pigeon'}
#{'dog', 'horse', 'cattle', 'cat', 'rabbit', 'goat', 'pigeon'}
#差集
v1 = {"cat","rabbit","goat","dog"}
v2 = {"horse","cattle","pigeon","dog"}
v3 = v1.difference(v2) #v1中有且v2中没有的值
v4 = v2.difference(v1)
print(v3)
print(v4)
v5 = v1-v2
v6 = v2-v1
print(v5)
print(v6)
#{'goat', 'rabbit', 'cat'}
#{'horse', 'cattle', 'pigeon'}
#{'goat', 'rabbit', 'cat'}
#{'horse', 'cattle', 'pigeon'}
公共功能
#长度
data = len(v)
#循环，不可以通过索引循环
v = {"a", "b", "c"}
for item in v:
print(item)
转换
其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。
提示：int/list/tuple/dict都可以转换为集合。
v1 = "武沛齐"
v2 = set(v1)
print(v2) # {"武","沛","齐"}
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}
#提示：这其实也是去重的一个手段。
data = {11,22,33,3,99}
v1 = list(data) # [11,22,33,3,99]
v2 = tuple(data) # (11,22,33,3,99)
其他
因存储原理，集合的元素必须是可哈希的值，即：内部通过通过哈希函数把值转换成一个数字。
目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。
总结：集合的元素只能是 int、bool、str、tuple 。
转换成功
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
转换失败
v1 = [11,22,["alex","eric"],33]
v2 = set(v1) # 报错
print(v2) #元素不可以是列表和集合
查找速度特别快
因存储原理特殊，集合的查找效率非常高（数据量大了才明显）。
- 低
user_list = ["武沛齐","alex","李璐"]
if "alex" in user_list:
print("在")
else:
print("不在")
user_tuple = ("武沛齐","alex","李璐")
if "alex" in user_tuple:
print("在")
else:
print("不在")
- 效率高
user_set = {"武沛齐","alex","李璐"}
if "alex" in user_set:
print("在")
else:
print("不在")
对比和嵌套
| 类型 | 是否可变 | 是否有序 | 元素要求 | 是否可哈希 | 转换 | 定义空 |
|---|---|---|---|---|---|---|
| list | 是 | 是 | 无 | 否 | list(其他) | v=[]或v=list() |
| tuple | 否 | 是 | 无 | 是 | tuple(其他) | v=()或v=tuple() |
| set | 是 | 否 | 可哈希 | 否 | set(其他) | v=set() |
data_list = [
"alex",
11,
(11, 22, 33, {"alex", "eric"}, 22),
[11, 22, 33, 22],
{11, 22, (True, ["中国", "北京"], "沙河"), 33}
#错误，列表不可以放在集合里
]
注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：
v1 = {True, 1}
print(v1) # {True}
v2 = {1, True}
print(v2) # {1}
v3 = {0, False}
print(v3) # {0}
v4 = {False, 0}
print(v4) # {False}
下面那些值不能做集合的元素
""
0
[11,22,33] # 不能
[] # 不能
(123)
{1,2,3} # 不能
给你个列表去重。
v = [11,22,11,22,44455]
data = set(v) # {11,22,44455}
result = list(data) # [11,22,44455]
None类型
Python的数据类型中有一个特殊的值None，意味着这个值啥都不是 或 表示空。 相当于其他语言中 null作用一样。
在一定程度上可以帮助我们去节省内存。例如：
v1 = None
v2 = None
..
v1 = [11,22,33,44]
v2 = [111,22,43]
字典
字典是 无序、键不重复 且 元素只能是键值对的可变的 个的容器。
data = { "k1":1, "k2":2 }
-
容器
-
元素必须键值对
-
键不重复，重复则会被覆盖
data = { "k1":1, "k1":2 }
print(data) # {"k1":2}
- 无序（在Python3.6+字典就是有序了，之前的字典都是无序。）
data = { "k1":1, "k2":2 }
print(data)
#定义
v1 = {}
v2 = dict()
data = {
"k1":1,
"k2":2
}
info = {
"age":12,
"status":True,
"name":"wupeiqi",
"hobby":['篮球','足球']
}
字典中对键值得要求：
- 键：必须可哈希。 目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/set/dict。（集合）
- 值：任意类型。
#合法
data_dict = {
"武沛齐":29,
True:5,
123:5,
(11,22,33):["alex","eric"]
}
data_dict = {
1: 29,
True: 5
}
print(data_dict) # {1: 5}
一般在什么情况下会用到字典呢？
当我们想要表示一组固定信息时，用字典可以更加的直观，例如：
# 用户列表
user_list = [ ("alex","123"), ("admin","666") ]
...
# 用户列表
user_list = [ {"name":"alex","pwd":"123"}, {"name":"eric","pwd":"123"} ]
独有功能
#获取值
info = {
"age":12,
"status":True,
"name":"武沛齐",
"data":None
}
data1 = info.get("name")
print(data1) # 输出：武沛齐
data2 = info.get("age")
print(data2) # 输出：12
data = info.get("email") # 键不存在，默认返回 None
#如果健不存在则返回123
data = info.get("hobby",123)
print(data) # 输出：123
#案列
user_list = {
"wupeiqi": "123",
"alex": "uk87",
}
username = input("请输入用户名：")
password = input("请输入密码：")
# None，用户名不存在
# 密码，接下来比较密码
pwd = user_list.get(username)
if pwd == None:
print("用户名不存在")
else:
if password == pwd:
print("登录成功")
else:
print("密码错误")
所有的键
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.keys()
print(data) # 输出：dict_keys(['age', 'status', 'name', 'email']) py2 -> ['age', 'status', 'name', 'email']
result = list(data)
print(result) # ['age', 'status', 'name', 'email']
注意：在Python2中 字典.keys()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。
# 循环
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for ele in info.keys():
print(ele)
# 是否存在
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
# info.keys() # dict_keys(['age', 'status', 'name', 'email'])
if "age" in info.keys():
print("age是字典的键")
else:
print("age不是")
所有的值
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.values()
print(data) # 输出：dict_values([12, True, 'wupeiqi', 'xx@live.com'])
# 循环
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for val in info.values():
print(val)
# 是否存在
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
if 12 in info.values():
print("12是字典的值")
else:
print("12不是")
所有的键值
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()
print(data) # 输出 dict_items([ ('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com') ])
for item in info.items():
print(item[0],item[1]) # item是一个元组 (键，值)
for key,value in info.items():
print(key,value) # key代表键，value代表值，将兼职从元组中直接拆分出来了。
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()
if ('age', 12) in data:
print("在")
else:
print("不在")
设置值
data = {
"name": "武沛齐",
"email": 'xxx@live.com'
}
data.setdefault("age", 18)
print(data) # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}
data.setdefault("name", "alex")
print(data) # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}
更新字典键值对
info = {"age":12, "status":True}
info.update( {"age":14,"name":"武沛齐"} ) # info中没有的键直接添加；有的键则更新值
print(info) # 输出：{"age":14, "status":True,"name":"武沛齐"}
移除指定键值对
info = {"age":12, "status":True,"name":"武沛齐"}
data = info.pop("age")
print(info) # {"status":True,"name":"武沛齐"}
print(data) # 12
按照顺序移除（后进先出）
info = {"age":12, "status":True,"name":"武沛齐"}
data = info.popitem() # ("name","武沛齐" )
print(info) # {"age":12, "status":True}
print(data) # ("name","武沛齐")
- py3.6后，popitem移除最后的值。
- py3.6之前，popitem随机删除。
公共功能
-
求
并集（Python3.9新加入）v1 = {"k1": 1, "k2": 2} v2 = {"k2": 22, "k3": 33} v3 = v1 | v2 print(v3) # {'k1': 1, 'k2': 22, 'k3': 33} -
长度
info = {"age":12, "status":True,"name":"武沛齐"} data = len(info) print(data) # 输出：3 -
是否包含
info = { "age":12, "status":True,"name":"武沛齐" } v1 = "age" in info #默认判断键 print(v1) v2 = "age" in info.keys() print(v2) if "age" in info: pass else: passinfo = {"age":12, "status":True,"name":"武沛齐"} v1 = "武佩奇" in info.values() print(v1)info = {"age": 12, "status": True, "name": "武沛齐"} # 输出info.items()获取到的 dict_items([ ('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com') ]) v1 = ("age", 12) in info.items() print(v1) -
索引（键）
字典不同于元组和列表，字典的索引是键，而列表和元组则是0、1、2等数值。info = { "age":12, "status":True, "name":"武沛齐"} print( info["age"] ) # 输出：12 print( info["name"] ) # 输出：武沛齐 print( info["status"] ) # 输出：True print( info["xxxx"] ) # 报错，通过键为索引去获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值） value = info.get("xxxxx") # None print(value) -
根据键 修改值 和 添加值 和 删除键值对
上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作info = {"age":12, "status":True,"name":"武沛齐"} info["gender"] = "男" print(info) # 输出： {"age":12, "status":True,"name":"武沛齐","gender":"男"}info = {"age":12, "status":True,"name":"武沛齐"} info["age"] = "18" print(info) # 输出： {"age":"18", "status":True,"name":"武沛齐"}info = {"age":12, "status":True,"name":"武沛齐"} del info["age"] # 删除info字典中键为age的那个键值对（键不存在则报错） print(info) # 输出： {"status":True,"name":"武沛齐"}info = {"age": 12, "status": True, "name": "武沛齐"} if "agea" in info: # del info["age"] data = info.pop("age") print(info) print(data) else: print("键不存在") -
for循环
由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；info = {"age":12, "status":True,"name":"武沛齐"} for item in info: print(item) # 所有键info = {"age":12, "status":True,"name":"武沛齐"} for item in info.key(): print(item)info = {"age":12, "status":True,"name":"武沛齐"} for item in info.values(): print(item)info = {"age":12, "status":True,"name":"武沛齐"} for key,value in info.items(): print(key,value)
转换
想要转换为字典.
v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )
print(v) # { "k1":"v1", "k2":"v2" }
info = { "age":12, "status":True, "name":"武沛齐" }
v1 = list(info) # ["age","status","name"]
v2 = list(info.keys()) # ["age","status","name"]
v3 = list(info.values()) # [12,True,"武沛齐"]
v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","武沛齐") ]
其他
速度快
info = {
"alex":["a","b"],
"老男孩":["c","d"]
}
for "alex" in info:
print("在"）
info = {
"alex":["a","b"],
"老男孩":["c","d"]
}
v1 = info["alex"]
v2 = info.get("alex")
嵌套
-
字典的键必须可哈希（list/set/dict不可哈希）。
info = { (11,22):123 } # 错误 info = { (11,[11,22,],22):"alex" } -
字典的值可以是任意类型。
info = { "k1":{12,3,5}, "k2":{"xx":"x1"} } -
字典的键和集合的元素在遇到 布尔值 和 1、0 时，需注意重复的情况。
-
元组的元素不可以被替换。
dic = {
'name':'汪峰',
'age':48,
'wife':[ {'name':'国际章','age':38},{'name':'李杰','age':48} ],
'children':['第一个','第二个']
}
"""
1. 获取汪峰的妻子名字
d1 = dic['wife'][0]['name']
print(d1)
2. 获取汪峰的孩子们
d2 = dic['children']
print(d2)
3. 获取汪峰的第一个孩子
d3 = dic['children'][0]
print(d3)
4. 汪峰的媳妇姓名变更为 章子怡
dic['wife'][0]['name] = "章子怡"
print(dic)
5. 汪峰再娶一任妻子
dic['wife'].append( {"name":"铁锤","age":19} )
print(dic)
6. 给汪峰添加一个爱好：1
dic['hobby'] = "1"
print(dic)
7. 删除汪峰的年龄
del dic['age']
或
dic.pop('age')
print(dic)
"""
浮点型
浮点型，一般在开发中用于表示小数。
v1 = 3.14
v2 = 9.89
关于浮点型的其他知识点如下：
-
在类型转换时需要，在浮点型转换为整型时，会将小数部分去掉。
v1 = 3.14 data = int(v1) print(data) # 3 -
想要保留小数点后N位
v1 = 3.1415926 result = round(v1,3) print(result) # 3.142 -
浮点型的坑（所有语言中）
底层原理视频：https://www.bilibili.com/video/BV1354y1B7o1/
在项目中如果遇到精确的小数计算应该怎么办？
import decimal
v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3
## 总结
1. 集合，是 无序、不重复、元素必须可哈希、可变的一个容器（子孙元素都必须是可哈希）。
2. 集合的查找速度比较快（底层是基于哈希进行存储）
3. 集合可以具有 交并差 的功能。
4. 字典是 无序、键不重复 且 元素只能是键值对的可变的一个容器（键子孙元素都必须是可哈希）。
5. py3.6+之后字典就变为有序了。
6. py3.9 新增了一个 `{} | {} `运算。
7. 字典的常见功能。
8. 在python2和python3中，字典的 keys() 、values()、items() 三个功能获取的数据类型不一样。
9. None是代表内存中的一个空值。
```python
0
""
[] or list()
() or tuple()
set()
None
{} or dict()
- 浮点型用于表示小数，但是由于其内部存储原理可能会引发数据存储不够精准。
补充
pass的作用
一般Python的代码块是基于 : 和缩进来实现，Python中规定代码块中必须要有代码才算完整，在没有代码的情况下为了保证语法的完整性可以用pass代替，例如：
if 条件 :
pass
else:
pass
is比较
is 和 ==的区别是什么？
==，用于比较两个值是否相等。- is，用于表示内存地址是否一致。
# 示例1
v1 = []
v2 = []
print( v1 == v2 ) # True，两个值相当
print( v1 is v2 ) # False，不属于同一块内存。
# 示例2
v1 = []
v2 = v1
print( v1 == v2 ) # True，两个值相当
print( v1 is v2 ) # True，属于同一块内存。
# 示例3
v1 = None
v2 = None
print(v1 == v2) # True，两个值相当
print(v1 is v2) # True，属于同一块内存。
位运算
计算机底层本质上都是二进制，我们平时在计算机中做的很多操作底层都会转换为二进制的操作，位运算就是对二进制的操作。
# &，与（都为1）
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = a & b # 12 = 0000 1100
# |，或（只要有一个为1）
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = a | b # 61 = 0011 1101
# ^，异或（值不同）
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = a ^ b # 49 = 0011 0001
# ~，取反
a = 60 # 60 = 0011 1100
c = ~a; # -61 = 1100 0011
# <<，左移动
a = 60 # 60 = 0011 1100
c = a << 2; # 240 = 1111 0000
# >>，右移动
a = 60 # 60 = 0011 1101
c = a >> 2; # 15 = 0000 1111
平时在开发中，二进制的位运算几乎很少使用，在计算机底层 或 网络协议底层用的会比较多，例如：
#计算 2**n
2**0 1 << 0 1 1
2**1 1 << 1 10 2
2**2 1 << 2 100 4
2**3 1 << 3 1000 8
...
#计算一个数的一半【面试题】
v1 = 10 >> 1
print(v1) # 值为5
v2 = 20 > 1
print(v2) # 值为 10
#网络传输数据，文件太大还未传完（websocket源码为例）。
第1个字节 第2个字节 ...
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
FIN位置是0，表示这是一部分数据，后续还有数据。
FIN位置是1，表示这是最后数据，已发送完毕。
# 例如：接收到的第一个字节的值为245（11110101），让v的二进制和 1000 0000 做 & 与运算。
v = 245 # 245 11110101
# 128 10000000
10000000
data = v & 128
if data == 0:
print("还有数据")
else:
print("已完毕")
浙公网安备 33010602011771号