L'equivalente di Python di && (logical-and) in un'istruzione if




5 Answers

Python usa and e / or condizionali.

vale a dire

if foo == 'abc' and bar == 'bac' or zoo == '123':
  # do something
python if-statement keyword logical-operators and-operator

Ecco il mio codice:

def front_back(a, b):
  # +++your code here+++
  if len(a) % 2 == 0 && len(b) % 2 == 0:
    return a[:(len(a)/2)] + b[:(len(b)/2)] + a[(len(a)/2):] + b[(len(b)/2):] 
  else:
    #todo! Not yet done. :P
  return

Sto ottenendo un errore nel condizionale IF. Che cosa sto facendo di sbagliato?




Sto ottenendo un errore nel condizionale IF. Che cosa sto facendo di sbagliato?

Il motivo per cui ottieni un SyntaxError è che non esiste un operatore && in Python. Allo stesso modo || e ! non sono operatori Python validi .

Alcuni degli operatori che potresti conoscere da altre lingue hanno un nome diverso in Python. Gli operatori logici && e || sono effettivamente chiamati and e or . Allo stesso modo l'operatore di negazione logica ! è chiamato not

Quindi potresti scrivere:

if len(a) % 2 == 0 and len(b) % 2 == 0:

o anche:

if not (len(a) % 2 or len(b) % 2):

Alcune informazioni aggiuntive (che potrebbero tornare utili):

Ho riassunto l'operatore "equivalenti" in questa tabella:

+------------------------------+---------------------+
|  Operator (other languages)  |  Operator (Python)  |
+==============================+=====================+
|              &&              |         and         |
+------------------------------+---------------------+
|              ||              |         or          |
+------------------------------+---------------------+
|              !               |         not         |
+------------------------------+---------------------+

Vedi anche la documentazione di Python: 6.11. Operazioni booleane .

Oltre agli operatori logici, Python ha anche operatori bit a bit / binari:

+--------------------+--------------------+
|  Logical operator  |  Bitwise operator  |
+====================+====================+
|        and         |         &          |
+--------------------+--------------------+
|         or         |         |          |
+--------------------+--------------------+

Non esiste alcuna negazione bit a bit in Python (solo l'operatore inverso bit a bit ~ - ma non è equivalente a not ).

Vedi anche 6.6. Operazioni aritmetiche unificate, bit a bit / binarie e 6.7. Operazioni aritmetiche binarie .

Gli operatori logici (come in molte altre lingue) hanno il vantaggio di essere cortocircuitati. Ciò significa che se il primo operando definisce già il risultato, allora il secondo operatore non viene valutato affatto.

Per dimostrarlo, utilizzo una funzione che prende semplicemente un valore, lo stampa e lo restituisce di nuovo. Questo è utile per vedere cosa viene effettivamente valutato a causa delle dichiarazioni di stampa:

>>> def print_and_return(value):
...     print(value)
...     return value

>>> res = print_and_return(False) and print_and_return(True)
False

Come puoi vedere, viene eseguita solo una istruzione print, quindi Python non ha nemmeno guardato l'operando giusto.

Questo non è il caso per gli operatori binari. Questi valutano sempre entrambi gli operandi:

>>> res = print_and_return(False) & print_and_return(True);
False
True

Ma se il primo operando non è sufficiente, ovviamente, viene valutato il secondo operatore:

>>> res = print_and_return(True) and print_and_return(False);
True
False

Per riassumere questo ecco un'altra tabella:

+-----------------+-------------------------+
|   Expression    |  Right side evaluated?  |
+=================+=========================+
| `True` and ...  |           Yes           |
+-----------------+-------------------------+
| `False` and ... |           No            |
+-----------------+-------------------------+
|  `True` or ...  |           No            |
+-----------------+-------------------------+
| `False` or ...  |           Yes           |
+-----------------+-------------------------+

True e False rappresentano i ritorni di bool(left-hand-side) , non devono essere True o False , devono solo restituire True o False quando viene richiamato il bool (1).

Quindi in Pseudo-Code (!) Le and e or funzioni funzionano come queste:

def and(expr1, expr2):
    left = evaluate(expr1)
    if bool(left):
        return evaluate(expr2)
    else:
        return left

def or(expr1, expr2):
    left = evaluate(expr1)
    if bool(left):
        return left
    else:
        return evaluate(expr2)

Si noti che questo è pseudo-codice non codice Python. In Python non è possibile creare funzioni chiamate and o or perché si tratta di parole chiave. Inoltre non dovresti mai usare "valutare" o if bool(...) .

Personalizzare il comportamento delle tue classi

Questa chiamata bool implicita può essere utilizzata per personalizzare il comportamento delle classi con and , or not .

Per mostrare come questo può essere personalizzato, utilizzo questa classe che print nuovo qualcosa per tenere traccia di ciò che sta accadendo:

class Test(object):
    def __init__(self, value):
        self.value = value

    def __bool__(self):
        print('__bool__ called on {!r}'.format(self))
        return bool(self.value)

    __nonzero__ = __bool__  # Python 2 compatibility

    def __repr__(self):
        return "{self.__class__.__name__}({self.value})".format(self=self)

Quindi vediamo cosa succede con quella classe in combinazione con questi operatori:

>>> if Test(True) and Test(False):
...     pass
__bool__ called on Test(True)
__bool__ called on Test(False)

>>> if Test(False) or Test(False):
...     pass
__bool__ called on Test(False)
__bool__ called on Test(False)

>>> if not Test(True):
...     pass
__bool__ called on Test(True)

Se non si dispone di un metodo __bool__ , Python controlla anche se l'oggetto ha un metodo __len__ e se restituisce un valore maggiore di zero. Potrebbe essere utile sapere se si crea un contenitore sequenza.

Vedi anche 4.1. Test del valore di verità .

NumPy matrici e sottoclassi

Probabilmente un po 'oltre lo scopo della domanda originale, ma nel caso in cui si tratti di array o sottoclassi di NumPy (come Pandas Series o DataFrames), la chiamata bool implicita solleverà il temuto ValueError :

>>> import numpy as np
>>> arr = np.array([1,2,3])
>>> bool(arr)
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
>>> arr and arr
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

>>> import pandas as pd
>>> s = pd.Series([1,2,3])
>>> bool(s)
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
>>> s and s
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

In questi casi è possibile utilizzare la logica e la funzione di NumPy che esegue un elemento-saggio and (o or ):

>>> np.logical_and(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([False, False,  True, False])
>>> np.logical_or(np.array([False,False,True,True]), np.array([True, False, True, False]))
array([ True, False,  True,  True])

Se hai a che fare solo con gli array booleani, puoi usare gli operatori binari con NumPy, questi eseguono confronti a livello di elemento (ma anche binari):

>>> np.array([False,False,True,True]) & np.array([True, False, True, False])
array([False, False,  True, False])
>>> np.array([False,False,True,True]) | np.array([True, False, True, False])
array([ True, False,  True,  True])

(1)

Che il richiamo bool degli operandi debba restituire True o False non è completamente corretto. È solo il primo operando che deve restituire un booleano nel suo metodo __bool__ :

class Test(object):
    def __init__(self, value):
        self.value = value

    def __bool__(self):
        return self.value

    __nonzero__ = __bool__  # Python 2 compatibility

    def __repr__(self):
        return "{self.__class__.__name__}({self.value})".format(self=self)

>>> x = Test(10) and Test(10)
TypeError: __bool__ should return bool, returned int
>>> x1 = Test(True) and Test(10)
>>> x2 = Test(False) and Test(10)

Questo perché restituisce effettivamente il primo operando se il primo operando viene valutato su False e se viene valutato su True , restituisce il secondo operando:

>>> x1
Test(10)
>>> x2
Test(False)

Allo stesso modo per or ma solo il contrario:

>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)

Tuttavia, se li si utilizza in una istruzione if , anche il if richiama implicitamente bool sul risultato. Quindi questi punti più fini potrebbero non essere rilevanti per te.




Si utilizzano and e or per eseguire operazioni logiche come in C, C ++. Come letteralmente and è && e or è || .

Dai un'occhiata a questo divertente esempio,

Supponiamo che tu voglia costruire Logic Gates in Python:

def AND(a,b):
    return (a and b) #using and operator

def OR(a,b):
    return (a or b)  #using or operator

Ora prova a chiamarli:

print AND(False, False)
print OR(True, False)

Questo produrrà:

False
True

Spero che questo ti aiuti!




Uso di "e" in condizionale. Lo uso spesso durante l'importazione in Jupyter Notebook:

def find_local_py_scripts():
    import os # does not cost if already imported
    for entry in os.scandir('.'):
        # find files ending with .py
        if entry.is_file() and entry.name.endswith(".py") :
            print("- ", entry.name)
find_local_py_scripts()

-  googlenet_custom_layers.py
-  GoogLeNet_Inception_v1.py



forse con & invece% è più veloce e mantieni la leggibilità

altri test anche / dispari

x è pari? x% 2 == 0

x è strano? non x% 2 == 0

forse è più chiaro con bit a bit e 1

x è strano? x e 1

x è pari? non x & 1 (non dispari)

def front_back(a, b):
    # +++your code here+++
    if not len(a) & 1 and not len(b) & 1:
        return a[:(len(a)/2)] + b[:(len(b)/2)] + a[(len(a)/2):] + b[(len(b)/2):] 
    else:
        #todo! Not yet done. :P
    return





Related