NUMPY 기초 문법 정리5_배열 연산

• NumPy의 배열 연산은 벡터화(vectorized) 연산을 사용
  • vectorized연산이란?
    단순히 배열에 대한 연산을 하려면 원래 요소들을 모두 꺼내서 반복문 등으로 연산해야하는데, 넘파이는 기본적으로 vectorized연산을 사용하기 때문에 여기에 대해서 각 요소들이 벡터연산으로 빠르게 연산할 수 있다.
• 일반적으로 NumPy의 범용 함수(universal functions)를 통해 구현
• 배열 요소에 대한 반복적인 계산을 효율적으로 수행

 

브로드캐스팅(Broadcasting)

 

산술 연산(Arithmetic Operators)

연산자	범용 함수	설명
+	np.add	덧셈
-	np.subtract	뺄셈
-	np.negative	단항 음수
*	np.multiply	곱셈
/	np.divide	나눗셈
//	np.floor_divide	나눗셈 내림
**	np.power	지수 연산
%	np.mod	나머지 연산

               

코드

a1 = np.arange(1, 10)
print("\na1\n", a1)
print("\na1 + 1\n", a1 + 1)
print("\nnp.add(a1, 10)\n", np.add(a1, 10))
print("\na1 - 2\n", a1 - 2)
print("\nnp.subtract(a1, 10)\n", np.subtract(a1, 10))
print("\n-a1\n", -a1)
print("\nnp.negative(a1)\n", np.negative(a1))
print("\na1 * 2\n", a1 * 2)
print("\nnp.multiply(a1, 2)\n", np.multiply(a1, 2))
print("\na1 / 2\n", a1 / 2)
print("\nnp.divide(a1, 2)\n", np.divide(a1, 2))
print("\na1 // 2\n", a1 // 2)
print("\nnp.floor_divide(a1, 2)\n", np.floor_divide(a1, 2))
print("\na1 ** 2\n", a1 ** 2)
print("\nnp.power(a1, 2)\n", np.power(a1, 2))
print("\na1 % 2\n", a1 % 2)
print("\nnp.mod(a1, 2)\n", np.mod(a1, 2))

 

결과

a1
 [1 2 3 4 5 6 7 8 9]

a1 + 1
 [ 2  3  4  5  6  7  8  9 10]

np.add(a1, 10)
 [11 12 13 14 15 16 17 18 19]

a1 - 2
 [-1  0  1  2  3  4  5  6  7]

np.subtract(a1, 10)
 [-9 -8 -7 -6 -5 -4 -3 -2 -1]

-a1
 [-1 -2 -3 -4 -5 -6 -7 -8 -9]

np.negative(a1)
 [-1 -2 -3 -4 -5 -6 -7 -8 -9]

a1 * 2
 [ 2  4  6  8 10 12 14 16 18]

np.multiply(a1, 2)
 [ 2  4  6  8 10 12 14 16 18]

a1 / 2
 [0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5]

np.divide(a1, 2)
 [0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5]

a1 // 2
 [0 1 1 2 2 3 3 4 4]

np.floor_divide(a1, 2)
 [0 1 1 2 2 3 3 4 4]

a1 ** 2
 [ 1  4  9 16 25 36 49 64 81]

np.power(a1, 2)
 [ 1  4  9 16 25 36 49 64 81]

a1 % 2
 [1 0 1 0 1 0 1 0 1]

np.mod(a1, 2)
 [1 0 1 0 1 0 1 0 1]

절대값 함수(Absolute Function)

• absolute() , abs() : 내장된 절대값 함수

제곱/제곱근 함수

• square , sqrt : 제곱, 제곱근 함수

지수와 로그 함수 (Exponential and Log Function)

코드

a1 = np.random.randint(-10, 10, size = 5)
print(a1)
print("\n절대값 함수")
print(np.absolute(a1))
print(np.abs(a1))

print("\n제곱근 함수")
print(np.square(a1))
print(np.sqrt(np.square(a1)))

print("\n지수와 로그 함수")
a2 = np.random.randint(1, 10, size = 5)
print(a2)
print(np.exp(a2))
print(np.exp2(a2))
print(np.power(a2, 2))
print(np.log(a2))
print(np.log2(a2))
print(np.log10(a2))

 

결과

[-8 -1  4  1 -2]

절대값 함수
[8 1 4 1 2]
[8 1 4 1 2]

제곱근 함수
[64  1 16  1  4]
[8. 1. 4. 1. 2.]

지수와 로그 함수
[2 3 7 9 4]
[7.38905610e+00 2.00855369e+01 1.09663316e+03 8.10308393e+03
 5.45981500e+01]
[  4.   8. 128. 512.  16.]
[ 4  9 49 81 16]
[0.69314718 1.09861229 1.94591015 2.19722458 1.38629436]
[1.         1.5849625  2.80735492 3.169925   2.        ]
[0.30103    0.47712125 0.84509804 0.95424251 0.60205999]

 

삼각 함수(Trigonometrical Function)

함수	설명
np.sin( array )	요소 별 사인
np.cos( array )	요소 별 코사인
np.tan( array )	요소 별 탄젠트
np.arcsin( array )	요소 별 아크 사인
np.arccos( array )	요소 별 아크 코사인
np.arctan( array )	요소 별 아크 탄젠트
np.arctan2( array1, array2 )	요소 별 아크 탄젠트 array1 / array2
np.sinh( array )	요소 별 하이퍼볼릭 사인
np.cosh( array )	요소 별 하이퍼볼릭 코사인
np.tanh( array )	요소 별 하이퍼볼릭 탄젠트
np.arcsinh( array )	요소 별 하이퍼볼릭 아크 사인
np.arccosh( array )	요소 별 하이퍼볼릭 아크 코사인
np.arctanh( array )	요소 별 하이퍼볼릭 아크 탄젠트
np.deg2rad( array )	요소 별 각도에서 라디안 변환
np.rad2deg( array )	요소 별 라디안에서 각도 변환
np.hypot( array1, array2 )	요소 별 유클리드 거리 계산

 

집계 함수(Aggregate Functions)

함수	NaN 안전 모드	설명
np.sum	np.nansum	요소의 합 계산
np.cumsum	np.nancumsum	요소의 누적 합
np.diff	N/A	요소의 차분
np.prod	np.nanprod	요소의 곱 계산
np.cumprod	np.nancumprod	요소의 누적 곱
np.dot	N/A	점 곱(dot product)
np.matmul	N/A	행렬 곱
np.tensordot	N/A	텐서곱(tensor product)
np.cross	N/A	벡터곱(cross product)
np.inner	N/A	내적(inner product)
np.outer	N/A	외적(outer product)
np.mean	np.nanmean	요소의 평균 계산
np.std	np.nanstd	표준 편차 계산
np.var	np.nanvar	분산 계산
np.min	np.nanmin	최소값
np.max	np.nanmax	최대값
np.argmin	np.nanargmin	최소값 인덱스
np.argmax	np.nanargmax	최대값 인덱스
np.median	np.nanmedian	중앙값
np.percentile	np.nanpercentile	요소의 순위 기반 백분위 수 계산
np.any	N/A	요소 중 참이 있는지 평가
np.all	N/A	모든 요소가 참인지 평가

 

비교 연산(Comparison Operators)

연산자	비교 범용 함수
==	np.equal
!=	np.not_equal
<	np.less
<=	np.less_equal
>	np.greater

 

비교 범용 함수	설명
np.isclose	배열 두개가 (z*1e+02)% 내외로 가까우면 True, 아니면 False
np.isinf	배열이 inf이면 True, 아니면 False
np.isfinite	배열이 inf, nan이면 False, 아니면 True
np.isnan	배열이 nan이면 True, 아니면 False

 

불리언 연산자(Boolean Operators)

연산자	비교 범용 함수
&	np.bitwise_and
|	np.bitwise_or
^	np.bitwise_xor
~	np.bitwise_not

 

배열 정렬

• 정렬 함수를 쓰면 새로운 배열이 반환된다. 

코드

a1 = np.random.randint(1, 10, size= 9)
print("a1배열\n ", a1)
print("\nnp.sort(a1)\n ", np.sort(a1))
a2 = a1.reshape((3,3))
print("\na2배열\n ", a2)
print("\nnp.sort(a2, axis=0)\n ", np.sort(a2, axis=0))
print("\nnp.sort(a2, axis=1)\n ", np.sort(a2, axis=1))
print("-"*70)
print("\nnp.argsort(a1)\n ", np.argsort(a1))
print("-"*70)
print("\na1.sort()\n ", a1.sort())

 

결과

a1배열
  [6 8 3 3 8 5 2 5 1]

np.sort(a1)
  [1 2 3 3 5 5 6 8 8]

a2배열
  [[6 8 3]
 [3 8 5]
 [2 5 1]]

np.sort(a2, axis=0)
  [[2 5 1]
 [3 8 3]
 [6 8 5]]

np.sort(a2, axis=1)
  [[3 6 8]
 [3 5 8]
 [1 2 5]]
----------------------------------------------------------------------

np.argsort(a1)
  [8 6 2 3 5 7 0 1 4]
----------------------------------------------------------------------

a1.sort()
  None

 

부분 정렬

• partition(arr, k) : 배열에서 순서 상관없이 작은 숫자 k개를 뽑아 왼쪽으로 놓은 배열을 반환
• partition(arr, -k) : 배열에서 순서 상관없이 큰 숫자 k개를 뽑아 오른쪽으로 놓은 배열을 반환
• np.argpartition : partition과 원리가 같지만 value값이 아닌 value의 index를 리턴한다.

코드

a1 = np.random.randint(1, 10, size=10)
print("a1배열\n", a1)
print("np.partition(a1, 3)\n", np.partition(a1, 3))
print("-"*70)

a2 = np.random.randint(1, 10, size=(5, 5))
print("a2배열\n", a2)
print("\nnp.partition(a2, 3)\n", np.partition(a2, 3))
print("\nnp.partition(a2, 3, axis=0)\n", np.partition(a2, 3, axis=0))
print("\nnp.partition(a2, 3, axis=1)\n", np.partition(a2, 3, axis=1))

 

결과

a1배열
 [3 4 7 5 5 1 3 2 9 1]
np.partition(a1, 3)
 [1 1 2 3 3 4 5 7 9 5]
----------------------------------------------------------------------
a2배열
 [[5 3 6 8 2]
 [4 1 5 4 8]
 [6 9 4 5 4]
 [1 3 7 2 2]
 [9 7 2 2 6]]

np.partition(a2, 3)
 [[3 2 5 6 8]
 [4 4 1 5 8]
 [4 4 5 6 9]
 [2 1 2 3 7]
 [2 2 6 7 9]]

np.partition(a2, 3, axis=0)
 [[1 3 2 2 2]
 [5 3 4 2 2]
 [4 1 5 4 4]
 [6 7 6 5 6]
 [9 9 7 8 8]]

np.partition(a2, 3, axis=1)
 [[3 2 5 6 8]
 [4 4 1 5 8]
 [4 4 5 6 9]
 [2 1 2 3 7]
 [2 2 6 7 9]]

 

출처: 이수안 컴퓨터 연구소