Setara dengan Python && (logis-dan) dalam pernyataan if


830

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?


10
Jelas Sergio ingin tahu mengapa kodenya rusak, tetapi saya membaca sedikit lebih banyak pada judul pertanyaan. Kenapa tidak && tersedia? == dan! = tersedia (tetapi berbeda dari ini dan tidak, saya tahu). Mengapa tidak menyertakan sintaks ini? Pilihan Pribadi?
physicsmichael

5
@ vgm64: Mengapa menyertakan sintaks berlebihan yang tidak meningkatkan satu aspek?
Konrad Rudolph

27
Tampak bagi saya bahwa penerjemah harus, daripada mencetak crytic "SyntaxError: invalid syntax" - mendeteksi bahwa pengguna telah menggunakan &&dan menyarankan kepada mereka bahwa mereka mungkin ingin menggunakan kata kunci andsebagai gantinya. Hal yang sama berlaku untuk hal-hal seperti ++dan operator umum lainnya dari bahasa lain.
ArtOfWarfare

3
@physicsmichael "harus ada satu, dan lebih disukai hanya satu, cara yang jelas untuk melakukannya." import this
Nick T

3
@KonradRudolph Ini benar-benar meningkatkan aspek bahasa. Ini lebih konsisten dan intuitif untuk siapa saja yang pernah menggunakan bahasa lain. fakta bahwa pertanyaan ini ada dan memiliki lalu lintas sebanyak yang jelas menyoroti masalah ini sebagai titik bertahan umum bagi orang-orang.
jterm

Jawaban:


1473

Anda ingin andbukan &&.


2
apa yang harus saya lakukan untuk ini: jika x == 'n' dan y == 'a' atau y == 'b': <lakukan sesuatu> Apakah itu akan berhasil!? @ChristopheD
diffracteD

7
@diffracteD: Gunakan tanda kurung jika Anda ingin menimpa prioritas operator standar (yang dapat Anda pelajari di sini: ibiblio.org/g2swap/byteofpython/read/operator-precedence.html )
ChristopheD

3
Saya suka bahwa David Titarenco memberikan cut-n-paste contoh
Alexx Roche

7
Saya tiba di sini setelah saya mengetik keduanya &&dan ANDmendapat kesalahan (tidak mengharapkan python ingin kata kecil and).
Xeoncross

2
Saya pikir Anda harus menggunakan & Lihat: stackoverflow.com/questions/36921951/…
user1761806

229

Penggunaan anddan orkondisi Python .

yaitu

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

5
Jangan lupa bahwa python juga belum (well, and!)
inspectorG4dget

9
Apakah contoh Anda mengevaluasi ke "(jika ini dan ini) atau itu" ATAU "jika ini dan (ini atau itu)"?
Jeff

12
@ Jeff, Cara pertama Anda. and memiliki prioritas lebih tinggi daripada or.
Buge

1
@ Besar sepertinya "atau" lebih tinggi di tabel yang Anda tautkan
Matt

5
@Matt tabel berubah dari prioritas terendah ke tertinggi. Lebih mudah untuk mengingat prioritasnya jika Anda telah mempelajari aljabar boolean; "atau" adalah tambahan dan "dan" adalah multiplikasi.
Michael Stroud

48

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.


36

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.

10

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!


9

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

7
Ini bukan jawaban untuk pertanyaan aktual.
Matius Baca

5

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

-3

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.


1
Tunggal & tidak akan membuat hubungan pendek ekspresi (yang berarti keduanya akan dievaluasi terlepas dari nilai pengembalian ekspresi pertama)
user528025

-4

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

-4

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

14
Pertanyaan ini ditanyakan dan dijawab hampir 7 tahun yang lalu. Apa jawaban Anda tambahkan ke jawaban yang sudah ada di sini? Secara umum, kecuali Anda memiliki sesuatu yang mengejutkan baru untuk dikatakan, Anda tidak boleh menambahkan jawaban baru ke pertanyaan lama - di mana yang lama diukur beberapa tahun - ketika ada jawaban yang baik sudah tersedia.
Jonathan Leffler
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.