python在true和false直接进行数值运算的时候,啥情况下得出的结果是浮点数

Posted 2023-05-09

参考技术A 题主你好,
做除法运算时结果是浮点数.
所以不仅是数字之间的除法得到的浮点数.
布尔值True和False做除法运算时得到的结果也是符点数.
-----
扩展阅读:
在做运算的时候,布尔值True被看作是1, 布尔值False被看作是0.
所以True/True 相当于 1/1 结果是1.0
因为False在做运算的时候被看做0,因此在除法中, False不能位于除数位置,因此下列的表达式是错误的:
True/False 相当于1/0
False/False 相当于0/0
希望可以帮到题主, 欢迎追问.

Python3 - 基础语法篇 - 运算符详解(第一天)

文章目录

• • 算数运算符
  • 赋值运算符
  • 比较运算符
  • 逻辑运算符
  • 成员运算符
  • 身份运算符
  • 位运算

算数运算符

+ 加法
	在数值中就是把两个数据进行相加
			BOOL类型的数据，和数值类型的数据进行算数运算时，True视为1，False视为0
		在字符串中 +表示的是字符串拼接，多个字符串拼接在一起，形成一个新的字符串
- 减法
		数值中的减法
* 乘法
		数值中的乘法
		如果在字符串中使用的话，只能乘以一个正整数，把字符串中的内容重复n次
/ 除法
		求商
// 向下取整
		结果是一个整数，获取的是比商小但是又最近于商的整数
** 幂数
		求指定的指定次方
% 余数
		获取的是余数

赋值运算符

简单的赋值运算符 =
符合赋值运算符 
	+=
	-=
	*=
	/=
	**=
	%=
	对指定的变量进行对应的运算之后 再把结果赋值给变量
	
	x = 10
	x += 15 ===> x = x + 15
	
	x = 3
	x **= 3 ===> x = x ** 3
	
	赋值运算符的优先级别最低，优先运算=等号右边的表达式，把右边的结果赋值给左边的变量
	
	优先级：** > * / // % > + -

比较运算符

> 判断前面的表达式的结果是否大于后面
< 判断前面的表达式的结果是否小于后面
>= 判断前面的表达式的结果是否大于等于后面
<= 判断前面的表达式的结果是否小于等于后面
!= 判断前面的表达式的结果是否不等于后面

比较运算符的结果是布尔类型的

算数运算符的优先级是高于比较运算符的

x = 11
y = 12
x + 1 >= y True
y - 2 >= x - 1  True
y * 3 <= x * 3 False
x != y True

字符串类型的数据也是可以比较大小的，比较的规则：
		相同位置的字符一一进行比较，直到比较出结果
		'abc' > 'ab' True

		字符和字符之间的比较是通过其对应的编码规则对应的十进制数据进行比较的
				a - 97  A -65
				b - 98
				c - 99
				...
				'm' > 'n' False
				'a' > 'A' True
				'你' > '我' False
		

逻辑运算符

逻辑与 and
	并且的关系，连接的表达式关系必须同时成立，结果才成立。一假则全假
	True and True = True
	短路原则：
		如果左边的表达式结果为假，右边的表达式不参与运算。如果后面有or连接的逻辑运算，执行or后面的表达式
	运算流程：
		如果左边不成立，结果就取左边表达式的结果
		如果左边成立，结果就取右边表达式的结果
	数据转化为布尔类型的规则:
		数值类型 --- 非0即为True
							bool(0) --- False
		字符串 --- 非空容器即为True （长度为0的容器数据即为False）
				      只有一对引号，里面没有字符
		
逻辑或 or
		或者的关系，连接的表达式只要有一方成立，结果即成立。一真则全真
		短路原则：
			如果左边的表达式结果为真，右边的表达式不参与运算
		运算流程：
			如果左边不成立，结果就取右边表达式的结果
	  	如果左边成立，结果就取左边表达式的结果
逻辑非 not
		真变假，假变真
		not True = False
		not False = True
		逻辑运算的优先级低于比较运算符
		
逻辑运算符的优先级 not > and > or

成员运算符

针对于容器型数据来说的。
in 判断某个元素是否在容器中
not in  判断某个元素是否不在容器中

身份运算符

针对于数据的地址的
is 判断两个数据是否是一致的
not is  判断两个数据是否是不一致的
id(数据) 获取数据的地址

注意：

面试题：
数据在内存中有缓存区 保存在-5到256的数据,如果拿的是这个范围的数据，把数据的地址直接赋值给变量
如果是超过这个范围的数据，生成一个数据会在内存中新开辟一块区域来存储数据
x = 10
y = 10
print(x is y) # True

x = 300
y = 300
print(x is y) # False 

例如：
>>> a = 10
>>> b = 10
>>> print(id(a))
4553687568
>>> print(id(b))
4553687568
>>> x = 100
>>> y = 300
>>> print(id(x))
4553690448
>>> print(id(y))
4558225808
>>> 
>>> print(x is y)
False

位运算

运算的结果是基于二进制形式运算的
二进制的形态是有三种的
	原码：数值转化为二进制的格式就是原码
	反码
	补码
	
	正数 原码 反码 补码 格式是一样的
	
	怎么确定二进制数的最高位：数据在进行存储的时候，最小的存储单位是字节，如果确定了字节数，这个数据对应的二进制数的位数就确定了，比如说utf-8编码下的汉字，一个汉字是三个字节，需要开辟24位二进制数。
	
	二进制数的最高位是符号位，不参与运算，0表示正数，1表示负位
	
	负数的原码：
			将正数格式的二进制数 最高位置为1
	负数的反码：
			在负数原码的基础上，除了最高位，其余位按位取反（0变1，1变0）
	负数的补码：
			在负数反码的基础上 +1
			
	假设以原码形态进行运算
			7 + (-6)
					假设以8位存储
							7 ---- 0b0000 0111
						 -6 ---- 0b1000 0110
							 -----------------
							 			0b1000	1101 --- -13 【错误的】
	假设以反码形态进行运算
							7 ---- 0b0000 0111
						 -6 ---- 0b1111 1001
							 -----------------
							 			1 0000	0000 --- 1溢出 (舍去)
							 			结果 0b0000 0000 ---- 0 【错误的】
						
   假设以补码形态进行运算
   						7 ---- 0b0000 0111
		  			 -6 ---- 0b1111 1010
							 -----------------
           1溢出      0b0000 0001 --- 1【正确的】
           
           
           7 - 8
           7 ---- 0b0000 0111
           -8的源码：0b1000 1000
           -8的反码：0b1111 0111
           -8的补码：0b1111 1000
            0b0000 0111
           	0b1000 1000
          -------------
            0b1111 1111 【补码】----反码Ob1111 1110 ---- 原码 0b0000 0001 【-1】
            
     要看一个二进制数的数据表示的十进制数，看的是原码

位运算符运算的时候，符号位都参与了运算

相同位上的数据进行对应的运算

按位与 &
		相同位上的数据只要有一个为0，该位上的数据就是0
		7 & 6
		假设以8位存储
		0b0000 0111
		0b0000 0110
		-----------
		0b0000 0110 ----> 6
		
		7 & -6(求一下-6的补码) 原码0b1000 0110 反码 0b1111 1001 补码 0b1111 1010
		0b0000 0111
		0b1111 1010
		-----------
		0b0000 0010 --- 2

按位或 |
		相同位上的数据只要有一个为1，该位上的数据就是1
		7 | -6
			0b0000 0111
			0b1111 1010
			-----------
			0b1111 1111[补码] -->反码 0b1111 1110 -->原码 0b1000 0001 [-1]

按位异或 ^
		相同位上的数据如果数据如果是一样的，那这一位上的数据就是0，不同的话这一位上的数据是1
			7 ^ -6
			0b0000 0111
			0b1111 1010
			-----------
			0b1111 1101[补码]--->反码0b1111 1100 --->原码 0b1000 0011 [-3]
			
			-3 ^ -6
			0b1111 1101
			0b1111 1010
			-----------
			0b0000 0111 ---> 7
			
			一个数与相同的数异或两次，结果是其本身
			a = 10
			b = 20 ===> a = 20 b = 10
			交换两个变量的值[面试题]
					方式1：借助第三方变量
						c = a # 将a的值赋值给c，c拥有了10
						a = b # 将b赋值给a，a拥有了20
						b = c # 将c赋值给了b，b拥有了10
						
					方式2：不借助第三方变量
						异或：
								a = a ^ b # a = 10 ^ 20
								b = a ^ b # b = 10 ^ 20 ^ 20 = 10
								a = a ^ b # a = 10 ^ 20 ^ 10 = 20
						距离解决问题：
								a = a + b # a = 10 + 20
								b = a - b # b = 10 + 20 - 20 = 10
								a = a - b # a = 10 + 20 - 10 = 20
								
					方式3：Python独有的
								a, b = b, a

按位取反 ~
		将对应位上的数据 0变1 1变0
		~7
		0b0000 0111 
		-----------
		0b1111 1000[补码] --->反码0b1111 0111 --->原码 0b1000 1000 [-8]

按位左移 <<
		将二进制数数据向左移动指定的位数，右边空出，空出补0
		1 << 3
		0000 0001
		0000 1000 ---> 8
		
		1 << 4
		0000 0001
		0001 0000 ---> 16
		
		结果 = 数值* 2**(移动的位数)
		
		如何快速的计算出2的3次方的结果===> 1向左移动3位

按位右移 >>
		将二进制数数据向右移动指定位数，左边空出，如果数据原本是负数 补1，如果数据原本是正数 补0
		16 >> 2
		0001 0000
		0000 0100 ---> 4
		
		16 >> 3
		0000 0010 ---> 2
		
		结果 = 数值 / 2**(移动位数)
		
		-16 
		0b1001 0000
		0b1110 1111
		0b1111 0000
		-16 >> 2
		 1111 1100[补码] -->反码 1111 1011 ---> 1000 0100 ---> -4