Python - Filtrer les éléments impairs de la liste de valeurs d'un dictionnaire

Un dictionnaire est un type de données populaire en Python qui possède une paire clé-valeur et n'autorise pas les doublons. Pour filtrer les éléments impairs, il dispose de fonctions intégrées telles que items(), filter(), lambda et list() qui seront utilisées pour filtrer les éléments impairs de la liste de valeurs du dictionnaire. Les éléments impairs de la liste sont ceux qui ne sont pas divisibles par 2.

Par exemple -

Étant donné la liste, [10, 22, 21, 19, 2, 5]

Après avoir filtré les éléments impairs de la liste :

Le résultat final devient [10, 22, 2] (ce sont des éléments divisibles par l'entier 2).

Grammaire

La syntaxe suivante est utilisée dans l'exemple -

items()

Il s'agit d'une méthode intégrée qui peut être utilisée pour renvoyer un objet de vue. L'objet est constitué de clés avec des paires de valeurs.

filter()

L'élément filter() de Python est utilisé pour filtrer des éléments en fonction de conditions spécifiques.

lambda

La fonction lambda fournit un raccourci pour déclarer de courtes fonctions anonymes à l'aide du mot-clé lambda. Les fonctions Lambda fonctionnent lorsqu'elles sont déclarées à l'aide du mot-clé def.

list()

list() est un Python intégré qui crée des objets de liste, il accepte une construction itérable et la convertit en liste.

x % 2 != 0
or
x % 2 == 1

Les deux représentations ci-dessus illustrent la logique du filtrage des éléments impairs à partir d'une liste de valeurs.

Utilisez les compréhensions de dictionnaire et les compréhensions de listes avec des instructions if-else

Ce programme utilise la compréhension du dictionnaire pour convertir le dictionnaire original en un nouveau dictionnaire en filtrant les éléments impairs. Cet élément étrange peut être filtré en utilisant la compression de liste avec des instructions if-else.

Exemple

Dans l'exemple suivant, le programme est démarré à l'aide d'une fonction nommée odd_element, qui accepte un paramètre nommé dictionnaire. Les mêmes paramètres sont utilisés avec les techniques de compréhension, à savoir list et dictionary et if-statement pour définir le dictionnaire de filtrage pour les éléments impairs dans la liste de valeurs. Créez ensuite la liste de valeurs du dictionnaire et stockez-les dans un nom de variable appelé dictionnaire. Ensuite, appelez la fonction en utilisant et transmettez les noms des paramètres sous forme de dictionnaire contenant des paires clé-valeur et stockez-la dans la variable filter_dict. Enfin, nous imprimons le résultat à l'aide de la variable filter_dict.

def odd_elements(dictionary):
   return {key: [x for x in value if x % 2 != 0] for key, value in dictionary.items()}

# Create the dictionary
dictionary = {'A': [2, 4, 16, 19, 17], 'B': [61, 71, 90, 80, 10], 'C': [11, 121, 13, 14, 15]}
filter_dict = odd_elements(dictionary)
print("Filter odd elements from the value lists in dictionary:\n", filter_dict)

Sortie

Filter odd elements from the value lists in dictionary:
{'A': [19, 17], 'B': [61, 71], 'C': [11, 121, 13, 15]}

Utiliser les boucles for et Filter() avec les fonctions Lambda

Ce programme utilise une boucle for qui parcourra les clés et les valeurs des éléments du dictionnaire à l'aide de la méthode intégrée items(). Il supprimera ensuite les éléments impairs de la liste du dictionnaire à l'aide de fonctions intégrées imbriquées telles que list(), filter() et lambda.

Exemple

Dans l'exemple ci-dessous, nous utiliserons une boucle for pour parcourir un dictionnaire de variables contenant des clés avec une liste de valeurs. Pour filtrer les éléments impairs, il utilisera trois fonctions intégrées imbriquées, à savoir list(), filter() et lambda() [Cette fonction définit la condition comme x%2 != 0 et vérifiera si la liste de valeurs donnée est si l'entier est divisible par 2] et le stocke dans la variable filtered_dictionary. Après avoir filtré les éléments impairs, définissez la valeur de filtered_dictionary dans filtered_dictionary. Créez ensuite un dictionnaire composé d'une liste de clés et de valeurs et stockez-le dans un dictionnaire de variables. Maintenant, cette variable est définie dans l'argument de la fonction appelante odd_element() et stockée dans la variable filter_dict().

def odd_elements(dictionary):
   filtered_dictionary = {}
# for loop
   for key, value in dictionary.items():
# Using filter() with lambda
      filtered_values = list(filter(lambda x: x % 2 != 0, value))
      filtered_dictionary[key] = filtered_values
   return filtered_dictionary
# create the dictionary
dictionary = {'A': [1, 2, 3, 4, 5], 'B': [6, 7, 8, 9, 10], 'C': [11, 12, 13, 14, 15], 'D': [16, 17, 18, 19, 20]}
filter_dict = odd_elements(dictionary)
print("Filter odd elements from the value lists in dictionary:\n", filter_dict)

Sortie

Filter odd elements from the value lists in dictionary:
 {'A': [1, 3, 5], 'B': [7, 9], 'C': [11, 13, 15], 'D': [17, 19]}

Utiliser pour les boucles et les compréhensions de listes

Le programme utilise une boucle for en utilisant la méthode intégrée items() pour parcourir le dictionnaire et les clés, puis il utilisera une boucle for et une instruction if sur une seule ligne qui représente une compréhension de liste.

Exemple

Dans l'exemple ci-dessous, nous démarrons le programme en définissant une fonction appelée filter_odd_elements(), qui accepte un paramètre appelé dictionnaire pour accéder à ses valeurs. Ensuite, créez un dictionnaire vide dans la variable filter_dictionary et stockez plus tard le nouveau dictionnaire comme résultat. Il utilisera ensuite une boucle for pour parcourir chaque liste de valeurs du dictionnaire. Continuez la compréhension de la liste en utilisant les instructions for et if et stockez-la dans la variable filter_values. Échangez les mêmes variables dans filter_dictionary[key]. Renvoyez ensuite le filter_dictionary dont le résultat filtré ne contient pas d'éléments impairs. Créez un dictionnaire contenant une liste de valeurs et stockez-le dans la variable dict. Une nouvelle variable nommée f_dictionary stocke la fonction récursive passée un argument nommé dict. Enfin, utilisez la fonction print qui accepte la variable f_dictionary pour obtenir le résultat.

def filter_odd_elements(dictionary):
   filter_dictionary = {}
   for key, value in dictionary.items():
# List Comprehension
      filter_values = [x for x in value if x % 2 != 0]
      filter_dictionary[key] = filter_values
   return filter_dictionary
# Creation of dictionary
dict = {'A': [307, 907], 'B': [100, 200], 'C': [110, 120]}
# use the calling function
f_dictionary = filter_odd_elements(dict)
print("Filtration of odd elements from dictionary value list:\n", f_dictionary)

Sortie

Filtration of odd elements from dictionary value list:
 {'A': [307, 907], 'B': [], 'C': []}

Utilisez les compréhensions de dictionnaire et Filter() avec les fonctions Lambda

Ce programme utilise la compréhension du dictionnaire pour aider à convertir un dictionnaire en une nouvelle forme de dictionnaire. La méthode filter() utilise la fonction lambda pour éliminer les éléments impairs de la liste de valeurs du dictionnaire.

Exemple

Dans l'exemple ci-dessous, nous montrerons comment la compréhension du dictionnaire utilise trois méthodes pour configurer une logique basée sur le filtrage des éléments impairs dans une liste de valeurs et utilise une boucle for pour parcourir chaque clé et valeur du dictionnaire.

def odd_elements(dictionary):
   return {key: list(filter(lambda x: x % 2 == 1, value)) for key, value in dictionary.items()}

# Create the dictionary
dict_1 = {'I': [1, 2, 3, 4, 5], 'II': [6, 7, 8, 9, 10], 'III': [11, 12, 13, 14, 15]}
filter_dict = odd_elements(dict_1)
print("ODD NUMBER FILTRATION IN DICTIONARY VALUES:\n", filter_dict)

Sortie

ODD NUMBER FILTRATION IN DICTIONARY VALUES:
 {'I': [1, 3, 5], 'II': [7, 9], 'III': [11, 13, 15]}

Utilisez la compréhension du dictionnaire et la compréhension de la liste

Le programme utilise des fonctions récursives, renvoyant des techniques de compréhension en utilisant des instructions de retour.

Exemple

Dans l'exemple suivant, nous utiliserons une fonction récursive dans le programme pour filtrer les éléments impairs des valeurs du dictionnaire et renvoyer un nouveau dictionnaire avec les mêmes clés et valeurs filtrées.

def odd_elements(dictionary):
   return {key: [x for x in value if x % 2 == 1] for key, value in dictionary.items()}
# create the dictionary and store the value by odd and even in the list
dictionary = {'list1': [100, 200, 300, 499, 599], 'list2': [699, 799, 899, 900, 1000]}
filter_dict = odd_elements(dictionary)
print("ODD NUMBER FILTRATION IN DICTIONARY VALUES:\n", filter_dict)

输出

ODD NUMBER FILTRATION IN DICTIONARY VALUES:
 {'list1': [499, 599], 'list2': [699, 799, 899]}

结论

我们讨论了基于从字典中的值列表中过滤奇数元素来解决此问题陈述的各种方法。上述所有示例大多使用综合技术，通过使用某种方法、循环或条件语句在 1-2 行内解决问题。当我们想要通过分配特定条件来过滤数据时，通常会使用程序目的。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!