내 코드는 다음과 같습니다.

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

IF 조건부 에서 오류가 발생했습니다 .
내가 무엇을 잘못하고 있지?

and대신에 원할 것입니다 &&.

파이썬은 사용 and및 or조건문.

즉

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

IF 조건부에서 오류가 발생했습니다. 내가 무엇을 잘못하고 있지?

당신이 얻을이 이유는 SyntaxError전혀 없다는 것입니다 &&파이썬에서 연산자. 마찬가지로|| 하고 !있는 유효하지 파이썬 연산자.

다른 언어에서 알 수있는 일부 연산자는 Python에서 다른 이름을 갖습니다. 논리 연산자 &&이며 ||실제로는and 하고 or. 마찬가지로 논리 부정 연산자 !를 호출 not합니다.

그래서 당신은 쓸 수 있습니다 :

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

또는:

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

몇 가지 추가 정보 (유용 할 수 있음) :

이 표에서 연산자 "등가"를 요약했습니다.

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

또한보십시오 Python 문서 6.11 . 부울 연산 .

논리 연산자 외에도 파이썬에는 비트 / 이진 연산자가 있습니다.

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

파이썬에는 비트 단위의 부정이 없습니다 (비트 단위의 역 연산자입니다 ~. 그러나 이는 동등 하지 않습니다not ).

6.6 도 참조하십시오 . 단항 산술 및 비트 / 이진 연산 및 6.7. 이진 산술 연산 .

논리 연산자 (다른 많은 언어에서와 같이)는 단락되어 있다는 장점이 있습니다. 즉, 첫 번째 피연산자가 이미 결과를 정의하면 두 번째 연산자는 전혀 평가되지 않습니다.

이것을 보여주기 위해 단순히 값을 가져 와서 인쇄하고 다시 반환하는 함수를 사용합니다. 이것은 인쇄 문으로 인해 실제로 평가되는 것을 보는 데 편리합니다.

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

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

보시다시피 하나의 print 문만 실행되므로 Python은 실제로 올바른 피연산자를 보지 못했습니다.

이진 연산자의 경우에는 해당되지 않습니다. 이들은 항상 두 피연산자를 모두 평가합니다.

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

그러나 첫 번째 피연산자가 충분하지 않은 경우 물론 두 번째 연산자가 평가됩니다.

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

이것을 요약하면 다른 테이블이 있습니다.

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

True과 False어떤 표현 bool(left-hand-side), 그들이 될 필요가 없습니다 반환 True또는 False그들은 단지 반환해야, True또는 False경우에 bool그 (1) 호출됩니다.

Pseudo-Code (!)에서 and및 or함수는 다음과 같이 작동합니다.

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)

이것은 파이썬 코드가 아닌 의사 코드입니다. 파이썬에서는 호출 된 and또는 or키워드이기 때문에 함수를 작성할 수 없습니다 . 또한 "평가"또는을 사용해서는 안됩니다 if bool(...).

자신의 클래스의 동작 사용자 정의

이 암시 적 bool호출은 클래스와 함께 행동하는 방법을 사용자 정의 할 수 있습니다 and, or하고 not.

이것이 어떻게 커스터마이징 될 수 있는지 보여주기 위해이 클래스를 사용하여 다시 print일어나고있는 일을 추적합니다.

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)

따라서 다음 연산자와 함께 해당 클래스에서 어떤 일이 발생하는지 봅시다.

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

__bool__메소드 가 없으면 Python은 객체에 __len__메소드 가 있는지 여부 와 0보다 큰 값을 반환하는지 확인합니다. 시퀀스 컨테이너를 만드는 경우에 유용 할 수 있습니다.

4.1 도 참조하십시오 . 진실 가치 테스트 .

NumPy 배열과 서브 클래스

아마도 원래 질문의 범위를 약간 벗어나지 만 NumPy 배열 또는 하위 클래스 (예 : Pandas Series 또는 DataFrames)를 처리하는 경우 암시 적 bool호출은 두려워합니다 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().

이 경우 NumPy 의 논리 및 기능 을 사용하여 요소 단위 and(또는 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])

부울 배열 을 다루는 경우 NumPy와 함께 이진 연산자를 사용할 수도 있습니다.이 연산자는 요소 별 (이진) 비교를 수행합니다.

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

bool피연산자에 대한 호출이 반환 True되거나 False완전히 정확하지 않아야합니다. 메소드에서 부울을 리턴해야하는 첫 번째 피연산자입니다 __bool__.

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)

그 때문에 and실제로 첫 번째 피연산자를 반환하는 경우에 첫 번째 피연산자들을 평가 False하고 평가되면 True다음은 두 번째 피연산자를 반환

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

마찬가지로 or다른 방법으로 :

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

그러나 if문장에서 그것들을 사용 하면 결과 if도 암시 적으로 호출 bool합니다. 따라서 이러한 미세한 점은 귀하와 관련이 없을 수 있습니다.

두 의견 :

• 파이썬에서 논리 연산을 사용 and하고 사용합니다 or.
• 2 대신에 들여 쓰기에 4 개의 공백을 사용하십시오. 코드는 다른 사람의 코드와 거의 동일하게 보이기 때문에 나중에 감사 할 것입니다. 자세한 내용은 PEP 8 을 참조하십시오.

C, C ++에서와 같이 논리 연산을 사용 and하고or 수행합니다. 말 그대로 andis &&and oris|| 입니다.

이 재미있는 예를 살펴보십시오.

파이썬에서 로직 게이트를 만들고 싶다고 가정 해보십시오.

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

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

이제 전화 해보십시오.

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

출력됩니다 :

False
True

도움이 되었기를 바랍니다!

나는 순전히 수학적인 해결책으로 갔다.

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

아마도 이것은이 작업에 가장 적합한 코드는 아니지만 작동하고 있습니다.

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

단일 &(double이 &&아님)이면 충분하거나 최상위 답변에서 'and'를 사용할 수 있다고 제안합니다. 나는 또한 판다에서 이것을 발견했다.

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

"&"를 "and"로 바꾸면 작동하지 않습니다.

아마도 & 대신 %는 더 빠르며 가독성이 높습니다.

다른 테스트도 / 홀수

x는 짝수? x % 2 == 0

x가 홀수? x % 2 아님 == 0

아마도 비트 단위로 더 명확하고 1

x가 홀수? x & 1

x는 짝수? x & 1이 아님 (홀수 아님)

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

조건부로 "and"사용. 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