qué - string en python
Longitud de un entero en Python (14)
En Python, ¿cómo se encuentra la cantidad de dígitos en un número entero?
Todas las soluciones math.log10 le darán problemas.
math.log10 es rápido pero da problemas cuando tu número es mayor que 999999999999997. Esto se debe a que el flotante tiene demasiados .9s, lo que hace que el resultado se redondee.
La solución es usar un método contador de tiempo para números por encima de ese umbral.
Para que esto sea aún más rápido, cree 10 ^ 16, 10 ^ 17 y así sucesivamente y almacene como variables en una lista. De esta forma, es como una búsqueda de tabla.
def getIntegerPlaces(theNumber):
if theNumber <= 999999999999997:
return int(math.log10(theNumber)) + 1
else:
counter = 15
while theNumber >= 10**counter:
counter += 1
return counter
Bueno, sin convertir a cadena, haría algo como:
def lenDigits(x):
"""
Assumes int(x)
"""
x = abs(x)
if x < 10:
return 1
return 1 + lenDigits(x / 10)
Recursividad minimalista FTW
Como mencionó el estimado usuario @ Calviner, la función math.log10 tiene un problema en un número fuera de un rango [-999999999999997, 999999999999997], donde obtenemos errores de coma flotante. Tuve este problema con el JavaScript (el Google V8 y el NodeJS) y el C (el compilador GNU GCC), por lo que una solución ''purely mathematically'' es imposible aquí.
En base a esta gist y la answer el querido usuario @ Calvintwr
import math
def get_count_digits(number: int):
"""Return number of digits in a number."""
if number == 0:
return 1
number = abs(number)
if number <= 999999999999997:
return math.floor(math.log10(number)) + 1
count = 0
while number:
count += 1
number //= 10
return count
Lo probé en números con una longitud de hasta 20 (inclusive) y todo bien. Debe ser suficiente, porque el número entero máximo de longitud en un sistema de 64 bits es 19 ( len(str(sys.maxsize)) == 19 ).
assert get_count_digits(-99999999999999999999) == 20
assert get_count_digits(-10000000000000000000) == 20
assert get_count_digits(-9999999999999999999) == 19
assert get_count_digits(-1000000000000000000) == 19
assert get_count_digits(-999999999999999999) == 18
assert get_count_digits(-100000000000000000) == 18
assert get_count_digits(-99999999999999999) == 17
assert get_count_digits(-10000000000000000) == 17
assert get_count_digits(-9999999999999999) == 16
assert get_count_digits(-1000000000000000) == 16
assert get_count_digits(-999999999999999) == 15
assert get_count_digits(-100000000000000) == 15
assert get_count_digits(-99999999999999) == 14
assert get_count_digits(-10000000000000) == 14
assert get_count_digits(-9999999999999) == 13
assert get_count_digits(-1000000000000) == 13
assert get_count_digits(-999999999999) == 12
assert get_count_digits(-100000000000) == 12
assert get_count_digits(-99999999999) == 11
assert get_count_digits(-10000000000) == 11
assert get_count_digits(-9999999999) == 10
assert get_count_digits(-1000000000) == 10
assert get_count_digits(-999999999) == 9
assert get_count_digits(-100000000) == 9
assert get_count_digits(-99999999) == 8
assert get_count_digits(-10000000) == 8
assert get_count_digits(-9999999) == 7
assert get_count_digits(-1000000) == 7
assert get_count_digits(-999999) == 6
assert get_count_digits(-100000) == 6
assert get_count_digits(-99999) == 5
assert get_count_digits(-10000) == 5
assert get_count_digits(-9999) == 4
assert get_count_digits(-1000) == 4
assert get_count_digits(-999) == 3
assert get_count_digits(-100) == 3
assert get_count_digits(-99) == 2
assert get_count_digits(-10) == 2
assert get_count_digits(-9) == 1
assert get_count_digits(-1) == 1
assert get_count_digits(0) == 1
assert get_count_digits(1) == 1
assert get_count_digits(9) == 1
assert get_count_digits(10) == 2
assert get_count_digits(99) == 2
assert get_count_digits(100) == 3
assert get_count_digits(999) == 3
assert get_count_digits(1000) == 4
assert get_count_digits(9999) == 4
assert get_count_digits(10000) == 5
assert get_count_digits(99999) == 5
assert get_count_digits(100000) == 6
assert get_count_digits(999999) == 6
assert get_count_digits(1000000) == 7
assert get_count_digits(9999999) == 7
assert get_count_digits(10000000) == 8
assert get_count_digits(99999999) == 8
assert get_count_digits(100000000) == 9
assert get_count_digits(999999999) == 9
assert get_count_digits(1000000000) == 10
assert get_count_digits(9999999999) == 10
assert get_count_digits(10000000000) == 11
assert get_count_digits(99999999999) == 11
assert get_count_digits(100000000000) == 12
assert get_count_digits(999999999999) == 12
assert get_count_digits(1000000000000) == 13
assert get_count_digits(9999999999999) == 13
assert get_count_digits(10000000000000) == 14
assert get_count_digits(99999999999999) == 14
assert get_count_digits(100000000000000) == 15
assert get_count_digits(999999999999999) == 15
assert get_count_digits(1000000000000000) == 16
assert get_count_digits(9999999999999999) == 16
assert get_count_digits(10000000000000000) == 17
assert get_count_digits(99999999999999999) == 17
assert get_count_digits(100000000000000000) == 18
assert get_count_digits(999999999999999999) == 18
assert get_count_digits(1000000000000000000) == 19
assert get_count_digits(9999999999999999999) == 19
assert get_count_digits(10000000000000000000) == 20
assert get_count_digits(99999999999999999999) == 20
Todos los ejemplos de códigos probados con Python 3.5
Deje que el número sea n entonces la cantidad de dígitos en n viene dada por:
math.floor(math.log10(n))+1
Tenga en cuenta que esto dará respuestas correctas para los enteros + ve <10e15. Más allá de eso, los límites de precisión del tipo de retorno de math.log10 en math.log10 y la respuesta puede estar desactivada en 1. Simplemente usaría len(str(n)) más allá de eso; esto requiere tiempo O(log(n)) que es lo mismo que iterar sobre potencias de 10.
Gracias a @SetiVolkylany por traer mi atención a esta limitación. Es sorprendente cómo las soluciones aparentemente correctas tienen advertencias en los detalles de implementación.
Formatee en notación científica y elimine el exponente:
int("{:.5e}".format(1000000).split("e")[1]) + 1
No sé acerca de la velocidad, pero es simple.
Tenga en cuenta el número de dígitos significativos después del decimal (el "5" en el ".5e" puede ser un problema si redondea la parte decimal de la notación científica a otro dígito. Lo configuré arbitrariamente grande, pero pude reflejar el longitud del mayor número que conoces
Para la posteridad, sin dudas la solución más lenta a este problema:
def num_digits(num, number_of_calls=1):
"Returns the number of digits of an integer num."
if num == 0 or num == -1:
return 1 if number_of_calls == 1 else 0
else:
return 1 + num_digits(num/10, number_of_calls+1)
Python 2.* int s toma 4 u 8 bytes (32 o 64 bits), dependiendo de su compilación de Python. sys.maxint ( 2**31-1 para 2**31-1 de 32 bits, 2**63-1 para 2**63-1 de 64 bits) le dirá cuál de las dos posibilidades obtiene.
En Python 3, int s (como long s en Python 2) puede tomar tamaños arbitrarios hasta la cantidad de memoria disponible; sys.getsizeof le da una buena indicación para cualquier valor dado, aunque también cuenta una cierta sobrecarga fija:
>>> import sys
>>> sys.getsizeof(0)
12
>>> sys.getsizeof(2**99)
28
Si, como sugieren otras respuestas, estás pensando en alguna representación de cadena del valor entero, entonces simplemente toma la len de esa representación, ya sea en la base 10 o de lo contrario.
Se puede hacer para enteros rápidamente usando:
len(str(abs(1234567890)))
Que obtiene la longitud de la cadena del valor absoluto de "1234567890"
abs devuelve el número SIN negativos (solo la magnitud del número), str convierte / lo convierte en una cadena y len devuelve la longitud de la cadena de esa cadena.
Si desea que funcione para flotadores, puede usar cualquiera de los siguientes:
# Ignore all after decimal place
len(str(abs(0.1234567890)).split(".")[0])
# Ignore just the decimal place
len(str(abs(0.1234567890)))-1
Para futura referencia.
Sin conversión a cadena
import math
digits = int(math.log10(n))+1
Manejar también números cero y negativos
import math
if n > 0:
digits = int(math.log10(n))+1
elif n == 0:
digits = 1
else:
digits = int(math.log10(-n))+2 # +1 if you don''t count the ''-''
Probablemente quieras poner eso en una función :)
Aquí hay algunos puntos de referencia. El len(str()) ya está detrás incluso para números bastante pequeños
timeit math.log10(2**8)
1000000 loops, best of 3: 746 ns per loop
timeit len(str(2**8))
1000000 loops, best of 3: 1.1 µs per loop
timeit math.log10(2**100)
1000000 loops, best of 3: 775 ns per loop
timeit len(str(2**100))
100000 loops, best of 3: 3.2 µs per loop
timeit math.log10(2**10000)
1000000 loops, best of 3: 844 ns per loop
timeit len(str(2**10000))
100 loops, best of 3: 10.3 ms per loop
Suponiendo que está pidiendo el número más grande que puede almacenar en un número entero, el valor depende de la implementación. Sugiero que no pienses de esa manera cuando uses Python. En cualquier caso, se puede almacenar un valor bastante grande en un ''entero'' de python. ¡Recuerda, Python usa el tipado de pato!
Editar: di mi respuesta antes de la aclaración de que el solicitante quería la cantidad de dígitos. Por eso, estoy de acuerdo con el método sugerido por la respuesta aceptada. ¡Nada más para agregar!
Si quieres la longitud de un número entero como en el número de dígitos en el entero, siempre puedes convertirlo a una cadena como str(133) y encontrar su longitud como len(str(123)) .
>>> a=12345
>>> a.__str__().__len__()
5
def length(i):
return len(str(i))
from math import log10
digits = lambda n: ((n==0) and 1) or int(log10(abs(n)))+1