python数据类型强制转换和运算符

　# Number 强制类型转换

　　 (1) int 强制类型转换整型

　　 将浮点型数据强制转换成整型，它会默认将小数点后的数值舍去，不存在四舍五入
　　 将布尔值强制转换成整型，它会默认将True和False的值转变为1和0
　　 复数不能强制转化成整型，它会报错
　　 字符串能够强制转化为整型，但首先字符串必须是全数字，否则不行，会报错

　　 int只能对   int   float   bool   str(必须是全数字) 进行转换

　　# (1) float 强制转换为浮点型

　　 将整型强制转化为浮点型，它会默认在整型之后面加上小数点.0
　　 将布尔值强制转化为浮点型，它会默认将Ture和False的值转化为1.0和0.0
　　 复数不能转化为浮点型，它会报错
　　 字符串能够强制转化为浮点型，但首先字符串必须是全数字，否则不行，会报错

　　# (3) complex 强制转化为复数

　　 将整型强制转化为复数，它会默认在整型后面加上 0j
　　 将浮点型强制转换为复数，同上
　　 将布尔值强制转化为复数，它会将True转化为 1+0j，False转化为 0j
　　 将字符串强制转化为复数，但首先字符串必须是全数字，否则不行，会报错

　　# (4) bool 强制转化为布尔类型 结果只有两种 要么True 要么False

　　# bool 可以转换所有的数据类型均为True

　　# 唯独有以下十种情况 会为False   0   0.0    0j   False   ‘‘空   ()空元祖     []空列表    set()空集合    None

　　# None 系统关键字 无特殊意义 代表啥也没有一般用于初始化变量的时候用

　# 容器类型强制转换 (str list tuple set dict) 只能相互转换，不能转换Number数据类型

　　    (1) str 所有数据类型都可以强制转化成字符串str
　　  　　　　规律：   在原有类型基础上，在外套一层引号即可
　　  　　　　repr 　　打印出字符串类型的那个引号(原型化输出)

 　　   (2) list 所有数据类型都可以强制转化为列表list
   　　　　　　规律：强制转换：如果是字符串，把字符串当中的每一个字符当成列表
 　　　　　　　　　  中的新元素，其它都是在原有数据类型上，在外面套一个[]即可

 　　　　　　将字符串强制转化为列表时，它会在外套一层  []  同时里面的字符也会一一显示出字符串的引号
 　　　　　　将字典强制转化为列表型时，它会在外套一层  []  同时只保留字典里的键，而忽略字典里的值

　　    (3) tuple 所有数据类型都可以强制转化为元组tuple
　　   　　　　规律：强制转换：如果是字符串，把字符串当中的每一个字符当成列表
　　 　　　　             中的新元素，其它都是在原有数据类型上，在外面套一个 () 即可

　　 　　　　  将字典强制转化为元组时，它会在外套一层  ()  同时只保留字典里的键，而忽略字典里的值

           (4) set 所有数据类型都可以强制转化为集合set
        　　　　  规律：强制转换：如果是字符串，把字符串当中的每一个字符当成列表
 　　　　　　　　     中的新元素，(列表中的字符串会无序排列，因为集合本是无序排列)
 　　　　　　　　     其它都是在原有数据类型上，在外面套一个  {}  即可

　　　　  # 将字典强制转化为集合时，它会在外套一层{}同时只保留字典里的键，而忽略字典里的值

　　　(5) dict 强制转化为字典类型

　　　# 多级容器数据: 该类型是容器数据，并且里面的元素还是容器类型数据

　　　# ## 二级容器

　　　# 二级列表
　　　　listvar = [1,2,3,4,5[6,7,8,9]]

　　　# 二级元组
　　　　tuplevar = (1,2,3,4,5(6,7,8,9))

　　　# 二级集合 (只能在里面放元组作为集合里面的容器数据,只能放可哈希不可变的数据)
　　　　setvar = {1,2,3,(4,5,6)}

　　　# 二级字典
　　　　dictvar = {‘a‘:{‘c‘:3},‘b‘:2}

　　　# 四级容器

　　　　content = [1,2,3,4,(4,6,{‘a‘:{4,5,6,7,8},‘b‘:2},7),5]

　　　# 等长的二级容器

　　　　‘‘‘
　　　　首先容器是两个，代表二级容器
　　　　每一个容器元素个数都是一样的叫做等长
　　　　‘‘‘
　　　　listvar = [(1,2,3,4),(5,6,7,8)]
　　　　tupvar = ([1,2],[3,4],[5,6])

　　　# ## dict 强制转换成字典: (里面的元素只能是两个)

　　　# (1) 外面是列表，里面是 列表、元组、字符串(元素个数只能是两个，否则会报错)
　　　　listvar = [[‘a‘,1],(‘b‘,2)]

　　　# (2) 外面是元组，里面是列表、元组、字符串
　　　　tupvar = ([‘c‘,3],(‘d‘,33))

　　　# (3) 外面是集合，里面是元组、字符串

　　　　setvar ={(‘a‘,1),(‘b‘,2)}

　　　# 总结:
　　　　‘‘‘
　　　　容器类型数据强转：
　　　　str()   tuple()   list()   set()   dict() 都能转换成对应的数据类型
　　　　Number数据类型强转：
　　　　int()   float()   bool()    complex() 都能转换成对应的数据类型

　　　　可以强转函数值进行初始化
　　　　‘‘‘

　# 变量存储的缓存机制 (为了节省空间)

　　# (1)Number (int float bool complex)

　　# int (整型类取值在-5~正无穷范围内，取两个相同的值，
　　# 这两个值得地址就相同，若超过这个取值范围，地址就不同)

　　# float (浮点型取值只要是非负数，值得地址就相同)

　　# bool (在布尔值相同的情况下，值得地址相同)

　　# complex (在实数加虚数的情况下，永远不一样，只有虚数的情况下，就会一样)

　　# (2)容器类型数据 (str list tuple set dict)

　　# str (字符串值相同情况下，值得地址是一样的)
　　# list   tuple   set   dict (无论啥情况，值得地址都不一样)
　　# 例外： (空元祖的值得地址是一样的)

　　# # python 运算符

　　# (1) 算数运算符： + - * / //地板除 %取余 **幂运算

　　#    /  (除法,结果一定是小数)
　　#   //  地板除(整除) (如果相除的两个含有小数，那么就在结果上加上.0)

　　var1 = -7
　　var2 = 4
　　res = var1 % var2
　　print(res) => 1
　　# 把-7的负号拿走，然后7 - 4 = 3
　　# 算出结果，再把负号拿回来变成-3
　　# 这时在与4相加，-3 + 4 = 1
　　# 就可求得整除的结果

　　var1 = 7
　　varl = -4
　　res = var1 % var2
　　print(res) => -1

　　# 跟上述同理，先7 - 4 = 3
　　# 然后再用3 + (-4)
　　# 就可求得整除的结果

　# ## 比较运算符   >    <    >=    <=    ==等于    !=不等于

　　# 比较运算符就只有两种结果，要么是True 要么是False

　　‘‘‘
　　是两个等号，不是一个等号，1个等号是在做变量的赋值，两个是比较是否相同
　　‘‘‘

　　# ### 身份运算符 is 和 is not (检测两个数据在内存中是否是同一个值)

　　var1 = 5
　　varl = 6
　　print(id(var1),id(var2))

　　# is 用来判断两个变量的地址是否一致
　　res = var1 is var2
　　print(res) => True

　　res = var1 is not var2
　　print(res) => False

　　# var1 == var2 与 var1 is var2 的区别
　　‘‘‘
　　一个是比较两个值是否相同
　　一个是比较两个值的地址是否相同
　　‘‘‘

　# ### 逻辑运算符 and or not

　　# and 与
　　‘‘‘全真则真,一假则假‘‘‘
　　res = True and True => True
　　res = True and False => False
　　res = False and True => False
　　res = False and False => False
　　print(res)


　　# or 或
　　‘‘‘全真则真,全假则假,(一假一真,一真一假 => 都为真)‘‘‘
　　res = True or True => True
　　res = True or False => True
　　res = False or True => True
　　res = False or False => False
　　print(res)

　　# not 非
　　‘‘‘真变假,假变真‘‘‘
　　res = not False => True
　　res = not True => False

　# (1)逻辑短路 (后面代码不走了)
　　‘‘‘
　　# 两种情况
　　res = False and 布尔值 => False
　　res = True or 布尔值 => False
　　‘‘‘
　# print 默认返回一个 None 而None的布尔值是假

　　res = False and print(1) => False
　　print(res)
　　res = True and print(1) => 1 None
　　res = True or print(3) => True
　　res = False or print(4) => 4 None

　# 逻辑运算符优先级
　　‘‘‘()  >  not  >  and  >  or‘‘‘

　　res = 5 or 6 and 7
　　# 5 or 7 => 5
　　print(res)

　　res = (5 or 6) and 7
　　# 5 and 7 => 7

　　res = not (5 or 6) and 7

　　# (5 or 6) => 5
　　# not 5 => False
　　# False and 7 => False

　　res = 5>6 or 7<8 and 9>10 or 11<12
　　print(res) => True

　　‘‘‘
　　有一种情况不用考虑and和or优先级问题,
　　就是or短路 比如 True or ...... => 结果一定为 True
　　‘‘‘

　　# ## 数据类型的判断 isinstance
　　‘‘‘
　　isinstance(要判断的数据,判断的类型) 要么返回真，要么返回假
　　ininstance(要判断的数据,(元组，放上各种数据类型,满足一个条件即为真))
　　‘‘‘

　　# 5 是 int 类型的吗？
　　res = isinstance(5,int) => True
　　res = isinstance(‘123‘,list) => False
　　print(res)

　　# 有一个类型满足 反为真,一个都不满足,反为假
　　res = isinstance(5,(list,tuple,str,int))
　　print(res) => True
　　res = isinstance(5,(list,tuple,str,))
　　print(res) => False

原文：https://www.cnblogs.com/kangqidong/p/10780828.html