Un coffre-fort (max) de la fonction pour vider les listes

De l'évaluation,

max_val = max(a)

sera la cause de l'erreur,

ValueError: max() arg is an empty sequence

Est-il un meilleur moyen de protection contre cette erreur autre que try, except attraper?

a = []
try:
    max_val = max(a)
except ValueError:
    max_val = default

Le default argument spécifie un objet de la déclaration si la condition itérable est vide.
Pourquoi vous ne post réponse comme réponse?!
parce que c'est trop simple.
Quel est le problème avec l'affichage des réponses qui sont "trop simple"? Maintenant, quelqu'un d'autre...
De toute façon si vous allez gérer l'erreur, vous devez utiliser except ValueError:, pas except:. Dans votre exemple, vous pourrez attraper TypeError: 'builtin_function_or_method' object is not subscriptable, alors peu importe quelle valeur a a, max_val sera à la fin False.
c'est vrai que je n'avais pas considéré que

InformationsquelleAutor Alexander McFarlane | 2016-03-22

44

En Python 3.4+, vous pouvez utiliser default argument mot-clé:
```
>>> max([], default=99)
99
```
Dans la version inférieure, vous pouvez utiliser or:
```
>>> max([] or [99])
99
```
REMARQUE: La deuxième approche ne fonctionne pas pour tous les iterables. surtout pour itérateur qui donnera rien, mais considéré comme valeur de vérité.
```
>>> max(iter([]) or 0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: max() arg is an empty sequence
```
- Une autre option pour pré-3.4 serait de créer un my_max fonction qui imite le plus récent comportement.
- max(iter([]) or 0) est précisément ce qui m'a donné le chagrin à la première place... avez-vous d'autres suggestions sur quoi faire avec elle? Deuxièmement, il n'est jamais venu à moi pour vérifier les docs... j'ai supposé que tel d'une fonction simple qui était l'un-en-un processus de
- Duncan a suggéré une belle alternative. Check it out.
- Je ne suis pas un locuteur natif. Je ne comprends pas ce one-in-one-out process. Signifie-t-il une tâche commune?
- par one-in-one-out, je veux dire un argument et une valeur de retour 🙂
InformationsquelleAutor falsetru
8

Dans les versions de Python âgés de plus de 3.4 vous pouvez utiliser itertools.chain() pour ajouter une autre valeur à la éventuellement séquence vide. Cela permettra de gérer tout vide itérable mais notez que ce n'est pas exactement la même que la fourniture de la default argument de la plus-value est toujours inclus:
```
>>> from itertools import chain
>>> max(chain([42], []))
42
```
Mais en Python 3.4, la valeur par défaut est ignoré si la séquence n'est pas vide:
```
>>> max([3], default=42)
3
```
- est-il une raison pour utiliser chain plus simple liste de concaténation par exemple max( [42], [] ) où la valeur par défaut est 42?
- l'appel de max avec plusieurs arguments ont un sens différent que de l'appeler avec un seul argument. Avec un seul objet iterable argument max sera de retour le plus grand élément qu'il contient, mais avec de multiples arguments, il les compare directement (c'est à dire ne pas effectuer une itération). par exemple, max([42], []) une liste [42] mais max(chain([42], [])) et max([], default=42) à la fois donner 42.
InformationsquelleAutor Duncan
1

Une autre solution pourrait être en utilisant des opérateurs ternaires:
```
nums = []
max_val = max(nums) if nums else 0
```
ou
```
max val = max(iter(nums) if nums else [0])
```
InformationsquelleAutor Kurohige
0

Le max d'une séquence vide "devraient" être un infiniment petit chose quel que soit le type des éléments de la séquence. Malheureusement, (1) avec une séquence vide vous ne pouvez pas dire quel est le type de ces éléments signifient, et (2) il n'y a, par exemple, aucune une telle chose comme la plus négative entier en Python.

Si vous avez besoin d'aide max si vous souhaitez faire quelque chose d'intelligent dans ce cas. Dans les dernières versions de Python il y a un default argument max (qui me semble un nom trompeur, mais jamais l'esprit) qui sera utilisé si vous passez dans une séquence vide. Dans les anciennes versions, vous avez simplement à s'assurer que la séquence que vous transmettez n'est pas vide (par exemple, par oring avec une séquence singleton contenant la valeur que vous souhaitez utiliser dans ce cas.

[ÉDITÉ longtemps après la publication parce que Yaakov Rot aimablement fait remarquer dans les commentaires que j'avais écrit "l'infiniment grand", où j'aurais écrit "l'infiniment petit".]
- C'est contre-intuitif: le max d'une liste vide doit être infiniment petite (max(x,liste...)=max(x,max(liste...))) et le min de la liste vide doit être infiniment grand.
- Oups, oui, j'ai écrit que la mauvaise voie; mes excuses. Je vais corriger ma réponse et de crédit que vous pour repérer l'erreur. [... Fait. Encore une fois merci.]
InformationsquelleAutor Gareth McCaughan

Compte tenu de tous les commentaires ci-dessus, il peut être un wrapper comme ceci:

def max_safe(*args, **kwargs):
    """
    Returns max element of an iterable.

    Adds a `default` keyword for any version of python that do not support it
    """
    if sys.version_info < (3, 4):  # `default` supported since 3.4
        if len(args) == 1:
            arg = args[0]
            if 'default' in kwargs:
                default = kwargs.pop('default')
                if not arg:
                    return default

                # https://stackoverflow.com/questions/36157995#comment59954203_36158079
                arg = list(arg)
                if not arg:
                    return default

                # if the `arg` was an iterator, it's exhausted already
                # so use a new list instead
                return max(arg, **kwargs)

    return max(*args, **kwargs)

InformationsquelleAutor tsionyx

Vous devez vous connecter pour publier un commentaire.