Python数据类型详解
2020-06-07 本文已影响0人
你怎么还在吃
字符串
-
字符串的定义方式
- 单引号定义字符串 ‘ ’
- 双引号定义字符串 “ ”
- 三引号定义字符串 ‘’‘内容’‘’或者 “”“内容”“”
- 字符串定义时，引号可以互相嵌套
-
转义字符
一个普通的字符出现在转义符 \ 的后面时，实现了另外一种意义
作为转义符时，在\后面出现的字符可能会实现另外一种意义。
作为续行符时，在行尾使用了\后，可以换行继续书写内容
\n 代表一个换行符
\r 代表光标位置（从\r出现的位置开始作为光标的起点）
\t 代表一个水平制表符（table 缩进）,按四下
\b 代表一个退格符
\\ 反转义\，输出了\，取消\的转义效果
#续行符
var = '123'\
'456'
print(var)#123456
#转义符
paper = '回复\n啊额会不会\n被哈把\n和部分诶俄碧'
print(paper)
#回复
#啊额会不会
#被哈把
#和部分诶俄碧
#\r 代表光标位置（从\r出现的位置开始作为光标的起点）
paper = '回复\r啊额会不会\n被哈把\n和部分诶俄碧'
print(paper)
#啊额会不会
#被哈把
#和部分诶俄碧
# \t 代表一个水平制表符（table 缩进）,按四下
paper = '回复\r啊额会不会\t被哈把\n和部分诶俄碧'
print(paper)
#啊额会不会 被哈把
#和部分诶俄碧
# \b 代表一个退格符,回删一下
paper = '回复，\b啊额会不，会\b被哈把和部分诶俄碧'
print(paper)#回复啊额会不，被哈把和部分诶俄碧
#`\\` 反转义\，输出了\，取消\的转义效果
var = '123\\456'
print(var)#123\456
# 把转义字符作为普通字符输出,在字符串的前面加 r''
paper = r'回复，\b啊额会不，会\b被哈把和部分诶俄碧'
print(paper)#回复，\b啊额会不，会\b被哈把和部分诶俄碧
-
字符串相关的操作
+操作
*操作
[ ] 切片操作
字符串[开始值：结束值：步进值]
开始值：默认为0，结束值默认是最后一个下标，步进值默认为1
#两种拼接方式
vara = '君不见，黄河之水天上来，奔流到海不复回.'
varb = '君不见，高堂明镜悲白发，朝如青丝暮成雪'
res1 = vara + varb
res2 = '将进酒 '+'李白'
print(res1)
print(res2)
# 字符串 * 操作
vars = '小太阳' * 5
print(vars)
# - 字符串 [] 切片操作
# 字符串的索引操作，字符串中只能使用[]下标 访问，不能修改
vars = '君不见，黄河之水天上来，奔流到海不复回'
print(vars[5])#河
print(vars[-5])#到
'''
字符串的切片操作
str[开始值：结束值：步进值]
开始值：默认为0，结束值默认是最后一个下标，步进值默认为1
'''
print(vars)
print(vars[5]) # 写一个值就是获取指定下标的元素
print(vars[2:5]) # 从2下标开始取值，一直到下标5之前，能取到2，取不到5
print(vars[4:8:2]) # 黄河之水 ==> 黄之
print(vars[::]) # 从头取到尾
print(vars[::2]) # 从头取到尾，每隔一个取一个
print(vars[::-1]) # 字符串倒转过来
print(vars[::-2]) # 字符串倒转过来，每隔一个取一个
print(vars[1::]) # 不见，黄河之水天上来，奔流到海不复回
print(vars[1::2]) # 不，河水上，流海复
-
字符串格式化的方法
.format()
f ' '
# 1 format 普通方式
a = '李白'
vars = '{}乘舟将欲行，互闻岸上踏歌声'.format(a)
vars = '{}乘舟将欲行，互闻岸上{}'.format(a,'踏歌声')
# 2 format 通过索引传参 0 1 2
vars = '{2}乘舟将欲行，互闻岸上{1}'.format('a','b','c')
# 3 format 关键字传参
vars = '{a}乘舟将欲行，互闻岸上{b}'.format(a='李白',b='踏歌声')
# 4 format 容器类型数据传参
vars = '豪放派：{0[0]}，婉约派：{0[1]}，蛋黄派：{0[2]}'.format(['李白','辛弃疾','达利园'])
#字典传参，**data当前的关键字必须按照定义的方式传递进来
data = {'a':'辛弃疾','b':'蛋黄派'}
vars = '{a}乘舟将欲行，互闻岸上{b}'.format(**data)
# 3.7中新增的 格式化方法 f方法
vars = f'{data["a"]}乘舟将欲行，互闻岸上{data["b"]}'
print(vars)
# 限定小数的位数
vars = '圆周率是多少：{:.4f}'.format(3.1415926)
print(vars)#3.1416
字符串相关函数
- 英文字符与字符检测相关函数
vars = 'too young to naive'
# 返回字符串的副本，该字符串的首个字符大写，其余小写。
# str.capitalize()
res1 = vars.capitalize()
# 把字符串中的一个单词的首字母大写
res2 = vars.title()
# 把字符串全部改为 大写
res3 = vars.upper()
# 把字符串全部改为 小写
res4 = vars.lower()
# 字符串中的大小写字符转换，大写转小写，小写转大写
res5 = vars.swapcase()
# 检测字符串是否为全部大写字母组成
res6 = vars.isupper()
# 检测字符串是否为全部小写字母组成
res7 = vars.islower()
# 检测字符串是否符合标题title的要求
res8 = vars.istitle()
# 检测字符串是否由数字和字母组成，如果字符串中包含来非数字字母的其它字符，比如空格则返回False
res9 = vars.isalnum()
# 检测字符串是否全部由字符(包含英文字符和中文)组成，不含空格，数字
res10 = vars.isalpha()
# 检测字符串是否由纯数字字符组成
res11 = vars.isdigit()
# 检测当前字符串是否为 空格 字符组成 ' '
res12 = vars.isspace()
# 检测字符串是否以指定的字符开始的，也可以指定开始和结束的位置
res13 = vars.startswith('t')
res14 = vars.startswith('y',4)
# 检测字符串是否以 指定的字符 结束的，也可以指定开始和结束的位置
res15 = vars.endswith('e')
res16 = vars.endswith('e',13,18)
- 查找与操作相关函数(重点)
vars = 'too young to naive'
# find() 方法 ，找到则返回字符中符合条件的第一个字符出现的索引位置。未找到返回 -1
res = vars.find('na')
print(res)#13
print(vars[res:res+5])#naive
# 字符串查找相关函数
# 从左向右 获取指定字符在字符串中第一次出现的索引位置，未找到则返回 -1
#str.find(sub[, start[, end]])
res1 = vars.find('to')
res2 = vars.find('young',0,14)
# 从右向左 获取指定字符在字符串中第一次出现的索引位置，未找到则返回 -1
res3 = vars.rfind('to')
res4 = vars.rfind('to',0,14)
print(res1)#0
print(res2)#0
print(res3)#10
print(res4)#10
vars = 'too young to naive'
# index() 方法
res = vars.index('you') # 找到则返回索引位置，未找到则报错 ValueError
print(res)#4
# str.index() 和find方法一样，只不过如果没有找到则报错 # ValueError: substring not found
# str.rindex() 和 rfind方法一样，没有找到则引发异常 # ValueError: substring not found
res = vars.rindex('you')#4
# str.count(sub[, start[, end]])# 统计一个字符在字符串中出现的字符
res = vars.count('o')#4
- 字符串操作相关函数( 重点)
vars = 'user_admin_id_123'
# str.split() 按照**指定的字符**进行分隔**，把一个字符串分隔成**一个列表**
print(vars.split('_')) # ['user', 'admin', 'id', '123']
print(vars.split('_')[2:4])#['id', '123']
vars = 'uid=123&type=ab&kw=hh'
res = vars.split('&')#先按照&进行分隔
for i in res:
r = i.split('=')#再按照=进行分隔
print(r.pop())#pop()用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
# 可以指定分隔的次数
# str.rsplit(sep=None,maxsplit=-1)
res = vars.split('_',2)
#['user', 'admin', 'id_123']
res = vars.rsplit('_')
# ['user', 'admin', 'id', '123']
res = vars.rsplit('_',2) #从最右边开始拆分，指定分割的次数
# ['user_admin', 'id', '123']
arr = ['user', 'admin', 'id', '123']
#str.join() 按照指定的字符，把任何容器类型中的数据链接成一个字符串
res = '-'.join(arr) # user-admin-id-123
vars = '###这是一个是#文章的标题##'
# 可以去除字符串左右两侧的指定字符
# str.strip()
res = vars.strip('#')
print(vars,len(vars))# ###这是一个是#文章的标题## 16
print(res,len(res))# 这是一个是#文章的标题 11
# str.lstrip() 去除字符串左侧的指定字符
# str.rstrip() 去除字符串右侧的指定字符
# str.replace() 替换
vars = 'iloveyoutosimidailoveyou'
res1 = vars.replace('love','like')
res2 = vars.replace('love','LOVE',1)#替换一次
vars = 'love'
res1 = vars.center(10)
res2 = vars.center(12,'*')
res3 = vars.ljust(10,'*')
res4 = vars.rjust(10,'*')
print(res1)
print(res2)
print(res3)
print(res4)
列表
-
定义
一组有序的数据组合，列表中的数据可以被修改
-
使用[ ]定义
-
使用list( )定义
-
在定义列表中的元素时，需要在每个元素之间使用逗号，进行分隔。[1,2,3,4]
-
列表中的元素可以是任意类型的，通常用于存放同类项目的集合
-
基本操作
# 列表定义与基本操作
varlist1 = [1,2,3,4]
varlist2 = ['a','b','c','d']
# 列表的拼接。把多个列表的元素拼接成一个列表
res = varlist1+varlist2+[11,22,33]
# 列表元素的重复
res = varlist1*3#重复列表1的内容
#不能列表乘列表
# 检测元素是否存在于列表
res = 'a' in varlist1#False
# 列表的索引操作
'''
0 1 2 3
'a','b','c','d'
-4 -3 -2 -1
'''
# 通过下标获取指定的元素
res = varlist2[2]
res = varlist2[-3]
# 通过下标修改元素
varlist2[2] = 'cc'
# 不能通过下标添加元素,
varlist2[4] = 'ff' #IndexError: list assignment index out of range
#向列表元素中追加元素
varlist2.append('ff')
print(varlist2)
# 列表元素的删除,通过下标进行元素的删除
del varlist2[2]#del 列表[下标]
res = varlist2.pop()#pop()函数 删除元素
print(res)
# 获取列表的长度 len()
res = len(varlist2)
print(res)
-
列表的切片
列表[开始索引:结束索引:步进值]
1、列表[开始索引:] ==> 从开始索引到列表的最后
2、列表[:结束值] ==> 从开始到指定的结束索引之前
3、列表[开始索引:结束索引] ==> 从开始索引到指定结束索引之前
4、 列表[开始索引:结束索引:步进值] ==> 从指定索引开始到指定索引前结束，按照指定步进进行取值切片
5、列表[:] 或 列表[::] ==> 所有列表元素的切片
6、列表[::-1] ==> 倒着获取列表的元素
varlist = ['刘德华','张学友','张国荣','黎明','郭富城','小沈阳','刘能','宋小宝','赵四']
# 从开始索引到列表的最后
res = varlist[2:] # ['张国荣','黎明','郭富城','小沈阳','刘能','宋小宝','赵四']
# 从开始到指定的结束索引之前
res = varlist[:2] # ['刘德华','张学友']
# 从开始索引到指定结束索引之前
res = varlist[2:6] # ['张国荣', '黎明', '郭富城', '小沈阳']
# 从指定索引开始到指定索引前结束，按照指定步进进行取值切片
res = varlist[2:6:2] # ['张国荣', '郭富城']
# 所有列表元素的切片
res = varlist[:]
res = varlist[::]
# 倒着输出列表的元素
res = varlist[::-1]
# 使用切片方法 对列表数据进行更新和删除
print(varlist)
# 从指定下标开始，到指定下标前结束，并替换为对应的数据(容器类型数据str list，会拆分成每个元素进行赋值)
varlist[2:6] = ['a','b','c',1,2,3]
varlist[2:6:2] = ['a','b'] # 需要与要更新的元素个数对应
# 切片删除
del varlist[2:6]
del varlist[2:6:2]
-
列表相关函数
varlist = ['刘德华','张学友','张国荣','张学友','黎明','郭富城','小沈阳','刘能','宋小宝','赵四']
# len() 检测当前列表的长度，列表中元素的个数
res = len(varlist)
# count() 检测当前列表中指定元素出现的次数
res = varlist.count('张学友')
# append() 向列表的尾部追加新的元素，返回值为 None
varlist.append('kris')
# insert() 可以向列表中指定的索引位置添加新的元素，
varlist.insert(20,'aa')
# pop() 可以对指定索引位置上的元素做 出栈 操作，返回出栈的元素
res = varlist.pop() # 默认会把列表中的最后一个元素 出栈
res = varlist.pop(2) # 会在列表中把指定索引的元素进行 出栈
varlist = [1,2,3,4,11,22,33,44,1,2,3,4]
# remove() 可以指定列表中的元素 进行 删除,只删除第一个。如果没有找到，则报错
res = varlist.remove(1)
# index() 可以查找指定元素在列表中第一次出现的索引位置
res = varlist.index(1)
res = varlist.index(1,5,10) # 可以在指定索引范围5-10内查找元素的索引位置
# extend() 接收一个容器类型的数据，把容器中的元素追加到原列表中
varlist.extend('123')
# s.clear() # 清空列表内容
varlist.clear()
# reverse() 列表翻转
varlist.reverse()
# sort() 对列表进行排序
res = varlist.sort() # 默认对元素进行从小到大的排序
res = varlist.sort(reverse=True) # 对元素进行从大到小的排序
res = varlist.sort(key=abs) # 可以传递一个函数，按照函数的处理结果进行排序
# copy() 拷贝，复制当前的列表、
varlist = ['a','b','c']
res = varlist.copy()
# 对copy后的列表进行操作
del res[2]
'''
['a', 'b']print(res)
['a', 'b', 'c']print(varlist)
'''
# 定义 多维列表
varlist = ['a','b','c',[11,22,33]]
res = varlist.copy()
# 对copy的列表进行一个操作
del res[1] # 对一维列表进行操作，没有问题
print(res)#['a', 'c', [11, 22, 33]]
print(varlist)#['a', 'b', 'c', [11, 22, 33]]
del res[3][1] # 对多维列表中的元素，进行操作，则出现了，全部改变的情况
print(res)#['a', 'b', 'c', [11, 33]]
print(varlist)#['a', 'b', 'c', [11, 33]]
- 浅拷贝—只能拷贝当前列表，不能拷贝列表中的多维列表元素
# 浅拷贝
varlist = [1,2,3]
# 简单的拷贝 就可以把列表复制一份
newlist = varlist.copy()
# 对新拷贝的列表进行操作，也是独立的
del newlist[1]
#两者id不同
print(varlist,id(varlist))#[1, 2, 3] 4332224992
print(newlist,id(newlist))#[1, 3] 4332227552
# 多维列表
varlist = [1,2,3,['a','b','c']]
# 使用copy函数 拷贝一个多维列表
newlist = varlist.copy()
print(newlist,id(newlist))#[1, 2, 3, ['a', 'b', 'c']] 4361085408
print(varlist,id(varlist))#[1, 2, 3, ['a', 'b', 'c']] 4361898496
# 如果是一个被拷贝的列表，对它的多维列表元素进行操作时，会导致原列表中的多维列表也发生了变化
del newlist[3][1]
#通过id检测，发现列表中的多维列表是同一个元素（对象）
print(newlist[3],id(newlist[3]))#['a', 'c'] 4325397360
print(varlist[3],id(varlist[3]))#['a', 'c'] 4325397360
- 深拷贝—不光拷贝了当前的列表，同时把列表中的多维元素也拷贝了一份
import copy
varlist = [1,2,3,['a','b','c']]
# 使用 copy模块中 深拷贝方法 deepcopy
newlist = copy.deepcopy(varlist)
del newlist[3][1]
print(varlist)
print(newlist)
print(newlist[3],id(newlist[3]))#['a', 'c'] 4483351248
print(varlist[3],id(varlist[3]))#['a', 'b', 'c'] 4483003568
-
列表推到式
提供一个更简单的创建列表的方法
采用一种表达式的当时，对数据进行过滤或处理，并且把结果组成一个新的列表
# 一，基本的列表推到式使用方式
# 变量 = [变量或变量的处理结果 for 变量 in 容器类型数据]
# 1. 创建一个平方列表
# 使用普通方法完成
varlist = []
for i in range(10):
varlist.append(i**2)
print(varlist) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 使用 map函数和list完成
varlist = list(map(lambda x: x**2, range(10)))
print(varlist) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 使用列表推到式完成 下面这个列表推到式和第一种方式是一样的
varlist = [i**2 for i in range(10)]
print(varlist) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 2. '1234' ==> [2,4,6,8]
# 常规方法完成需求
varstr = '1234'
newlist = []
for i in varstr:
newlist.append(int(i)*2)
print(newlist) # [2, 4, 6, 8]
# 使用列表推到式完成上面的需求
newlist = [int(i)*2 for i in varstr]
print(newlist) # [2, 4, 6, 8]
# 使用列表推到式+位运算完成
newlist = [int(i) << 1 for i in varstr]
print(newlist) # [2, 4, 6, 8]
# 二，带有判断条件的列表推到式
# 变量 = [变量或变量的处理结果 for i in 容器类型数据 条件表达式]
# 0-9 求所有的偶数，==> [0, 2, 4, 6, 8]
# 常规方法完成
newlist = []
for i in range(10):
if i % 2 == 0:
newlist.append(i)
print(newlist) # [0, 2, 4, 6, 8]
# 列表推到式完成
newlist = [i for i in range(10) if i % 2 == 0]
print(newlist) # [0, 2, 4, 6, 8]
# 三， 带有条件判断的多循环的推到式
# [1,2,3],[3,1,4] ==> 把两个列表中的元素 两两组合，要求组合的元素不能重复
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
# 常规方法实现
newlist = []
for x in [1,2,3]:
for y in [3,1,4]:
if x != y:
newlist.append((x,y))
print(newlist)
# 使用列表推到式完成
newlist = [(x,y) for x in [1,2,3] for y in [3,1,4] if x != y]
print(newlist)
# 四，对于嵌套循环的列表推到式
'''
# 下面这个 3x4的矩阵，它由3个长度为4的列表组成，交换其行和列
[
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
]
==>
[
[1, 5, 9],
[2, 6, 10],
[3, 7, 11],
[4, 8, 12]
]
'''
arr = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
]
# 常规方法完成
newlist = []
for i in range(4):
res = []
for row in arr:
res.append(row[i])
newlist.append(res)
print(newlist)
# 使用列表推到式完成
newlist = [[row[i] for row in arr] for i in range(4)]
print(newlist)
元祖
-
定义
元组和列表一样都是一组有序的数据的组合。
元组中的元素一但定义不可以修改，因此元组称为 不可变数据类型
- 定义空元组 变量 = (),或者 变量=tuple()
- 还可以使用 变量 = (1,2,3) 定义含有数据的元组
- 注意：如果元组中只有一个元素时，必须加逗号 变量=(1,)
- 特例：变量=1,2,3 这种方式也可以定义为一个元组
-
相关操作
由于是不可变的数据类型，只能使用索引进行访问，不能进行其它操作
元组可以和列表一样使用切片方式获取元素
#元组的切片操作 和列表是一样的
vart = (1,2,3,4,5,5,4,3,2,1)
res = vart[:] # 获取全部
res = vart[::] # 获取全部
res = vart[1:] # 从索引1开始获取到最后
res = vart[1:3] # 从索引1开始到索引3之前
res = vart[:3] # 从索引 0 开始 到 索引 3之前
res = vart[1:5:2] # 从索引1开始到索引5之前，步进值为2
res = vart[::2] # 从索引 0 开始 到 最后 ，步进值为2
res = vart[5:1:-1] # 从索引5开始 到索引 1，步进值为-1 倒着输出
-
语法：
列表推导式 ==> [变量运算 for i in 容器] ==> 结果 是一个 列表
元组推导式 ==> (变量运算 for i in 容器) ==> 结果 是一个 生成器
列表推导式结果返回了一个列表，元组推导式返回的是生成器
字典
字典也是一种数据的集合，由键值对组成的数据集合，字典中的键不能重复
字典中的键必须是不可变的数据类型，常用的键主要是：字符串，整型。。。
-
字典的定义
# 1。 使用{}定义
vardict = {'a':1,'b':2,'c':2}
# 2。 使用 dict(key=value,key=value) 函数进行定义
vardict = dict(name='zhangsan',sex='男',age=22)
# 3。 数据类型的转换 dict(二级容器类型) 列表或元组，并且是二级容易才可以转换
vardict = dict([['a',1],['b',2],['c',3]]) # {'a': 1, 'b': 2, 'c': 3}
# 4。zip压缩函数，dict转类型
var1 = [1,2,3,4]
var2 = ['a','b','c','d']
# 转换的原理和上面的第三种 是一个原理
vardict = dict(zip(var1,var2)) # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
print(vardict)# 1。 使用{}定义
vardict = {'a':1,'b':2,'c':2}
# 2。 使用 dict(key=value,key=value) 函数进行定义
vardict = dict(name='zhangsan',sex='男',age=22)
# 3。 数据类型的转换 dict(二级容器类型) 列表或元组，并且是二级容易才可以转换
vardict = dict([['a',1],['b',2],['c',3]]) # {'a': 1, 'b': 2, 'c': 3}
# 4。zip压缩函数，dict转类型
var1 = [1,2,3,4]
var2 = ['a','b','c','d']
# 转换的原理和上面的第三种 是一个原理
vardict = dict(zip(var1,var2)) # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
print(vardict)
-
字典的操作
var1 = {'a': 1, 'b': 2, 'c': 3}
var2 = {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
# res = var1 + var2 # XXXX TypeError
# res = var1 * 3 # xxxx TypeError
# 获取元素
res = var1['a']
# 修改元素
res = var1['a'] = 111
# 删除元素
del var1['a']
# 添加元素
var1['aa'] = 'AA'
# 如果字典中的key重复了，会被覆盖
# var1['aa'] = 'aa'
-
成员检测和获取
# 三 成员检测和获取 ,只能检测key，不能检测value
res = 'AA' in var1
res = 'AA' not in var1
# 获取当前字典的长度 只能检测当前又多少个键值对
res = len(var1)
# 获取当前字典中的所有 key 键
res = var1.keys()
# 获取字典中所有的 value 值
res = var1.values()
# 获取当前字典中所有 键值对
res = var1.items()
-
字典的遍历
# 四， 对字典进行遍历
# （1）在遍历当前的字典时，只能获取当前的key
for i in var1:
print(i) # 只能获取 key
print(var1[i]) # 通过字典的key获取对应value
#（2）遍历字典时，使用 items() 函数，可以在遍历中获取key和value
for k,v in var1.items():
print(k) # 遍历时的 key
print(v) # 遍历时的 value
print('===='*20)
# (3) 遍历字典的所有key
for k in var1.keys():
print(k)
print('===='*20)
# (4) 遍历字典的所有 value
for v in var1.values():
print(v)
-
字典的相关函数
len(字典) #获取字典的键值对个数
dict.keys() # 获取当前字典的所有key 键，组成的列表
dict.values() # 获取当前字典的所有 value 值，组成的列表
dict.items() # 返回由字典项 ((键, 值) 对) 组成的一个新视图
iter(d) 返回以字典的键为元素的迭代器。
vardict = {'a':1,'b':2,'c':3}
dict.pop(key) # 通过 key 从当前字典中弹出键值对 删除
res = vardict.pop('a')
dict.popitem() LIFO: Last in, First out.后进先出
res = vardict.popitem() # 把最后加入到字典中的键值对删除并返回一个元组
# 使用key获取字典中不存在元素，会报错
print(vardict['aa'])
# 可以使用get获取一个元素，存在则返回，不存在默认返回None
res = vardict.get('aa')
res = vardict.get('aa','abc')
# dict.update(),更新字典,如果key存在，则更新，对应的key不存在则添加
# vardict.update(a=11,b=22)
# vardict.update({'c':33,'d':44})
# dict.setdefault(key[,default])
# 如果字典存在键 key ，返回它的值。
# 如果不存在，插入值为 default 的键 key ，并返回 default 。
# default 默认为 None。
res = vardict.setdefault('aa','123')
print(res)
print(vardict)
-
字典推导式
# 把字典中的键值对位置进行交换 {'a':1,'b':2,'c':3}
vardict = {'a':1,'b':2,'c':3}
# 普通方法实现 字典中的键值交换 {1: 'a', 2: 'b', 3: 'c'}
newdict = {}
for k,v in vardict.items():
newdict[v] = k
# print(newdict)
# 使用字典推导式完成 {1: 'a', 2: 'b', 3: 'c'}
newdict = {v:k for k,v in vardict.items()}
# print(newdict)
# 注意：以下推导式，返回的结果是一个集合，集合推导式
newdict = {v for k,v in vardict.items()}
# print(newdict,type(newdict))
# 把以下字典中的是偶数的值，保留下来，并且交换键值对的位置
vardict = {'a':1,'b':2,'c':3,'d':4}
# 普通方式完成 {2: 'b', 4: 'd'}
# newdict = {}
# for k,v in vardict.items():
# if v % 2 == 0:
# newdict[v] = k
# print(newdict)
# 字典推导式完成 {2: 'b', 4: 'd'}
newdict = {v:k for k,v in vardict.items() if v % 2 == 0}
# print(newdict)
集合
- 确定的一组无序的数据的组合
- 确定的？ 当前集合中元素的值不能重复
- 由多个数据组合的复合型数据（容器类型数据）
- 集合中的数据没有顺序
- 功能：成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等。
-
集合的定义
- 可以直接使用 {} 来定义集合
- 可以使用set()进行集合的定义和转换
- 使用集合推导式完成集合的定义
注意：集合中的元素不能重复，集合中存放的数据：Number,Strings,Tuple,冰冻集合
-
集合的基本操作和常规函数
# 定义集合
vars = {123,'abc',False,'love',True,(1,2,3),0,3.1415,'123'}
# 1。无序。
# 2。布尔类型 True 表示为 1，False 表示为 0，布尔和数字只存在一个
# 3。元素的值不能重复
# {0, 'abc', 'love', True, 3.1415, (1, 2, 3), 123}
# 检测集合中的值
res = '123' in vars
res = '123' not in vars
# 获取集合中元素的个数 len()
# res = len(vars)
# 集合的遍历
# for i in vars:
# print(i,type(i))
# 向集合中追加元素 add()
res = vars.add('def')
# 删除集合中的元素 随机删除一个元素并返回 abc False True 3.1415
# r1 = vars.pop()
# 指定删除集合中的元素 remove() 返回None，不存在则报错
# res = vars.remove('aaa')
# discard 指定删除集合中的元素，不存在也不会报错
# res = vars.discard('aaa')
# clear() 清空集合
# res = vars.clear()
# update(others) 更新集合，添加来自 others 中的所有元素。
res = vars.update({1,2,3,4,5})
# 当前集合中的浅拷贝并不存在 深拷贝的问题
res = vars.copy()
'''
当前集合中的浅拷贝并不存在 深拷贝的问题
因为集合中的元素都是不可变，包括元组和冰冻集合
不存在拷贝后，对集合中不可变的二级容器进行操作的问题
'''
-
集合的推导式
# 集合推导式
varset = {1,2,3,4}
# (1) 普通推导式
newset = {i<<1 for i in varset }
# (2) 带有条件表达式的推导式
newset = {i<<1 for i in varset if i%2==0}
# (3) 多循环的集合推导式
vars1 = {1,2,3}
vars2 = {4,5,6}
# newset = set()
# for i in vars1:
# for j in vars2:
# print(i,j)
# newset.add(i+j)
# print(newset)
newset = {i+j for i in vars1 for j in vars2}
# print(newset)
# (4) 带条件表达式的多循环的集合推导式
newset = {i+j for i in vars1 for j in vars2 if i%2==0 and j%2==0}
print(newset)
-
集合的主要运算
- 交集 & set.intersection() set.intersection_update()
- 并集 | union() update()
- 差集 - difference(),difference_update()
- 对称差集 ^ symmetric_difference() symmetric_difference_update()
vars1 = {'郭富城','刘德华','张学友','黎明','都敏俊',1}
vars2 = {'尼古拉斯赵四','刘能','小沈阳','宋小宝','都敏俊',1}
# & 求两个集合相交的部分
res = vars1 & vars2
# | 求两个集合的并集，就是把集合中所有元素全部集中起来，（去除重复）
res = vars1 | vars2
# - 差集运算
res = vars1 - vars2 # vars1有，而，vars2 没有的
res = vars2 - vars1 # vars2有，而，vars1 没有的
# ^ 对称差集
res = vars1 ^ vars2
# 交集运算函数 intersection intersection_update
# set.intersection() # 返回交集的结果 新的集合
# res = vars1.intersection(vars2)
# set.intersection_update() # 没有返回值
# 计算两个集合的相交部分，把计算结果重新赋值给第一个集合
# res = vars1.intersection_update(vars2)
# 并集运算函数 | union() update()
# res = vars1.union(vars2) # 返回并集结果，新的集合
# 求并集运算，并且把结果赋值给第一个集合
# res = vars1.update(vars2) # 没有返回值
# print(vars1)
# 差集运算 函数 difference(),difference_update()
# res = vars1.difference(vars2) # 返回差集结果 新的集合
# 把差集的结果，重新赋值给第一个集合
# res = vars1.difference_update(vars2) # 没有返回值
# 求对称差集
# res = vars1.symmetric_difference(vars2) # 返回对称差集的结果 新的集合
# 把对称差集的运算结果，重新赋值给第一个集合
res = vars1.symmetric_difference_update(vars2)# 没有返回值
-
集合检测
- issuperset() 检测是否为超集
- issubset() 检测是否为子集
- isdisjoint() 检测是否不相交
# 检测 超集 子集
vars1 = {1,2,3,4,5,6,7,8,9}
vars2 = {1,2,3}
# issuperset() 检测是否为超集
res = vars1.issuperset(vars2) # True vars1是vars2的超集
res = vars2.issuperset(vars1) # False
# issubset() 检测是否为子集
res = vars1.issubset(vars2) # False
res = vars2.issubset(vars1) # True vars2是vars1的子集
# 检测两个集合是否相交
vars1 = {1,2,3}
vars2 = {5,6,3}
# isdisjoint 检测是否不相交， 不相交返回True，相交则返回False
res = vars1.isdisjoint(vars2)
print(res)
