Hướng dẫn display n in binary number format python - hiển thị n ở định dạng số nhị phân python

Đã hỏi 13 năm, 7 tháng trước 13 years, 7 months ago

Đã xem 1,1 triệu lần 1.1m times

Có bất kỳ phương pháp python đóng hộp nào để chuyển đổi một số nguyên [hoặc dài] thành một chuỗi nhị phân trong Python?

Có vô số chức năng của Dec2bin [] trên Google ... nhưng tôi đã hy vọng tôi có thể sử dụng một chức năng / thư viện tích hợp.

DREFTYMAC

30.4K26 Huy hiệu vàng116 Huy hiệu bạc178 Huy hiệu đồng26 gold badges116 silver badges178 bronze badges

Đã hỏi ngày 31 tháng 3 năm 2009 lúc 3:04Mar 31, 2009 at 3:04

1

Nếu bạn đang tìm kiếm

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

1 tương đương với

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

2, nó đã được thêm vào Python 2.6.

Example:

>>> bin[10]
'0b1010'

Akseli Palén

26.4K9 Huy hiệu vàng62 Huy hiệu bạc73 Huy hiệu Đồng9 gold badges62 silver badges73 bronze badges

Đã trả lời ngày 31 tháng 3 năm 2009 lúc 3:17Mar 31, 2009 at 3:17

John Fouhyjohn FouhyJohn Fouhy

40K19 Huy hiệu vàng62 Huy hiệu bạc77 Huy hiệu đồng19 gold badges62 silver badges77 bronze badges

5

Python thực sự có một cái gì đó đã được tích hợp cho việc này, khả năng thực hiện các hoạt động như

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

3, sẽ cung cấp cho bạn mẫu bit [trong một chuỗi] cho

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

4 hoặc

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

5.

Đối với một triết lý tổng quát hơn, không có ngôn ngữ hoặc thư viện nào sẽ cung cấp cho người dùng cơ sở mọi thứ mà họ mong muốn. Nếu bạn đang làm việc trong một môi trường không cung cấp chính xác những gì bạn cần, bạn nên thu thập các đoạn mã khi bạn phát triển để đảm bảo bạn không bao giờ phải viết điều tương tự hai lần. Chẳng hạn như, ví dụ, mã giả:

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

sẽ xây dựng chuỗi nhị phân của bạn dựa trên giá trị thập phân. Chỉ cần lưu ý rằng đó là một phần chung của mã giả có thể không phải là cách hiệu quả nhất để thực hiện nó, với các lần lặp mà bạn dường như đang đề xuất, nó sẽ không tạo ra nhiều sự khác biệt. Nó thực sự chỉ có ý nghĩa như một hướng dẫn về cách nó có thể được thực hiện.

Ý tưởng chung là sử dụng mã từ [theo thứ tự ưu tiên]:

• ngôn ngữ hoặc thư viện tích hợp.
• Thư viện bên thứ ba với giấy phép phù hợp.
• Bộ sưu tập của riêng bạn.
• Một cái gì đó mới bạn cần viết [và lưu trong bộ sưu tập của riêng bạn cho sau này].

Đã trả lời ngày 31 tháng 3 năm 2009 lúc 3:25Mar 31, 2009 at 3:25

Paxdiablopaxdiablopaxdiablo

829K227 Huy hiệu vàng1550 Huy hiệu bạc1919 Huy hiệu Đồng227 gold badges1550 silver badges1919 bronze badges

5

Nếu bạn muốn một biểu diễn văn bản mà không có 0b-prefix, bạn có thể sử dụng điều này:

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

Khi bạn muốn một đại diện N-bit:

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

Ngoài ra, nếu bạn thích có một chức năng:

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

Đã trả lời ngày 12 tháng 2 năm 2014 lúc 15:33Feb 12, 2014 at 15:33

Martin Thomamartin ThomaMartin Thoma

Huy hiệu vàng 114K148574 Huy hiệu bạc879 Huy hiệu đồng148 gold badges574 silver badges879 bronze badges

9

Tôi ngạc nhiên rằng không có đề cập đến một cách hay để thực hiện điều này bằng cách sử dụng các chuỗi định dạng được hỗ trợ trong Python 3.6 trở lên. TLDR:

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

Câu chuyện dài hơn

Đây là chức năng của các chuỗi định dạng có sẵn từ Python 3.6:

>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'

Bạn cũng có thể yêu cầu nhị phân:

>>> f'{z:b}'
'11'

Chỉ định chiều rộng:

>>> f'{z:8b}'
'      11'

Yêu cầu đệm không:

f'{z:08b}'
'00000011'

Và thêm tiền tố phổ biến để biểu thị số nhị phân:

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

0

Bạn cũng có thể để Python thêm tiền tố cho bạn nhưng tôi không thích nó nhiều như phiên bản ở trên vì bạn phải đưa tiền tố vào xem xét chiều rộng:

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

1

Thông tin thêm có sẵn trong tài liệu chính thức về các chữ cái được định dạng và đặc điểm kỹ thuật định dạng.

Đã trả lời ngày 19 tháng 8 năm 2020 lúc 10:37Aug 19, 2020 at 10:37

La Mã Pavelkaroman PavelkaRoman Pavelka

3.0741 Huy hiệu vàng11 Huy hiệu bạc26 Huy hiệu đồng1 gold badge11 silver badges26 bronze badges

4

Như một tài liệu tham khảo:

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

2

Hàm này có thể chuyển đổi một số nguyên dương lớn như

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

6, được biểu thị dưới dạng chuỗi

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

7.

Nó có thể được sửa đổi để phục vụ một số nguyên lớn hơn nhiều, mặc dù nó có thể không tiện dụng như

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

8 hoặc

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

1.

Đã trả lời ngày 17 tháng 12 năm 2013 lúc 19:39Dec 17, 2013 at 19:39

kctong529kctong529kctong529

8588 Huy hiệu bạc10 Huy hiệu đồng8 silver badges10 bronze badges

2

Đây là cho Python 3 và nó giữ các số không hàng đầu!

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

3

Đã trả lời ngày 13 tháng 11 năm 2018 lúc 7:04Nov 13, 2018 at 7:04

grepitgrepitgrepit

Phim thương hiệu vàng 19.7k66 gold badges99 silver badges80 bronze badges

3

Một cách đơn giản để làm điều đó là sử dụng định dạng chuỗi, xem trang này.

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

4

Và nếu bạn muốn có một độ dài cố định của chuỗi nhị phân, bạn có thể sử dụng điều này:

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

5

Nếu cần có bổ sung của Two, thì dòng sau có thể được sử dụng:

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

6

trong đó n là chiều rộng của chuỗi nhị phân.

Đã trả lời ngày 19 tháng 1 năm 2016 lúc 21:29Jan 19, 2016 at 21:29

XiangxiangXiang

4014 Huy hiệu bạc4 Huy hiệu đồng4 silver badges4 bronze badges

0

One-Liner với Lambda:lambda:

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

7

test:

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

8

CHỈNH SỬA::

nhưng sau đó :[

define intToBinString, receiving intVal:
    if intVal is equal to zero:
        return "0"
    set strVal to ""
    while intVal is greater than zero:
        if intVal is odd:
            prefix "1" to strVal
        else:
            prefix "0" to strVal
        divide intVal by two, rounding down
    return strVal

9

so với

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

0

Đã trả lời ngày 15 tháng 6 năm 2015 lúc 2:12Jun 15, 2015 at 2:12

Aziz Altoaziz AltoAziz Alto

17.7K4 Huy hiệu vàng73 Huy hiệu bạc57 Huy hiệu đồng4 gold badges73 silver badges57 bronze badges

2

Vì các câu trả lời trước đó chủ yếu định dạng [], đây là triển khai chuỗi F.

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

1

Output:

00111

Để thuận tiện ở đây là liên kết Python Docs cho các chuỗi được định dạng: //docs.python.org/3/reference/lexical_analysis.html#f-strings.

Đã trả lời ngày 7 tháng 6 năm 2019 lúc 20:41Jun 7, 2019 at 20:41

John Forbesjohn ForbesJohn Forbes

1.17812 Huy hiệu bạc17 Huy hiệu đồng12 silver badges17 bronze badges

Tóm tắt các lựa chọn thay thế:

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

2

Những người đóng góp bao gồm John Fouhy, Tung Nguyen, MVCHR, Martin Thoma. và Martijn Pieters.

1

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

3

Đã trả lời ngày 7 tháng 12 năm 2018 lúc 15:17Dec 7, 2018 at 15:17

Sandu Ursusandu UrsuSandu Ursu

1.0811 Huy hiệu vàng16 Huy hiệu bạc27 Huy hiệu đồng1 gold badge16 silver badges27 bronze badges

0

Đối với những người trong chúng ta cần chuyển đổi số nguyên đã ký [phạm vi -2 ** [chữ số-1] thành 2 ** [chữ số-1] -1] sang chuỗi nhị phân bổ sung của 2, điều này hoạt động:

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

4

Điều này tạo ra:

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

5

Daniel

3.12313 Huy hiệu bạc33 Huy hiệu đồng13 silver badges33 bronze badges

Đã trả lời ngày 18 tháng 12 năm 2018 lúc 19:32Dec 18, 2018 at 19:32

DeanmdeanmDeanM

4.4971 Huy hiệu vàng10 Huy hiệu bạc10 Huy hiệu đồng1 gold badge10 silver badges10 bronze badges

Bạn có thể làm như vậy:

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

6

hoặc :

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

7

Đã trả lời ngày 21 tháng 6 năm 2018 lúc 22:19Jun 21, 2018 at 22:19

Skiller Dzskiller DZSkiller Dz

88910 Huy hiệu bạc17 Huy hiệu đồng10 silver badges17 bronze badges

1

Sử dụng gói/giải nén Numpy, họ là những người bạn tốt nhất của bạn.

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

8

Đã trả lời ngày 27 tháng 8 năm 2015 lúc 3:39Aug 27, 2015 at 3:39

Fitfallpitfallpitfall

2.44120 Huy hiệu bạc21 Huy hiệu đồng20 silver badges21 bronze badges

2

Một giải pháp khác với một thuật toán khác, bằng cách sử dụng các toán tử bitwise.

get_bin = lambda x: format[x, 'b']

print[get_bin[3]]
>>> '11'

print[get_bin[-3]]
>>> '-11'

9

Một phiên bản nhanh hơn mà không đảo ngược chuỗi.

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

0

Đã trả lời ngày 18 tháng 10 năm 2014 lúc 22:45Oct 18, 2014 at 22:45

Reza Abtinreza AbtinReza Abtin

2053 Huy hiệu bạc7 Huy hiệu đồng3 silver badges7 bronze badges

1

Câu trả lời được chấp nhận không giải quyết các số âm, mà tôi sẽ đề cập. Ngoài các câu trả lời ở trên, bạn cũng có thể chỉ sử dụng các hàm bin và hex. Và theo hướng ngược lại, sử dụng ký hiệu nhị phân:

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

1

Nhưng với số lượng âm, mọi thứ trở nên phức tạp hơn một chút. Câu hỏi không chỉ định cách bạn muốn xử lý các số âm.

Python chỉ thêm một dấu hiệu tiêu cực để kết quả cho -37 sẽ là:

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

2

Trong dữ liệu nhị phân máy tính/phần cứng, các dấu hiệu tiêu cực không tồn tại. Tất cả những gì chúng ta có là 1 và 0. Vì vậy, nếu bạn đang đọc hoặc tạo các luồng dữ liệu nhị phân được xử lý bởi phần mềm/phần cứng khác, trước tiên bạn cần biết ký hiệu được sử dụng.

Một ký hiệu là ký hiệu độ chính xác, trong đó bit đầu tiên đại diện cho dấu hiệu âm và phần còn lại là giá trị thực. Trong trường hợp đó, -37 sẽ là

>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'

0 và 37 sẽ là

>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'

1. Điều này trông giống như những gì Python sản xuất, nhưng chỉ cần thêm 0 hoặc 1 ở phía trước cho các số dương / âm.

Phổ biến hơn là ký hiệu bổ sung của Two, có vẻ phức tạp hơn và kết quả rất khác với định dạng chuỗi của Python. Bạn có thể đọc các chi tiết trong liên kết, nhưng với số nguyên đã ký 8bit -37 sẽ là

>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'

2 và 37 sẽ là

>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'

3.

Python không có cách nào dễ dàng để tạo ra các biểu diễn nhị phân này. Bạn có thể sử dụng Numpy để biến các giá trị nhị phân bổ sung của Two thành số nguyên Python:

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

3

Nhưng tôi không biết một cách dễ dàng để làm ngược lại với các chức năng tích hợp. Gói bitstring có thể giúp mặc dù.

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

4

Đã trả lời ngày 26 tháng 6 năm 2020 lúc 2:49Jun 26, 2020 at 2:49

Dolf Andringadolf AndringaDolf Andringa

1.9231 Huy hiệu vàng19 Huy hiệu bạc34 Huy hiệu đồng1 gold badge19 silver badges34 bronze badges

Python 3.6 đã thêm một cách tiếp cận định dạng chuỗi mới được gọi là chuỗi chữ được định dạng hoặc các chuỗi F F. Thí dụ:

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

5

Đầu ra sẽ là 'Xin chào, Bob, số của bạn là 00001010!'

Một cuộc thảo luận về câu hỏi này có thể được tìm thấy ở đây - ở đây

Đã trả lời ngày 27 tháng 10 năm 2020 lúc 13:47Oct 27, 2020 at 13:47

Tim Uzlovtim UzlovTim Uzlov

1612 Huy hiệu bạc5 Huy hiệu Đồng2 silver badges5 bronze badges

Trừ khi tôi hiểu sai ý bạn là chuỗi nhị phân, tôi nghĩ rằng mô -đun bạn đang tìm kiếm là cấu trúc

Đã trả lời ngày 31 tháng 3 năm 2009 lúc 3:08Mar 31, 2009 at 3:08

Van Galevan GaleVan Gale

43.2K9 Huy hiệu vàng69 Huy hiệu bạc80 Huy hiệu Đồng9 gold badges69 silver badges80 bronze badges

1

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

6

Đã trả lời ngày 29 tháng 11 năm 2014 lúc 12:45Nov 29, 2014 at 12:45

0

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

7

output:

1010

Đã trả lời ngày 4 tháng 10 năm 2014 lúc 2:07Oct 4, 2014 at 2:07

Mukundanmukundanmukundan

Huy hiệu Bạc 9911 silver badge1 bronze badge

>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'

4

Ví dụ từ liên kết tài liệu ở trên:

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

8

Hai bổ sung được trả về khi số đầu vào âm và chiều rộng được chỉ định:

get_bin = lambda x, n: format[x, 'b'].zfill[n]
>>> get_bin[12, 32]
'00000000000000000000000000001100'
>>> get_bin[-12, 32]
'-00000000000000000000000000001100'

9

Đã trả lời ngày 30 tháng 4 năm 2019 lúc 9:28Apr 30, 2019 at 9:28

Tom Haletom HaleTom Hale

36K27 Huy hiệu vàng164 Huy hiệu bạc226 Huy hiệu đồng27 gold badges164 silver badges226 bronze badges

Đây là mã tôi vừa thực hiện. Đây không phải là một phương pháp nhưng bạn có thể sử dụng nó như một chức năng sẵn sàng sử dụng!method but you can use it as a ready-to-use function!

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

0

Đã trả lời ngày 15 tháng 3 năm 2014 lúc 13:18Mar 15, 2014 at 13:18

Quý tựquents

1113 Huy hiệu bạc8 Huy hiệu Đồng3 silver badges8 bronze badges

0

Một số giải pháp tương tự

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

1

Đã trả lời ngày 26 tháng 4 năm 2014 lúc 12:42Apr 26, 2014 at 12:42

Dưới đây là giải pháp đơn giản bằng cách sử dụng fucntion divmod [] trả về lời nhắc và kết quả của một bộ phận mà không có phân số.

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

2

Đã trả lời ngày 18 tháng 7 năm 2014 lúc 14:35Jul 18, 2014 at 14:35

1

Đây là một cách khác bằng cách sử dụng toán học thông thường, không có vòng lặp, chỉ đệ quy. [Trường hợp tầm thường 0 không trả lại gì].

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

3

Đã trả lời ngày 23 tháng 10 năm 2015 lúc 12:53Oct 23, 2015 at 12:53

Ergonauterergonautergonaut

6.7731 Huy hiệu vàng15 Huy hiệu bạc47 Huy hiệu đồng1 gold badge15 silver badges47 bronze badges

1

Máy tính với tất cả các chức năng cần thiết cho DEC, BIN, HEX: [được thực hiện và thử nghiệm với Python 3.5]

Bạn có thể thay đổi số kiểm tra đầu vào và nhận được các số chuyển đổi.

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

4

Đã trả lời ngày 29 tháng 8 năm 2017 lúc 8:11Aug 29, 2017 at 8:11

HKC72HKC72HKC72

4621 Huy hiệu vàng8 Huy hiệu bạc18 Huy hiệu đồng1 gold badge8 silver badges18 bronze badges

Để tính toán nhị phân của các số:

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

5

Để tính toán số thập phân hexa của một số::

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

6

Để tính tất cả các nhị phân không đến 16 ::

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

7

Để tính toán số thập phân hexa không đến 17

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

8

Đã trả lời ngày 3 tháng 4 năm 2018 lúc 16:16Apr 3, 2018 at 16:16

def get_bin[x, n=0]:
    """
    Get the binary representation of x.

    Parameters
    ----------
    x : int
    n : int
        Minimum number of digits. If x needs less digits in binary, the rest
        is filled with zeros.

    Returns
    -------
    str
    """
    return format[x, 'b'].zfill[n]

9

Đã trả lời ngày 27 tháng 4 năm 2017 lúc 8:53Apr 27, 2017 at 8:53

Advay168Advay168Advay168

5486 Huy hiệu bạc9 Huy hiệu Đồng6 silver badges9 bronze badges

1

Tôi tìm thấy một phương pháp sử dụng hoạt động ma trận để chuyển đổi thập phân thành nhị phân.

>>> number = 1
>>> f'0b{number:08b}'
'0b00000001'

0

>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'

5 Họ đầu vào dữ liệu thập phân, ________ 66 là đơn đặt hàng nhị phân.

>>> x, y, z = 1, 2, 3
>>> f'{x} {y} {2*z}'
'1 2 6'

7 là dữ liệu nhị phân đầu ra, ở định dạng 1 bởi M ma trận nhị phân.

Đã trả lời ngày 29 tháng 5 năm 2018 lúc 20:22May 29, 2018 at 20:22

Làm thế nào để bạn hiển thị số nhị phân trong Python?

Làm thế nào để bạn chuyển đổi int thành nhị phân trong python?

08B làm gì trong Python?

Định dạng nhị phân ở Python là gì?