operators expressão - Python tem um operador condicional ternário?



atribuição desvio (20)

Se o Python não tiver um operador condicional ternário, é possível simular um usando outras construções de linguagem?


Answers

Absolutamente, e é incrivelmente fácil de entender.

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

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

Sim, python tem um operador ternário, aqui está a sintaxe e um código de exemplo para demonstrar o mesmo :)

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

se variável é definida e você quer verificar se tem valor você pode apenas 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)

vai sair

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

Você pode encontrar frequentemente

cond and on_true or on_false

mas isso leva ao problema quando on_true == 0

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

onde você esperaria para um operador ternário normal este resultado

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

Mais uma dica do que uma resposta (não é necessário repetir o óbvio pela centésima vez), mas às vezes uso-o como um atalho on-line em tais construções:

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

, torna-se:

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

Alguns (muitos :) podem desaprová-lo como não-cético (mesmo, ruby-ish :), mas eu pessoalmente acho isso mais natural - ou seja, como você o expressaria normalmente, além de um pouco mais visualmente atraente em grandes blocos de código.


Sintaxe: O operador Ternary será dado como:

[on_true] if [expression] else [on_false]

por exemplo

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

Você pode indexar em uma tupla:

(falseValue, trueValue)[test]

test precisa retornar True ou False .
Pode ser mais seguro implementá-lo sempre como:

(falseValue, trueValue)[test == True]

ou você pode usar o bool() embutido para assegurar um valor Boolean :

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

@acima:

Infelizmente, o

(falseValue, trueValue)[test]

solução não tem comportamento de curto-circuito; assim, ambos falseValue e trueValue são avaliados independentemente da condição. Isso poderia ser insatisfatório ou mesmo com erros (ou seja, trueValue e falseValue poderiam ser métodos e ter efeitos colaterais).

Uma solução para isso seria

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

(execução atrasada até que o vencedor seja conhecido;)), mas introduz inconsistência entre objetos que podem ser chamados e que não podem ser chamados. Além disso, não resolve o caso ao usar propriedades.

E assim a história vai - escolhendo entre 3 soluções mencionadas é uma troca entre ter o recurso de curto-circuito, usando pelo menos python 2.5 (IMHO não é mais um problema) e não ser propenso a "trueValue-avalia-to-false" erros.


Sim.

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

Um operador para uma expressão condicional no Python foi adicionado em 2006 como parte da Python Enhancement Proposal 308 . Sua forma difere do comum ?: Operador e é:

<expression1> if <condition> else <expression2>

o que equivale a:

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

Aqui está um exemplo:

result = x if a > b else y

Outra sintaxe que pode ser usada (compatível com versões anteriores a 2.5):

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

onde operandos são avaliados preguiçosamente .

Outra maneira é indexar uma tupla (que não é consistente com o operador condicional da maioria das outras linguagens):

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

ou dicionário explicitamente construído:

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

Outro (menos confiável), mas método mais simples é usar and / or operadores:

result = (a > b) and x or y

no entanto, isso não funcionará se x for False .

Uma possível solução alternativa é criar listas x e y ou tuplas da seguinte maneira:

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

ou:

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

Se você está trabalhando com dicionários, ao invés de usar uma condicional ternária, você pode tirar proveito de get(key, default) , por exemplo:

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

Fonte: ?:



Para versões anteriores a 2.5, existe o truque:

[expression] and [on_true] or [on_false]

Pode dar resultados errados quando on_true tiver um valor booleano falso. 1
Embora tenha o benefício de avaliar expressões da esquerda para a direita, o que é mais claro na minha opinião.

1. Existe um equivalente do operador ternário C?


O operador condicional ternário simplesmente permite testar uma condição em uma única linha substituindo a multilinha se-else tornando o código compacto.

Sintaxe:

[on_true] if [expressão] mais [on_false]

1- Método simples para usar o operador ternário:

# 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 direto de usar tuplas, dicionário e 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- operador Ternary pode ser escrito como aninhado if-else:

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

A abordagem acima pode ser escrita 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

Sim, foi added na versão 2.5.
A sintaxe é:

a if condition else b

A primeira condition é avaliada e, em seguida, a ou b é retornada com base no valor Boolean da condition
Se a condition for avaliada como True a é retornada, else b será retornado.

Por exemplo:

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

Note que condicionais são uma expressão , não uma declaração . Isso significa que você não pode usar atribuições ou pass ou outras declarações em um condicional:

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

Nesse caso, você tem que usar uma instrução if normal em vez de uma condicional.

Tenha em mente que isso é desaprovado por alguns Pythonistas por vários motivos:

  • A ordem dos argumentos é diferente de muitas outras linguagens (como C, Ruby, Java, etc.), o que pode levar a bugs quando pessoas não familiarizadas com o comportamento "surpreendente" do Python o usam (elas podem reverter a ordem).
  • Alguns acham "difícil de manejar", uma vez que contraria o fluxo normal do pensamento (pensando primeiro na condição e depois nos efeitos).
  • Razões estilísticas.

Se você está tendo problemas para lembrar o pedido, lembre-se de que, se você ler em voz alta, você (quase) diz o que quer dizer. Por exemplo, x = 4 if b > 8 else 9 for lido em voz alta como x will be 4 if b is greater than 8 otherwise 9 .

Documentação oficial:


Python tem um operador condicional ternário?

Sim. Do arquivo de gramática :

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

A parte de interesse é:

or_test ['if' or_test 'else' test]

Portanto, uma operação condicional ternária é da seguinte forma:

expression1 if expression2 else expression3

expression3 será avaliado com preguiça (isto é, avaliado apenas se expression2 for false em um contexto booleano). E por causa da definição recursiva, você pode encadeá-los indefinidamente (embora possa ser considerado um estilo ruim).

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

Uma nota sobre o uso:

Note que cada if deve ser seguido por else . As pessoas que aprendem a compreensão de listas e expressões geradoras podem achar isso uma lição difícil de aprender - o seguinte não funcionará, já que o Python espera uma terceira expressão para outra coisa:

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

que gera um SyntaxError: invalid syntax . Portanto, o que está acima é uma parte incompleta da lógica (talvez o usuário espere um não-op na condição falsa) ou o que pode ser pretendido é usar expression2 como um filtro - observa que o seguinte é legal em Python:

[expression1 for element in iterable if expression2]

expression2 funciona como um filtro para a compreensão da lista e não é um operador condicional ternário.

Sintaxe alternativa para um caso mais restrito:

Você pode achar um pouco doloroso escrever o seguinte:

expression1 if expression1 else expression2

expression1 terá que ser avaliado duas vezes com o uso acima. Pode limitar a redundância se for simplesmente uma variável local. No entanto, um idioma Pythonic comum e de alto desempenho para este caso de uso é usar or o comportamento de atalho:

expression1 or expression2

que é equivalente em semântica. Observe que alguns guias de estilo podem limitar esse uso com base em clareza - ele contém muito significado em pouca sintaxe.


expression1 if condition else expression2

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

você consegue fazer isso :-

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

Exemplo:-

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

Isso imprimiria "ímpar" se o número for ímpar ou "par", se o número for par.

O resultado: - Se a condição for verdadeira, exp_1 será executado, ou então exp_2 será executado.

Nota: - 0, None, False, emptylist, emptyString é avaliado como False. E qualquer dado diferente de 0 é avaliado como Verdadeiro.

Veja como isso funciona:

se a condição [condição] se tornar "Verdadeira", a expressão_1 será avaliada, mas não a expressão_2. Se nós "e" algo com 0 (zero), o resultado será sempre fasle. Então, na declaração abaixo,

0 and exp

A expressão exp não será avaliada de todo, já que "e" com 0 sempre será avaliado como zero e não há necessidade de avaliar a expressão. É assim que o próprio compilador funciona, em todas as linguagens.

Em

1 or exp

a expressão exp não será avaliada de forma alguma, já que "or" com 1 será sempre 1. Portanto, não será necessário avaliar a expressão exp, pois o resultado será 1 de qualquer maneira. (métodos de otimização de compilador).

Mas em caso de

True and exp1 or exp2

A segunda expressão exp2 não será avaliada, pois True and exp1 serão True quando exp1 não for falso.

Similarmente em

False and exp1 or exp2

A expressão exp1 não será avaliada, pois False equivale a escrever 0 e fazer "e" com 0 seria 0 em si, mas depois de exp1, já que "ou" é usado, ele avaliará a expressão exp2 depois de "ou".

Nota: - Esse tipo de ramificação usando "ou" e "e" só pode ser usado quando a expressão_1 não tiver um valor Verdadeiro de Falso (ou 0 ou Nenhum ou lista vazia [] ou string vazia). False, então a expressão_2 será avaliada devido à presença "ou" entre exp_1 e exp_2.

Caso você ainda queira fazer com que funcione para todos os casos, independentemente de quais valores de verdade exp_1 e exp_2, faça o seguinte:

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


Da documentação :

Expressões condicionais (às vezes chamadas de "operador ternário") têm a menor prioridade de todas as operações do Python.

A expressão x if C else y primeiro avalia a condição, C ( não x ); se C é verdadeiro, x é avaliado e seu valor é retornado; Caso contrário, y é avaliado e seu valor é retornado.

Veja PEP 308 para mais detalhes sobre expressões condicionais.

Novo desde a versão 2.5.


Se você está feliz com "blah" in somestring mas quer que seja uma chamada de função, você provavelmente pode fazer isso

import operator

if not operator.contains(somestring, "blah"):
    continue

Todos os operadores em Python podem ser mais ou menos encontrados no módulo operador, incluindo in .





python operators ternary-operator conditional-operator python-2.5