operators if que - ¿Python tiene un operador condicional ternario?




11 Answers

Puede indexar en una tupla:

(falseValue, trueValue)[test]

test debe devolver verdadero o falso .
Podría ser más seguro implementarlo siempre como:

(falseValue, trueValue)[test == True]

o puede usar el bool() incorporado bool() para asegurar un valor Boolean :

(falseValue, trueValue)[bool(<expression>)]
es programacion triple

Si Python no tiene un operador condicional ternario, ¿es posible simular uno usando otras construcciones de lenguaje?




expresión1 si condición más expresión2

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



Un operador para una expresión condicional en Python se agregó en 2006 como parte de la Propuesta 308 de mejora de Python . ¿Su forma difiere de la común ?: Operador y es:

<expression1> if <condition> else <expression2>

que es equivalente a:

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

Aquí hay un ejemplo:

result = x if a > b else y

Otra sintaxis que se puede usar (compatible con versiones anteriores a 2.5):

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

donde los operandos son perezosamente evaluados .

Otra forma es indexando una tupla (que no es consistente con el operador condicional de la mayoría de los otros idiomas):

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

o diccionario construido explícitamente:

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

Otro método (menos confiable), pero más simple es usar and / or operadores:

result = (a > b) and x or y

Sin embargo, esto no funcionará si x sería False .

Una posible solución es hacer listas x e y tuplas como en lo siguiente:

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

o:

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

Si está trabajando con diccionarios, en lugar de usar un condicional ternario, puede aprovechar get(key, default) , por ejemplo:

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

Fuente: ?:




Para Python 2.5 y posteriores hay una sintaxis específica:

[on_true] if [cond] else [on_false]

En Pythons más antiguos no se implementa un operador ternario, pero es posible simularlo.

cond and on_true or on_false

Sin embargo, hay un problema potencial, que si cond evalúa como True y on_true evalúa como False , se devuelve on_true lugar de on_true . Si desea este comportamiento, el método es correcto, de lo contrario use esto:

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

el cual puede ser envuelto por:

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

y utilizado de esta manera:

q(cond, on_true, on_false)

Es compatible con todas las versiones de Python.




A menudo puede encontrar

cond and on_true or on_false

pero esto lleva al problema cuando on_true == 0

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

donde se esperaría para un operador ternario normal este resultado

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



¿Python tiene un operador condicional ternario?

Sí. Desde el archivo de gramática :

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

La parte de interés es:

or_test ['if' or_test 'else' test]

Así, una operación condicional ternaria es de la forma:

expression1 if expression2 else expression3

expression3 se evaluará perezosamente (es decir, se evaluará solo si expression2 es falsa en un contexto booleano). Y debido a la definición recursiva, puede encadenarlos indefinidamente (aunque puede considerarse un estilo malo).

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

Una nota sobre el uso:

Tenga en cuenta que cada if debe ser seguido con un else . La comprensión de las listas de aprendizaje de las personas y las expresiones generadoras pueden encontrar que esta es una lección difícil de aprender; lo siguiente no funcionará, ya que Python espera una tercera expresión para otra cosa:

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

que plantea un SyntaxError: invalid syntax . Por lo tanto, lo anterior es una pieza de lógica incompleta (tal vez el usuario espera una no-op en la condición falsa) o lo que se pretende es usar expresión2 como filtro. Observa que lo siguiente es legal de Python:

[expression1 for element in iterable if expression2]

expression2 funciona como un filtro para la comprensión de la lista y no es un operador condicional ternario.

Sintaxis alternativa para un caso más estrecho:

Puede resultarle un poco doloroso escribir lo siguiente:

expression1 if expression1 else expression2

expression1 tendrá que evaluarse dos veces con el uso anterior. Puede limitar la redundancia si es simplemente una variable local. Sin embargo, un lenguaje Pythonic común y eficaz para este caso de uso es usar or el método abreviado:

expression1 or expression2

Lo cual es equivalente en semántica. Tenga en cuenta que algunas guías de estilo pueden limitar este uso por razones de claridad, ya que contienen mucho significado en muy poca sintaxis.




Puedes hacerlo :-

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

Ejemplo:-

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

Esto imprimiría "impar" si el número es impar o "par" si el número es par.

El resultado: - Si la condición es verdadera, exp_1 se ejecuta, de lo contrario se ejecuta exp_2.

Nota: - 0, Ninguno, Falso, lista vacía, emptyString se evalúa como Falso. Y cualquier dato distinto de 0 se evalúa como Verdadero.

Así es como funciona:

si la condición [condición] se convierte en "Verdadero", entonces se evaluará expresión_1 pero no expresión_2. Si "y" algo con 0 (cero), el resultado siempre será fasle. Por lo tanto, en la siguiente declaración,

0 and exp

La expresión exp no se evaluará en absoluto, ya que "y" con 0 siempre se evaluará a cero y no hay necesidad de evaluar la expresión. Así es como funciona el compilador, en todos los idiomas.

En

1 or exp

la expresión exp no se evaluará en absoluto, ya que "o" con 1 siempre será 1. Por lo tanto, no se molestará en evaluar la expresión exp, ya que el resultado será 1 de todos modos. (métodos de optimización del compilador).

Pero en caso de

True and exp1 or exp2

La segunda expresión exp2 no se evaluará ya que True and exp1 serían True si exp1 no es false.

Del mismo modo en

False and exp1 or exp2

La expresión exp1 no se evaluará ya que False es equivalente a escribir 0 y hacer "y" con 0 sería 0 en sí mismo, pero luego de exp1, ya que "o" se usa, evaluará la expresión exp2 después de "o".

Nota: - Este tipo de ramificación con "o" y "y" solo se puede usar cuando la expresión_1 no tiene un valor de Verdad de Falso (o 0 o Ninguno o lista vacía [] o cadena vacía ''.), Ya que si expresión_1 se convierte en Falso, la expresión_2 se evaluará debido a la presencia "o" entre exp_1 y exp_2.

En caso de que aún desee que funcione para todos los casos, independientemente de los valores de verdad de exp_1 y exp_2, haga lo siguiente:

[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






SÍ, Python tiene un operador ternario, aquí está la sintaxis y un código de ejemplo para demostrar lo mismo :)

#[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 la variable está definida y desea verificar si tiene valor, puede simplemente 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)

dará salida

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



Related