第二章 标准数据类型
1. 六大标准数据类型
1.1 Number数字类型
#(1) int整型(正整型,0,负整形)
#二进制整型
intvar = 0b110
#八进制整型
intvar = 0o127
#十进制整型
intvar1 = 100
intvar2 = 0
intvar3 = -10
#十六进制整型
intvar = 0xff
#(2) float 浮点型（小数）
# 表达式1
floatvar = 3.6
# 表达式2 科学计数法
floatvar = 5.7e5 #小数点右移5位
floatvar = 5.7e-5 #小数点左移5位
#(3) bool 布尔型 （True真的、False假的）
boolvar = True
boolvar = False
#(4) complex 复数类型
"""
3 + 4j
实数+虚数
实数：3
虚数：4j
j：如果有一个数他的平方等于-1，那么这个数就是j，科学家认为，表达一个高精度的类型
"""
# 表达式1
complexvar = 3 + 4j
complexvar = -3j
# 表达式2
# complex(实数、虚数) => 复数
res = complex(3,4)
1.2 str字符串类型
特征：可获取、不可修改 、有序
#有引号的就是字符串,单引号，双引号，三引号
#(1)单引号的字符串
strvar = '美丽'
#(2)双引号的字符串
strvar = "美丽"
#(3)三引号的字符串(可以支持跨行效果)
strvar = """
英国
法国
美国
"""
#(4)获取字符串中的元素
strvar = "小明,吃饭"
print(strvar[1])
#(5)不能修改字符串中的元素
strvar[1] = 10 #error报错
1.3 list列表类型
特征：可获取、可修改、有序
#(1)定义一个空列表
listvar = []
#(2)定义普通列表
listvar = [98,5.6"大小"，True，"12-90j"]
#(3) 获取列表中的元素
#正向索引 0 1 2 3 4
listvar = [98,5.6"大小"，True，"12-90j"]
#逆向索引 -5 -4 -3 -2 -1
res = listvar[2]
res = listvar[-2]
#(4)修改列表中的元素
listvar = [98,5.6"大小"，True，"12-90j"]
listvar[3] = "大象"
# (5)len 获取容器类型数据中元素的个数
length = len(listvar)
res = listvar[length-1]
# 简写
res = listvar[len(listvar)-1]
1.4 tuple元组类型
特征：可获取、不可修改、有序
#(1)定义一个元组
tuplevar = (1,2,3,4,"美国")
#(2)获取元组中的元素
# 正向索引 0 1 2 3 4
tuplevar = (12,23,36,49,"美国")
# 逆向索引 -5 -4 -3 -2 -1
print(tuplevar[2])
#(3)修改元组中的元素：元组中的元素不可以修改
tuplevar[0] = 100 # error报错
#(4)注意：逗号才是区分是否是元组的标识符
tuplevar =（1） #int整型
tuplevar = 1, #tuple元组
tuplevar = (1.5,) #tuple元组
tuplevar = ("中国",) #tuple元组
#(5)定义空元组
tuplevar = ()
1.5 dict字典类型
"""
键值对存储的数据：
dictvar = {键1:值1,键2:值2,...}
"""
#(1)定义一个字典
dictvar = {"top":"the shy","middle":"肉鸡","boottom":"jacklove"}
#(2)定义一个空字典
dictvar = {}
#(3)获取字典中的值
res = dictvar["top"]
#(4)修改字典中的值
dictvar["middle"] = "facker"
#(5)注意:
"""
字典的键有数据类型上的要求
(允许的类型范围)不可变的数据类型:number(int float complex bool) str tuple
(不允许的类型)可变的类型：list set dict
表面上有序，本质上无序
字典的键有要求，值无要求
字典的值可以任意换掉，但是键不可以
python3.6版本之前，完全无序
python3.6版本之后，存储的时候，保留了字典定义的字面顺序，在获取内存中数据时
重新按照字面顺序做了排序，所以看起来有序，实际上存储时还是无序
"""
1.6 set集合类型
特征：无序、自动去重
# 交差并补
# 特征：无序、自动去重
#(1)定义一个集合
setvar={"小明","小红","小兰"}
#(2)集合自动去重
setvar = {"英国","法国","美国","韩国","韩国"}
#(3)定义一个空集合
setvar = set()
#(4)获取集合中的元素：不可以获取
set[0] #error报错
#(5)修改集合中的元素：不可以修改
set[0] = 100 #error报错
#(6)注意：
"""
集合的元素有数据类型上的要求
(允许的类型范围)不可变的数据类型:number(int float complex bool) str tuple
(不允许的类型)可变的类型：list set dict
哈希算法的提出目的是让数据尽量均匀在内存当中分配，以减少哈希碰撞，提升存储分配的效率
哈希算法一定是无序的散列，所以集合和字典是无序的
"""
2. 数据类型的转换
2.1 number的强制转换
# 1.number的强制转换（int float complex bool）
#(1)int强制把数据变成整型
"""
如果是list,dict,set不可以被int强制转换,只能转换float ，bool， 纯数字字符串
"""
var1 = 13
var2 = 5.67
var3 = True
var4 = "123456"
var5 = "123abc"
var6 = 3+5j
res = int(var2) #5
res = int(var3) #True --> 1
res = int(False) #False --> 0
res = int(var4) #123456
res = int(var5) #error报错
res = int(var6) #error报错
#(2)folat 强制把数据变成小数
"""int，float， bool ，纯数字字符串"""
res = float(var1) #13.0
res = float(var3) #True -->1.0
res = float(False) #False -->0.0
res = float(var4) #123456.0
#(3)complex 强制把数据变成复数
res = complex(var1) #添加0j 表达复数
res = complex(var2)
res = complex(var3) #True --> 1+0j
res = complex(False) #False --> 0j
res = complex(var4) #123456+0j
#(4)bool强制把数据变成布尔型（布尔为假的十种情况）
"""
布尔值可以强转一切数据类型
0,0.0 False,0j, "",[] ,(), set(), {},None
res = bool("") //False
"""
#(5)初始化变量时，不清楚用什么值，无脑写上None,
# None 代表空的，代表什么也没有，一般用于初始化
a = None
b = None
#(6)默认转转换成当前数据类型的一个值
"""int() float() complex() bool()"""
res = bool() #False
res = int() #0
res = folat() #0.0
res = complex() #0j
# 2.number 自动类型转换（int float complex bool）
"""
低精度默认向高精度进行转换
bool -> int -> float -> complex
"""
# bool + int
res = True + 100 # 1 + 100 --》101
# bool + float
res = True + 344.565 #1.0 + 344.565 --》345.565
# bool + complex
res = True + 7 -90j #1 + 0j +7 -90j --》8 -90j
# int + float
res = 5 + 7.88 # 5.0 + 7.88--》12.88
# int + complex
res = 5 + 6 +8j # 5 + 0j 6+8j=>11+8j
# float + complex
res = 5.66 + 9.1 - 90j #5.66 + 0j +9.1 => 14.76 - 90j
# 小数的精度损耗
# 不要用小数作比较，小数后面一般有时截取15~18位，但是不完全，存在精度损耗
print(0.1 + 0.2 == 0.3)
print(5.1 + 5.9 == 11.0)
2.2 str字符串的强制转换
# 所有的数据类型都可以转换，在当前的数据类型两边套上引号
var1 = 90
var2 = 16.5
var3 = [1,2,3]
var4 = (4,5,6)
var5 ={"陈路","范冰冰","刘诗诗"}
var6 = {"a":"10","b":"20"}
var7 = True
res1 = str(var1)
res2= str(var2)
res3 = str(var3)
res4 = str(var4)
res5 = str(var5)
res6 = str(var6)
res7 = str(var7)
print(repr(res1)) #'90'
print(repr(res2)) #'16.5'
print(repr(res3)) #'[1, 2, 3]'
print(repr(res4)) #'(4, 5, 6)'
print(repr(res5)) #"{'范冰冰', '刘诗诗', '陈路'}"
print(repr(res6)) #"{'a': '10', 'b': '20'}"
print(repr(res7)) #'True'
# repr 不转义字符原型化输出字符串,在当前的数据类型两边套上引号
2.3 list列表的强制转换
"""
(1)如果是number数字类型(int,float,bool)将其转换为列表会报错,只能是容器数据类型的互转
(2)如果是字符串：把字符串中的每个元素单独拿出来，作为列表中的新元素
(3)如果是字典：只保留字典中的键
(4)如果是集合：就是单纯的在原数据类型的两边换上[]括号
(5)如果是元组：就是单纯的在原数据类型的两边换上[]括号
"""
var1 = "我爱祖国"
var2 = (4,5,6)
var3 ={"陈路","范冰冰","刘诗诗"}
var4 = {"a":"10","b":"20"}
res1 = list(var1)
res2 = list(var2)
res3 = list(var3)
res4 = list(var4)
print(res1) #['我', '爱', '祖', '国']
print(res2) #[4, 5, 6]
print(res3) #['陈路', '范冰冰', '刘诗诗']
print(res4) #['a', 'b']
2.4 tuple元组的强制转换
"""
(1)如果是number数字类型(int,float,bool)将其转换为列表会报错,只能是容器数据类型的互转
(2)如果是字符串：把字符串中的每个元素单独拿出来，作为列表中的新元素
(3)如果是字典：只保留字典中的键
(4)如果是集合：就是单纯的在原数据类型的两边换上()括号
(5)如果是列表：就是单纯的在原数据类型的两边换上()括号
"""
var1 = "我爱祖国"
var2 = [4,5,6]
var3 ={"陈路","范冰冰","刘诗诗"}
var4 = {"a":"10","b":"20"}
res1 = tuple(var1)
res2 = tuple(var2)
res3 = tuple(var3)
res4 = tuple(var4)
print(res1) #('我', '爱', '祖', '国')
print(res2) #(4, 5, 6)
print(res3) #('刘诗诗', '陈路', '范冰冰')
print(res4) #('a', 'b')
2.5 dict字典的强制转换
"""
要求：必须是等长的二级容器。并且里面的元素个数是2个
外层是列表，元组，集合，里层是列表或者元组的等长二级容器-->字典；
"""
#(1)外层是列表，里层是列表或者元组
lst = [["a",1],("b",2)]
dic = dict(lst)
print(dic,type(dic)) # {'a': 1, 'b': 2}
#(2)外层是元组，里层是列表或者元组
tup =(["a",1],("b",2))
dic = dict(lst)
print(dic ,type(dic))
#(3)外层是集合，里层是元组
setvar = {("a",1),("b",2)}
dic = dict(setvar)
print(dic ,type(dic))
#(4)例外1：外层是列表，里层放集合
"""可以实现，不推荐使用 ，因为达不到想要的目的，集合无序，不推荐使用"""
lst = [["a",1],{"b",250}]
dic = dict(lst)
print(dic)
#(5)例外2：外层是列表/元组，里层放字符串
"""字符串长度只能是2位，有极大的局限性，不推荐使用"""
lst = ["a11","b22"]
dic = dict(lst)
print(dic)
#(6)判断类型 isinstance
"""
# 使用方法一
isinstance(数据，类型)
如果该数据是这个类型，返回True 反之 ，返回False
类型：int float complex bool str list tuple set dict
# 使用方法二
isinstance（数据,（类型1，类型2，类型3...））
如果该数据在所对应的类型元组当中，返回True，反之，返回False
"""
# 使用方法一
n = 123
res = isinstance(n, int)
print(res)
n = [1, 2, 3]
res = isinstance(n, list)
res = isinstance(n, tuple)
print(res)
# 使用方法二
n = 123
res = isinstance(n, (list, str, set, tuple))
print(res)
2.6 set集合的强制转换
"""
(1)如果是number数字类型(int,float,bool)将其转换为列表会报错,只能是容器数据类型的互转
(2)如果是字符串：把字符串中的每个元素单独拿出来，作为集合中的新元素
(3)如果是字典：只保留字典中的键
(4)如果是元组：就是单纯的在原数据类型的俩边换上{}
"""
var1 = "我爱祖国"
var2 = [4,5,6]
var3 =("陈路","范冰冰","刘诗诗")
var4 = {"a":"10","b":"20"}
res1 = set(var1)
res2 = set(var2)
res3 = set(var3)
res4 = set(var4)
print(res1) #{'祖', '我', '国', '爱'}
print(res2) #{4, 5, 6}
print(res3) #{'陈路', '范冰冰', '刘诗诗'}
print(res4) #{'b', 'a'}
# 过滤掉列表中所有重复元素
list1 = [1,2,3,4,5,5,5]
res2 = set(list1)
# 再把当前的集合转换成原来的列表
res2 = list(res2)
print(res2)
"""
默认不加任何值，转换成该数据类型的空值
int() str() list() tuple() set() dict()
"""
print(int()) # 0
print(str()) # ""
print(list()) # []
print(tuple()) # ()
print(dict()) # {}
print(set()) # set()
3. 二级容器
#(1)二级列表
list = [1,2,3,[4,5,6]]
#(2)二级元组
tup =(1,2,(10,11))
#(3)二级集合
setvar = {1,2,("a","b")}
#(4)二级字典
dic = {"a":1,"b":{"c":10}}
print(dic)
#(5)四级容器
container = [1,2,3,(4,5,6),{"a":1,"b":[11,"p"]}]
res1 = container[-1]
print(res1)
#(6)等长的二级容器
"""外面是容器，里面的元素也是容器，且元素个数相同"""
list = [(1,2,3),[4,5,6],{7,8,9}]