raw_input - Longitud de bits de un entero positivo en Python

python input()

Question

1 = 0b1 -> 1
5 = 0b101 -> 3
10 = 0b1010 -> 4
100 = 0b1100100 -> 7
1000 = 0b1111101000 -> 10
…

¿Cómo puedo obtener la longitud de bits de un entero, es decir, la cantidad de bits necesarios para representar un entero positivo en Python?

Answer 1

Aquí hay otra manera:

def number_of_bits(n):
    return len(''{:b}''.format(n))

No tan eficiente, supongo, pero no aparece en ninguna de las respuestas anteriores ...

Answer 2

En Python 2.7+ hay un método int.bit_length() :

>>> a = 100
>>> a.bit_length()
7

Answer 3

Esta solución aprovecha las ventajas de .bit_length() si está disponible, y .bit_length() a len(hex(a)) para versiones anteriores de Python. Tiene la ventaja sobre bin porque crea una cadena temporal más pequeña, por lo que utiliza menos memoria.

Tenga en cuenta que devuelve 1 por 0, pero eso es fácil de cambiar.

_HEX_BIT_COUNT_MAP = {
    ''0'': 0, ''1'': 1, ''2'': 2, ''3'': 2, ''4'': 3, ''5'': 3, ''6'': 3, ''7'': 3}

def bit_count(a):
  """Returns the number of bits needed to represent abs(a). Returns 1 for 0."""
  if not isinstance(a, (int, long)):
    raise TypeError
  if not a:
    return 1
  # Example: hex(-0xabc) == ''-0xabc''. ''L'' is appended for longs.
  s = hex(a)
  d = len(s)
  if s[-1] == ''L'':
    d -= 1
  if s[0] == ''-'':
    d -= 4
    c = s[3]
  else:
    d -= 3
    c = s[2]
  return _HEX_BIT_COUNT_MAP.get(c, 4) + (d << 2)


# Use int.bit_length and long.bit_length introduced in Python 2.7 and 3.x.
if getattr(0, ''bit_length'', None):
  __doc = bit_count.__doc__
  def bit_count(a):
    return a.bit_length() or 1
  bit_count.__doc__ = __doc

assert bit_count(0) == 1
assert bit_count(1) == 1
assert bit_count(2) == 2
assert bit_count(3) == 2
assert bit_count(63) == 6
assert bit_count(64) == 7
assert bit_count(75) == 7
assert bit_count(2047) == 11
assert bit_count(2048) == 12
assert bit_count(-4007) == 12
assert bit_count(4095) == 12
assert bit_count(4096) == 13
assert bit_count(1 << 1203) == 1204
assert bit_count(-(1 << 1203)) == 1204
assert bit_count(1 << 1204) == 1205
assert bit_count(1 << 1205) == 1206
assert bit_count(1 << 1206) == 1207

Answer 4

Si su versión de Python lo tiene (≥2.7 para Python 2, ≥3.1 para Python 3), use el método bit_length de la biblioteca estándar.

De lo contrario, len(bin(n))-2 como lo sugirió USTED es rápido (porque está implementado en Python). Tenga en cuenta que esto devuelve 1 para 0.

De lo contrario, un método simple es dividir repetidamente por 2 (lo que es un simple cambio de bit), y contar cuánto tiempo se tarda en llegar a 0.

def bit_length(n): # return the bit size of a non-negative integer
    bits = 0
    while n >> bits: bits += 1
    return bits

Es significativamente más rápido (al menos para números grandes, un punto de referencia rápido dice que es más de 10 veces más rápido para 1000 dígitos) para desplazarse por palabras completas a la vez, luego retroceder y trabajar en los bits de la última palabra.

def bit_length(n): # return the bit size of a non-negative integer
    if n == 0: return 0
    bits = -32
    m = 0
    while n:
        m = n
        n >>= 32; bits += 32
    while m: m >>= 1; bits += 1
    return bits

En mi rápido punto de referencia, len(bin(n)) salió significativamente más rápido que incluso la versión de tamaño de palabra. Aunque bin(n) construye una cadena que se descarta de inmediato, aparece en la parte superior debido a que tiene un bucle interno que se compila al código de la máquina. ( math.log es aún más rápido, pero eso no es importante porque está mal).

Answer 5

Simplemente almacene el valor en una variable y acceda a bit_length() en ella. Disponible en Python 2 y 3.

n = 5
print(n.bit_length())

Answer 6

>>> len(bin(1000))-2
10
>>> len(bin(100))-2
7
>>> len(bin(10))-2
4

Nota : no funcionará con números negativos, puede ser necesario restar 3 en lugar de 2

Answer 7

def bitcounter(n):
    return math.floor(math.log(n,2)) + 1

EDITAR fijo para que funcione con 1