equivalente del pitón de && (lógico-y) en una sentencia if

Question

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 SI condicional. ¿Qué estoy haciendo mal?

Answer 1

Usted quiere and en lugar de &&.

Answer 2

Python usa and y or condicionales.

es decir.

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

Answer 3

Dos observaciones:

• Uso and y or para las operaciones lógicas en Python.
• Use 4 espacios para sangrar en lugar de 2. Se le agradecerá más adelante debido a que su código será más o menos el mismo que el código de todos los demás. Ver PEP 8 para más detalles.

Answer 4

  

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

Hay razón por la que se obtiene una SyntaxError es que no hay ningún operador && en Python. Asimismo || y ! son operadores no válidos Python.

Algunos de los operadores que se sepa desde otros lenguajes tienen un nombre diferente en Python. La operadores && y || lógica se llama en realidad and y or. Asimismo, el ! operador de negación lógica se llama not.

Por lo que sólo podría escribir:

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

o incluso:

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

Algunas informaciones adicionales (que podría ser útil):

resumí el operador "equivalentes" en esta tabla:

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

Vea también la documentación Python: 6.11. Las operaciones booleanas .

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

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

No hay negación bit a bit en Python (sólo el ~ operador bit a bit inversa - pero eso es no equivalente a not).

6.6. aritmética unario y operaciones bit a bit / binarios y 6.7. operaciones aritméticas binarias .

Los operadores lógicos (como en muchos otros idiomas) tienen la ventaja de que éstas se ponen en cortocircuito. Esto significa que si el primer operando ya define el resultado, entonces el segundo operador no es evaluada en absoluto.

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

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

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

Como se puede ver sólo se ejecuta una instrucción de impresión, lo que Python realmente ni siquiera mira el operando de la derecha.

Este no es el caso para los operadores binarios. Los que siempre se evalúan los dos 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í es otra tabla:

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

El True y False representar lo bool(left-hand-side) rendimientos, que no tienen que ser True o False, que sólo hay que volver True o False cuando bool se llama en ellos (1).

Así que en pseudo-código y las funciones and or funcionan como estos (!):

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 pseudo-código no código Python. En Python no puede crear funciones llamadas and o or porque estas son palabras clave. Además nunca se debe utilizar "evaluar" o if bool(...).

Personalización del comportamiento de sus propias clases

Esta llamada bool implícita se puede utilizar para personalizar la forma en sus clases se comportan con and, or y not.

Para mostrar cómo se puede modificar para requisitos particulares que utilizo esta clase que a su vez prints algo para realizar un seguimiento de 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)

Así que vamos a ver qué pasa 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 usted no tiene un método __bool__ continuación, Python también comprueba si el objeto tiene un método __len__ y si devuelve un valor mayor que cero. Eso podría ser útil saber en caso de que se crea un contenedor de secuencias.

Ver también 4.1. La verdad Prueba Valor .

NumPy arrays y subclases

Probablemente un poco más allá del alcance de la pregunta original, pero en caso de que usted está tratando con matrices NumPy o subclases (como la serie o de tramas de datos pandas) entonces la llamada implícita bool elevará el ValueError temida:

>>> 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 se puede utilizar la lógica y la función de NumPy que realiza una and elemento a elemento (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 simplemente con matrices booleanas también se puede utilizar los operadores binarios con NumPy, éstos realizan comparaciones elemento a elemento (pero también binario):

>>> 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 la llamada bool de los operandos tiene que volver True o False no es del todo correcta. Es sólo el primer operando que tiene que devolver un valor lógico en el mismo método de __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)

Esto se debe a and realidad devuelve el primer operando si el primer operando se evalúa como False y si se evalúa como True entonces se devuelve el segundo operando:

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

Del mismo modo para or pero justo al revés:

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

Sin embargo, si se utilizan en una declaración if la if también llamará implícitamente bool en el resultado. Por lo que estos puntos más finos pueden no ser relevantes para usted.

Answer 5

Me fui con una solución matemática purlely:

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:]

Answer 6

Se utiliza and y or para realizar operaciones lógicas como en C, C ++. Al igual que literalmente and es && y or es || .

---

Echa un vistazo a este divertido ejemplo,

Digamos que quiere construir puertas lógicas 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 intente llamar:

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

Esta es la salida:

False
True

Espero que esto ayude!

Answer 7

Probablemente esto no es el mejor código para esta tarea, pero está trabajando -

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:]

Answer 8

En una "instrucción If" en Python que usaría y, o, no y estos son equivalentes a &&, ||,! los operadores lógicos que se utilizan en otros lenguajes de programación

Answer 9

El uso de "y" en condicional. A menudo utilizo este al importar 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

Answer 10

Una sola & (no doble &&) es suficiente o como la respuesta más común sugiere que se puede utilizar '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 sustituimos el "&" por "y", no va a funcionar.

Answer 11

y quizás con su lugar% es más rápido y MANTENER 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 el nivel de bits y 1

x es impar? x y 1

x es par? no x y 1 (no impar)

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