Comment arrondir chaque élément d'une liste de flottants à deux décimales ?

Question

J'ai une liste qui se compose de valeurs flottantes mais elles sont trop détaillées pour que je puisse procéder. Je sais que l'on peut les raccourcir en utilisant la fonction ("%.f" % variable) opérateur, comme :

result = [359.70000000000005]
result = "%.2f" % result
result = [359.70]

Ma question est la suivante : comment puis-je transformer une liste de valeurs en leurs équivalents arrondis sans utiliser un itérateur ? J'ai essayé quelque chose, mais j'ai obtenu un résultat négatif. TypeError :

list = [0.30000000000000004, 0.5, 0.20000000000000001]
list = "%.2f" % list
TypeError: not all arguments converted during string formatting

Comment puis-je fournir une liste propre comme :

list = [0.30, 0.5, 0.20]

Answer 1

"%.2f" ne renvoie pas un nettoyer flotteur. Il renvoie un chaîne de caractères représentant ce flotteur avec deux décimales.

my_list = [0.30000000000000004, 0.5, 0.20000000000000001]
my_formatted_list = [ '%.2f' % elem for elem in my_list ]

retours :

['0.30', '0.50', '0.20']

Aussi, n'appelez pas votre variable list . C'est un mot réservé à la création de listes. Utilisez un autre nom, par exemple my_list .

Si vous voulez obtenir [0.30, 0.5, 0.20] (ou du moins les flottes les plus proches possibles), vous pouvez essayer ceci :

my_rounded_list = [ round(elem, 2) for elem in my_list ]

retours :

[0.29999999999999999, 0.5, 0.20000000000000001]

Answer 2

Si vous voulez vraiment une solution sans itérateur, vous pouvez utiliser numpy et sa fonction round de l'array fonction.

import numpy as np
myList = list(np.around(np.array(myList),2))

Answer 3

Vous pouvez consulter l'outil Python decimal qui peut rendre l'utilisation de nombres à virgule flottante et l'exécution d'opérations arithmétiques avec eux beaucoup plus intuitive. Voici un exemple trivial d'une façon de l'utiliser pour "nettoyer" les valeurs de votre liste :

>>> from decimal import *
>>> mylist = [0.30000000000000004, 0.5, 0.20000000000000001]
>>> getcontext().prec = 2
>>> ["%.2f" % e for e in mylist]
['0.30', '0.50', '0.20']
>>> [Decimal("%.2f" % e) for e in mylist]
[Decimal('0.30'), Decimal('0.50'), Decimal('0.20')]
>>> data = [float(Decimal("%.2f" % e)) for e in mylist]
>>> data
[0.3, 0.5, 0.2]

Answer 4

mylist = [0.30000000000000004, 0.5, 0.20000000000000001]
myRoundedList =  [round(x,2) for x in mylist] 
# [0.3, 0.5, 0.2]

Answer 5

Vous pouvez utiliser la fonction intégrée map ainsi qu'un lambda expression :

my_list = [0.2111111111, 0.5, 0.3777777777]
my_list_rounded = list(map(lambda x: round(x, ndigits=2), my_list))
my_list_rounded                                                                                                                                                                                                                 
Out[3]: [0.21, 0.5, 0.38]

Vous pouvez aussi créer une fonction nommée pour l'arrondi à un chiffre spécifique en utilisant partial de la functools module pour travailler avec des fonctions d'ordre supérieur :

from functools import partial

my_list = [0.2111111111, 0.5, 0.3777777777]
round_2digits = partial(round, ndigits=2)
my_list_rounded = list(map(round_2digits, my_list))
my_list_rounded                                                                                                                                                                                                                 
Out[6]: [0.21, 0.5, 0.38]