python 类型转换

# python 3.7.5
# Time : 2019/4/1
# #
# 列表的基本操作
# #
# 列表的取值
# 这里我取1
# list=[1,2,3,4,5,6,7,8,9]
# # print(list[0])
# # #取5
# # print(list[4])
# # #反向取值
# # #取7
# # print(list[-3])
# #
# 列表的定义
# list=[1,2,3,['a','b','c']]
# #print(list[3])
# var=list[3]
# print(var)
# 继续取反
# print(list[-1])
# 查看类型
# print(var,type(var))
# #
# 更改列表中的值
# 更改1为100
# 首先解决一个问题为什么我要在列表中定义a，b，c时要加'因为如果不加，列表就会认为他是一个变量，那他既然是变量我又没有给它赋值，所以它当然会报错
# 当然加' " '''   这些都可以 不加的话也可以就直接在上方给变量赋值就可以了
# list=[1,2,3,['a','b','c']]
# list[0]=100
# print(list[0])
# 更改b为y
# list[3][1]='y'
# print(list[3][1])
# print(list)
# 查看类型
# print(list[3][0],type(list[3][0]))
# #
# 元组
# 它是一系列顺序的组合，标识符时逗号，初始化之后元组内的值不能被更改
# tuple1=("a","b","c","d",1,2,3,4,5)
# print(tuple1,type(tuple1))
# print(tuple1[2])
# var=tuple1[1]
# print(var)
# 元组内的值一旦被定义就无法修改
# tuple1=("a","b","c",1,2,3,("d","e"),[5,6])
# tuple1[6][9]=8
# print(tuple1)
# #
# 当然元组可以为空
# a=()
# print(a,type(a))
# 但是如歌这么设置元组会不成功他会变成一个其他的类型
# a=(1)
# print(a,type(a))
# 这样才可以
# a=(1,2)
# print(a,type(a))
# #
# 集合：它是一个特定的无序组合。在集合中所有元素不能重复，标识符：无
# set1={1,2,3,4,5}
# print(set1,type(set1))
# 上次也说过如果想要定义一个空的集合
# set2=set()
# print(set,type(set))
# #
# 字典是一种键值映射的一组无序组合，他的值可以修改，标识符{}
# 字典时唯一不可以重复
# dict1={"名字1":"杨洋1","名字2":"杨洋2","名字3":"洋洋"}
# print(dict1,type(dict1))
# 打印单个字典中的值时，他的目标时靠键来索引
# var1=dict1["名字2"]
# print(var1)
# #
# 想要更改字典中的值时：
# dict1["名字3"]="杨洋3"
# print(dict1)
# #
# 如果我想在字典中添加一个新的K/V怎做？？
# dict1["名字4"]="杨洋4"
# print(dict1)
# #
# 在字典中添加一个更多的值
# dict1={"name1":"yy1","夜深":["人静","我","独自坐在","家中"],"day":["Today","is","good","day"]}
# print(dict1)
# print(dict1,type(dict1["夜深"],))
# var1=dict1["夜深"]
# print(var1)
# #
# dict1={"我现在":"兴奋","状态":{"夜深":"人静","我独自":"坐在家中","敲着":"代码"}}
# print(dict1)
# var1=dict1["状态"]
# print(var1)
# dict1["状态"]["我独自"]="写着"
# print(dict1)
# 更改字典内容
# dict1["状态"]["我独自"]="在我的小屋子里"
# print(dict1)
# #
# #
# li=["hello","seven",["mon",["h","kelly"],'all'],123,446]
# var=li[2][2]
# print(var)
# var1=li[2][1][1]
# print(var1)
# var2=li[3]
# print(var2)
#
#
# tu=("alex",[11,22,{"k1":"v1","k2":["age","name"],"k3":(11,22,33)},44])
# tu[1][2]["k2"][1]="yangyang"
# print(tu)
#
# dict={"k1":"v1","k2":"v2","k3":[11,22,33]}
# print(dict)
# dict["k1"]="alex"
# print(dict)

# num1=1;
# num2=1.5;
# print(num1,type(num1))
# print(num2,type(num2))
# var=num1+num2
# print(var,type(var))

#手动数据类型转换:随开发的意志进行转换（思想，代码需求）
#整型转换
#int
#转换之后会把小数之后的的数全部舍弃，1.51舍弃51
# float1=1.51
# var=(int(float1))
# print(var,type(var))

#bool（布尔类型）
#boll在转换时True会被转换成1，False会被转换成0
# bool1=True
# bool2=False
# var1=(int(bool1))
# var2=(int(bool2))
# print(var1,type(var1))
# print(var2,type(var2))

#复数
#complex
#复数不可以被转换
# complex1=10 + 0j
# var1=(int(complex1))
# print(var1,type(var1))

#str字符串
# str="1"
# var1=(int(str))
# print(var1,type(var1))

#字符串并不能对字符进行转型
# str2="helloworld"
# var2=(int(str2))
# print(var,type(var2))

#字符串只能转型纯整数
# str3="4.2"
# var3=(int(str3))
# print(var3,type(var3))

#列表
#列表可一转型，但是只能转型整数，如果列表中的值为其他的类型而并非整数则不能转型
# list1=[1,2,3,4]
# var1=(int(list1[1]))
# #var1=(int(list1))
# # print(var1,type(var1))

#元组
#元组不能被转型，因为它违反了元组的规则，不可一被更改，！
# tuple1=(1,2,3,4,5,6,7)
# var1=(int(tuple1))
# print(var1,type(var1))

#set（集合）
#当然集合也不能被转型
# set1={1,2,3,4,5,60}
# var1=int(set1)
# print(var1,type(var1))

#字典
#它也不能被转型
#它怎么样都不能被转型
# dict1={"name":1,"name2":2}
#var1=(dict1,int(dict1))
#print(var1,type(var1))
# var2=(int(dict1["name"][0]))
# print(var2,type(var2))


#float(浮点型转型)
# int1 = 1
# print(int1,type(int1))
# var1=float,(int1)
# print(var1)
# var1=(float,(int1))
# print(var1,type(var1))


#布尔类型bool
#可以转换它们转换成小数之后会变成1.0and0.0
# bool1=True
# bool2=False
# var1=float(bool1)
# var2=float(bool2)
# print(var1,type(var1))
# print(var2,type(var2))

#float和整数转换一样
#其中复数，字符串（纯整数），列表，元组，集合，字典都不能进行转型
# list    不可以转换
# tuple   不可以转换
# set     不可以转换
# dict    不可以转换

#复数类型的转换
#int类型(可以转换)
# int1 = 1
# var1=complex(int1)
# print(var1,type(var1))

#float类型
#可以转换
# float1=4.2
# var1=complex(float1)
# print(var1,type(var1))

#boll（布尔类型）
#可以转换
# bool1=True
# bool2=False
# var1=complex(bool1)
# var2=complex(bool2)
# print(var1,type(var1))
# print(var2,type(var2))

#字符串类型可以转换纯整数，但不能转型字符
# str1='1'
# var1=complex(str1)
# print(var1,type(var1))

#列表无法进行转换
# list1=[1]
# var1=complex(list1)
# print(var1,type(var1))

#元组无法被转换
# tuple1=(1,2,3,4)
# var1=complex(tuple1)
# print(var1,type(var1))

#集合无法被转换
# set1={1,2,3,4,5}
# var1=complex(set1)
# print(var1,type(var1))

#字典也无法进行转换
# dict1={"a":"0","b":"1"}
# var1=complex(dict1)
# print(var1,type(var1))

#bool值的转换
#在布尔类型中1为True，0为False
# int1 = 1
# var1=bool(int1)
# print(var1,type(var1))

#0为False
# int1=0
# var1=bool(int1)
# print(var1,type(var1))

#浮点型
#原理与整数int同理
# float1=1.5
# var1=bool(float1)
# print(var1,type(var1))
#
# float2=0.0
# var2=bool(float2)
# print(var2,type(var2))

#复数
#True
# complex1=10 + 5j
# var1=bool(complex1)
# print(var1,type(complex1))

#False为0j
# complex2=0j
#这样写0+0j=0j
# complex2=0+0j
# var2=bool(complex2)
# print(var2,type(var2))

#字符串
#True
# str1="1"
# var1=bool(str1)
# print(var1,type(var1))

#flase
#注意就算这样写字符串的类型也不会变成flase
# str2="0"
# var2=bool(str2)
# print(var2,type(var2))
#所以字符串的类型想为flase如下：
#如果让字符串为flase字符串的值必须为空
# str2=""
# var2=bool(str2)
# print(var2,type(str2))

#列表
#True
# list1=[1]
# var1=bool(list1)
# print(var1,type(var1))
#flase
# list2=[ ]
# var2=bool(list2)
# print(var2,type(var2))

#元组
#True
# tuple1=(1)
# var1=bool(tuple1)
# print(var1,type(var1))
#flase
# tuple2=( )
# var2=bool(tuple2)
# print(var2,tuple2)

#集合
#True
# set1={1,2,3}
# var1=bool(set1)
# print(var1,type(var1))
#flase
# set2=set()
# print(set2)
# var2=bool(set2)
# print(var2,type(var2))

#字典
#true
# dict1={"a":"1","b":"2"}
# var1=bool(dict1)
# print(var1,type(var1))
#flase
# dict2={}
# var2=bool(dict2)
# print(var2,type(var2))

#总结bool：只要不为下面的值，就全是true
"""
int     0
float   0.0
complex 0j
str     "" 空字符串
list    [  ]空列表
tuple   (  )空元组
set      set()空集合
dict    {}  空字典
"""

#list（列表转换）
#int
#不能转换
# int1=1
# var1=list(int1)
# print(var1,type(var1))

#float(浮点型)
#也不能转换
# float1=10.5
# var1=list(float1)
# print(var1,type(var1))

#布尔bool
#也不能转换
# bool1=True
# var1=list(bool1)
# print(var1,type(var1))

#复数complex
#复数依旧不可以
# complex1=10 + 5j
# var1=list(complex1)
# print(var1,type(var1))

#总结：int float bool complex 都不可以转换

#字符串
#可以转换，list转换会把字符串中的每一个值都划分到一个元素
# str1="12345"
# var1=list(str1)
# print(var1,type(var1))

# 元组
# 可以转换，也是把元组中的每一个数变成一个元素
# tuple1=(1,2,3,4,5,6)
# var1=list(tuple1)
# print(var1,type(var1))

#集合
#也可以转换，依旧是换成元素
# set1={1,2,3,4,5,6,7,8}
# var1=list(set1)
# print(var1,type(var1))

#字典
#字典也可以但是他会按照键来转型，只会转换键，不会转换值
# dict1={"name":"yy1","name2":"yy2"}
# var1=list(dict1)
# print(var1,type(var1))

#字符串的转换
#int类型
#可以转换
# var=1
# val=str(var)
# print(var,type(val))

#浮点型（float）
#可以转换
# var1=4.2
# var2=str(var1)
# print(var2,type(var2))

#复数
#可以
# complex1=10 + 5j
# str1=str(complex1)
# print(str1,type(str1))

#列表
#也可以转换
# var1=[1,2,3,4,5,6]
# var2=str(var1)
# print(var2,type(var2))

#元组
#可以转换
# var1=(1,2,3,4,5,6)
# var2=str(var1)
# print(var2,type(var2))

#集合
#可以转换
# var1={1,2,3,4,5,6,7,8}
# var2=str(var1)
# print(var2,type(var2))

#字典
#可以转换
# dict1={"name1":"yy1","name2":"yy2"}
# var1=str(dict1)
# print(var1,type(var1))

#总结：字符串转换可以转换任何的类型

#元组的转换
#int
#不能转换
# var=1
# var2=tuple(var)
# print(var2,type(var2))

#folat(浮点型)
#浮点型不能转换
# float1=4.2
# tuple1=tuple(float1)
# print(tuple1,type(tuple1))

#复数
#也不能转换
# var1=4 + 2j
# var2=tuple(var1)
# print(var2,type(var2))

#字符串
#可以转换
# var1="hello"
# var2=tuple(var1)
# print(var2,type(var2))

#列表
#可以转换
# var1=[1,2,3,4,5,6]
# var2=tuple(var1)
# print(var2,type(var2))

#元组
#可以转换
# var1=(1,2,3,4,5,6)
# var2=tuple(var1)
# print(var2,type(var2))

#集合
#可以转换
# var1={1,2,3,4,5,6,7,8}
# var2=tuple(var1)
# print(var2,type(var2))


#字典
#可以转换但是只能转换建，不能转换值
# dict1={"name1":"yy1","name2":"yy2"}
# var1=tuple(dict1)
# print(var1,type(var1))

#总结：元组不能转dict换数字类型，但是只要是容器的类型都可以转换

#集合转换
#int
# var1=1
# val=set(var1)
# print(val)

#float
# var=4.2
# val=set(var)
# print(val)

#bool
# var=True
# val=set(var)
# print(val)

#complex
# var=0j
# val=set(var)
# print(val)

#str
#可以转换但是因为容器是无序的所以转换之后的数据不能保证一致性
# var="abc"
# val=set(var)
# print(val)
#------------------------------------------------------
#当然空的字符串也可以转换
# var=""
# val=set(var)
# print(val,type(val))

#列表
#可以转换
# var=[1,2,3,5]
# val=set(var)
# print(val,type(val))
#------------------------------------------------------
#空列表
#当然可以转换
# var=[]
# val=set(var)
# print(val,type(val))

#元组
#可以转换
# var=(1,2,3,5)
# val=set(var)
# print(val,type(val))
#------------------------------------------------------
#空元组
#可以转换
# var=()
# val=set(var)
# print(val,type(val))

#字典
#字典可以转换，但是只会转换建，不会转变值
# var={"name1":"yy1","name2":"yy2"}
# val=set(var)
# print(val,type(val))

#------------------------------------------------------
#空字典
#可以转换
# var={}
# val=set(var)
# print(val,type(val))

#总结：在集合中不能转换数值类型，容器都可以转换，但字典只转换键，不转换值



#字典的转换
#字典的原理跟集合一样在数值类型中都不可以转换，

#数值都不可以转换
#int
# var=1
# val=dict(var)
# print(val)

#float
# var=4.2
# val=dict(var)
# print(val)

#complex
# var=0j
# val=dict(var)
# print(val)

#bool
# var=True
# val=dict(var)
# print(val)

#以上的数值类型都不可以转换
#---------------------------------------------------------

#字符串
#注意如果想让字符串转换，字符串必须为空值
# var="111"
# var=""
# val=dict(var)
# print(val)

#列表
#如果想让列表转换，需要嵌套二级列表，二级列表中最多只能有（也只能有）两个元素
# var=[1,2,3,5]
# var=[[1,2],[3,5]]
# val=dict(var)
# print(val)

#元组
#同理，元组如果想要转换也需要嵌套二级元组
# var=(1,2,3,4)
# var=((1,2),(3,4))
# val=dict(var)
# print(val,type(val))

#集合
#集合转换就必须呀嵌套二级元组，为什么选择用元组而不用列表？
#因为元组的特性：它是不可改变的，元组中的数是多少，那就是多少。
# var={(1,2),(3,5)}
# val=dict(var)
# print(val,type(val))