Aici's codul meu:
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
Am'm obtinerea o eroare în CAZUL în care condiționată. Ce fac gresit?
Python folosește " și " și " sau " condiționale.
de exemplu
if foo == 'abc' and bar == 'bac' or zoo == '123':
# do something
Două comentarii:
nu'm obtinerea o eroare în CAZUL în care condiționată. Ce fac gresit?
Acolo motivul pentru care ai SyntaxErroreste că nu există nici
&&operator în Python. De asemenea,
| | și
!` sunt nu este valabil operatorii de Python.
Unii dintre operatorii știți din alte limbi au un nume diferit în Python.
Operatorii logici && " și "| |
sunt de fapt numite " și " și "sau".
De asemenea logic de negație operatorul !
este numit nu
.
Deci, ai putea scrie:
if len(a) % 2 == 0 and len(b) % 2 == 0:
sau chiar:
if not (len(a) % 2 or len(b) % 2):
M-am rezumat operatorul "echivalent" în acest tabel:
+------------------------------+---------------------+
| Operator (other languages) | Operator (Python) |
+==============================+=====================+
| && | and |
+------------------------------+---------------------+
| || | or |
+------------------------------+---------------------+
| ! | not |
+------------------------------+---------------------+
A se vedea, de asemenea, Piton documentație: 6.11. Operațiunile de booleene.
Pe lângă operatorii logici Python are, de asemenea, la nivel de bit/binar operatori:
+--------------------+--------------------+
| Logical operator | Bitwise operator |
+====================+====================+
| and | & |
+--------------------+--------------------+
| or | | |
+--------------------+--------------------+
Nu există nici o negare la nivel de bit în Python (doar la nivel de bit inversul operatorului ~
- dar asta este nu echivalent cu "nu").
A se vedea, de asemenea, 6.6. Unar aritmetică și la nivel de bit/binar operations și 6.7. Binar operații aritmetice.
Operatorii logici (ca și în multe alte limbi) au avantajul că acestea sunt scurt-circuitat. Asta înseamnă că, dacă primul operand deja definește rezultatul, apoi cel de-al doilea operator de e't evaluate la toate.
Pentru a arăta acest lucru am utilizat o funcție care pur și simplu are o valoare, se imprimă și se întoarce din nou. Acest lucru este la îndemână pentru a vedea ce este de fapt evaluate pentru a imprima declarații:
>>> def print_and_return(value):
... print(value)
... return value
>>> res = print_and_return(False) and print_and_return(True)
False
După cum puteți vedea doar o amprentă declarație este executat, astfel încât Python-am't se uite chiar și la dreptul de operand.
Acest lucru nu este cazul pentru binar operatori. Cei evalua întotdeauna ambii operanzi:
>>> res = print_and_return(False) & print_and_return(True);
False
True
Dar dacă primul operand este't suficient, atunci, desigur, cel de-al doilea operator este evaluat:
>>> res = print_and_return(True) and print_and_return(False);
True
False
Pentru a rezuma, aceasta de aici este un alt Tabel:
+-----------------+-------------------------+
| Expression | Right side evaluated? |
+=================+=========================+
| `True` and ... | Yes |
+-----------------+-------------------------+
| `False` and ... | No |
+-----------------+-------------------------+
| `True` or ... | No |
+-----------------+-------------------------+
| `False` or ... | Yes |
+-----------------+-------------------------+
Adevărat
și Fals
reprezintă ceea ce bool(partea stângă)
întoarce, ei nu't trebuie să fie "Adevărat" sau "Fals", au nevoie doar pentru a returna "True" sau "False" atunci când bool
este numit pe ele (1).
Deci, în Pseudo-Cod(!) "și" și " sau " funcții de lucru ca acestea:
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)
Rețineți că acest lucru este pseudo-cod cod Python. În Python nu puteți crea funcții numite " si " sau "sau", deoarece acestea sunt cuvinte cheie. De asemenea, niciodată nu ar trebui să utilizați "evaluarea" sau dacă bool(...)`.
Acest implicite bool
apel pot fi folosite pentru a personaliza modul în clase se comporte cu "și", " sau " și "nu".
Pentru a arăta cum pot fi personalizate eu folosesc această clasă care, din nou, `print ceva pentru a urmări ceea ce se întâmplă:
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)
Deci sa's vedem ce se întâmplă cu clasa în combinație cu acești 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)
Dacă tu nu't au o __bool__
metoda atunci Python verifică, de asemenea, în cazul în care obiectul are o __len__
metoda și dacă se întoarce o valoare mai mare decât zero.
Care ar putea fi util să știți în cazul în care creați o secvență container.
A se vedea, de asemenea, 4.1. Valoare de adevăr Testarea.
Probabil, un pic dincolo de domeniul de aplicare de întrebarea inițială, dar în cazul în care te're de-a face cu NumPy tablouri sau subclase (cum ar fi Panda Serie sau DataFrames), atunci implicit bool
sun
va ridica temut 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().
În aceste cazuri, aveți posibilitatea să utilizați logică și funcția de ** din NumPy care efectuează un element-înțelept " și "(sau, "sau"):
>>> 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])
Daca're de-a face doar cu boolean tablouri ai putea folosi, de asemenea, binar operatorii cu NumPy, aceste efectua element-înțelept (dar, de asemenea, binare) comparații:
>>> 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)
Că bool
apel la operanzi trebuie să se întoarcă Adevărat
sau Fals
e't complet corecte. L's doar primul operand, care trebuie să se întoarcă un boolean din it's __bool__
metoda:
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)
Ca's, pentru că " și "de fapt, se întoarce primul operand dacă primul operand are valoarea "False" și dacă se evaluează la "Adevărat", apoi se întoarce cel de-al doilea operand:
>>> x1
Test(10)
>>> x2
Test(False)
În mod similar pentru " sau " dar tocmai invers:
>>> Test(True) or Test(10)
Test(True)
>>> Test(False) or Test(10)
Test(10)
Cu toate acestea, dacă utilizați-le într-un "dacă" declarație "dacă" va, de asemenea, implicit apel `bool pe rezultat. Deci, aceste puncte fine nu pot fi relevante pentru tine.
Utilizați " și " și " sau " pentru a efectua operații logice ca în C, C++. Ca literalmente și
e &&
și sau
este ||
.
Dacă vrei să construiești Porți Logice în Python:
def AND(a,b):
return (a and b) #using and operator
def OR(a,b):
return (a or b) #using or operator
Acum incearca sa-i suni:
print AND(False, False)
print OR(True, False)
False
True
Sper că acest lucru vă ajută!
Probabil că acest lucru nu este cel mai bun cod pentru această sarcină, dar este de lucru -
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:]
Utilizarea "și" în condiționate. Eu folosesc de multe ori acest lucru atunci când importă în 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
O singur &
(nu dublu &&
) este suficient sau ca răspunsul de sus sugerează puteți utiliza 'si'.
De asemenea, am găsit asta în panda
cities['Is wide and has saint name'] = (cities['Population'] > 1000000)
& cities['City name'].apply(lambda name: name.startswith('San'))
dacă vom înlocui "&" cu "și", va't de lucru.
poate cu & în loc % este mult mai rapid și menținerea lizibilitate
alte teste/impar
x este chiar ? x % 2 == 0
x este impar ? nu x % 2 == 0
poate este mai clar, cu nivel de bit și 1
x este impar ? x & 1
x este chiar ? nu x & 1 (nu ciudat)
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