Python数据类型详解

字符串

• 字符串的定义方式

1. 单引号定义字符串 ‘ ’
2. 双引号定义字符串 “ ”
3. 三引号定义字符串 ‘’‘内容’‘’或者 “”“内容”“”
4. 字符串定义时，引号可以互相嵌套

• 转义字符

一个普通的字符出现在转义符 \ 的后面时，实现了另外一种意义

    作为转义符时，在\后面出现的字符可能会实现另外一种意义。

    作为续行符时，在行尾使用了\后，可以换行继续书写内容

\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)