Python's echivalente de && (logic-și) în cazul în care o declarație

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?

Stevoisiak
Întrebarea editată 23 mai 2018 в 7:50
Programare
python if-statement keyword logical-operators and-operator
21 martie 2010 в 1:23
10 vizualizări
Comentarii la întrebare (9)
Soluția

Ce-ar vrea " și " în loc de &&.

Comentarii (6)

Python folosește " și " și " sau " condiționale.

de exemplu

if foo == 'abc' and bar == 'bac' or zoo == '123':
  # do something
detly
Răspuns editat 7 noiembrie 2013 в 3:15
Comentarii (6)

Două comentarii:

  • Utilizați " și " și " sau " pentru operațiuni logice în Python.
  • Utilizarea 4 spații pentru liniuță în loc de 2. Te va mulțumi mai târziu pentru că codul va arata cam la fel ca oricine altcineva's cod. A se vedea PEP 8 pentru mai multe detalii.
Comentarii (0)

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

Unele informații suplimentare (care ar putea veni la îndemână):

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(...)`.

Personalizarea comportamentului propriile clase

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.

NumPy tablouri și subclase

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.

MSeifert
Răspuns editat 1 iulie 2018 в 10:19
Comentarii (0)

M-am dus cu un purlely matematică soluție:

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
Răspuns editat 10 iunie 2014 в 7:27
Comentarii (1)

Utilizați " și " și " sau " pentru a efectua operații logice ca în C, C++. Ca literalmente și e && și sau este ||.

Să ia o privire la acest joc distractiv de exemplu,

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)

Acest lucru va genera:

False
True

Sper că acest lucru vă ajută!

MarianD
Răspuns editat 22 iulie 2017 в 8:43
Comentarii (0)

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:]
bstpierre
Răspuns editat 25 mai 2011 в 12:45
Comentarii (0)

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
Comentarii (1)

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.

AlessioX
Răspuns editat 3 martie 2018 в 12:24
Comentarii (1)

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