集合和字典类型；数据类型的强制转换

2.4.5 set集合类型（作用：交叉并补；特点：无序，自动去重，不可修改，不可获取）

# 定义集合
setvar = {"刘德华","郭富城","张学友","黎明"}
# 自动去重
setvar = {"刘德华","郭富城","张学友","黎明"，"刘德华","郭富城","张学友","黎明"}
print(setvar)
# 定义空集合
setvar = {}
setvar = set()
print(setvar, type(setvar))

2.4.6 dict字典类型（特点：以键值对存储数据，表面上有序，实际上无序）

​ 语法：divtvar = {键1：值1，键2：值2，. . . }

"""
字典的键：推荐用变量命名的字符串进行使用
字典的键和集合的值有数据类型上的要求
可哈希的数据类型可以做字典的键：Number（int，float，bool，complete），str，tuple
可变类型，不可哈希（不可被应用在set中和字典的键）：list dict set
哈希算法都是典型的无序特征，目的：为了更加均匀的把数据分配到内存中，随机，无序，底层用了取模类似的算法。

python3.6版本，对字典做了优化，存储数据的时候用的哈希算法
但是在拿出数据的时候，重新按照定义的顺序做了排序，所以看起来有序，实际是无序的
"""

# 定义空字典
dictvar = {}
dictvar = dict{}

# 定义普通字典
dictvar = dict{"name":"eric", "sex":"男", "age":"22", "hobby":"无"}

# 获取字典值
dictvar['name']

# 修改字典值
dictvar['name'] = "jack"

# 字典的键有一定要求
dictvar = {1:'asdf', False:'asd', 1+2j:'asd', 3.14:'asd', (1,2):"asd", "中文":"asd"}

3、 变量的缓存机制(仅对python3.6有效)

1. Number(int,float,bool,complex)类型

整型：-5 ~ 正无穷范围内的值相同  id 值一致
var1 = 1
var2 = 2

浮点数：非负数范围内的两个值相同时 id 值一致
var1 = 1.0
var2 = 2.0

布尔值：值相同的情况下，id一致
var1 = True
var2 = False
print(id(var1),id(var2))

复数对于 实数+虚数 这种结构中永不相同（只有虚数的情况例外）
intvar1 = 1+2j
intvar2 = 1+2j
intvar3 = 1j
intvar4 = 1j
print(id(intvar1),id(intvar2),id(intvar3),id(intvar4))

2. 容器类型

字符串和空元组相同的情况下，地址相同
var1 = "你"
var2 = "你"
var3 = ()
var4 = ()
print(id(var1),id(var2),id(var3),id(var4))

列表，元组，字典，集合无论什么情况id值都不同(空元组例外)
listvar1 = [1,2,3]
listvar2 = [1,2,3]
setvar3 = {1,2,3}
setvar4 = {1,2,3}
dictvar5 = {1:'2'}
dictvar6 = {1:'2'}
print(id())

4、 数据类型转换

1. Numbei（int，bool，float，complex）强制类型转换

类型转换方法：int（），bool（），float（），complex（）

强制转换整型(纯数字类型字符串，浮点型，布尔型，整型)
var1 = int(1.0)
var2 = int('12')
var3 = int(False)
var4 = int(12)

强制转换浮点型(纯数字类型字符串，浮点型，布尔型，整型)
var1 = float(1.1)
var2 = float('12')
var3 = float(False)
var4 = float(12)

强制转换布尔型(纯数字类型字符串，浮点型，布尔型，整型)
var1 = bool(1.1)
var2 = bool('12')
var3 = bool(False)
var4 = bool(12)
强制转化布尔型为假的十种情况
0 0.0 False 0j () [] {} set() '' None

强制转换成复数(纯数字字符串，浮点型，布尔型，整形)
var1 = complex(1.1)
var2 = complex('12')
var3 = complex(False)
var4 = complex(12)

2. 自动类型转换Number(int float bool complex)

​ 转换原则：数据精度默认从低到高转换：bool int float complex

bool + int     布尔类型 + int整型 = 整型
ret = True + 12

bool + float   布尔类型 + float浮点型 = 浮点型
ret = True + 1.2 

bool + complex 布尔类型 + complex复数 = 复数
ret = True + 1+2j 

int + float    int整型 + float浮点型 = 浮点型
ret = 1 + 1.1 

int + complex  int整型 + complex复数 = 复数
ret = 1 + 1+2j 

float + complex float浮点型 + complex复数 = 复数
ret = 1.1 + 1+2j

3. 容器类型的强制转换（str tuple list set dict）

强制转化成str字符串（Number类型数据和容器类型数据都可以转化）
ret = str([1,2])

强制转化成元组(自身转化无变化)
ret = tuple("sfaf")    字符串强制转化成元组会拆分成单个字符 ("s","f","a","f")
ret = tuple([1,2,3])   列表强制转化成元组表面上看就是换了外面的括号
ret = tuple({1,2,3})   集合强制转化成元组表面上看就是换了外面的括号 
ret = tuple({1:'1',2:'2'})  字典强制转化成元组只会保留字典的键以元组的方式呈现
Number数据类型不能强制转化成元组

强制转化成列表(自身转化无变化)
ret = list("sfaf")     字符串强制转化成列表会拆分成单个字符 ("s","f","a","f")
ret = list((1,2,3))    元组强制转化成列表从表面上看就是换了外面的括号
ret = list({1,2,3})    集合强制转化成列表从表面上看就是换了外面的括号 
ret = list({1:'1',2:'2'})   字典强制转化成列表只会保留字典的键以元组的方式呈现
Number数据类型不能强制转化成列表

强制转化成集合(自身转化无变化）
ret = set("sfaf")      字符串强制转化成集合会被拆分成单个字符并自动去重 ("s","f","a")
ret = set([1,2,3])     列表强制转化成集合会自动去重，从表面上看外层括号会变成{}
ret = set((1,2,3))     元组强制转换成集合会自动去重，从表面上看外层括号会变成{}
ret = set({1:'1',2:'2'})    字典强制转化成列表只会保留字典的键以集合的方式呈现，并会自动去重

强制转化成字典(自身转化无变化)
注：强转成字典时，必须是等长的二级容器，元素个数为2
外层可以是列表、元组或集合，里面的容器是元组或者列表
ret = [(1,2,),[1,2]]
ret = ((1,2,),[1,2])
ret = {(1,2,),[1,2]}
如果里面出现集合（外层不是set集合{}），语法上是允许的，但有局限性
ret = ([1,2],{1,2})
如果里面出现字符串，语法上是允许的，但有局限性，字符串的长度只能是2
ret = ([1,2],'as')

4. 二级容器

二级列表
ret = [1,[2,3]]

二级元组
ret = (1,(2,3,),)

二级集合
ret = {1,{1,2}}

二级字典
ret = {1:'1',{1:'2'}}

多级容器就是嵌套使用