Comment puis-je améliorer ce code?

Question

# max_list = [83, 1350, 1, 100] 
for i in range(len(max_list)): 
    new_value = 1 
    while new_value < max_list[i]: 
      new_value *= 10 
    max_list = new_value 

Qu'est-ce que je fais est d'arrondir les nombres jusqu'à la valeur la plus proche, uhm, zéro rempli? Je ne suis pas sûr de ce que ça s'appellerait. Mais fondamentalement, je veux 83 -> 100, 1 -> 1, 1350 -> 10000, 100 -> 100. J'ai essayé d'utiliser la fonction round() mais je n'ai pas réussi à faire ce que je voulais.

Cela le fait mais je pensais qu'il pourrait être écrit en moins de lignes.

Answer 1

que je le ferais mathématiquement:

from math import ceil, log10 
int(pow(10, ceil(log10(abs(x or 0.1))))) 

Answer 2

def nextPowerOfTen(x): 
    if x in [0, 1]: 
    return x 
    elif x < 1: 
    return -nextPowerOfTen(abs(x)) 
    else: 
    return 10**len(str(int(x) - 1)) 

>>> nextPowerOfTen(83) 
100 
>>> nextPowerOfTen(1350) 
10000 
>>> nextPowerOfTen(1) 
1 
>>> nextPowerOfTen(100) 
100 
>>> nextPowerOfTen(0) 
0 
>>> nextPowerOfTen(-1) 
-1 
>>> nextPowerOfTen(-2) 
-10 

Il fait quelque chose de sensible avec des négatifs, pas sûr si c'est le comportement que vous voulez ou non.

Answer 3

J'ai besoin qu'il soit 1350/10000 = 0.135 donc c'est dans la gamme [0, 1].

Pourquoi ne l'avez-vous pas dit initialement?

new_val = float("0." + str(old_val)) 

À moins que vous n'ayez besoin des chiffres pour quelque chose d'autre?

Answer 4

>>> x = 12345.678 
>>> y = round(x) 
>>> round(10 * y, -len(str(y))) 
100000 

Answer 5

pseudocode:

div = input != 1 ? power(10,truncate(log10(abs(input))) + 1) : 1; 
percent = input/div; 

Answer 6

Votre code d'origine était proche, et de lire plus facilement que une expression laconique. Le problème avec votre code est un couple d'erreurs mineures: initialisation new_value chaque fois dans l'analyse initiale, plutôt qu'une seule fois; et en remplaçant le max_list par un scalaire calculé tout en le bouclant en tant que liste.

Sur la dernière ligne, vous devez avoir l'intention:

max_list[i] = float(max_list[i])/new_value 

mais vous avez laissé tomber l'index du tableau, qui remplacerait la liste avec une valeur unique. Lors de la deuxième itération de la boucle, votre Python donnerait une exception en raison de l'index invalide dans une non-liste. Comme votre code développe des valeurs de plus en plus grandes de new_value à mesure qu'il progresse, je vous recommande de ne pas remplacer les éléments de la liste lors de la première analyse. Faire une deuxième analyse une fois que vous calculez une valeur finale pour new_value:

max_list = [83, 1350, 1, 100] 

# Calculate the required "normalizing" power-of-ten 
new_value = 1.0 
for i in range(len(max_list)): 
    while new_value < max_list[i]: 
     new_value *= 10.0 

# Convert the values to fractions in [0.0, 1.0] 
for i in range(len(max_list)): 
    max_list[i] = max_list[i]/new_value 

print max_list 
# "[0.0083000000000000001, 0.13500000000000001, 0.0001, 0.01]" 

Notez que je requis pour initialiser new_value comme si elle était une valeur à virgule flottante, afin qu'il entraînerait quotients à virgule flottante. Il existe d'autres manières de procéder, par exemple en utilisant float(max_list[i]) pour récupérer la valeur pour la normalisation. Le calcul initial de new_value commençait sur chaque élément, de sorte que votre exemple retournerait parce que cela a été basé sur l'élément final dans la liste d'entrée, qui est 100.

Answer 7

from math import ceil, log10 

# works for floats, too. 
x = [83, 1350, 1, 100, 12.75] 
y = [10**ceil(log10(el)) for el in x] 

# alt list-comprehension if integers needed 
# y = [int(10**ceil(log10(el))) for el in x]