Ini kode saya:

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

Saya mendapatkan kesalahan dalam kondisi IF .
Apa yang saya lakukan salah?

Anda ingin andbukan &&.

Penggunaan anddan orkondisi Python .

yaitu

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

Saya mendapatkan kesalahan dalam kondisi IF. Apa yang saya lakukan salah?

Ada alasan yang Anda dapatkan SyntaxErroradalah bahwa tidak ada &&operator di Python. Demikian juga ||dan !yang tidak sah operator Python.

Beberapa operator yang mungkin Anda kenal dari bahasa lain memiliki nama yang berbeda dengan Python. Operator logis &&dan ||sebenarnya dipanggil anddan or. Demikian juga operator negasi logis !disebut not.

Jadi Anda bisa menulis:

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

atau bahkan:

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

Beberapa informasi tambahan (yang mungkin berguna):

Saya meringkas "ekivalen" operator dalam tabel ini:

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

Lihat juga dokumentasi Python: 6.11. Operasi Boolean .

Selain operator logis, Python juga memiliki operator bitwise / biner:

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

Tidak ada negasi bitwise dalam Python (hanya operator bitwise terbalik ~- tapi itu tidak setara dengan not).

Lihat juga 6.6. Hitung aritmatika dan operasi bitwise / biner dan 6.7. Operasi aritmatika biner .

Operator logis (seperti dalam banyak bahasa lain) memiliki keuntungan bahwa ini hubung singkat. Itu berarti jika operan pertama sudah menentukan hasilnya, maka operator kedua tidak dievaluasi sama sekali.

Untuk menunjukkan ini saya menggunakan fungsi yang hanya mengambil nilai, mencetaknya dan mengembalikannya lagi. Ini berguna untuk melihat apa yang sebenarnya dievaluasi karena pernyataan cetak:

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

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

Seperti yang Anda lihat, hanya satu pernyataan cetak yang dijalankan, jadi Python benar-benar tidak melihat operan yang tepat.

Ini bukan kasus untuk operator biner. Mereka selalu mengevaluasi kedua operan:

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

Tetapi jika operan pertama tidak cukup maka, tentu saja, operator kedua dievaluasi:

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

Untuk meringkas ini di sini adalah Tabel lain:

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

The Truedan Falsemewakili apa bool(left-hand-side)kembali, mereka tidak harus menjadi Trueatau False, mereka hanya perlu kembali Trueatau Falseketika booldipanggil pada mereka (1).

Jadi dalam Pseudo-Code (!) andDan orfungsinya bekerja seperti ini:

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)

Perhatikan bahwa ini adalah pseudo-code bukan kode Python. Dalam Python Anda tidak dapat membuat fungsi yang disebut andatau orkarena ini adalah kata kunci. Anda juga tidak boleh menggunakan "evaluasi" atau if bool(...).

Menyesuaikan perilaku kelas Anda sendiri

boolPanggilan implisit ini dapat digunakan untuk menyesuaikan bagaimana perilaku kelas Anda and, ordan not.

Untuk menunjukkan bagaimana ini dapat dikustomisasi, saya menggunakan kelas ini yang lagi-lagi printsesuatu untuk melacak apa yang terjadi:

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)

Jadi mari kita lihat apa yang terjadi dengan kelas itu dalam kombinasi dengan operator ini:

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

Jika Anda tidak memiliki __bool__metode maka Python juga memeriksa apakah objek memiliki __len__metode dan jika itu mengembalikan nilai lebih besar dari nol. Itu mungkin berguna untuk diketahui jika Anda membuat wadah urutan.

Lihat juga 4.1. Pengujian Nilai Kebenaran .

Array dan subkelas NumPy

Mungkin sedikit di luar ruang lingkup pertanyaan asli tetapi jika Anda berurusan dengan array atau subkelas NumPy (seperti Pandas Series atau DataFrames) maka boolpanggilan implisit akan meningkatkan yang ditakuti 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().

Dalam kasus ini Anda dapat menggunakan logis dan fungsi dari NumPy yang melakukan unsur-bijaksana and(atau 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])

Jika Anda hanya berurusan dengan boolean array Anda juga bisa menggunakan operator biner dengan NumPy, ini memang melakukan perbandingan elemen-bijaksana (tetapi juga biner):

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

Bahwa boolpanggilan pada operan harus kembali Trueatau Falsetidak sepenuhnya benar. Ini hanya operan pertama yang perlu mengembalikan boolean dalam __bool__metode itu:

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)

Itu karena andsebenarnya mengembalikan operan pertama jika operan pertama mengevaluasi Falsedan jika mengevaluasi Truemaka mengembalikan operan kedua:

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

Demikian pula untuk ortetapi sebaliknya:

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

Namun, jika Anda menggunakannya dalam sebuah ifpernyataan, ifmaka secara implisit juga akan memanggil boolhasilnya. Jadi poin yang lebih baik ini mungkin tidak relevan untuk Anda.

Dua komentar:

• Gunakan anddan oruntuk operasi logis dengan Python.
• Gunakan 4 spasi untuk indentasi alih-alih 2. Anda akan berterima kasih pada diri sendiri nanti karena kode Anda akan terlihat hampir sama dengan kode orang lain. Lihat PEP 8 untuk lebih jelasnya.

Anda menggunakan anddanor untuk melakukan operasi logis seperti di C, C ++. Seperti secara harfiah andadalah &&dan orsekarang|| .

Lihatlah contoh yang menyenangkan ini,

Katakanlah Anda ingin membangun Logic Gates dengan Python:

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

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

Sekarang coba panggil mereka:

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

Ini akan menampilkan:

False
True

Semoga ini membantu!

Saya menggunakan solusi matematika murni:

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

Mungkin ini bukan kode terbaik untuk tugas ini, tetapi berfungsi -

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

Satu &(bukan ganda &&) sudah cukup atau seperti jawaban teratas menyarankan Anda bisa menggunakan 'dan'. Saya juga menemukan ini di panda

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

jika kita mengganti "&" dengan "dan", itu tidak akan berfungsi.

mungkin dengan & bukannya% lebih cepat dan menjaga kesiapan

tes lain genap / ganjil

x genap? x% 2 == 0

x aneh? bukan x% 2 == 0

mungkin lebih jelas dengan bitwise dan 1

x aneh? x & 1

x genap? bukan x & 1 (tidak aneh)

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

Penggunaan "dan" dalam kondisi. Saya sering menggunakan ini ketika mengimpor di 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