O equivalente de & & & (lógico-e) em Python numa declaração de fi
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
estou a ter um erro no SE condicional.
O que estou a fazer de errado?
10 answers
Você iria querer {[[0]} em vez de &&
.
O Python usa as condições and
e or
.
I. e.
if foo == 'abc' and bar == 'bac' or zoo == '123':
# do something
Estou a ter um erro no condicional IF. O que estou a fazer de errado?
Há uma razão para se ter um SyntaxError
é que não há nenhum operador &&
em Python. Do mesmo modo ||
e !
Não são operadores de Python válidos.
Alguns dos operadores que você pode conhecer de outras línguas têm um nome diferente em Python.
Os operadores lógicos &&
e ||
são realmente chamados and
e or
.
Da mesma forma, o operador de negação lógica !
é chamada not
if len(a) % 2 == 0 and len(b) % 2 == 0:
Ou mesmo:
if not (len(a) % 2 or len(b) % 2):
Algumas informações adicionais (que podem vir a ser úteis):
Resumi os "equivalentes" do operador nesta tabela:
+------------------------------+---------------------+
| Operator (other languages) | Operator (Python) |
+==============================+=====================+
| && | and |
+------------------------------+---------------------+
| || | or |
+------------------------------+---------------------+
| ! | not |
+------------------------------+---------------------+
Ver também documentação em Python: 6.11. Operações booleanas .
Além dos operadores lógicos Python também tem operadores binários / binários:
+--------------------+--------------------+
| Logical operator | Bitwise operator |
+====================+====================+
| and | & |
+--------------------+--------------------+
| or | | |
+--------------------+--------------------+
Não existe uma negação bitwise em Python (apenas o operador inverso bitwise ~
- mas isso é não equivalente a not
).
Ver também 6. 6. Aritmética unária e operações binárias/Binárias e 6, 7. Operações aritméticas Binárias.
Os operadores lógicos (como em muitas outras línguas) têm a vantagem de que estes são curto-circuitos. Isso significa que se o primeiro operando já define o resultado, então o segundo operador não é avaliado de todo.
Para mostrar isto eu uso uma função que simplesmente tem um valor, imprime - o e devolve-o outra vez. Isto é útil para ver o que é realmente avaliado devido às declarações de impressão:
>>> def print_and_return(value):
... print(value)
... return value
>>> res = print_and_return(False) and print_and_return(True)
False
Como você pode ver apenas uma declaração de impressão é executada, então Python realmente nem olhou para o operando direito.
Este não é o caso dos operadores binários. Aqueles sempre avaliam ambos os operandos:
>>> res = print_and_return(False) & print_and_return(True);
False
True
Mas se o primeiro operando não for suficiente, então, é claro, o segundo operador é avaliado:
>>> res = print_and_return(True) and print_and_return(False);
True
False
Para resumir, isto é ... outro quadro:
+-----------------+-------------------------+
| Expression | Right side evaluated? |
+=================+=========================+
| `True` and ... | Yes |
+-----------------+-------------------------+
| `False` and ... | No |
+-----------------+-------------------------+
| `True` or ... | No |
+-----------------+-------------------------+
| `False` or ... | Yes |
+-----------------+-------------------------+
A True
e False
representam o que bool(left-hand-side)
retorna, eles não têm que ser True
ou False
, eles só precisam de retorno True
ou False
quando bool
é chamado de no-los (1).
So in Pseudo-Code (!) as funções and
e or
funcionam assim:
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)
Note que isto é um pseudo-código e não um código Python. Em Python você não pode criar funções chamadas and
ou or
porque estas são palavras-chave.
Também você nunca deve usar "avaliar" ou if bool(...)
.
Esta chamada implícita bool
pode ser usada para personalizar a forma como as suas classes se comportam com and
, or
e not
Para mostrar como isto pode ser personalizado eu uso Esta classe que novamente print
é algo para rastrear o que está acontecendo:
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)
Então vamos ver o que acontece com essa classe em combinação com estes 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)
Se não tiver um método __bool__
, então o Python também verifica se o object has a __len__
method and if it returns a value greater than zero.
Isso pode ser útil para saber no caso de criar um recipiente de sequência.
Ver também 4. 1. Teste Do Valor Da Verdade.
Matrizes e subclasses NumPyProvavelmente um pouco além do âmbito da pergunta original, mas no caso de estar a lidar com matrizes NumPy ou subclasses (como séries Pandas ou DataFrames), então a chamada implícita bool
vai levantar o 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().
Em estes casos você pode usar a função lógica e de NumPy que executa um elemento sábio and
(ou 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 você está lidando apenas com arrays booleanos você também poderia usar os operadores binários com NumPy, estes realizam comparações de elemento-sábio (mas também binário):
>>> 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 a chamada para os operandos tem de voltar True
ou False
não está completamente correcta. É só a primeira operação que precisa de devolver um booleano no seu 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)
Porque and
devolve realmente o primeiro operando se o primeiro operando for avaliado em False
e se for avaliado em True
Então devolve o segundo operando:
>>> x1
Test(10)
>>> x2
Test(False)
Da mesma forma para {[24] } mas ao contrário:
>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)
No entanto, se os usar numa declaração if
, o if
também implicitamente chamará bool
sobre o resultado. Por isso, estes pontos mais finos podem não ser relevantes para si.
Duas observações:
- usar
and
eor
para Operações lógicas em Python. - utilize 4 espaços para indentar em vez de 2. Você vai agradecer a si mesmo mais tarde, porque o seu código vai ser praticamente o mesmo que o código de todos os outros. Ver PEP 8 para mais detalhes.
and
e or
para realizar operações lógicas como em C, C++. Literalmente and
o &&
e or
é ||
.
Olha para este exemplo divertido.
diz que queres construir portas lógicas em Python:
def AND(a,b):
return (a and b) #using and operator
def OR(a,b):
return (a or b) #using or operator
Agora tenta ligar - lhes.
print AND(False, False)
print OR(True, False)
Isto irá resultar:
False
True
espero que isto ajude!
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:]
Provavelmente este não é o melhor código para esta tarefa, mas está a funcionar -
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:]
Talvez com & em vez de % é mais rápido e a readibilidade Manta
Outros testes par / ímpar
X está empatado ? x % 2 == 0 X é estranho ? Não x % 2 == 0Talvez seja mais claro com bitwise e 1
X é estranho ? x & 1 X está empatado ? not x & 1 (not odd)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
Uso condicional de" e". Uso isto muitas vezes na importação no caderno de Jupyter:
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
Um único &
(não duplo &&
) é suficiente ou como a resposta de cima sugere que você pode usar 'e'.
Também encontrei isto em pandas.
cities['Is wide and has saint name'] = (cities['Population'] > 1000000)
& cities['City name'].apply(lambda name: name.startswith('San'))
Se substituirmos o " & " por "e", não vai funcionar.