python1010

‘壹’ 如何用python把二进制数转换为十进制数

length = input("请输入这个二进制数有几位数：")

numbers = []

for i in range(eval(length)):

numbers.append(input("请输入数字：")) #这里有缩进

print(eval("0b"+"".join(numbers)))

然后再改一下缩进应该就行了

‘贰’ python中的进制转换和原码,反码,补码

python中的进制转换和原码,反码,补码

计算机文件大小单位

b = bit 位(比特)

B = Byte 字节

1Byte = 8 bit #一个字节等于8位 可以简写成 1B = 8b

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

1PB = 1024TB

1EB = 1024PB

进制分类

二进制:由2个数字组成,有0 和 1 python中标志：0b

八进制:由8个数字组成,有0,1,2,3,4,5,6,7 python中标志：0o

十进制:有10个数字组成,有0,1,2,3,4,5,6,7,8,9 python中标志：无

十六进制:有16个数字组成,有0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f(进制字母大小写都可以,分别代表10,11,12,13,14,15) python中标志：0x

python中的进制转换:

其他进制转换为十进制：int(相应进制)

其他进制转换为二进制：bin(相应进制)

其他进制转换为八进制：oct(相应进制)

其他进制转换为十六进制：hex(相应进制)

二进制 转化成 十进制:

例: 0b10100101

运算:1* 2^0 + 0* 2^1 + 1* 2^2 + 0* 2^3 + 0* 2^4 + 1* 2^5 + 0* 2^6 + 1* 2^7=

1 + 0 + 4 + 0 + 0 + 32 + 0 + 128 = 165

八进制 转化成 十进制:

例: 0o127

运算:7*8^0 + 2*8^1 + 1*8^2 = 7+16+64 = 87

十六进制 转化成 十进制:

例: 0xff

运算:15*16^0 + 15*16^1 = 255

十进制 转化成 二进制:

426 => 0b110101010

运算过程: 用426除以2,得出的结果再去不停地除以2,

直到除完最后的结果小于2停止,

在把每个阶段求得的余数从下到上依次拼接完毕即可

十进制 转化成 八进制:

426 => 0o652

运算过程: 用426除以8,得出的结果再去不停地除以8,

直到除完最后的结果小于8停止,

在把每个阶段求得的余数从下到上依次拼接完毕即可

十进制 转化成 十六进制:

运算过程: 用426除以16,得出的结果再去不停地除以16,

直到除完最后的结果小于16停止,

在把每个阶段求得的余数从下到上依次拼接完毕即可。

相关推荐：《Python视频教程》

原码,反码,补码

实际人们看到的数字是原码转化之后显示出来的。

而原码是通过补码得到的。

计算机的所有数据在底层都是以二进制的补码形式存储。

***进制转换的时候需要先把内存存储的补码拿出来变成原码在进行转换输出***

反码:二进制码0变1,1变0叫做反码,反码用于原码补码之间的转换。

补码:用来做数据的存储运算,可以实现计算机底层的减法操作,因而提出(可以表达出一个数的正负)。

也就是说默认计算机只会做加法,例:5+(-3) => 5 - 3。

乘法除法是通过左移和右移 << >> 来实现。

正数高位补0，负数高位补1。

正数:

原码 = 反码 = 补码

负数：

反码 = 原码取反（除高位）

补码 = 反码加1

反码 = 补码减1

原码 = 反码取反（除高位）

我们会发现，在取反前减1和在取反后加1的效果是一样的，这就和-2-1 = -(2+1)一个道理，所以会得出这样的规律：

原码 = 补码取反加1

补码 = 原码取反加1

一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 叫符号位正数为0, 负数为1。

比如

正数1在计算机中的存储即为

0 00000000000000000000001

负数1 在计算机中的存储即为

1 00000000000000000000001

一个正数，转换为二进制位就是这个正数的原码。负数的绝对值转换成二进制位然后在高位补1就是这个负数的原码。

正数的反码就是原码，负数的反码等于原码除符号位以外所有的位取反。

正数的补码与原码相同，负数的补码为 其原码除符号位外所有位取反（得到反码了），然后最低位加1。

所以原码,反码,补码正数情况下是一致的,负数情况下是不一致的。

计算机的运算过程实际就是补码相加的一个过程。

比如-2 + 3

-2 的原码为

1 000000000000000000000000010

反码为:

1 111111111111111111111111101

补码为:

1 111111111111111111111111110

3的原码为

0 000000000000000000000000011

反码为:

0 000000000000000000000000011

补码为:

0 000000000000000000000000011

那么二者补码相加结果为

1 111111111111111111111111110

+

0 000000000000000000000000011

=

10 000000000000000000000000001(计算机存储为32位,故前面溢出的1被舍弃,高位为0)

0 000000000000000000000000001

结果为1

再比如-2 + 1

-2 的原码为

1 000000000000000000000000010

反码为:

1 111111111111111111111111101

补码为:

1 111111111111111111111111110

1的原码为

0 000000000000000000000000001

1的反码为:

0 000000000000000000000000001

1的补码为:

0 000000000000000000000000001

二者的补码相加结果为

1 111111111111111111111111110

+

0 000000000000000000000000001

=

1 111111111111111111111111111

得出的补码转化为原码, 最低位减一得到反码,然后除符号位外所有位取反,得到结果

1 000000000000000000000000001

结果为1

‘叁’ python中0b1010是什么意思

0b1010表示二进制的1010,就是十进制的10,
a>>1表示去掉a二进制的最后一位所以a变成了ob101也就是十进制的5
需要注意的是>>是针对二进制进行操作,比如
a=10
a>>1
结果a还是5

‘肆’ python中两个等号符号，怎么用键盘打出来

Python中提供了各种各样的运算符帮助我们解决各种实际问题。Python中的运算符主要包括算术运算符、比较运算符、位运算符、逻辑运算符和赋值运算符。下面将一一介绍这些运算符的具体种类和使用方法。

算术运算符

算术运算符帮助我们完成各种各样的算术运算，如加减乘除等。Python中的算术运算符的种类如下表所示：

下面在Python中演示一个例子看看其具体输出情况：

x = 7
y = 3
print(x+y)
print(x-y)
print(x*y)
print(x/y)
print(x**y)
print(x//y)
print(7.0/3)
print(7.0//3)
print(7//3.0)
print(7.0//3.0)

上面程序在Python自带的IDLE中的运行情况如下图所示：

比较运算符

比较运算符的作用是对变量或表达式的结果进行大小或真假的比较。其计算结果有两种：True或False。

下表中给出了Python中所有的比较运算符的形式以及其含义。

表中的x、y、a和b的取值：x = 7, y = 8，a = 4， b = 7

在Python3.8.2Shell中运行上面的例子，其结果如下图所示：

赋值运算符

Python中，变量无须定义，可以直接使用，即在使用时，可以直接把基本赋值运算符“=”右边的值赋给左边的变量，也可以进行某些运算后再赋值给左边的变量。

Python中的赋值运算符有两种形式：

（1）基本的赋值运算符，即单个“=”，其把右边的值或运算结果赋给左边的变量；

（2）复合的赋值运算符，即由算术运算符和“=”组合成的赋值运算符，其兼有运算和赋值的功能，如+=，相当于左边的操作数加上右边的操作数后，再赋值给左边的操作数。

在Python中常用的赋值运算符如下表所示。

在Python IDLE中使用上面赋值运算符操作的例子如下图所示：

上面的例子中要注意 c=-13,c //=3 这个结果，//相当于向下取整。

最后一个例子中x %= 3,由于前面运算完毕后，x的值为4.8，这里进行取模运算后，结果应该是1.8，但由于精度问题，显示成了图所示的结果。

逻辑运算符

Python有三种逻辑运算符：逻辑与，逻辑或和逻辑非。

一、基本用法

（1）and ： 逻辑与

and运算需要两个操作数，如果参与运算的两个操作数都为True，则结果为True，否则运算结果为False。

b1 = True
b2 = True
b3 = False
b4 = False
print( b1 and b2)
print( b1 and b3)
print( b3 and b1)
print( b3 and b4)

其运行结果如下：

从运算结果可以总结出：如果and左侧操作数为False，则结果为False，否则为右侧操作数的值。

（2）or ： 逻辑或

逻辑or运算也需要两个操作数，如果参与or运算的两个操作数有一个为True，则运算结果为True；两个操作数都False时，则返回结果False.

b1 = True
b2 = True
b3 = False
b4 = False
print( b1 or b2)
print( b2 or b3)
print( b3 or b4)
print( b3 or b1)

其运算结果如下：

可以看出，如果or左侧操作数的值为True，则结果为True，否则为右侧操作数的结果。

（3）not ： 逻辑非

not只需要一个操作数，它对原值取反，即操作数为True时，非运算完后为False；原操作数为False时，非运算完后True。

b1 = True
b2 = False
print( not b1)
print( not b2)

其运算结果如下：

在Python中，逻辑运算符可以运用到非逻辑类型的数据中。

二、用于非逻辑数据类型

Python中，非0的数值类型被视为True，0被视为False；非空字符串被视True，空字符串被视为False。

1、and：逻辑与

（1）数字参与的运算

b1 = 2
b2 = 3
b3 = 0
print(b1 and b2)
print(b1 and b3)
print(b3 and b1)

其运算结果如下：

可以简单的概括为：如果and左侧为0，则结果为0，否则返回右侧操作数的值。

（2）字符串运算

s1 = "百家号"
s2 = "翔宇亭IT乐园"
s3 = ''
s4 = ''
print( s1 and s2)
print( s1 and s3)
print( s3 and s2)
print( s3 and s4)

其运算结果如下：

从运算结果可以简单总结：左操作数如果为空字符串，则返回空，否则为右侧操作数的值。

2、or：逻辑或

（1）数字参与的运算

b1 = 2
b2 = 3
b3 = 0
b4 = 0
print( b1 or b2)
print( b2 or b1)
print( b2 or b3)
print( b3 or b2)
print( b3 or b4)

其在Python3.8.2中的运算结果如下：

从上面的运算结果可以总结：如果or左侧的操作数是非0值，则返回左侧的数值，否则返回右侧操作数的值。

（2）字符串参与的运算

s1 = "翔宇亭IT乐园"
s2 = "biye5ucom"
s3 = ''
s4 = ''
print( s1 or s2)
print( s2 or s1)
print( s1 or s3)
print( s3 or s2)
print( s3 or s4)

其在Python3.8.2中的运算结果如下：

从上面结果可以总结：如果or左侧操作数为非空字符串，则返回左操作数的值，否则返回右侧操作数的值。

3、not：逻辑非

（1）有数字参与的运算

从上面可以看出：非0值取反后结果为False，0值取反后结果为True。

（2）有字符串参与的运算

从上面的运算结果来看：非空字符串取反后结果为False，空字符串取反后结果为True。

位运算符

位运算符也称二进制运算符，并且这些运算符只用于对整型数进行运算。

进行位运算时，整型数被转换为二进制形式，然后位运算符对每位执行有关运算后，将结果再转换回十进制形式，并返回给用户。

Python中共有6种位运算符：

（1）&：按位与运算

对应位上的二进制数进行与运算，如果参加位运算的两个二进制数为1，则结果为1，只要有一个为0，则结果为0，如10和4进行按位与运算，他们对应的二进制形式分别为：1010 和 100，则：

1 0 1 0
& 0 1 0 0
-----------
0 0 0 0

即10和4按位与运算的结果为二进制的0，也对应着10进制的0，最终结果即为0，即 10 & 4 = 0

再如，5和6进行按位与运算，其对应的二进制形式分别为： 101 和 110，

0 1 0 1
& 0 1 1 0
-------------
0 1 0 0

其运算结果为二进制的100，即十进制的4，也就是说： 5 & 6 = 4

在Python中的运行结果如下：

（2）按位或运算

按位或运算是二进制对应的每位进行或运算。如果对应的两位都为0，则结果为0，只要有一个为1，则结果为1。

10 和 4的或运算：

1 0 1 0
| 0 1 0 0
------------
1 1 1 0

其或运算的结果为二进制的 1110，对应着十进制的 14，即 10 | 4 = 14.

5 和 6的或运算：

0 1 0 1
| 0 1 1 0
------------
0 1 1 1

5 和 6的按位或运算结果为 0111，对应的十进制为 7 ，即 5 | 6 = 7.

在Python中的运行结果：

（3）按位异或运算

按位异或运算，即对应的两个二进制位不同时，结果为1，否则为0.

10 和 4 的按位异或运算：

1 0 1 0
^ 0 1 0 0
------------
1 1 1 0

即，结果为二进制1110，对应的十进制为14，亦即： 10 ^ 4 = 14

5 和 6 的按位异或运算：

0 1 0 1
^0 1 1 0
------------
0 0 1 1

0011对应的十进制数为3，也就是说： 5 ^ 6 = 3

在Python中的运行结果：

（4）按位取反运算符

该运算是单操作数运算符，即其只需要一个操作数参与运算。运算时，二进制数上的每位取反，即1变为0, 0变为1.

这里涉及到数字在计算机中的存储形式，在计算机中，最高位为符号位，符号位为0时表示正数，符号位为1时表示负数。

数字在计算机中是以补码的形式进行存储的，整数的补码与原码相同，负数的补码是在原码的基础上除符号位外，按位取反后，再加1.

如 +1，原码为0 0001，补码为 0 0001.

-1 ，原码为1 0001，补码为：1 1111。

再如：+2 ，原码为： 0 0010，补码为：0 0010.

-2，原码为：1 0010，补码为：1 1110

10按位取反运算（第1位为符号位）：

~ 0 1 0 1 0
--------------
1 0 1 0 1

结果最高位为1，为负数，因为负数在计算机中以补码形式存储，转换为原码（先减1，再按位反）为：

1 1011

即对应的十进制数为 -11，即： ~10 = -11.

5 按位取反运算：

~ 0 0 1 0 1
---------------
1 1 0 1 0

结果对应的原码为： 1 0110，对应的十进制数为：-6

在Python中的运行结果：

（5）<<：按位左移运算符

其形式为：m<<n

按位左移运算，m对应的二进制数的每位向左移动n位，后面补0.

如10的二进制数 1010 向左移动两位后为：10 1000，其对应的十进制数为：40.

5的二进制数：0101，向左移动两位后为：1 0100，其对应的十进制数为：20

也就是说，一个整数左移n位相当于这个数 m×2n

在Python中的运算结果：

（6）>>：按位右移运算符

其形式为：m >> n

即m对应的二进制数每位向右移动n位，移出的二进制数字去掉，最左边空出的变为0.

10的二进制 1010 向右移动1位为：0101，即变为十进制的5；再移动1位变为0010，变为2，再移动1位变为0001，变为1，再移动就一直为0了。

即每向右移动1位，相当于原数除以2，只保留整数部分；移动n位，相当于原数除以2n，只保留整数部分。

在Python中的运算结果：

以上详细讲解了Python中各种运算符的使用方法，如果你对Python、R等感兴趣，欢迎关注我，本号将持续更新相关内容的文章。

‘伍’ python语言中整数1010的二进制

n = 1010
print(bin(n))
# 0b1111110010

n = '1010'
print(bin(int(n)))

‘陆’ 如何用Python将十进制数字转为二进制，以及将二进制转为十六进制

1、将十进制转换成二进制，利用bin()方法。

‘柒’ 求教如何Python十进制小数和二进制小数相互转换的实现方式，用代码表示出来，谢谢

• 从二进制转换为十进制有几种方式第一种是在二进制数前加上0b，显示时会自动转换为十进制，注意这并不是字符串
  x
  =
  0b1010print(x)
  如果是字符串可以利用eval求值
  x
  =
  eval('0b1010')
  第二种是利用int函数，字符串可以以0b为前缀，也可以不使用
  int('1010',base=2)int('0b1010',2)
  函数会将输入base进制的字符串转换为十进制

‘捌’ python递归 例:把10x0中 x转成1和0 输出1010 和1000

我不明白的是，为什么会只能处理10个以下的x。虽然python有1000次的递归次数上限，但你的问题所需要的递归次数是由x的个数决定的，应该还远没有达到递归上限