without - python ternary tuple




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

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.

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


Opérateur ternaire dans différents langages de programmation

Ici, je tente simplement de montrer une différence importante d’ ternary operator entre deux langages de programmation.

Opérateur ternaire en Javascript

var a = true ? 1 : 0;
# 1
var b = false ? 1 : 0;
# 0

Opérateur ternaire en rubis

a = true ? 1 : 0
# 1
b = false ? 1 : 0
# 0

Opérateur ternaire à Scala

val a = true ? 1 | 0
# 1
val b = false ? 1 | 0
# 0

Opérateur ternaire en programmation R

a <- if (TRUE) 1 else 0
# 1
b <- if (FALSE) 1 else 0
# 0

Opérateur ternaire en Python

a = 1 if True else 0
# 1
b = 1 if False else 0
# 0

Maintenant, vous pouvez voir la beauté du langage python. son très lisible et maintenable.


Absolument, et c'est incroyablement facile à comprendre.

general syntax : first_expression if bool_expression_is_true else second_expression

Example: x= 3 if 3 > 2 else 4 
# assigns 3 to x if the boolean expression evaluates to true or 4 if it is false

De la documentation :

Les expressions conditionnelles (parfois appelées «opérateur ternaire») ont la priorité la plus basse de toutes les opérations Python.

L'expression x if C else y évalue d'abord la condition, C ( pas x ); si C est vrai, x est évalué et sa valeur est renvoyée; sinon, y est évalué et sa valeur est renvoyée.

Voir PEP 308 pour plus de détails sur les expressions conditionnelles.

Nouveau depuis la version 2.5.


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")

Oui, il a été added à la version 2.5.
La syntaxe est la suivante:

a if condition else b

La première condition est évaluée, puis a ou b est renvoyé en fonction de la valeur Boolean de la condition
Si la condition évaluée à True, a est renvoyé, sinon b est renvoyé.

Par exemple:

>>> 'true' if True else 'false'
'true'
>>> 'true' if False else 'false'
'false'

Notez que les conditions sont une expression , pas une déclaration . Cela signifie que vous ne pouvez pas utiliser d'affectations, de pass ou d'autres instructions dans une condition:

>>> pass if False else x = 3
  File "<stdin>", line 1
    pass if False else x = 3
          ^
SyntaxError: invalid syntax

Dans ce cas, vous devez utiliser une instruction if normale if lieu d'une condition.

N'oubliez pas que certains pythonistes la désapprouvent pour plusieurs raisons:

  • L'ordre des arguments est différent de celui de nombreux autres langages (tels que C, Ruby, Java, etc.), ce qui peut entraîner des problèmes lorsque des personnes non familiarisées avec le comportement "surprenant" de Python l'utilisent (elles peuvent inverser cet ordre).
  • Certains le trouvent "lourd", car cela va à l’encontre du courant normal de la pensée (penser à la condition en premier lieu, puis aux effets).
  • Raisons stylistiques.

Si vous avez des difficultés à vous rappeler l'ordre, souvenez-vous que si vous le lisez à haute voix, vous dites (presque) ce que vous voulez dire. Par exemple, x = 4 if b > 8 else 9 est lu à voix haute car x will be 4 if b is greater than 8 otherwise 9 .

Documentation officielle:


Oui.

>>> b = (True if 5 > 4 else False)
>>> print b
True

Oui:

Supposons que vous vouliez donner à la variable x une valeur si un booléen est vrai et de même

X = 5 si autre chose x = 10

X = [une valeur] if [si ceci est vrai, la première valeur est évaluée] else [une autre valeur est évaluée]


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.


Pour les versions antérieures à 2.5, l'astuce est la suivante:

[expression] and [on_true] or [on_false]

Cela peut donner des résultats erronés quand on_true a une fausse valeur booléenne. 1
Bien qu'il ait l'avantage d'évaluer les expressions de gauche à droite, ce qui est plus clair à mon avis.

1. Y a-t-il un équivalent de C ”?:“ Opérateur ternaire?


Syntaxe: L'opérateur ternaire sera donné comme:

[on_true] if [expression] else [on_false]

par exemple

x, y = 25, 50
big = x if x < y else y
print(big)

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: ?:


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>)]

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

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

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




python-2.5