Python's setara && (logis-dan) dalam if-pernyataan

Berikut ini's my kode:

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

I'm mendapatkan kesalahan di IF conditional. Apa yang saya lakukan salah?

Stevoisiak
Pertanyaan edit 23 Mei 2018 в 7:50
Pemrograman
python if-statement keyword logical-operators and-operator
21 Maret 2010 в 1:23
54 tayangan
Mengomentari pertanyaan (9)
Larutan

Anda akan ingin dan bukan &&.

Komentar (6)

Python menggunakan dan dan atau conditional.

yaitu

if foo == 'abc' and bar == 'bac' or zoo == '123':
  # do something
detly
Jawaban edit 7 November 2013 в 3:15
Komentar (6)

Dua komentar:

  • Gunakan dan dan atau untuk operasi logis dalam Python.
  • Menggunakan 4 ruang untuk indent bukan 2. Anda akan terima sendiri nanti karena kode anda akan melihat cukup banyak yang sama seperti orang lain's code. Lihat PEP 8 untuk lebih jelasnya.
Komentar (0)

I'm mendapatkan kesalahan di IF conditional. Apa yang saya lakukan salah?

Ada alasan bahwa anda mendapatkan SyntaxError adalah bahwa tidak ada && operator pada Python. Demikian juga || dan ! adalah tidak berlaku Python operator.

Beberapa dari operator anda mungkin tahu dari bahasa lain memiliki nama yang berbeda di Python. Logical operator && dan || adalah benar-benar disebut and dan or. Demikian juga logis negasi operator ! disebut tidak.

Jadi anda hanya 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 akan berguna):

Saya diringkas operator "setara" di tabel ini:

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

Lihat juga Python dokumentasi: 6.11. Operasi Boolean.

Selain operator logika Python juga telah bitwise/operator biner:

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

Tidak ada bitwise negasi di Python (hanya bitwise invers operator ~ - tapi itu tidak **** setara dengan tidak).

Lihat juga 6.6. Unary aritmatika dan bitwise/biner operations dan 6.7. Biner operasi aritmatika.

Logical operator (seperti dalam banyak bahasa lainnya) memiliki keuntungan bahwa ini adalah hubung pendek. Itu berarti jika operan pertama sudah mendefinisikan hasil, maka kedua operator isn't dievaluasi pada semua.

Untuk menunjukkan hal ini saya menggunakan sebuah fungsi yang hanya mengambil nilai, cetakan dan kembali lagi. Hal ini berguna untuk melihat apa yang sebenarnya dievaluasi karena dari statement print:

>>> 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 mencetak satu pernyataan yang dijalankan, sehingga Python benar-benar tidak't bahkan melihat operan kanan.

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

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

Tapi jika operan pertama isn't cukup maka, tentu saja, kedua operator dievaluasi:

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

Untuk meringkas ini berikut ini adalah Tabel yang lain:

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

Benar dan Salah mewakili bool(kiri-sisi-sisi) kembali, mereka don't harus menjadi True atau False, mereka hanya perlu untuk mengembalikan True atau False ketika bool disebut pada mereka (1).

Jadi dalam Pseudo-Code(!) kata and dan or fungsi pekerjaan 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)

Catatan bahwa ini adalah pseudo-code tidak kode Python. Di Python anda tidak dapat membuat fungsi bernama dan atau atau karena ini adalah kata kunci. Anda juga harus menggunakan "mengevaluasi" atau jika bool(...).

Menyesuaikan perilaku anda sendiri kelas

Ini implisit bool call dapat digunakan untuk menyesuaikan bagaimana anda kelas berperilaku dengan dan, atau dan tidak.

Untuk menunjukkan bagaimana hal ini dapat disesuaikan aku menggunakan kelas ini yang lagi-lagi `mencetak sesuatu 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 let's melihat apa yang terjadi dengan kelas yang di kombinasi dengan operator-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 don't memiliki __bool__ metode kemudian Python juga memeriksa jika objek memiliki __len__ metode dan jika ia mengembalikan nilai yang lebih besar dari nol. Yang mungkin akan berguna untuk mengetahui dalam kasus anda membuat urutan wadah.

Lihat juga 4.1. Nilai kebenaran Pengujian.

NumPy array dan subclass

Mungkin sedikit di luar lingkup pertanyaan yang asli tapi dalam kasus anda're berurusan dengan array NumPy atau subclass (seperti Panda Seri atau DataFrames) maka implisit bool call akan menaikkan 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-bijak dan (atau atau):

>>> 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're berurusan hanya dengan boolean array anda juga bisa menggunakan operator biner dengan NumPy, ini tidak melakukan unsur-bijaksana (tapi juga biner) perbandingan:

>>> 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 bool panggilan pada operan telah mengembalikan True atau False isn't benar-benar benar. It's hanya operan pertama yang perlu untuk mengembalikan boolean dalam it's __bool__ metode:

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)

Yang's karena dan benar-benar kembali operan pertama jika operan pertama mengevaluasi untuk Palsu dan jika mengevaluasi ke Benar maka ia mengembalikan kedua operan:

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

Demikian pula untuk atau tapi justru sebaliknya:

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

Namun jika anda menggunakan mereka dalam sebuah jika pernyataan jika juga akan secara implisit menyebut bool pada hasil. Jadi, ini poin-poin penting yang mungkin tidak relevan untuk anda.

MSeifert
Jawaban edit 1 Juli 2018 в 10:19
Komentar (0)

Aku pergi dengan purlely matematika solusi:

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:]
Big Red
Jawaban edit 10 Juni 2014 в 7:27
Komentar (1)

Anda menggunakan dan dan atau untuk melakukan operasi logis seperti di C, C++. Seperti benar-benar dan adalah && dan atau ini ||.

Lihatlah ini menyenangkan contoh,

Katakan anda ingin membangun Gerbang Logika di Python: 

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

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

Sekarang mencoba memanggil mereka: 

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

Ini akan menampilkan:

False
True

Harap ini membantu!

MarianD
Jawaban edit 22 Juli 2017 в 8:43
Komentar (0)

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

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:]
bstpierre
Jawaban edit 25 Mei 2011 в 12:45
Komentar (0)

Gunakan "dan" dalam bersyarat. Saya sering menggunakan ini ketika mengimpor dalam 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
Komentar (1)

Single & (tidak double &&) sudah cukup atau sebagai jawaban atas menunjukkan anda dapat 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't bekerja.

AlessioX
Jawaban edit 3 Maret 2018 в 12:24
Komentar (1)

mungkin dengan & bukannya % lebih cepat dan menjaga readibility

tes-tes lain bahkan/ganjil

x ini bahkan ? x % 2 == 0

x adalah ganjil ? tidak x % 2 == 0

mungkin lebih jelas dengan bitwise dan 1

x adalah ganjil ? x & 1

x ini bahkan ? tidak x & 1 (tidak ganjil)

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
Komentar (0)