def only_evens(lst):
    """ (list of list of int) -> list of list of int

    Return a list of the lists in lst that contain only even integers. 

    >>> only_evens([[1, 2, 4], [4, 0, 6], [22, 4, 3], [2]])
    [[4, 0, 6], [2]]
    """

    even_lists = []

    for sublist in lst:
        for i in sublist:
            if i % 2 == 0:
                even_lists.append(i)
    return even_lists

Je ne peux pas faire cela car il retourne tout dans une seule liste [] Mais comment puis-je retourner une sous-liste composée uniquement d'entiers pairs?

0
Chang Dae Hyun 4 mars 2016 à 23:57

4 réponses

Meilleure réponse

Je la diviserais en deux fonctions: l'une qui vérifie si une liste ne contient que des nombres pairs, et l'autre est votre fonction principale (je l'ai renommée en get_even_lists()), qui obtient toutes les listes paires d'une liste de listes :

def only_even_elements(l):
    """ (list of int) -> bool

    Return a whether a list contains only even integers.

    >>> only_even_elements([1, 2, 4])  # 1 is not even
    False
    """
    for e in l:
        if e % 2 == 1:
            return False
    return True

def get_even_lists(lst):
    """ (list of list of int) -> list of list of int

    Return a list of the lists in lst that contain only even integers. 

    >>> only_evens([[1, 2, 4], [4, 0, 6], [22, 4, 3], [2]])
    [[4, 0, 6], [2]]
    """
    # return [l for l in lst if only_even_elements(l)]
    even_lists = []
    for sublist in lst:
        if only_even_elements(sublist):
            even_lists.append(sublist)
    return even_lists

Bien que cela puisse être fait avec for / else:

def get_even_lists(lst):
    """ (list of list of int) -> list of list of int

    Return a list of the lists in lst that contain only even integers. 

    >>> only_evens([[1, 2, 4], [4, 0, 6], [22, 4, 3], [2]])
    [[4, 0, 6], [2]]
    """
    even_lists = []
    for sublist in lst:
        for i in sublist:
            if i % 2 == 1:
                break
        else:
            even_lists.append(sublist)
    return even_lists

Ou, comme d'autres l'ont suggéré, une ligne:

def get_even_lists(lst):
    """ (list of list of int) -> list of list of int

    Return a list of the lists in lst that contain only even integers. 

    >>> only_evens([[1, 2, 4], [4, 0, 6], [22, 4, 3], [2]])
    [[4, 0, 6], [2]]
    """
    return [sublst for sublst in lst if all(i % 2 == 0 for i in sublst)]

Mais soyons honnêtes ici: même si on peut soutenir que l'utilisation de deux fonctions peut être un peu plus longue et pas aussi "cool" que les deux autres solutions, elle est réutilisable, facile à lire et à comprendre, et elle est maintenable. Je dirais que c'est beaucoup mieux que toute autre option.

5
Markus Meskanen 4 mars 2016 à 21:32

Je suppose que vous pouvez diviser votre problème en petites parties.

def contains_only_evens(lst):
    return sum([x%2 for x in lst]) == 0

def only_evens(lst):
    for sublist in lst:
        if not contains_only_evens(sublist):
            lst.remove(sublist)
    return lst

De cette façon, vous pouvez:

  • parcourir une liste et ses sous-listes
  • vérifier si la liste contient un entier impair
  • ne conserver que la sous-liste sans valeurs de cotes
-1
mabe02 4 mars 2016 à 21:46

Vous pouvez également le faire en utilisant une programmation fonctionnelle:

def only_evens(lst):
    return filter(lambda ls: all(map(lambda n: not n & 1, ls)), lst)

MODIFIER

Conformément à la recommandation de J.F. Sebastian, je l'ai divisé en trois fonctions:

is_odd = lambda n: n & 1
all_even = lambda arr: not any(map(is_odd, arr))
only_evens = lambda arr: filter(all_even, arr)

is_odd on vérifie si un nombre est impair en utilisant des opérations au niveau du bit pour plus d'efficacité. all_even vérifie si une liste a tous les nombres pairs et renvoie un booléen. only_evens prend une liste de liste d'entiers et retourne une liste des listes qui ne contiennent que des entiers pairs.

1
pzp 6 mars 2016 à 19:30

Je ne penserais pas à ce que vous gardez, mais à ce que vous supprimez (toutes les listes contenant un nombre impair). Quelque chose comme

import copy

list_copy = copy.copy(lists)
def only_evens(list_copy):
    for l in list_copy:
        for i in l:
            if i % 2 != 0:
                list_copy.remove(l)
                break
    return(list_copy) 

(qui met l'accent sur la lisibilité sur la concision, bien sûr.)

0
Silenced Temporarily 4 mars 2016 à 21:42