significa - sentencias en python

El equivalente de Python 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

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

Answer 1

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

La razón por la que obtiene un SyntaxError es que no hay un operador && en Python. Igualmente || y ! No son operadores Python válidos .

Algunos de los operadores que conoces de otros idiomas tienen un nombre diferente en Python. Los operadores lógicos && y || En realidad se llaman yy or . Igualmente el operador lógico de negación ! Se llama not .

Así que 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 |
+------------------------------+---------------------+

Véase también la documentación de Python: 6.11. Operaciones booleanas .

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

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

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

Ver también 6.6. Aritmética unaria y operaciones bitwise / binarias y 6.7. Operaciones aritméticas binarias .

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

Para mostrar esto, uso una función que simplemente toma un valor, lo imprime y lo devuelve de nuevo. Esto es útil para ver qué se evalúa realmente 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 se puede ver, solo se ejecuta una instrucción de impresión, por lo que Python ni siquiera miró el operando correcto.

Este no es el caso de los operadores binarios. Los que 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 al 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 |
+-----------------+-------------------------+

El True y el False representan lo que devuelve bool(left-hand-side) , no tienen que ser True o False , solo necesitan devolver True o False cuando se les llama a bool (1).

Así que en Pseudo-Code (!), Las funciones and y or 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 este es un pseudocódigo, no un código de Python. En Python no puede crear funciones llamadas or porque estas son palabras clave. Además, nunca debes usar "evaluar" o if bool(...) .

Personalizando el comportamiento de tus propias clases.

Esta llamada bool implícita se puede usar para personalizar cómo se comportan tus clases con and , or not .

Para mostrar cómo se puede personalizar, utilizo esta clase que, de nuevo, print 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)

Así que veamos 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 no tiene un método __bool__ , Python también verifica si el objeto tiene un método __len__ 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. Prueba de valor de verdad .

NumPy matrices y subclases

Probablemente un poco más allá del alcance de la pregunta original, pero en caso de que estés tratando con arrays o subclases NumPy (como Pandas Series o DataFrames), entonces la llamada bool implícita elevará 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 función lógica y de NumPy que realiza un elemento 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á tratando solo con matrices booleanas , también podría usar los operadores binarios con NumPy, estos realizan comparaciones de elementos (pero también binarias):

>>> 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 en los operandos tenga que devolver True o False no es completamente correcto. Es solo el primer operando que necesita devolver un booleano en su método __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 que, de hecho, devuelve el primer operando si el primer operando se evalúa como False y si se evalúa como True , 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 declaración if , if también llamará implícitamente a bool en el resultado. Por lo tanto, estos puntos más finos pueden no ser relevantes para usted.

Answer 2

Dos comentarios:

• Utilice and or para operaciones lógicas en Python.
• Usa 4 espacios para sangrar en lugar de 2. Te lo 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.

Answer 3

Fui con una solución puramente 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:]

Answer 4

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

Answer 5

Python usa yy condicionales.

es decir

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

Answer 6

Un solo & (no doble && ) es suficiente o como la respuesta principal sugiere que puede usar ''y''. También encontré esto en los 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á.

Answer 7

Uso de "y" en condicional. A menudo utilizo esto 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 8

Usted querría and lugar de && .

Answer 9

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

Echa un vistazo a este divertido ejemplo,

Digamos que quieres 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 trata de llamarlos:

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

Esto dará como resultado:

False
True

¡Espero que esto ayude!

Answer 10

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

otras pruebas par / impar

x es par? x% 2 == 0

x es impar? no x% 2 == 0

Tal vez sea más claro con bitwise y 1

x es impar? x & 1

x es par? no x & 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