Manera rápida de contar bits distintos de cero en un entero positivo

Necesito una forma rápida de contar la cantidad de bits en un número entero en Python. Mi solución actual es

bin(n).count("1")

pero me pregunto si hay alguna forma más rápida de hacer esto.

PD: (estoy representando una gran matriz binaria 2D como una lista única de números y haciendo operaciones bit a bit, y eso reduce el tiempo de horas a minutos. Y ahora me gustaría deshacerme de esos minutos adicionales.

Editar: 1. tiene que estar en Python 2.7 o 2.6

y optimizar para números pequeños no importa mucho, ya que eso no sería un cuello de botella claro, pero tengo números con más de 10000 bits en algunos lugares

por ejemplo, este es un caso de 2000 bits:

12448057941136394342297748548545082997815840357634948550739612798732309975923280685245876950055614362283769710705811182976142803324242407017104841062064840113262840137625582646683068904149296501029754654149991842951570880471230098259905004533869130509989042199261339990315125973721454059973605358766253998615919997174542922163484086066438120268185904663422979603026066685824578356173882166747093246377302371176167843247359636030248569148734824287739046916641832890744168385253915508446422276378715722482359321205673933317512861336054835392844676749610712462818600179225635467147870208L

Para enteros de longitud arbitraria, bin(n).count("1")es lo más rápido que pude encontrar en Python puro.

Intenté adaptar las soluciones de Óscar y Adam para procesar el entero en trozos de 64 bits y 32 bits, respectivamente. Ambos fueron al menos diez veces más lentos que bin(n).count("1")(la versión de 32 bits tomó aproximadamente la mitad de tiempo).

Por otro lado, gmpy popcount() tomó aproximadamente una vigésima parte del tiempo de bin(n).count("1"). Entonces, si puedes instalar gmpy, úsalo.

Para responder una pregunta en los comentarios, para bytes usaría una tabla de búsqueda. Puede generarlo en tiempo de ejecución:

counts = bytes(bin(x).count("1") for x in range(256))  # py2: use bytearray

O simplemente defínalo literalmente:

counts = (b'\x00\x01\x01\x02\x01\x02\x02\x03\x01\x02\x02\x03\x02\x03\x03\x04'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x04\x05\x05\x06\x05\x06\x06\x07\x05\x06\x06\x07\x06\x07\x07\x08')

Entonces es counts[x]para obtener el número de 1 bits en xdonde 0 ≤ x ≤ 255.

Puede adaptar el siguiente algoritmo:

def CountBits(n):
  n = (n & 0x5555555555555555) + ((n & 0xAAAAAAAAAAAAAAAA) >> 1)
  n = (n & 0x3333333333333333) + ((n & 0xCCCCCCCCCCCCCCCC) >> 2)
  n = (n & 0x0F0F0F0F0F0F0F0F) + ((n & 0xF0F0F0F0F0F0F0F0) >> 4)
  n = (n & 0x00FF00FF00FF00FF) + ((n & 0xFF00FF00FF00FF00) >> 8)
  n = (n & 0x0000FFFF0000FFFF) + ((n & 0xFFFF0000FFFF0000) >> 16)
  n = (n & 0x00000000FFFFFFFF) + ((n & 0xFFFFFFFF00000000) >> 32) # This last & isn't strictly necessary.
  return n

Esto funciona para números positivos de 64 bits, pero es fácilmente ampliable y el número de operaciones crece con el logaritmo del argumento (es decir, linealmente con el tamaño de bits del argumento).

Para entender cómo funciona esto, imagine que divide toda la cadena de 64 bits en 64 depósitos de 1 bit. El valor de cada depósito es igual al número de bits establecidos en el depósito (0 si no se establecen bits y 1 si se establece un bit). La primera transformación da como resultado un estado análogo, pero con 32 cubos cada uno de 2 bits de longitud. Esto se logra cambiando apropiadamente los cubos y agregando sus valores (una adición se encarga de todos los cubos, ya que no puede ocurrir ningún acarreo entre cubos; el número de n bits siempre es lo suficientemente largo para codificar el número n). Las transformaciones adicionales conducen a estados con un número de cubos que disminuye exponencialmente y un tamaño que crece exponencialmente hasta que llegamos a un contenedor de 64 bits de longitud. Esto da el número de bits establecidos en el argumento original.

Aquí hay una implementación de Python del algoritmo de conteo de población, como se explica en esta publicación :

def numberOfSetBits(i):
    i = i - ((i >> 1) & 0x55555555)
    i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
    return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24

Funcionará para 0 <= i < 0x100000000.

Según esta publicación , esta parece ser una de las implementaciones más rápidas del peso Hamming (si no le importa usar alrededor de 64 KB de memoria).

#http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetTable
POPCOUNT_TABLE16 = [0] * 2**16
for index in range(len(POPCOUNT_TABLE16)):
    POPCOUNT_TABLE16[index] = (index & 1) + POPCOUNT_TABLE16[index >> 1]

def popcount32_table16(v):
    return (POPCOUNT_TABLE16[ v        & 0xffff] +
            POPCOUNT_TABLE16[(v >> 16) & 0xffff])

En Python 2.x debe reemplazarlo rangecon xrange.

Editar

Si necesita un mejor rendimiento (y sus números son enteros grandes), eche un vistazo a la GMPbiblioteca. Contiene implementaciones de ensamblaje escritas a mano para muchas arquitecturas diferentes.

gmpy es un módulo de extensión de Python codificado en C que envuelve la biblioteca GMP.

>>> import gmpy
>>> gmpy.popcount(2**1024-1)
1024

Me gusta mucho este método. Es simple y bastante rápido, pero tampoco está limitado en la longitud de bits, ya que Python tiene números enteros infinitos.

En realidad, es más astuto de lo que parece, porque evita perder el tiempo escaneando los ceros. Por ejemplo, tomará el mismo tiempo contar los bits establecidos en 1000000000000000000000010100000001 que en 1111.

def get_bit_count(value):
   n = 0
   while value:
      n += 1
      value &= value-1
   return n

Puede utilizar el algoritmo para obtener la cadena binaria [1] de un entero, pero en lugar de concatenar la cadena, contando el número de unos:

def count_ones(a):
    s = 0
    t = {'0':0, '1':1, '2':1, '3':2, '4':1, '5':2, '6':2, '7':3}
    for c in oct(a)[1:]:
        s += t[c]
    return s

[1] https://wiki.python.org/moin/BitManipulation

Dijiste que Numpy era demasiado lento. ¿Lo estaba utilizando para almacenar bits individuales? ¿Por qué no extender la idea de usar ints como matrices de bits pero usar Numpy para almacenarlos?

Almacene n bits como una matriz de entradas de ceil(n/32.)32 bits. Luego puede trabajar con la matriz numpy de la misma manera (bueno, lo suficientemente similar) en la que usa ints, incluido su uso para indexar otra matriz.

El algoritmo consiste básicamente en calcular, en paralelo, el número de bits establecidos en cada celda, y suman el recuento de bits de cada celda.

setup = """
import numpy as np
#Using Paolo Moretti's answer http://stackoverflow.com/a/9829855/2963903
POPCOUNT_TABLE16 = np.zeros(2**16, dtype=int) #has to be an array

for index in range(len(POPCOUNT_TABLE16)):
    POPCOUNT_TABLE16[index] = (index & 1) + POPCOUNT_TABLE16[index >> 1]

def popcount32_table16(v):
    return (POPCOUNT_TABLE16[ v        & 0xffff] +
            POPCOUNT_TABLE16[(v >> 16) & 0xffff])

def count1s(v):
    return popcount32_table16(v).sum()

v1 = np.arange(1000)*1234567                       #numpy array
v2 = sum(int(x)<<(32*i) for i, x in enumerate(v1)) #single int
"""
from timeit import timeit

timeit("count1s(v1)", setup=setup)        #49.55184188873349
timeit("bin(v2).count('1')", setup=setup) #225.1857464598633

Aunque me sorprende que nadie te sugiera que escribas un módulo C.

#Python prg to count set bits
#Function to count set bits
def bin(n):
    count=0
    while(n>=1):
        if(n%2==0):
            n=n//2
        else:
            count+=1
            n=n//2
    print("Count of set bits:",count)
#Fetch the input from user
num=int(input("Enter number: "))
#Output
bin(num)

Resulta que su representación inicial es una lista de listas de entradas que son 1 o 0. Simplemente cuéntelas en esa representación.

El número de bits en un entero es constante en Python.

Sin embargo, si desea contar el número de bits establecidos, la forma más rápida es crear una lista que se ajuste al siguiente pseudocódigo: [numberofsetbits(n) for n in range(MAXINT)]

Esto le proporcionará una búsqueda de tiempo constante después de haber generado la lista. Vea la respuesta de @ PaoloMoretti para una buena implementación de esto. Por supuesto, no es necesario que guarde todo esto en la memoria; puede usar algún tipo de almacén de valores clave persistente o incluso MySql. (Otra opción sería implementar su propio almacenamiento simple basado en disco).