parte - redondear decimales python

Dividir un número entero en dígitos para calcular una suma de verificación ISBN

Question

Estoy escribiendo un programa que calcula el dígito de control de un número ISBN. Tengo que leer la entrada del usuario (nueve dígitos de un ISBN) en una variable entera, y luego multiplicar el último dígito por 2, el segundo último dígito por 3 y así sucesivamente. ¿Cómo puedo "dividir" el número entero en sus dígitos constituyentes para hacer esto? Como se trata de un ejercicio de tarea básica, no debo utilizar una lista.

Answer 1

¿Qué tal una lista de dígitos de una sola línea ...

ldigits = lambda n, l=[]: not n and l or l.insert(0,n%10) or ldigits(n/10,l)

Answer 2

Conviértalo a cadena y mapéelo con la función int ().

map(int, str(1231231231))

Answer 3

Después de búsquedas diligentes, encontré varias soluciones, donde cada una tiene ventajas y desventajas. Utiliza los más adecuados para tu tarea.

Todos los ejemplos probados con el CPython 3.5 en el sistema operativo GNU / Linux Debian 8.

Utilizando una recursion

Código

def get_digits_from_left_to_right(number, lst=None):
"""Return digits of an integer excluding the sign."""
if lst is None:
lst = list()
number = abs(number)
if number < 10:
lst.append(number)
return tuple(lst)
get_digits_from_left_to_right(number // 10, lst)
lst.append(number % 10)
return tuple(lst)

Manifestación

In [121]: get_digits_from_left_to_right(-64517643246567536423)
Out[121]: (6, 4, 5, 1, 7, 6, 4, 3, 2, 4, 6, 5, 6, 7, 5, 3, 6, 4, 2, 3)
In [122]: get_digits_from_left_to_right(0)
Out[122]: (0,)
In [123]: get_digits_from_left_to_right(123012312312321312312312)
Out[123]: (1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 1, 3, 1, 2, 3, 1, 2, 3, 1, 2)

Usando la función divmod

Código

def get_digits_from_right_to_left(number):
"""Return digits of an integer excluding the sign."""
number = abs(number)
if number < 10:
return (number, )
lst = list()
while number:
number, digit = divmod(number, 10)
lst.insert(0, digit)
return tuple(lst)

Manifestación

In [125]: get_digits_from_right_to_left(-3245214012321021213)
Out[125]: (3, 2, 4, 5, 2, 1, 4, 0, 1, 2, 3, 2, 1, 0, 2, 1, 2, 1, 3)
In [126]: get_digits_from_right_to_left(0)
Out[126]: (0,)
In [127]: get_digits_from_right_to_left(9999999999999999)
Out[127]: (9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9)

Usando una tuple(map(int, str(abs(number))) construcción tuple(map(int, str(abs(number)))

In [109]: tuple(map(int, str(abs(-123123123))))
Out[109]: (1, 2, 3, 1, 2, 3, 1, 2, 3)
In [110]: tuple(map(int, str(abs(1412421321312))))
Out[110]: (1, 4, 1, 2, 4, 2, 1, 3, 2, 1, 3, 1, 2)
In [111]: tuple(map(int, str(abs(0))))
Out[111]: (0,)

Usando la función re.findall

In [112]: tuple(map(int, re.findall(r''/d'', str(1321321312))))
Out[112]: (1, 3, 2, 1, 3, 2, 1, 3, 1, 2)
In [113]: tuple(map(int, re.findall(r''/d'', str(-1321321312))))
Out[113]: (1, 3, 2, 1, 3, 2, 1, 3, 1, 2)
In [114]: tuple(map(int, re.findall(r''/d'', str(0))))
Out[114]: (0,)

Usando el módulo decimal

In [117]: decimal.Decimal(0).as_tuple().digits
Out[117]: (0,)
In [118]: decimal.Decimal(3441120391321).as_tuple().digits
Out[118]: (3, 4, 4, 1, 1, 2, 0, 3, 9, 1, 3, 2, 1)
In [119]: decimal.Decimal(-3441120391321).as_tuple().digits
Out[119]: (3, 4, 4, 1, 1, 2, 0, 3, 9, 1, 3, 2, 1)

Answer 4

En versiones anteriores de Python ...

map(int,str(123))

En la nueva versión 3k

list(map(int,str(123)))

Answer 5

He creado este programa y aquí está el código que en realidad calcula el dígito de control en mi programa

 #Get the 10 digit number
number=input("Please enter ISBN number: ")
#Explained below
no11 = (((int(number[0])*11) + (int(number[1])*10) + (int(number[2])*9) + (int(number[3])*8)
+ (int(number[4])*7) + (int(number[5])*6) + (int(number[6])*5) + (int(number[7])*4) +
(int(number[8])*3) + (int(number[9])*2))/11)
#Round to 1 dp
no11 = round(no11, 1)
#explained below
no11 = str(no11).split(".")
#get the remainder and check digit
remainder = no11[1]
no11 = (11 - int(remainder))
#Calculate 11 digit ISBN
print("Correct ISBN number is " + number + str(no11))

Es una larga línea de código, pero divide el número, multiplica los dígitos por la cantidad apropiada, los suma y los divide por 11, en una línea de código. La función .split () simplemente crea una lista (se divide en el decimal) para que pueda tomar el segundo elemento de la lista y tomarlo del 11 para encontrar el dígito de control. Esto también podría hacerse aún más eficiente cambiando estas dos líneas:

 remainder = no11[1]
no11 = (11 - int(remainder))

A esto:

 no11 = (11 - int(no11[1]))

Espero que esto ayude :)

Answer 6

La conversión a str es definitivamente más lenta que la división por 10.

map es un poco más lento que la comprensión de la lista:

convert to string with map 2.13599181175
convert to string with list comprehension 1.92812991142
modulo, division, recursive 0.948769807816
modulo, division 0.699964046478

Estos tiempos fueron devueltos por el siguiente código en mi computadora portátil:

foo = """/
def foo(limit):
return sorted(set(map(sum, map(lambda x: map(int, list(str(x))), map(lambda x: x * 9, range(limit))))))
foo(%i)
"""
bar = """/
def bar(limit):
return sorted(set([sum([int(i) for i in str(n)]) for n in [k *9 for k in range(limit)]]))
bar(%i)
"""
rac = """/
def digits(n):
return [n] if n<10 else digits(n / 10)+[n %% 10]
def rabbit(limit):
return sorted(set([sum(digits(n)) for n in [k *9 for k in range(limit)]]))
rabbit(%i)
"""
rab = """/
def sum_digits(number):
result = 0
while number:
digit = number %% 10
result += digit
number /= 10
return result
def rabbit(limit):
return sorted(set([sum_digits(n) for n in [k *9 for k in range(limit)]]))
rabbit(%i)
"""
import timeit
print "convert to string with map", timeit.timeit(foo % 100, number=10000)
print "convert to string with list comprehension", timeit.timeit(bar % 100, number=10000)
print "modulo, division, recursive", timeit.timeit(rac % 100, number=10000)
print "modulo, division", timeit.timeit(rab % 100, number=10000)

Answer 7

Similar a this respuesta, pero más una forma más "pirónica" de iterar sobre los digis sería:

while number:
# "pop" the rightmost digit
number, digit = divmod(number, 10)

Answer 8

Solo crea una cadena fuera de ella.

myinteger = 212345
number_string = str(myinteger)

Eso es suficiente. Ahora puedes iterar sobre esto:

for ch in number_string:
print ch # will print each digit in order

O puedes cortarlo:

print number_string[:2] # first two digits
print number_string[-3:] # last three digits
print number_string[3] # forth digit

O mejor, no convierta la entrada del usuario a un entero (el usuario escribe una cadena)

isbn = raw_input()
for pos, ch in enumerate(reversed(isbn)):
print "%d * %d is %d" % pos + 2, int(ch), int(ch) * (pos + 2)

Para más información lea un tutorial .

Answer 9

Suponiendo que desea obtener el i -el dígito menos significativo de un número entero x , puede intentar:

(abs(x)%(10**i))/(10**(i-1))

Espero que ayude.

Answer 10

Usa el cuerpo de este bucle para hacer lo que quieras con los dígitos

for digit in map(int, str(my_number)):

Answer 11

Versión recursiva:

def int_digits(n):
return [n] if n<10 else int_digits(n/10)+[n%10]

Answer 12

Respuesta: 165

Método: ¡fuerza bruta! Aquí hay un poquito de código de Python (versión 2.7) para contarlos todos.

from math import sqrt, floor
is_ps = lambda x: floor(sqrt(x)) ** 2 == x
count = 0
for n in range(1002, 10000, 3):
if n % 11 and is_ps(sum(map(int, str(n)))):
count += 1
print "#%i: %s" % (count, n)

Answer 13

while number:
digit = number % 10
# do whatever with digit
# remove last digit from number (as integer)
number //= 10

En cada iteración del bucle, elimina el último dígito del número, asignándolo a digit . Está en reversa, comienza desde el último dígito, termina con el primer

Answer 14

list_of_ints = [int(i) for i in str(ISBN)]

Le dará una lista ordenada de ints. Por supuesto, dado el tipeo de pato, también podría trabajar con str (ISBN).

Edit: Como se mencionó en los comentarios, esta lista no está ordenada en el sentido de ser ascendente o descendente, pero sí tiene un orden definido (conjuntos, diccionarios, etc. en python en teoría no, aunque en la práctica el orden tiende a ser bastante confiable). Si quieres ordenarlo:

list_of_ints.sort ()

es tu amigo. Tenga en cuenta que sort () se ordena en su lugar (como en, realmente cambia el orden de la lista existente) y no devuelve una nueva lista.

Answer 15

(number/10**x)%10

Puede usar esto en un bucle, donde número es el número completo, x es cada iteración del bucle (0,1,2,3, ..., n) siendo n el punto de parada. x = 0 da el lugar de las unidades, x = 1 da las decenas, x = 2 da las centenas, y así sucesivamente. Tenga en cuenta que esto le dará el valor de los dígitos de derecha a izquierda, por lo que podría no ser el valor de un ISBN, pero seguirá aislando cada dígito.