λ΄ μ½λλ λ€μκ³Ό κ°μ΅λλ€.
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
μνν©λλ€. λ§ κ·Έλλ‘ and
is &&
and or
is||
μ
λλ€.
μ΄ μ¬λ―Έμλ μλ₯Ό μ΄ν΄λ³΄μμμ€.
νμ΄μ¬μμ λ‘μ§ κ²μ΄νΈλ₯Ό λ§λ€κ³ μΆλ€κ³ κ°μ ν΄λ³΄μμμ€.
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:]