operators in - Python ha un operatore condizionale ternario?




ternary conditional (20)

Se Python non ha un operatore condizionale ternario, è possibile simularne uno utilizzando altri costrutti linguistici?


Answers

Simulazione dell'operatore ternario di Python.

Per esempio

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

produzione:

'b greater than a'

Potresti trovarlo spesso

cond and on_true or on_false

ma questo porta a un 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

dove ti aspetteresti per un normale operatore ternario questo risultato

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

Puoi indicizzare in una tupla:

(falseValue, trueValue)[test]

test deve restituire Vero o Falso .
Potrebbe essere più sicuro implementarlo sempre come:

(falseValue, trueValue)[test == True]

oppure puoi usare il built-in bool() per assicurare un valore Boolean :

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

Assolutamente, ed è incredibilmente facile da capire.

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


L'operatore condizionale ternario consente semplicemente di testare una condizione in una singola riga sostituendo la multilinea if-else rendendo il codice compatto.

Sintassi:

[on_true] if [expression] else [on_false]

1- Metodo semplice per utilizzare l'operatore 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- Metodo diretto di utilizzo di tuple, dizionario 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- L'operatore Ternario può essere scritto come nidificato se-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")

L'approccio sopra può essere scritto come:

# 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

Sì, python ha un operatore ternario, ecco la sintassi e un codice di esempio per dimostrare lo stesso :)

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

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ì, è stato added nella versione 2.5.
La sintassi è:

a if condition else b

Viene valutata la prima condition , quindi a o b viene restituito in base al valore Boolean della condition
Se la condition restituisce True, viene restituito, altrimenti viene restituito b .

Per esempio:

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

Nota che i condizionali sono un'espressione , non un'affermazione . Ciò significa che non è possibile utilizzare assegnazioni o pass o altre dichiarazioni in modo condizionale:

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

In tal caso, devi usare una normale istruzione if invece di una condizionale.

Tieni presente che è sfigurato da alcuni Pythonistas per diversi motivi:

  • L'ordine degli argomenti è diverso da molti altri linguaggi (come C, Ruby, Java, ecc.), Che possono portare a bug quando le persone che non hanno familiarità con il comportamento "sorprendente" di Python lo usano (potrebbero invertire l'ordine).
  • Alcuni lo trovano "ingombrante", poiché va contro il normale flusso del pensiero (pensando prima alla condizione e poi agli effetti).
  • Ragioni stilistiche

Se hai difficoltà a ricordare l'ordine, ricorda che se lo leggi ad alta voce, dici (quasi) cosa intendi. Ad esempio, x = 4 if b > 8 else 9 viene letto ad alta voce come x will be 4 if b is greater than 8 otherwise 9 .

Documentazione ufficiale:


Più un suggerimento che una risposta (non è necessario ripetere l'ovvio per il periodo di tempo), ma a volte lo uso come scorciatoia oneliner in questi costrutti:

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

, diventa:

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

Alcuni (molti) potrebbero disapprovarlo come unpitonico (anche, rubino-ish :), ma personalmente lo trovo più naturale - cioè come lo si esprimerebbe normalmente, più un po 'più visivamente accattivante in grandi blocchi di codice.


Sì:

Diciamo che vuoi dare una variabile a qualche valore se qualche bool è vero e allo stesso modo

X = 5 se qualcos'altro x = 10

X = [qualche valore] se [se questo è vero il primo valore valuta] else [altro valore valuta]


Python ha un operatore condizionale ternario?

Sì. Dal file di grammatica :

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

La parte di interesse è:

or_test ['if' or_test 'else' test]

Quindi, un'operazione ternaria condizionale ha la forma:

expression1 if expression2 else expression3

expression3 sarà valutato pigramente (cioè valutato solo se expression2 è false in un contesto booleano). E a causa della definizione ricorsiva, puoi incatenarli indefinitamente (anche se potrebbe essere considerato un cattivo stile).

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

Una nota sull'utilizzo:

Nota che ogni if deve essere seguito con un else . Le persone che imparano le comprensioni delle liste e le espressioni del generatore possono ritenere che questa sia una lezione difficile da imparare - il seguente non funzionerà, dato che Python si aspetta una terza espressione per un altro:

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

che solleva un SyntaxError: invalid syntax . Quindi quanto sopra è una parte di logica incompleta (forse l'utente si aspetta un no-op nella falsa condizione) o quello che può essere inteso è usare expression2 come filtro - nota che il seguente è legale Python:

[expression1 for element in iterable if expression2]

expression2 funziona come un filtro per la comprensione dell'elenco e non è un operatore condizionale ternario.

Sintassi alternativa per un caso più stretto:

Potresti trovare un po 'doloroso scrivere quanto segue:

expression1 if expression1 else expression2

expression1 dovrà essere valutato due volte con l'utilizzo di cui sopra. Può limitare la ridondanza se è semplicemente una variabile locale. Tuttavia, un idioma Pythonic comune e performante per questo caso d'uso è l'uso or il comportamento shortcutting:

expression1 or expression2

che è equivalente in semantica. Si noti che alcune guide di stile possono limitare questo utilizzo per motivi di chiarezza: esso racchiude molto significato in pochissima sintassi.


Puoi farlo :-

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

Esempio:-

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

Questo verrebbe stampato "dispari" se il numero è dispari o "pari" se il numero è pari.

Il risultato: - Se la condizione è vera, exp_1 viene eseguita altrimenti viene eseguita exp_2.

Nota: - 0, Nessuna, False, lista vuota, emptyString viene valutata come False. E qualsiasi dato diverso da 0 viene valutato come True.

Ecco come funziona:

se la condizione [condizione] diventa "Vero", allora espressione_1 sarà valutata ma non espressione_2. Se noi "e" qualcosa con 0 (zero), il risultato sarà sempre fasullo. Quindi nella seguente istruzione,

0 and exp

L'espressione exp non verrà valutata affatto poiché "e" con 0 valuterà sempre a zero e non è necessario valutare l'espressione. Ecco come funziona il compilatore stesso, in tutte le lingue.

Nel

1 or exp

l'espressione exp non verrà valutata affatto poiché "o" con 1 sarà sempre 1. Quindi non si preoccuperà di valutare l'espressione exp poiché il risultato sarà 1 comunque. (metodi di ottimizzazione del compilatore).

Ma in caso di

True and exp1 or exp2

La seconda espressione exp2 non verrà valutata poiché True and exp1 sarebbe True se exp1 non è falso.

Allo stesso modo in

False and exp1 or exp2

L'espressione exp1 non sarà valutata poiché False equivale a scrivere 0 e fare "e" con 0 sarebbe 0 stesso ma dopo exp1 poiché "or" è usato, valuterà l'espressione exp2 dopo "o".

Nota: - Questo tipo di diramazione che utilizza "or" e "and" può essere utilizzato solo quando expression_1 non ha un valore di verità di False (o 0 o None o emptylist [] o emptystring ''.) Poiché if expression_1 diventa False, quindi l'espressione_2 verrà valutata a causa della presenza "o" tra exp_1 e exp_2.

Se vuoi comunque farlo funzionare per tutti i casi indipendentemente dai valori di verità exp_1 e exp_2, fai questo: -

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


Per Python 2.5 e versioni successive esiste una sintassi specifica:

[on_true] if [cond] else [on_false]

Nei vecchi Python un operatore ternario non è implementato ma è possibile simularlo.

cond and on_true or on_false

Tuttavia, esiste un potenziale problema, che se cond valuta su True e su on_true valutato su False viene restituito on_true anziché on_true . Se vuoi questo comportamento il metodo è OK, altrimenti usa questo:

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

che può essere avvolto da:

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

e usato in questo modo:

q(cond, on_true, on_false)

È compatibile con tutte le versioni di Python.


Sì.

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

@su:

Sfortunatamente, il

(falseValue, trueValue)[test]

la soluzione non ha un comportamento di cortocircuito; quindi sia falseValue che trueValue vengono valutati indipendentemente dalla condizione. Questo potrebbe essere subottimale o addirittura buggato (cioè sia trueValue che falseValue potrebbero essere metodi e avere effetti collaterali).

Una soluzione a questo sarebbe

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

(l'esecuzione è ritardata fino a quando il vincitore non è noto;)), ma introduce un'incoerenza tra oggetti chiamabili e non richiamabili. Inoltre, non risolve il caso quando si utilizzano le proprietà.

E così la trama va - scegliere tra 3 soluzioni menzionate è un compromesso tra avere la caratteristica di cortocircuito, usare almeno python 2.5 (IMHO non è più un problema) e non essere incline a "trueValue-evaluation-to-false" errori.


Operatore ternario in diversi linguaggi di programmazione

Qui cerco solo di mostrare alcune importanti differenze nell'operatore ternary operator tra un paio di linguaggi di programmazione.

Operatore ternario in Javascript

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

Operatore ternario in Ruby

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

Operatore ternario in Scala

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

Operatore ternario nella programmazione R

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

Operatore ternario in Python

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

Ora puoi vedere la bellezza del linguaggio Python. è altamente leggibile e mantenibile.


espressione1 se condizione else espressione2

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

Sintassi: l'operatore Ternario verrà indicato come:

[on_true] if [expression] else [on_false]

per esempio

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

È un trigraph C. ??! è | , quindi ??!??! è l'operatore ||





python operators ternary-operator conditional-operator python-2.5