Pregunta El equivalente de Python de && (lógico-y) en una instrucción if


Aquí está mi código:

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

Recibo un error en el condicional IF. ¿Qué estoy haciendo mal?


572
2018-03-21 01:23


origen


Respuestas:


Querrías and en lugar de &&.


1029
2018-03-21 01:25



Python usa and y or condicionales.

es decir

if foo == 'abc' and bar == 'bac' or zoo == '123':
  # do something

168
2018-03-21 01:26



Dos comentarios:

  • Utilizar and y or para operaciones lógicas en Python.
  • Usa 4 espacios para sangrar en lugar de 2. Te agradecerás más tarde porque tu código se verá más o menos igual que el código de todos los demás. Ver PEP 8 para más detalles.

28
2018-03-21 01:35



Fui con una solución purlely matemática:

def front_back(a, b):
  return a[:(len(a)+1)//2]+b[:(len(b)+1)//2]+a[(len(a)+1)//2:]+b[(len(b)+1)//2:]

11
2018-06-10 19:10



Probablemente este no sea el mejor código para esta tarea, pero está funcionando -

def front_back(a, b):

 if len(a) % 2 == 0 and len(b) % 2 == 0:
    print a[:(len(a)/2)] + b[:(len(b)/2)] + a[(len(a)/2):] + b[(len(b)/2):]

 elif len(a) % 2 == 1 and len(b) % 2 == 0:
    print a[:(len(a)/2)+1] + b[:(len(b)/2)] + a[(len(a)/2)+1:] + b[(len(b)/2):] 

 elif len(a) % 2 == 0 and len(b) % 2 == 1:
     print a[:(len(a)/2)] + b[:(len(b)/2)+1] + a[(len(a)/2):] + b[(len(b)/2)+1:] 

 else :
     print a[:(len(a)/2)+1] + b[:(len(b)/2)+1] + a[(len(a)/2)+1:] + b[(len(b)/2)+1:]

7
2018-05-25 08:33



Tu usas and y or para realizar operaciones lógicas como en C, C ++. Como literalmente and es && y or es ||.


Eche un vistazo a este divertido ejemplo

Supongamos que quiere construir Logic Gates en Python: 

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

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

Ahora intenta llamarlos:

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

Esto dará como resultado:

False
True

¡Espero que esto ayude!


7
2017-11-12 00:58



Recibo un error en el condicional IF. ¿Qué estoy haciendo mal?

Hay razón por la que obtienes un SyntaxError es que no hay && operador en Python. Igualmente || y ! son no es válido Operadores de Python.

Algunos de los operadores que puede conocer de otros idiomas tienen un nombre diferente en Python. Los operadores lógicos && y || en realidad se llaman and y or. Del mismo modo, el operador de negación lógica ! se llama not.

Entonces podrías escribir:

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

o incluso:

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

Alguna información adicional (que podría ser útil):

Resumí el operador "equivalentes" en esta tabla:

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

Ver también Documentación de Python: 6.11. Operaciones booleanas.

Además de los operadores lógicos, Python también tiene operadores binarios / binarios:

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

No hay una negación a nivel de bits en Python (solo el operador inverso a nivel de bit ~ - pero eso es no equivalente a not)

Ver también 6.6. Aritmética unitaria y operaciones bit a bit / binarias y 6.7. Operaciones aritméticas binarias.

Los operadores lógicos (como en muchos otros idiomas) tienen la ventaja de que están en cortocircuito. Eso significa que si el primer operando ya define el resultado, entonces el segundo operador no se evalúa en absoluto.

Para mostrarlo, utilizo una función que simplemente toma un valor, lo imprime y lo devuelve. Esto es útil para ver lo que es realmente evaluado debido a las declaraciones impresas:

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

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

Como puede ver, solo se ejecuta una instrucción de impresión, por lo que Python realmente ni siquiera miró el operando correcto.

Este no es el caso para los operadores binarios. Esos siempre evalúan ambos operandos:

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

Pero si el primer operando no es suficiente entonces, por supuesto, se evalúa el segundo operador:

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

Para resumir esto aquí hay otra Tabla:

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

los True y False representar lo que bool(left-hand-side) regresa, no tienen que ser True o False, solo necesitan regresar True o False cuando bool es llamado sobre ellos (1).

Entonces en Pseudo-Code (!) El and y or funciones funcionan de la siguiente manera:

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)

Tenga en cuenta que esto es un pseudocódigo, no un código de Python. En Python no puede crear funciones llamadas and o orporque estas son palabras clave Además, nunca debes usar "evaluar" o if bool(...).

Personalizando el comportamiento de sus propias clases

Esto implícito bool la llamada se puede usar para personalizar cómo se comportan sus clases con and, or y not.

Para mostrar cómo se puede personalizar esto, uso esta clase que nuevamente prints algo para rastrear lo que está sucediendo:

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)

Entonces veamos qué sucede con esa clase en combinación con estos operadores:

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

Si no tienes un __bool__ método entonces Python también verifica si el objeto tiene un __len__ método y si devuelve un valor mayor que cero. Puede ser útil saberlo en caso de que cree un contenedor de secuencia.

Ver también 4.1. Verificación del valor de la verdad.

Arrays y subclases de NumPy

Probablemente un poco más allá del alcance de la pregunta original, pero en el caso de que se trate de matrices o subclases NumPy (como Pandas Series o DataFrames), entonces lo implícito bool llamada levantará el temido 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().

En estos casos, puede usar la lógica y función de NumPy que realiza un elemento inteligente 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])

Si estás tratando solo con matrices booleanas también puede usar los operadores binarios con NumPy, estos realizan comparaciones de elementos (pero también binarios):

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

Que el bool llame a los operandos tiene que regresar True o False no es completamente correcto Es solo el primer operando que necesita devolver un booleano en su __bool__ método:

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)

Eso es porque and en realidad devuelve el primer operando si el primer operando se evalúa como False y si se evalúa como True luego devuelve el segundo operando:

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

Del mismo modo para or pero al revés:

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

Sin embargo, si los usa en una if declaración el if también llamará implícitamente bool en el resultado. Entonces estos puntos más finos pueden no ser relevantes para usted.


4
2018-06-26 16:24



Uso de "y" en condicional. A menudo uso esto cuando importo en 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

0
2018-02-04 00:46



Una sola & (no doble &&) es suficiente o como la respuesta superior sugiere que puede usar 'y'. También encontré esto en pandas

cities['Is wide and has saint name'] = (cities['Population'] > 1000000) 
& cities['City name'].apply(lambda name: name.startswith('San'))

si reemplazamos el "&" con "y", no funcionará.


0
2018-03-03 00:39



tal vez con & en lugar de% es más rápido y mantener la legibilidad

otras pruebas par / impar

x es par? x% 2 == 0

x es impar? no x% 2 == 0

tal vez es más claro con bitwise y 1

x es impar? x y 1

x es par? no x y 1 (no es extraño)

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

-1
2017-08-24 13:21