Sí, lo era adicional en la versión 2.5. La sintaxis de la expresión es:

a if condition else b

Primero condition se evalúa, entonces exactamente uno de a or b se evalúa y devuelve en función de la Boolean valor de condition. Si condition evalúa a True, entonces a se evalúa y devuelve pero b se ignora, o de lo contrario cuando b se evalúa y devuelve pero a se ignora.

Esto permite un cortocircuito porque cuando condition es verdad solo a es evaluado y b no se evalúa en absoluto, pero cuando condition es solo falso b es evaluado y a no se evalúa en absoluto.

Por ejemplo:

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

Tenga en cuenta que los condicionales son una expresiónno es un ambiental. Esto significa que no puede usar declaraciones de asignación o pass u otros declaraciones dentro de un condicional expresión:

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

Sin embargo, puede usar expresiones condicionales para asignar una variable como esta:

x = a if True else b

Piense en la expresión condicional como un cambio entre dos valores. Es muy útil cuando estás en una situación de 'un valor u otro', pero no hace mucho más.

Si necesita usar declaraciones, debe usar un if ambiental en lugar de un condicional expresión.

Tenga en cuenta que algunos Pythonistas lo desaprueban por varias razones:

• El orden de los argumentos es diferente al del clásico condition ? a : b operador ternario de muchos otros lenguajes (como C, C ++, Go, Perl, Ruby, Java, Javascript, etc.), que pueden provocar errores cuando las personas que no están familiarizadas con el comportamiento "sorprendente" de Python lo utilizan (pueden invertir el orden de los argumentos ).
• Algunos lo encuentran "difícil de manejar", ya que va en contra del flujo normal de pensamiento (pensar primero en la condición y luego en los efectos).
• Razones estilísticas. (Aunque el 'inline if' puede ser realmente útil y hace que su script sea más conciso, realmente complica su código)

Si tiene problemas para recordar el orden, recuerde que cuando lo lee en voz alta, (casi) dice lo que quiere decir. Por ejemplo, x = 4 if b > 8 else 9 se lee en voz alta como x will be 4 if b is greater than 8 otherwise 9.

Documentación oficial:

• Expresiones condicionales
• ¿Existe un equivalente de C's ”?:” Operador ternario?

Puede indexar en una tupla:

(falseValue, trueValue)[test]

test necesita regresar Verdadero or Falso.
Podría ser más seguro implementarlo siempre como:

(falseValue, trueValue)[test == True]

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

(falseValue, trueValue)[bool(<expression>)]

Para las versiones anteriores a la 2.5, existe el truco:

[expression] and [on_true] or [on_false]

Puede dar resultados incorrectos cuando on_true tiene un valor booleano falso.¹
Aunque tiene el beneficio de evaluar expresiones de izquierda a derecha, lo cual es más claro en mi opinión.

_{1. ¿Existe un equivalente de C's ”?:” Operador ternario?}

<expression 1> if <condition> else <expression 2>

a = 1
b = 2

1 if a > b else -1 
# Output is -1

1 if a > b else -1 if a < b else 0
# Output is -1

Desde la documentación:

Las expresiones condicionales (a veces llamadas "operador ternario") tienen la prioridad más baja de todas las operaciones de Python.

La expresion x if C else y primero evalúa la condición, C (no x); Si C es verdad, x se evalúa y se devuelve su valor; de lo contrario, y se evalúa y se devuelve su valor.

Ver PEP 308 para obtener más detalles sobre las expresiones condicionales.

Nuevo desde la versión 2.5.

En 2006 se agregó un operador para una expresión condicional en Python como parte de Propuesta de mejora de Python 308. 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 utilizar (compatible con versiones anteriores a la 2.5):

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

donde están los operandos evaluado perezosamente.

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

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 y 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 x y y listas o tuplas como en el siguiente:

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

o bien:

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

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

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

^{Fuente: ?: en Python en Wikipedia}

Desafortunadamente, el

(falseValue, trueValue)[test]

la solución no tiene comportamiento de cortocircuito; así ambos falseValue y trueValue se evalúan independientemente de la condición. Esto podría ser subóptimo o incluso con errores (es decir, ambos trueValue y falseValue podrían ser métodos y tener efectos secundarios).

Una solución a esto sería

(lambda: falseValue, lambda: trueValue)[test]()

(ejecución retrasada hasta que se conoce el ganador;)), pero introduce inconsistencias entre los objetos invocables y no invocables. Además, no resuelve el caso al usar propiedades.

Y así sigue la historia: elegir entre las 3 soluciones mencionadas es una compensación entre tener la función de cortocircuito, usar al menos Зython 2.5 (en mi humilde opinión ya no es un problema) y no ser propenso a "trueValue-evalúa-a-falso "errores.

Operador ternario en diferentes lenguajes de programación

Aquí solo trato de mostrar alguna diferencia importante en ternary operator entre un par de lenguajes de programación.

Operador ternario en Javascript

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

Operador ternario en Ruby

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

Operador ternario en Scala

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

Operador ternario en programación R

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

Operador ternario en Python

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

Para Python 2.5 y versiones 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, existe un problema potencial, que si cond evalúa a True y on_true evalúa a False luego on_false se devuelve en lugar de on_true. Si desea este comportamiento, el método está bien, de lo contrario use esto:

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

que puede ser envuelto por:

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

y se usa de esta manera:

q(cond, on_true, on_false)

Es compatible con todas las versiones de Python.

A menudo puedes encontrar

cond and on_true or on_false

pero esto conduce a un 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 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?

Si. 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]

Entonces, una operación condicional ternaria tiene la forma:

expression1 if expression2 else expression3

expression3 será evaluado con pereza (es decir, evaluado solo si expression2 es falso en un contexto booleano). Y debido a la definición recursiva, puede encadenarlos indefinidamente (aunque puede considerarse de mal estilo).

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. Las personas que aprenden listas de comprensión y 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:

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

que plantea un SyntaxError: invalid syntax. Entonces, lo anterior es una pieza de lógica incompleta (quizás el usuario espera una operación no operativa en la condición falsa) o lo que se puede pretender es usar expression2 como filtro; tenga en cuenta que lo siguiente es Python legal:

[expression1 for element in iterable if expression2]

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

Sintaxis alternativa para un caso más estrecho:

Puede resultarle algo doloroso escribir lo siguiente:

expression1 if expression1 else expression2

expression1 tendrá que ser evaluado dos veces con el uso anterior. Puede limitar la redundancia si es simplemente una variable local. Sin embargo, un modismo Pythonic común y eficaz para este caso de uso es usar orComportamiento de atajo:

expression1 or expression2

que es equivalente en semántica. Tenga en cuenta que algunas guías de estilo pueden limitar este uso por motivos de claridad: contiene mucho significado en muy poca sintaxis.

Simulando el operador ternario de Python.

Por ejemplo:

a, b, x, y = 1, 2, 'a greather than b', 'b greater than a'
result = (lambda:y, lambda:x)[a > b]()

salida:

'b greater than a'

El operador condicional ternario simplemente permite probar una condición en una sola línea reemplazando el if-else de varias líneas, lo que hace que el código sea compacto.

Sintaxis:

[on_true] si [expresión] else [on_false]

1- Método simple para utilizar el operador ternario:

# Program to demonstrate conditional operator
a, b = 10, 20
# Copy value of a in min if a < b else copy b
min = a if a < b else b
print(min)  # Output: 10

2- Método directo de uso de tuplas, diccionario y lambda:

# Python program to demonstrate ternary operator
a, b = 10, 20
# Use tuple for selecting an item
print( (b, a) [a < b] )
# Use Dictionary for selecting an item
print({True: a, False: b} [a < b])
# lamda is more efficient than above two methods
# because in lambda  we are assure that
# only one expression will be evaluated unlike in
# tuple and Dictionary
print((lambda: b, lambda: a)[a < b]()) # in output you should see three 10

3- El operador ternario se puede escribir como if-else anidado:

# Python program to demonstrate nested ternary operator
a, b = 10, 20
print ("Both a and b are equal" if a == b else "a is greater than b"
        if a > b else "b is greater than a")

El enfoque anterior se puede escribir como:

# Python program to demonstrate nested ternary operator
a, b = 10, 20
if a != b:
    if a > b:
        print("a is greater than b")
    else:
        print("b is greater than a")
else:
    print("Both a and b are equal") 
# Output: b is greater than a

a if condition else b

Simplemente memorice esta pirámide si tiene problemas para recordar:

     condition
  if           else
a                   b 

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 se ejecuta exp_1, de lo contrario se ejecuta exp_2.

Nota :- 0, None, False, emptylist, emptyString se evalúa como False. Y cualquier dato que no sea 0 se evalúa como Verdadero.

Así es como funciona:

si la condición [condición] se convierte en "Verdadero", se evaluará expresión_1 pero no expresión_2. Si "y" algo con 0 (cero), el resultado siempre será rápido. Entonces, 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á como cero y no es necesario evaluar la expresión. Así es como funciona el propio compilador, en todos los lenguajes.

In

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ía Verdadero cuando exp1 no es falso.

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 después de exp1 ya que se usa "o", evaluará la expresión exp2 después de "o".

Nota: - Este tipo de ramificación que usa "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 vuelve Falsa, entonces 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 exp_1 y exp_2, haga esto: -

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

Una de las alternativas a Python expresión condicional

"yes" if boolean else "no"

es el siguiente:

{True:"yes", False:"no"}[boolean]

que tiene la siguiente extensión agradable:

{True:"yes", False:"no", None:"maybe"}[boolean_or_none]

La alternativa más corta sigue siendo:

("no", "yes")[boolean]

pero no hay alternativa a

yes() if boolean else no()

si quiere evitar la evaluación de yes() y no(), porque en

(no(), yes())[boolean]  # bad

ambas no() y yes() son evaluados.

Más un consejo que una respuesta (no es necesario repetir lo obvio por centésima vez), pero a veces lo uso como un atajo de línea en tales construcciones:

if conditionX:
    print('yes')
else:
    print('nah')

, se convierte en:

print('yes') if conditionX else print('nah')

Algunos (muchos :) pueden fruncir el ceño por considerarlo poco pitónico (incluso, ruby-ish :), pero personalmente lo encuentro más natural, es decir, cómo lo expresarías normalmente, además de un poco más atractivo visualmente en grandes bloques de código.

Como ya se respondió, sí, hay un operador ternario en Python:

<expression 1> if <condition> else <expression 2>

Información Adicional:

If <expression 1> es la condición que puedes usar Evaluación de cortocircuito:

a = True
b = False

# Instead of this:
x = a if a else b

# You could use Short-cirquit evaluation:
x = a or b

PD: Por supuesto, una evaluación de cortocircuito no es un operador ternario, pero a menudo se utiliza el ternario en los casos en que el cortocircuito sería suficiente.

Muchos lenguajes de programación derivados de C generalmente tienen la siguiente sintaxis de operador condicional ternario:

<condition> ? <expression1> : <expression2>

Al principio, el Python Benevolente Dictador For Life (me refiero a Guido van Rossum, por supuesto) lo rechazó (como estilo no pitónico), ya que es bastante difícil de entender para las personas que no están acostumbradas a C idioma. Además, el signo de los dos puntos : ya tiene muchos usos en Python. Después PEP 308 fue aprovado, Python finalmente recibió su propia expresión condicional de acceso directo (lo que usamos ahora):

<expression1> if <condition> else <expression2>

Entonces, primero evalúa la condición. Si vuelve True, expresión1 será evaluado para dar el resultado, de lo contrario expresión2 será evaluado. Debido a Evaluación perezosa mecánica: solo se ejecutará una expresión.

A continuación se muestran algunos ejemplos (las condiciones se evaluarán de izquierda a derecha):

pressure = 10
print('High' if pressure < 20 else 'Critical')

# Result is 'High'

Los operadores ternarios se pueden encadenar en serie:

pressure = 5
print('Normal' if pressure < 10 else 'High' if pressure < 20 else 'Critical')

# Result is 'Normal'

El siguiente es el mismo que el anterior:

pressure = 5

if pressure < 20:
    if pressure < 10:
        print('Normal')
    else:
        print('High')
else:
    print('Critical')

# Result is 'Normal'

Espero que esto ayude.

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

La respuesta de Vinko Vrsalovic es suficientemente buena. Solo queda una cosa más:

Tenga en cuenta que los condicionales son una expresiónno es un ambiental. Esto significa que no puede usar declaraciones de asignación o pass u otros declaraciones dentro de un condicional expresión

Operador de morsa en Python 3.8

Después de que se introdujo el operador de morsa en Python 3.8, algo cambió.

(a := 3) if True else (b := 5)

da a = 3 y b is not defined,

(a := 3) if False else (b := 5)

da a is not defined y b = 5 y

c = (a := 3) if False else (b := 5)

da c = 5, a is not defined y b = 5.

Incluso si esto puede ser feo, asignaciones se puede hacer dentro Expresiones condicionales posteriores a Python 3.8. De todos modos, es mejor usar normal if ambiental en su lugar en este caso.

Python tiene una forma ternaria para las asignaciones; sin embargo, puede haber incluso una forma más corta que la gente debería conocer.

Es muy común tener que asignar a una variable un valor u otro dependiendo de una condición.

>>> li1 = None
>>> li2 = [1, 2, 3]
>>> 
>>> if li1:
...     a = li1
... else:
...     a = li2
...     
>>> a
[1, 2, 3]

^ Esta es la forma larga para realizar este tipo de asignaciones.

A continuación se muestra la forma ternaria. Pero esta no es la forma más concisa, vea el último ejemplo.

>>> a = li1 if li1 else li2
>>> 
>>> a
[1, 2, 3]
>>> 

Con Python, simplemente puede usar or para asignaciones alternativas.

>>> a = li1 or li2
>>> 
>>> a
[1, 2, 3]
>>> 

Lo anterior funciona desde li1 is None y la interpretación lo trata como Falso en expresiones lógicas. El interp luego avanza y evalúa la segunda expresión, que no es None y no es una lista vacía, por lo que se asigna a un.

Esto también funciona con listas vacías. Por ejemplo, si desea asignar a cualquier lista que tenga elementos.

>>> li1 = []
>>> li2 = [1, 2, 3]
>>> 
>>> a = li1 or li2
>>> 
>>> a
[1, 2, 3]
>>> 

Sabiendo esto, puede simplemente realizar esas asignaciones cada vez que las encuentre. Esto también funciona con cadenas y otros iterables. Podrías asignar a cualquier cadena que no esté vacía.

>>> s1 = ''
>>> s2 = 'hello world'
>>> 
>>> a = s1 or s2
>>> 
>>> a
'hello world'
>>> 

Siempre me gustó la sintaxis ternaria de C, ¡pero Python va un paso más allá!

Entiendo que algunos puedan decir que esta no es una buena opción estilística porque se basa en mecánicas que no son evidentes de inmediato para todos los desarrolladores. Personalmente, no estoy de acuerdo con ese punto de vista. Python es un lenguaje rico en sintaxis con muchos trucos idiomáticos que no son evidentes de inmediato para el aficionado. Pero cuanto más aprende y comprende la mecánica del sistema subyacente, más lo aprecia.

Otras respuestas hablan correctamente sobre el operador ternario de Python. Me gustaría complementar mencionando un escenario para el que se usa a menudo el operador ternario pero para el que hay un mejor idioma. Este es el escenario de usar un valor predeterminado.

Supongamos que queremos usar option_value con un valor predeterminado si no está configurado:

run_algorithm(option_value if option_value is not None else 10)

o si option_value nunca se establece en un valor falso (0, "", etc.), simplemente

run_algorithm(option_value if option_value else 10)

Sin embargo, en este caso, una solución cada vez mejor es simplemente escribir

run_algorithm(option_value or 10)

El operador ternario es una forma de escribir declaraciones condicionales en Python. Como sugiere el nombre ternario, este operador de Python consta de tres operandos.

Sintaxis: los tres operandos de un operador ternario incluyen:

condición: una expresión booleana que se evalúa como verdadera o falsa.

true_val: un valor que se asignará si la expresión se evalúa como verdadera.

false_val: un valor que se asignará si la expresión se evalúa como falsa.

    var = true_val if condition else false_val

Se asignará la variable var en el lado izquierdo del operador = (asignación):

value1 si booleanExpression se evalúa como verdadero.

value2 si booleanExpression se evalúa como falso.

Ejemplo:

    # USING TERNARY OPERATOR
    to_check = 6
    msg = "Even" if to_check%2 == 0 else "Odd"
    print(msg) 

    # USING USUAL IF-ELSE
    msg = ""
    if(to_check%2 == 0):
    msg = "Even"
    else:
    msg = "Odd"
    print(msg)

Una forma ordenada de encadenar múltiples operadores:

f = lambda x,y: 'greater' if x > y else 'less' if y > x else 'equal'

array = [(0,0),(0,1),(1,0),(1,1)]

for a in array:
  x, y = a[0], a[1]
  print(f(x,y))

# Output is:
#   equal,
#   less,
#   greater,
#   equal

Encuentro engorrosa la sintaxis predeterminada de Python val = a if cond else b, entonces a veces hago esto:

iif = lambda (cond, a, b): a if cond else b
# so I can then use it like:
val = iif(cond, a, b)

Por supuesto, tiene la desventaja de evaluar siempre ambos lados (ayb), pero la sintaxis es mucho más clara para mí.

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)

saldrá

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

is_spacial=True if gender = "Female" else (True if age >= 65 else False)

**

se puede anidar según sus necesidades. la mejor de las suertes

**