In Python, hoe vindt u het aantal cijfers in een geheel getal?
1, Autoriteit 100%
Als u de lengte van een geheel getal wilt als in het aantal cijfers in het gehele getal, kunt u het altijd converteren naar string als str(133)en het vinden van zijn lengte als len(str(123)).
2, Autoriteit 76%
Zonder conversie naar string
import math
digits = int(math.log10(n))+1
Om ook de nul- en negatieve nummers af te handelen
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 '-'
U wilt dat waarschijnlijk in een functie plaatsen 🙂
Hier zijn enkele benchmarks. De len(str())is al achter voor nog vrij kleine nummers
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
3, Autoriteit 13%
Alle Math.log10-oplossingen geven u problemen.
MATH.LOG10 is snel, maar geeft het probleem wanneer uw nummer groter is dan 999999999999997. Dit komt omdat de float te veel .9s heeft, waardoor het resultaat rond.
De oplossing is om een Teller-methode voor cijfers boven die drempel te gebruiken.
Om dit nog sneller te maken, maak 10 ^ 16, 10 ^ 17, dus op en bewaar als variabelen in een lijst. Op die manier is het als een tafel opzoeken.
def getIntegerPlaces(theNumber):
if theNumber <= 999999999999997:
return int(math.log10(theNumber)) + 1
else:
counter = 15
while theNumber >= 10**counter:
counter += 1
return counter
4, Autoriteit 7%
Python 2.*intS Neem 4 of 8 bytes (32 of 64 bits), afhankelijk van uw Python-build. sys.maxint(2**31-1voor 32-bits inten, 2**63-1voor 64-bits inten) vertel u welke van de twee mogelijkheden verkrijgt.
In Python 3, intS (zoals longS IN PYTHON 2) kan willekeurige maten innemen tot het bedrag van het beschikbare geheugen; sys.getsizeofgeeft u een goede indicatie voor elke gewenste waarde, hoewel het ook telt, telt ook een aantal vaste overhead:
>>> import sys
>>> sys.getsizeof(0)
12
>>> sys.getsizeof(2**99)
28
Als, zoals andere antwoorden suggereert, denkt u aan een reeksvertegenwoordiging van de gehele getal-waarde, neem dan gewoon de lenvan die representatie, of anderszins in basis 10 of anderszins!
5, Autoriteit 4%
Laat het nummer ndan het aantal cijfers in ngegeven door:
math.floor(math.log10(n))+1
Merk op dat dit de juiste antwoorden geeft voor + ve-gehele getallen & lt; 10E15. Daarnaast kan de precisielimieten van het retourtype van math.log10in- en het antwoord worden uitgeschakeld door 1. Ik gebruik gewoon len(str(n))Beyond Dat; Dit vereist O(log(n))TIJD DIE ZE ZELF ZIJN ALS MERIKELAAR OVER MOETERS VAN 10.
Dankzij @Setivolkylany voor het brengen van mijn verzwakking naar deze beperking. Het is verbazingwekkend hoe ogenschijnlijk correcte oplossingen voorbehouden hebben in implementatiedetails.
6, Autoriteit 3%
Nou, zonder te converteren naar een reeks, zou ik iets doen als:
def lenDigits(x):
"""
Assumes int(x)
"""
x = abs(x)
if x < 10:
return 1
return 1 + lenDigits(x / 10)
Minimalistische recursie ftw
7, Autoriteit 3%
Tel het aantal cijfers zonder Ateger naar een reeks:
x=123
x=abs(x)
i = 0
while x >= 10**i:
i +=1
# i is the number of digits
8, Autoriteit 3%
Zoals de beste gebruiker @Calvintwr vermeld, heeft de functie math.log10een probleem in een getal buiten een bereik [-999999999999997, 999999999999997], waarbij we floating point-fouten krijgen. Ik had dit probleem met JavaScript (de Google V8 en de NodeJS) en de C (de GNU GCC-compiler), dus een 'purely mathematically'-oplossing is hier onmogelijk.
Op basis van deze gisten de antwoordde beste gebruiker @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
Ik heb het getest op getallen met een lengte tot 20 (inclusief) en goed. Het moet voldoende zijn, want de maximale lengte van een geheel getal op een 64-bits systeem is 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
Al het voorbeeld van codes getest met de Python 3.5
9
Voor het nageslacht, ongetwijfeld veruit de langzaamste oplossing voor dit probleem:
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)
10
Hier is een volumineuze maar snelle versie:
def nbdigit ( x ):
if x >= 10000000000000000 : # 17 -
return len( str( x ))
if x < 100000000 : # 1 - 8
if x < 10000 : # 1 - 4
if x < 100 : return (x >= 10)+1
else : return (x >= 1000)+3
else: # 5 - 8
if x < 1000000 : return (x >= 100000)+5
else : return (x >= 10000000)+7
else: # 9 - 16
if x < 1000000000000 : # 9 - 12
if x < 10000000000 : return (x >= 1000000000)+9
else : return (x >= 100000000000)+11
else: # 13 - 16
if x < 100000000000000 : return (x >= 10000000000000)+13
else : return (x >= 1000000000000000)+15
Slechts 5 vergelijkingen voor niet al te grote aantallen.
Op mijn computer is het ongeveer 30% sneller dan de math.log10versie en 5% sneller dan de len( str())versie.
Ok… nee zo aantrekkelijk als je het niet razend gebruikt.
En hier is de reeks getallen die ik heb gebruikt om mijn functie te testen/meten:
n = [ int( (i+1)**( 17/7. )) for i in xrange( 1000000 )] + [0,10**16-1,10**16,10**16+1]
NB: het beheert geen negatieve getallen, maar de aanpassing is eenvoudig…
Antwoord 11
from math import log10
digits = lambda n: ((n==0) and 1) or int(log10(abs(n)))+1
Antwoord 12
Ervan uitgaande dat u vraagt om het grootste getal dat u in een geheel getal kunt opslaan, is de waarde afhankelijk van de implementatie. Ik stel voor dat je niet op die manier denkt als je python gebruikt. In ieder geval kan een behoorlijk grote waarde worden opgeslagen in een python ‘integer’. Onthoud dat Python eendtypering gebruikt!
Bewerken:
Ik gaf mijn antwoord vóór de verduidelijking dat de vrager het aantal cijfers wilde. Daarvoor ben ik het eens met de methode die wordt voorgesteld door het geaccepteerde antwoord. Niets meer toe te voegen!
Antwoord 13
def length(i):
return len(str(i))
Antwoord 14
Het kan snel gedaan worden voor gehele getallen met:
len(str(abs(1234567890)))
Wat de lengte van de string van de absolute waarde van “1234567890” krijgt
absgeeft het getal ZONDER negatieven (alleen de grootte van het getal), strcast/converteert het naar een string en lengeeft de tekenreekslengte van die tekenreeks terug.
Als je wilt dat het werkt voor floats, kun je een van de volgende opties gebruiken:
# Ignore all after decimal place
len(str(abs(0.1234567890)).split(".")[0])
# Ignore just the decimal place
len(str(abs(0.1234567890)))-1
Voor toekomstig gebruik.
Antwoord 15
Formaat in wetenschappelijke notatie en pluk de exponent:
int("{:.5e}".format(1000000).split("e")[1]) + 1
Ik weet niets van snelheid, maar het is eenvoudig.
Let op het aantal significante cijfers na de komma (de “5” in de “.5e” kan een probleem zijn als het decimaal deel van de wetenschappelijke notatie naar een ander cijfer wordt afgerond. Ik heb het willekeurig groot ingesteld, maar zou de lengte kunnen weerspiegelen van het grootste getal dat je kent.
Antwoord 16
def digits(n)
count = 0
if n == 0:
return 1
if n < 0:
n *= -1
while (n >= 10**count):
count += 1
n += n%10
return count
print(digits(25)) # Should print 2
print(digits(144)) # Should print 3
print(digits(1000)) # Should print 4
print(digits(0)) # Should print 1
Antwoord 17
def count_digit(number):
if number >= 10:
count = 2
else:
count = 1
while number//10 > 9:
count += 1
number = number//10
return count
Antwoord 18
Als je een gebruiker moet vragen om invoer te geven en dan moet je tellen hoeveel getallen er zijn, dan kun je dit volgen:
count_number = input('Please enter a number\t')
print(len(count_number))
Opmerking: neem nooit een int als gebruikersinvoer.
Antwoord 19
Mijn code voor hetzelfde is als volgt; ik heb de log10-methode gebruikt:
from math import *
def digit_count(number):
if number>1 and round(log10(number))>=log10(number) and number%10!=0 :
return round(log10(number))
elif number>1 and round(log10(number))<log10(number) and number%10!=0:
return round(log10(number))+1
elif number%10==0 and number!=0:
return int(log10(number)+1)
elif number==1 or number==0:
return 1
Ik moest specificeren in het geval van 1 en 0 omdat log10(1)=0 en log10(0)=ND en daarom is niet voldaan aan de genoemde voorwaarde. Deze code werkt echter alleen voor hele getallen.
Antwoord 20
De beste antwoorden zeggen dat mathlog10 sneller is, maar ik heb resultaten die suggereren dat len(str(n)) sneller is.
arr = []
for i in range(5000000):
arr.append(random.randint(0,12345678901234567890))
%%timeit
for n in arr:
len(str(n))
//2.72 s ± 304 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%%timeit
for n in arr:
int(math.log10(n))+1
//3.13 s ± 545 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
Bovendien heb ik geen logica toegevoegd aan de wiskundige manier om nauwkeurige resultaten te geven en ik kan me alleen maar voorstellen dat het het nog meer vertraagt.
Ik heb geen idee hoe de vorige antwoorden hebben bewezen dat de manier van rekenen sneller is.
Antwoord 21
n = 3566002020360505
count = 0
while(n>0):
count += 1
n = n //10
print(f"The number of digits in the number are: {count}")
output: het aantal cijfers in het nummer is: 16
Antwoord 22
Als u op zoek bent naar een oplossing zonder ingebouwde functies te gebruiken.
Enige waarschuwing is wanneer u a = 000verzendt.
def number_length(a: int) -> int:
length = 0
if a == 0:
return length + 1
else:
while a > 0:
a = a // 10
length += 1
return length
if __name__ == '__main__':
print(number_length(123)
assert number_length(10) == 2
assert number_length(0) == 1
assert number_length(256) == 3
assert number_length(4444) == 4
Antwoord 23
Hier is een andere manier om het aantal cijfers vóór het decimaalteken van een willekeurig getal te berekenen
from math import fabs
len(format(fabs(100),".0f"))
Out[102]: 3
len(format(fabs(1e10),".0f"))
Out[165]: 11
len(format(fabs(1235.4576),".0f"))
Out[166]: 4
Ik heb een korte benchmarktest gedaan, voor 10.000 loops
num len(str(num)) ---- len(format(fabs(num),".0f")) ---- speed-up
2**1e0 2.179400e-07 sec ---- 8.577000e-07 sec ---- 0.2541
2**1e1 2.396900e-07 sec ---- 8.668800e-07 sec ---- 0.2765
2**1e2 9.587700e-07 sec ---- 1.330370e-06 sec ---- 0.7207
2**1e3 2.321700e-06 sec ---- 1.761305e-05 sec ---- 0.1318
Het is langzamer maar een eenvoudigere optie.
Maar zelfs deze oplossing geeft verkeerde resultaten van 9999999999999998
len(format(fabs(9999999999999998),".0f"))
Out[146]: 16
len(format(fabs(9999999999999999),".0f"))
Out[145]: 17
Antwoord 24
coin_digit = str(coin_fark).split(".")[1]
coin_digit_len = len(coin_digit)
print(coin_digit_len)
Antwoord 25
>>> a=12345
>>> a.__str__().__len__()
5