operators ternary operator - Python a-t-il un opérateur conditionnel ternaire?





11 Answers

Vous pouvez indexer dans un tuple:

(falseValue, trueValue)[test]

test doit renvoyer Vrai ou Faux .
Il pourrait être plus sûr de toujours le mettre en œuvre de la manière suivante:

(falseValue, trueValue)[test == True]

ou vous pouvez utiliser bool() intégré pour assurer une valeur Boolean :

(falseValue, trueValue)[bool(<expression>)]
without else conditional

Si Python n’a pas d’opérateur conditionnel ternaire, est-il possible de le simuler avec d’autres constructions de langage?




expression1 si condition sinon expression2

>>> a = 1
>>> b = 2
>>> 1 if a > b else -1 
-1
>>> 1 if a > b else -1 if a < b else 0
-1



Un opérateur pour une expression conditionnelle en Python a été ajouté en 2006 dans le cadre de la proposition d'amélioration 308 de Python . Sa forme est différente de common ?: Operator et sa:

<expression1> if <condition> else <expression2>

ce qui équivaut à:

if <condition>: <expression1> else: <expression2>

Voici un exemple:

result = x if a > b else y

Une autre syntaxe utilisable (compatible avec les versions antérieures à 2.5):

result = (lambda:y, lambda:x)[a > b]()

où les opérandes sont évalués paresseusement .

Une autre méthode consiste à indexer un tuple (ce qui n'est pas cohérent avec l'opérateur conditionnel de la plupart des autres langues):

result = (y, x)[a > b]

ou dictionnaire explicitement construit:

result = {True: x, False: y}[a > b]

Une autre méthode (moins fiable), mais plus simple, consiste à utiliser and / or opérateurs:

result = (a > b) and x or y

Cependant, cela ne fonctionnera pas si x serait False .

Une solution possible consiste à créer des listes ou des nuplets x et y comme suit:

result = ((a > b) and [x] or [y])[0]

ou:

result = ((a > b) and (x,) or (y,))[0]

Si vous travaillez avec des dictionnaires, au lieu d'utiliser un conditionnel ternaire, vous pouvez tirer parti de get(key, default) , par exemple:

shell = os.environ.get('SHELL', "/bin/sh")

Source: ?:




Pour Python 2.5 et les versions plus récentes, il existe une syntaxe spécifique:

[on_true] if [cond] else [on_false]

Dans les Pythons plus anciens, aucun opérateur ternaire n’est implémenté, mais il est possible de le simuler.

cond and on_true or on_false

Cependant, il existe un problème potentiel qui, si cond évalué à True et on_true à False on_false est renvoyé à la place de on_true . Si vous voulez que ce comportement la méthode soit OK, sinon utilisez ceci:

{True: on_true, False: on_false}[cond is True] # is True, not == True

qui peut être emballé par:

def q(cond, on_true, on_false)
    return {True: on_true, False: on_false}[cond is True]

et utilisé de cette façon:

q(cond, on_true, on_false)

Il est compatible avec toutes les versions de Python.




Vous pourriez souvent trouver

cond and on_true or on_false

mais cela pose problème quand on_true == 0

>>> x = 0
>>> print x == 0 and 0 or 1 
1
>>> x = 1
>>> print x == 0 and 0 or 1 
1

où vous vous attendriez pour un opérateur ternaire normal, ce résultat

>>> x = 0
>>> print 0 if x == 0 else 1 
0
>>> x = 1
>>> print 0 if x == 0 else 1 
1



Python a-t-il un opérateur conditionnel ternaire?

Oui. Du fichier de grammaire :

test: or_test ['if' or_test 'else' test] | lambdef

La partie d'intérêt est:

or_test ['if' or_test 'else' test]

Ainsi, une opération conditionnelle ternaire est de la forme:

expression1 if expression2 else expression3

expression3 sera évalué paresseusement (c'est-à-dire uniquement si expression2 est false dans un contexte booléen). Et à cause de la définition récursive, vous pouvez les chaîner indéfiniment (bien que cela puisse être considéré comme un mauvais style.)

expression1 if expression2 else expression3 if expression4 else expression5 # and so on

Une note sur l'utilisation:

Notez que chaque if doit être suivi avec un else . Les personnes apprenant la compréhension des listes et les expressions génératrices peuvent trouver cette leçon difficile à apprendre. Ce qui suit ne fonctionnera pas, car Python attend une troisième expression pour une autre:

[expression1 if expression2 for element in iterable]
#                          ^-- need an else here

qui soulève une SyntaxError: invalid syntax . Ce qui précède est donc un élément de logique incomplet (peut-être l'utilisateur s'attend-il à une non-opération dans la condition fausse) ou bien peut-être est-il prévu d'utiliser expression2 en tant que filtre - remarque que ce qui suit est légal Python:

[expression1 for element in iterable if expression2]

expression2 fonctionne comme un filtre pour la compréhension de la liste et n'est pas un opérateur conditionnel ternaire.

Syntaxe alternative pour un cas plus étroit:

Vous trouverez peut-être un peu pénible d’écrire ce qui suit:

expression1 if expression1 else expression2

expression1 devra être évalué deux fois avec l'utilisation ci-dessus. Cela peut limiter la redondance s'il s'agit simplement d'une variable locale. Cependant, un idiome Pythonic commun et performant pour ce cas d'utilisation consiste à utiliser le comportement de raccourci de ou:

expression1 or expression2

ce qui est équivalent en sémantique. Notez que certains guides de style peuvent limiter cette utilisation pour des raisons de clarté - cela contient beaucoup de sens dans très peu de syntaxe.




tu peux le faire :-

[condition] and [expression_1] or [expression_2] ;

Exemple:-

print(number%2 and "odd" or "even")

Cela afficherait "impair" si le nombre est impair ou "pair" si le nombre est pair.

Le résultat: - Si la condition est vraie, exp_1 est exécuté, sinon exp_2 est exécuté.

Remarque: - 0, None, False, emptylist, emptyString est évalué par False. Et toutes les données autres que 0 sont évaluées à True.

Voici comment ça fonctionne:

Si la condition [condition] devient "True", expression_1 sera évaluée, mais pas expression_2. Si nous "et" quelque chose avec 0 (zéro), le résultat sera toujours fasle .Alors dans la déclaration ci-dessous,

0 and exp

L'expression exp ne sera pas du tout évaluée car "et" avec 0 seront toujours évalués à zéro et il n'est pas nécessaire d'évaluer l'expression. Voici comment le compilateur lui-même fonctionne, dans toutes les langues.

Dans

1 or exp

l'expression exp ne sera pas du tout évaluée car "ou" avec 1 sera toujours 1. Donc, il ne sera pas inutile d'évaluer l'expression exp puisque le résultat sera de toute façon 1. (méthodes d'optimisation du compilateur).

Mais en cas de

True and exp1 or exp2

La deuxième expression exp2 ne sera pas évaluée car True and exp1 seraient True si exp1 n'était pas false.

De même dans

False and exp1 or exp2

L'expression exp1 ne sera pas évaluée car False équivaut à écrire 0 et faire "et" avec 0 serait lui-même 0 mais après exp1 car "or" est utilisé, il évaluera l'expression exp2 après "ou".

Remarque: - Ce type de ramification utilisant "ou" et "et" ne peut être utilisé que si l'expression_1 n'a pas la valeur Vérité de False (ou 0 ou Aucun ou la liste vide [] ou la chaîne vide ''.), Car si expression_1 devient False, l'expression_2 sera évaluée en raison de la présence "ou" entre exp_1 et exp_2.

Si vous souhaitez toujours que cela fonctionne dans tous les cas, quelles que soient les valeurs de vérité exp_1 et exp_2, procédez comme suit: -

[condition] and ([expression_1] or 1) or [expression_2] ;




In [1]: a = 1 if False else 0

In [2]: a
Out[2]: 0

In [3]: b = 1 if True else 0

In [4]: b
Out[4]: 1



Oui, vous pouvez l'utiliser de cette façon:

is_fat = True
state = "fat" if is_fat else "not fat"

En savoir plus sur l' opérateur conditionnel ternaire




OUI, python a un opérateur ternaire, voici la syntaxe et un exemple de code pour démontrer la même chose :)

#[On true] if [expression] else[On false]
# if the expression evaluates to true then it will pass On true otherwise On false


a= input("Enter the First Number ")
b= input("Enter the Second Number ")

print("A is Bigger") if a>b else print("B is Bigger")



si variable est définie et que vous voulez vérifier si elle a une valeur, vous pouvez simplement a or b

def test(myvar=None):
    # shorter than: print myvar if myvar else "no Input"
    print myvar or "no Input"

test()
test([])
test(False)
test('hello')
test(['Hello'])
test(True)

va sortir

no Input
no Input
no Input
hello
['Hello']
True



Related