La façon la plus pythonique de convertir une liste de flottants fs en une liste d'entiers est d'utiliser la ligne fs =[int(x) for x in fs]. Il itère sur tous les éléments de la liste fs à l'aide d'une compréhension de liste et convertit chaque élément de la liste x en une valeur entière à l'aide du constructeur int(x).
Cet article montre les moyens les plus simples de convertir une liste unidimensionnelle composée uniquement de flottants , à une liste d'entiers .
Problème :Étant donné une liste de nombres à virgule flottante [1.0, 2.0, 3.0] . Comment le convertir en une liste d'entiers [1, 2, 3] ?
Les méthodes ne sont pas applicables aux listes de listes. Vous pouvez ajouter des boucles ou définir des fonctions définies par l'utilisateur selon vos besoins.
Méthode 1 :Liste
Supposons que nous ayons une liste :
a = [1.1, 1.2, 1.8, 0.5, 5.9, -2.3]
Vérifions le type des éléments de la liste :
print(type(a[0])) # <class 'float'>
Utilisons la fonction intégrée int, obtenir une liste d'entiers :
print([int(a) for a in a]) # [1, 1, 1, 0, 5, -2]
Vérifions le type des éléments de la liste :
A = [int(a) for a in a] print(type(A[0])) # <class ‘int’>
Donc, en utilisant la fonction intégrée int , qui, en convertissant un nombre réel, arrondit vers zéro, ou plutôt, il supprime la partie fractionnaire, nous pouvons obtenir une nouvelle liste d'entiers avec un code à une ligne.
Méthode 2 :fonction de carte
Fonction intégrée carte, est bien optimisé et efficace, lorsqu'il est appelé, les éléments de la liste sont récupérés lors de l'accès, et donc un élément est localisé et traité en mémoire, ce qui permet au programme de ne pas stocker toute la liste des éléments dans la mémoire système.
Appliquez le code ci-dessous à la même liste 'a' :
print(list(map(int, a))) # [1, 1, 1, 0, 5, -2]
Nous ne vérifierons pas le type des éléments de la liste résultante, puisque lors de l'appel de la 'map' lui a passé la fonction ‘int’ déjà décrite dans la méthode 1 comme argument, et le résultat est enveloppé dans une liste à l'aide de la fonction 'list'.
Méthode 3 :la fonction d'arrondi dans la définition de liste
Il est très similaire au premier, mais contrairement à 'int', il ne se contente pas de supprimer la partie fractionnaire, mais arrondit à l'entier pair le plus proche si la partie fractionnaire est de 0,5. Vous pouvez également passer en deuxième argument le nombre de décimales auxquelles l'arrondi est requis, par défaut c'est 0, nous utiliserons ceci :
print([round(a) for a in a])
Vérifions le type de numéro de la nouvelle liste :
D = [round(a) for a in a] print(type(D[0])) # <class ‘int’>
Comme vous pouvez le voir sur cet exemple, il existe différentes fonctions intégrées pour atteindre notre objectif, la différence réside dans la méthode et la quantité d'erreur d'arrondi.
Méthode 4 :Module de mathématiques
De cette façon, je vous propose d'utiliser le module d'importation 'math', dans lequel nous utiliserons trois fonctions ceil() , floor() , et trunc() . Examinons chacun de plus près. Ils ont la même syntaxe, la différence réside dans la méthode d'arrondi.
Appliquer à la liste d'origine :
a = [1.1, 1.2, 1.8, 0.5, 5.9, -2.3] print([math.ceil(a) for a in a]) # [2, 2, 2, 1, 6, -2]
'Ceil' arrondit à l'entier signé supérieur le plus proche (-2.3 <-2 la sortie sera True )
Vérifions le type de nombres dans la liste résultante :
C = [math.ceil(a) for a in a] print(type(C[0])) # <class ‘int’>
Considérez la fonction suivante dans le module 'math' - 'floor', qui est l'opposé de 'ceil' - arrondit à l'entier le plus proche :
print([math.floor(a) for a in a]) # [1, 1, 1, 0, 5, -3]
Vérification de type :
F = [math.floor(a) for a in a] print(type(F[0])) # <class ‘int’>
La fonction suivante, 'trunc', est un analogue de la fonction intégrée 'int' - elle supprime simplement la partie fractionnaire, quelle qu'elle soit :
print([math.trunc(a) for a in a]) # [1, 1, 1, 0, 5, -2]
Et encore une fois, vérifiez le type de numéros de la nouvelle liste :
T = [math.trunc(a) for a in a] print(type(T[0])) # <class ‘int’>
Méthode 5 :NumPy
Ici, nous allons envisager de convertir une liste de 'int' en un tableau à l'aide du module NumPy. La différence entre un tableau et une liste est que tous les éléments d'un tableau doivent être du même type, comme "float" et "int". Les opérations numériques avec une grande quantité de données peuvent être effectuées avec des tableaux beaucoup plus rapidement et plus efficacement qu'avec des listes.
Transformons notre première liste 'a' en un tableau :
import numpy as np N = np.array(a, int)
Vers la fonction tableau nous passons deux arguments, le nom de la liste à convertir en tableau et le type de chaque élément.
# [ 1 1 1 0 5 -2]
Vérifions le type des éléments :
print(type(N[0])) # <class 'numpy.int32'>
Contrairement au type de nombre 'int' en Python, ils sont définis différemment dans le module NumPy et sont divisés en plusieurs sous-groupes. Par exemple, 'int32' sont des nombres entiers allant de -2147483648 à 2147483647 (nombres de 4 octets), 'int64' sont des nombres de -9223372036854775808 à 9223372036854775807 (nombres de 8 octets), il existe également différents types de 'int' pour 32- et les systèmes d'exploitation 64 bits, cela doit être pris en compte lors du calcul avec des tableaux.
