L'interconversion entre les types de données est facilitée assez facilement par les bibliothèques Python. Mais le problème de la conversion de la liste complète des chaînes en entiers est assez courant dans le domaine du développement. Discutons de quelques façons de résoudre ce problème particulier.
Conversion de toutes les chaînes de la liste en entiers à l'aide de eval()
Fonction Python eval() analysez l'argument de l'expression et évaluez-le en tant qu'expression python et exécutez l'expression Python (code). Si l'expression est une représentation int, Python convertit l'argument en entier.
Python3
lis> => [> '1'> ,> '-4'> ,> '3'> ,> '-6'> ,> '7'> ]> res> => [> eval> (i)> for> i> in> lis]> print> (> 'Modified list is: '> , res)> |
>
>
qu'est-ce que le hashmap Java
Sortir:
Modified list is: [1, -4, 3, -6, 7]>
Conversion de toutes les chaînes de la liste en entiers Méthode naïve
Il s’agit de la méthode la plus générique qui frappe tout programmeur lors de l’exécution de ce type d’opération. Il suffit de parcourir toute la liste et de convertir chaque chaîne de la liste en int par conversion de type.
Python3
test_list> => [> '1'> ,> '4'> ,> '3'> ,> '6'> ,> '7'> ]> # using loop> for> i> in> range> (> 0> ,> len> (test_list)):> > test_list[i]> => int> (test_list[i])> # Printing modified list> print> (> 'Modified list is : '> +> str> (test_list))> |
>
>
Sortir:
Modified list is: [1, 4, 3, 6, 7]>
Conversion de toutes les chaînes de la liste en entiers compréhension de liste
Il s'agit simplement d'une sorte de réplique de la méthode ci-dessus, simplement implémentée en utilisant la compréhension de liste, une sorte de raccourci qu'un développeur recherche toujours. Cela permet d'économiser du temps et de la complexité liés au codage d'une solution.
Python3
test_list> => [> '1'> ,> '4'> ,> '3'> ,> '6'> ,> '7'> ]> # using list comprehension to> # perform conversion> test_list> => [> int> (i)> for> i> in> test_list]> > # Printing modified list> print> (> 'Modified list is : '> +> str> (test_list))> |
>
>
Sortir:
Modified list is : [1, 4, 3, 6, 7]>
Conversion de toutes les chaînes de la liste en entiers carte()
Il s’agit de la méthode la plus élégante, pythonique et recommandée pour effectuer cette tâche particulière. Cette fonction est exclusivement conçue pour ce genre de tâches et doit être utilisée pour les réaliser.
Python3
test_list> => [> '1'> ,> '4'> ,> '3'> ,> '6'> ,> '7'> ]> # using map() to> # perform conversion> test_list> => list> (> map> (> int> , test_list))> # Printing modified list> print> (> 'Modified list is : '> +> str> (test_list))> |
>
>
Sortir:
Modified list is : [1, 4, 3, 6, 7]>
Conversion de toutes les chaînes de la liste en entiers Liste de chaînes avec des représentations entières mixtes
Ici, nous allons d'abord convertir chaque chaîne en float, puis nous la convertirons en entier en utilisant la fonction round(), sinon cela générera une erreur.
Python3
lis> => [> '1.1'> ,> '4'> ,> '3.5'> ,> '6.7'> ,> '7.2'> ]> res> => [> round> (> float> (i))> for> i> in> lis]> print> (> 'Modified list is: '> , res)> |
>
>
Sortir:
Modified list is: [1, 4, 4, 7, 7]>
Conversion de toutes les chaînes de la liste en entiers Utilisation de la fonction ast.literal_eval() du module ast
Une autre approche qui peut être utilisée pour convertir une liste de chaînes en une liste d'entiers consiste à utiliser la fonction ast.literal_eval() du module ast. Cette fonction vous permet d'évaluer une chaîne en tant que littéral Python, ce qui signifie qu'elle peut analyser et évaluer des chaînes contenant des expressions Python, telles que des nombres, des listes, des dictionnaires, etc.
Voici un exemple d'utilisation de ast.literal_eval() pour convertir une liste de chaînes en liste d'entiers :
Python3
import> ast> # Initialize list of strings> test_list> => [> '1'> ,> '4'> ,> '3'> ,> '6'> ,> '7'> ]> # Convert strings to integers using ast.literal_eval()> test_list> => [ast.literal_eval(s)> for> s> in> test_list]> # Print resulting list> print> (> 'Modified list:'> , test_list)> #This code is contributed by Edula Vinay Kumar Reddy> |
>
>Sortir
Modified list: [1, 4, 3, 6, 7]>
La complexité temporelle de l'utilisation de la fonction ast.literal_eval() du module ast pour convertir une liste de chaînes en liste d'entiers est O(n), où n est la longueur de la liste. Cela signifie que le temps requis pour exécuter cette approche est directement proportionnel à la taille de la liste d'entrée.
En termes de complexité spatiale, cette approche a une complexité spatiale de O(n), car elle crée une nouvelle liste d'entiers de la même taille que la liste d'entrée.
Conversion de toutes les chaînes de la liste en entiers à l'aide de la fonction numpy.array()
- Définir une liste de chaînes
- Convertissez la liste en un tableau numpy de type int à l'aide de la fonction numpy.array()
- Reconvertissez le tableau numpy en liste en utilisant fonction liste()
- Imprimer la liste modifiée
Python3
import> numpy as np> > # Define list of strings> my_list> => [> '1'> ,> '4'> ,> '3'> ,> '6'> ,> '7'> ]> > # Convert list to numpy array of type int> my_array> => np.array(my_list, dtype> => int> )> > # Convert numpy array back to list> modified_list> => list> (my_array)> > # Print modified list> print> (> 'Modified list is: '> , modified_list)> |
>
>
Sortir:
Modified list is: [1, 4, 3, 6, 7]>
Complexité temporelle : la complexité temporelle de cette approche est O(n), où n est la longueur de la liste. La fonction numpy.array() prend un temps O(n) pour créer un nouveau tableau, et la fonction list() prend un temps O(n) pour reconvertir le tableau en liste.
Complexité spatiale : la complexité spatiale de cette approche est O(n), car elle crée un nouveau tableau numpy de type int de la même taille que la liste d'entrée.
Approche : Utilisation de la fonction json.loads() :
Algorithme:
- Créez une liste de chaînes test_list avec les valeurs ['1', '4', '3', '6', '7']
- Utilisez la méthode join() pour joindre les chaînes de test_list avec des virgules, ce qui donne la chaîne « 1,4,3,6,7 ».
- Ajoutez des crochets autour de la chaîne résultante, ce qui donne la chaîne « [1,4,3,6,7] »
Utilisez la méthodeloads() de la bibliothèque json pour analyser la chaîne sous forme de tableau JSON, ce qui donne la liste [1, 4, 3, 6, 7] - Attribuez la liste résultante à new_list
- Imprimer la chaîne Modified list est : suivi de la représentation sous forme de chaîne de new_list
Python3
import> json> test_list> => [> '1'> ,> '4'> ,> '3'> ,> '6'> ,> '7'> ]> new_list> => json.loads(> '['> +> ','> .join(test_list)> +> ']'> )> print> (> 'Modified list is : '> +> str> (new_list))> #This code is contributed by Vinay pinjala> |
>
>Sortir
Modified list is : [1, 4, 3, 6, 7]>
La complexité temporelle : O(n), où n est la longueur de test_list. En effet, la méthode join() prend un temps O(n) pour concaténer les chaînes, et la méthode loads() prend un temps O(n) pour analyser la chaîne résultante.
La complexité spatiale : O(n), puisque la liste résultante occupe O(n) d’espace en mémoire.
Conversion de toutes les chaînes de la liste en entiers à l'aide du module re
algorithme étape par étape pour l'approche des expressions régulières pour extraire des valeurs numériques d'une liste de chaînes
que fait Ravel en python
- Définissez une liste d’entrée de chaînes.
- Définissez un modèle d'expression régulière pour faire correspondre les valeurs numériques dans les chaînes.
- Initialisez une liste vide pour stocker les valeurs numériques converties.
- Parcourez chaque chaîne de la liste d’entrée.
- Utilisez le modèle d'expression régulière pour rechercher une valeur numérique dans la chaîne.
- Si une correspondance est trouvée, extrayez la sous-chaîne correspondante et convertissez-la en float.
- Ajoutez la valeur convertie à la liste de sortie.
- Une fois que toutes les chaînes de la liste d'entrée ont été traitées, renvoyez la liste de sortie.
Python3
import> re> # Define the input list> lis> => [> '1'> ,> '-4'> ,> '3'> ,> '-6'> ,> '7'> ]> # Define a regular expression pattern to match numerical values> pattern> => re.> compile> (r> '-?d+(?:.d+)?'> )> # Initialize an empty list to store converted values> res> => []> # Iterate over each string in the input list> for> s> in> lis:> > # Use the pattern to search for a numerical value in the string> > match> => pattern.search(s)> > # If a match is found, extract the matched substring and convert it to a float> > if> match> is> not> None> :> > res.append(> int> (match.group()))> # Print the modified list of converted values> print> (> 'Modified list is: '> , res)> |
>
>Sortir
Modified list is: [1, -4, 3, -6, 7]>
Complexité temporelle : La complexité temporelle de cette approche est O(nm), où n est le nombre de chaînes dans la liste d'entrée et m est la longueur maximale de n'importe quelle chaîne de la liste. Le modèle d'expression régulière doit être appliqué à chaque chaîne de la liste, ce qui prend un temps O(m) dans le pire des cas. Par conséquent, la complexité temporelle globale est O(nm).
Complexité de l'espace auxiliaire : La complexité spatiale auxiliaire de cette approche est O(k), où k est le nombre de valeurs numériques dans la liste d'entrée. Nous devons stocker chaque valeur numérique convertie dans la liste de sortie, ce qui nécessite un espace O(k). De plus, nous devons stocker un objet d’expression régulière, qui nécessite un espace constant. Par conséquent, la complexité globale de l’espace auxiliaire est O(k).