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的個數決定的，應該還遠沒有達到遞歸上限