[Python] Numpy (배열 연산 / 배열 입출력)

6. 배열 연산

• Numpy의 배열 연산은 벡터화(vectorized) 연산을 사용
• 일반적으로 Numpy의 범용함수(universal functions)를 통해 구현
• 배열 요소에 대한 반복적인 계산을 효율적으로 수행

브로드캐스팅(Broadcasting)

a1 = np.array([1, 2, 3])
print(a1)
print(a1 + 5)
>>
[1 2 3]
[6 7 8]

a2= np.arange(1, 10).reshape(3,3)
print(a2)
print(a1+a2)
>>
[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[ 2  4  6]
 [ 5  7  9]
 [ 8 10 12]]

b2 = np.array([1, 2, 3]).reshape(3,1)
print(b2)
print(a1+b2)
>>
[[1]
 [2]
 [3]]
[[2 3 4]
 [3 4 5]
 [4 5 6]]

산술 연산

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

a1 = np.arange(1, 10)
print(a1)
>> [1 2 3 4 5 6 7 8 9]

print(a1 + 1)
>> [ 2  3  4  5  6  7  8  9 10]

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

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

print(-a1)
>> [-1 -2 -3 -4 -5 -6 -7 -8 -9]

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

print(a1 % 2)
>> [1 0 1 0 1 0 1 0 1]

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

a1 = np.arange(1, 10)
print(a1)
b1 = np.random.randint(1, 10, size = 9)
print(b1)

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

print(a1 + b1)
print(a1 - b1)
print(a1 / b1)
print(a1 // b1)
print(a1 ** b1)
print(a1 % b1)

[ 4  9  6 11 11 14  9 16 15]
[-2 -5  0 -3 -1 -2  5  0  3]
[0.33333333 0.28571429 1.         0.57142857 0.83333333 0.75
 3.5        1.         1.5       ]
[0 0 1 0 0 0 3 1 1]
[       1      128       27    16384    15625  1679616       49 16777216
   531441]
[1 2 0 4 5 6 1 0 3]

a2 = np.arange(1, 10).reshape(3,3)
print(a2)
b2= np.random.randint(1, 10, size = (3,3))
print(b2)

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

print(a2 + b2)
print(a2 - b2)
print(a2 / b2)
print(a2 // b2)
print(a2 % b2)

[[10  9 12]
 [12 10 13]
 [12 12 12]]
[[-8 -5 -6]
 [-4  0 -1]
 [ 2  4  6]]
[[0.11111111 0.28571429 0.33333333]
 [0.5        1.         0.85714286]
 [1.4        2.         3.        ]]
[[0 0 0]
 [0 1 0]
 [1 2 3]]
[[1 2 3]
 [4 0 6]
 [2 0 0]]

 

절대값 함수(Absolute Function)

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

a1 = np.random.randint(-10, 10, size = 5)
print(a1)

[ 8  2  5 -4  0]

print(np.absolute(a1))
print(np.abs(a1))
>>
[8 2 5 4 0]
[8 2 5 4 0]

 

제곱 / 제곱근 함수

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

print(a1)
print(np.square(a1))
print(np.sqrt(a1))
>>
[ 8  2  5 -4  0]
[64  4 25 16  0]
[2.82842712 1.41421356 2.23606798        nan 0.        ]

제곱 제곱근 한지 너무 오래됐음… ㅎ

 

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

a1 = np.random.randint(1, 10, size = 5)
print(a1)
print(np.exp(a1))
print(np.exp2(a1))
print(np.power(a1, 2))
>>
[8 2 5 3 6]
[2980.95798704    7.3890561   148.4131591    20.08553692  403.42879349]
[256.   4.  32.   8.  64.]
[64  4 25  9 36]

print(a1)
print(np.log(a1))
print(np.log2(a1))
print(np.log10(a1))
>>
[8 2 5 3 6]
[2.07944154 0.69314718 1.60943791 1.09861229 1.79175947]
[3.         1.         2.32192809 1.5849625  2.5849625 ]
[0.90308999 0.30103    0.69897    0.47712125 0.77815125]

 

삼각함수(Trigonometrical Function)

함수	설명
np.sin(array)	요소 별 사인
np.cos(array)	요소 별 코사인
np.tan(array)	요소 별 탄젠트
np.arcsin(array)	요소 별 아크 사인
np.arccos(array)	요소 별 아크 코사인
np.artan(array)	요소 별 아크 탄젠트
np.arctan2(array)	요소 별 아크 탄젠트 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)	요소 별 유클리드 거리 계산

t = np.linspace(0, np.pi, 3)
print(t)
print(np.sin(t))
print(np.cos(t))
print(np.tan(t))
>> 
[0.         1.57079633 3.14159265]
[0.0000000e+00 1.0000000e+00 1.2246468e-16]
[ 1.000000e+00  6.123234e-17 -1.000000e+00]
[ 0.00000000e+00  1.63312394e+16 -1.22464680e-16]

x = [-1, 0, 1]
print(x)
print(np.arcsin(x))
print(np.arccos(x))
print(np.arctan(x))
>>
[-1, 0, 1]
[-1.57079633  0.          1.57079633]
[3.14159265 1.57079633 0.        ]
[-0.78539816  0.          0.78539816]

 

집계 함수(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	텐서 곱
np.cross	N/A	벡터 곱
np.inner	N/A	내적
np.outer	N/A	외적
np.mean	np.nanmean	요소의 평균 계산
np.std	np.nansntd	표준 편차 계산
np.var	np.nanvar	분산 계산
np.min	np.nanmin	최소값
np.max	np.nanma	최대값
np.argmin	np.nanargmin	최소값 인덱스
np.argmax	np.nanargmax	최대값 인덱스
np.median	np.nanmedian	중앙값
np.percentile	np.nanpercentile	요소의 순위 기반 백분위 수 계산
np.any	N/A	요소 중 참이 있는지 평가
np.all	N/A	모든 요소가 참인지 평가

 

sum(): 합계산

a2 = np.random.randint(1, 10, size = (3,3))
print(a2)
print(a2.sum(), np.sum(a2)) # 둘다 가능
print(a2.sum(axis = 0), np.sum(a2, axis = 0))
print(a2.sum(axis = 1), np.sum(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
46 46
[17 18 11] [17 18 11]
[ 9 19 18] [ 9 19 18]

2차원 axis 에서 

axis = 1 / axis = 0이 헷갈리면

axis = 0 은 행이 늘어나는 방향에 따라

axis = 1 은 열이 늘어나는 방향에 따라서~ 이렇게 생각하기

https://steadiness-193.tistory.com/46

Numpy - 2차원 axis 이해하기

3차원 axis 에서는

axis = 0 은 차원에 따라서 압축

axis = 1 은 행에 따라서 압축

axis = 2 은 열에 따라서 압축

https://steadiness-193.tistory.com/50

Numpy - 3차원 axis 이해하기

cumsum(): 누적합 계산

print(a2)
print(np.cumsum(a2)) 
print(np.cumsum(a2, axis = 0))
print(np.cumsum(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
[ 3  8  9 15 19 28 36 45 46]
[[ 3  5  1]
 [ 9  9 10]
 [17 18 11]]
[[ 3  8  9]
 [ 6 10 19]
 [ 8 17 18]]

diff(): 차분 계산

print(a2)
print(np.diff(a2)) 
print(np.diff(a2, axis = 0))
print(np.diff(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
[[ 2 -4]
 [-2  5]
 [ 1 -8]]
[[ 3 -1  8]
 [ 2  5 -8]]
[[ 2 -4]
 [-2  5]
 [ 1 -8]]

print(np.diff(a2, axis = 1))
>>
[[ 2 -4]
 [-2  5]
 [ 1 -8]]

prod(): 곱 계산

print(a2)
print(np.prod(a2)) 
print(np.prod(a2, axis = 0))
print(np.prod(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
233280
[144 180   9]
[ 15 216  72]

cumprod(): 누적곱 계산

print(a2)
print(np.cumprod(a2)) 
print(np.cumprod(a2, axis = 0))
print(np.cumprod(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
[     3     15     15     90    360   3240  25920 233280 233280]
[[  3   5   1]
 [ 18  20   9]
 [144 180   9]]
[[  3  15  15]
 [  6  24 216]
 [  8  72  72]]

dot() / matmul(): 점곱 / 행렬곱 계산

print(a2)
b2 = np.ones_like(a2)
print(b2)
print(np.dot(a2, b2)) 
print(np.matmul(a2, b2))
>>
print(a2)
b2 = np.ones_like(a2)
print(b2)
print(np.dot(a2, b2)) 
print(np.matmul(a2, b2))
print(a2)
b2 = np.ones_like(a2)
print(b2)
print(np.dot(a2, b2)) 
print(np.matmul(a2, b2))
[[3 5 1]
 [6 4 9]
 [8 9 1]]
[[1 1 1]
 [1 1 1]
 [1 1 1]]
[[ 9  9  9]
 [19 19 19]
 [18 18 18]]
[[ 9  9  9]
 [19 19 19]
 [18 18 18]]

print(3*1 + 5*1 + 1*1)
print(6*1 + 4*1 + 9*1)
print(8*1 + 9*1 + 1*1 )
>>
9
19
18

tensordot(): 텐서곱 계산

print(a2)
print(b2)
print(np.tensordot(a2, b2))
print(np.tensordot(a2, b2, axes = 0))
print(np.tensordot(a2, b2, axes = 1)) # dot이랑 같은 결과

[[3 5 1]
 [6 4 9]
 [8 9 1]]
[[1 1 1]
 [1 1 1]
 [1 1 1]]
46
[[[[3 3 3]
   [3 3 3]
   [3 3 3]]

  [[5 5 5]
   [5 5 5]
   [5 5 5]]

  [[1 1 1]
   [1 1 1]
   [1 1 1]]]


 [[[6 6 6]
   [6 6 6]
   [6 6 6]]

  [[4 4 4]
   [4 4 4]
   [4 4 4]]

  [[9 9 9]
   [9 9 9]
   [9 9 9]]]


 [[[8 8 8]
   [8 8 8]
   [8 8 8]]

  [[9 9 9]
   [9 9 9]
   [9 9 9]]

  [[1 1 1]
   [1 1 1]
   [1 1 1]]]]
[[ 9  9  9]
 [19 19 19]
 [18 18 18]]

crss(): 벡터곱

x = [1, 2, 3]
y = [4, 5, 6]
print(np.cross(x, y))

print(2*6 - 3*5)
print(3*4 - 1*6)
print(1*5 - 2*4)

>>
[-3  6 -3]
-3
6
-3

inner() / outer(): 내적 / 외적

print(a2)
print(b2)
print(np.inner(a2, b2))
print(np.outer(a2, b2))

[[3 5 1]
 [6 4 9]
 [8 9 1]]
[[1 1 1]
 [1 1 1]
 [1 1 1]]
[[ 9  9  9]
 [19 19 19]
 [18 18 18]]
[[3 3 3 3 3 3 3 3 3]
 [5 5 5 5 5 5 5 5 5]
 [1 1 1 1 1 1 1 1 1]
 [6 6 6 6 6 6 6 6 6]
 [4 4 4 4 4 4 4 4 4]
 [9 9 9 9 9 9 9 9 9]
 [8 8 8 8 8 8 8 8 8]
 [9 9 9 9 9 9 9 9 9]
 [1 1 1 1 1 1 1 1 1]]

mean(): 평균 계산

print(a2)
print(np.mean(a2))
print(np.mean(a2, axis = 0))
print(np.mean(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
5.111111111111111
[5.66666667 6.         3.66666667]
[3.         6.33333333 6.        ]

std(): 표준 편차 계산

print(a2)
print(np.std(a2))
print(np.std(a2, axis = 0))
print(np.std(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
2.960647243216495
[2.05480467 2.1602469  3.77123617]
[1.63299316 2.05480467 3.55902608]

var(): 분산 계산

print(a2)
print(np.var(a2))
print(np.var(a2, axis = 0))
print(np.var(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
8.765432098765432
[ 4.22222222  4.66666667 14.22222222]
[ 2.66666667  4.22222222 12.66666667]

min(): 최소값 

print(a2)
print(np.min(a2))
print(np.min(a2, axis = 0))
print(np.min(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
1
[3 4 1]
[1 4 1]

max(): 최대값

print(a2)
print(np.max(a2))
print(np.max(a2, axis = 0))
print(np.max(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
9
[8 9 9]
[5 9 9]

argmin(): 최소값 인덱스

print(a2)
print(np.argmin(a2))
print(np.argmin(a2, axis = 0))
print(np.argmin(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
2
[0 1 0]
[2 1 2]

argmax(): 최대값 인덱스

print(a2)
print(np.argmax(a2))
print(np.argmax(a2, axis = 0))
print(np.argmax(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
5
[2 2 1]
[1 2 1]

median(): 중앙값

print(a2)
print(np.median(a2))
print(np.median(a2, axis = 0))
print(np.median(a2, axis = 1))
>>
[[3 5 1]
 [6 4 9]
 [8 9 1]]
5.0
[6. 5. 1.]
[3. 6. 8.]

- mean이랑은 다르고 가장 정중앙값

percentile(): 백분위 수

a1 = np.array([0, 1, 2, 3])
print(a1)
print(np.percentile(a1, [0 ,20, 40, 60, 80, 100], interpolation= 'linear'))
print(np.percentile(a1, [0 ,20, 40, 60, 80, 100], interpolation= 'higher'))
print(np.percentile(a1, [0 ,20, 40, 60, 80, 100], interpolation= 'lower'))
print(np.percentile(a1, [0 ,20, 40, 60, 80, 100], interpolation= 'nearest'))
print(np.percentile(a1, [0 ,20, 40, 60, 80, 100], interpolation= 'midpoint'))

[0 1 2 3]
[0.  0.6 1.2 1.8 2.4 3. ]
[0 1 2 2 3 3]
[0 0 1 1 2 3]
[0 1 1 2 2 3]
[0.  0.5 1.5 1.5 2.5 3. ]

any()

a2 = np.array([[False, False, False],
               [False, True, True],
               [False, True, True]])
print(a2)
print(np.any(a2))
print(np.any(a2, axis = 0))
print(np.any(a2, axis = 1))
>>
[[False False False]
 [False  True  True]
 [False  True  True]]
True
[False  True  True]
[False  True  True]

- any는 이 중 하나만 True면 TRUE

all()

a2 = np.array([[False, False, True],
               [True, True, True],
               [False, True, True]])
print(a2)
print(np.any(a2))
print(np.any(a2, axis = 0))
print(np.any(a2, axis = 1))
>>
[[False False  True]
 [ True  True  True]
 [False  True  True]]
True
[ True  True  True]
[ True  True  True]

 

비교 연산(Comparison Operators)

 

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

a1 = np.arange(1, 10)
print(a1)
>> [1 2 3 4 5 6 7 8 9]

print(a1 == 5)
>> [False False False False  True False False False False]

print(a1 <= 5)
>> [ True  True  True  True  True False False False False]

a2= np.arange(1, 10).reshape(3,3)
print(a2)
>> 
[[1 2 3]
 [4 5 6]
 [7 8 9]]

print(np.sum(a2))
print(np.count_nonzero(a2 > 5)) # 0이 아닌데 5이상인 걸 세줘 6789
print(np.sum(a2 > 5))
print(np.sum(a2 > 5, axis = 0))
print(np.sum(a2 > 5, axis = 1))
>>
45
4
4
[1 1 2]
[0 1 3]

print(np.all(a2 > 5))
print(np.all(a2 > 5, axis = 0))
print(np.all(a2 > 5, axis = 1))
>>
False
[False False False]
[False False  True]

 

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

a1 = np.array([1, 2, 3, 4, 5])
print(a1)
b1 = np.array([1, 2, 3, 3, 4])
print(b1)
print(np.isclose(a1, b1))
>>
[1 2 3 4 5]
[1 2 3 3 4]
[ True  True  True False False]

a1 = np.array([np.nan, 2, np.inf, 4, np.NINF])
print(a1)
print(np.isnan(a1))
print(np.isinf(a1))
print(np.isfinite(a1))
>>
[ nan   2.  inf   4. -inf]
[ True False False False False]
[False False  True False  True]
[False  True False  True False]

 

불리언 연산자(Boolean Operators)

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

a2 = np.arange(1, 10).reshape(3,3)
print(a2)

print((a2 > 5) & (a2 < 8))
print(a2[(a2 > 5) & (a2 < 8)])

print((a2 > 5) | (a2 < 8))
print(a2[(a2 > 5) | (a2 < 8)])

print((a2 > 5) ^ (a2 < 8))
print(a2[(a2 > 5) ^ (a2 < 8)])
# 6, 7 뺀 나머지 

print(~(a2 > 5))
print(a2[~(a2 > 5)])

[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[False False False]
 [False False  True]
 [ True False False]]
[6 7]
[[ True  True  True]
 [ True  True  True]
 [ True  True  True]]
[1 2 3 4 5 6 7 8 9]
[[ True  True  True]
 [ True  True False]
 [False  True  True]]
[1 2 3 4 5 8 9]
[[ True  True  True]
 [ True  True False]
 [False False False]]
[1 2 3 4 5]

 

배열 정렬

 

a1 = np.random.randint(1, 10, size = 10)
print(a1)
print(np.sort(a1))
print(a1) # 원본은 그대로 
print(np.argsort(a1)) # 5번째 값인 1이 여기로 와야 한다 
print(a1)
>>
[6 6 8 2 3 1 5 8 4 2]
[1 2 2 3 4 5 6 6 8 8]
[6 6 8 2 3 1 5 8 4 2]
[5 3 9 4 8 6 0 1 2 7]
[6 6 8 2 3 1 5 8 4 2]

print(a1. sort())
print(a1)
>>
None
[1 2 2 3 4 5 6 6 8 8]

a2 = np.random.randint(1, 10, size = (3,3))
print(a2)
print(np.sort(a2, axis = 0))
print(np.sort(a2, axis = 1))
>>
[[8 9 2]
 [5 6 5]
 [3 3 4]]
[[3 3 2]
 [5 6 4]
 [8 9 5]]
[[2 8 9]
 [5 5 6]
 [3 3 4]]

부분 정렬

• partition(): 배열에서 k개의 작은 값을 반환

a1 = np.random.randint(1, 10, size = 10)
print(a1)
print(np.partition(a1, 3)) #작은값 3개를 앞으로 뽑아줘
>>
[1 8 9 6 3 7 4 6 1 8]
[1 1 3 4 6 6 8 7 9 8]

a2 = np.random.randint(1, 10, size = (5,5))
print(a2)
print(np.partition(a2, 3))

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

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

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

 

7. 배열 입출력

함수	설명	파일 종류
np.save()	Numpy 배열 객체 1개를 파일에 저장	바이너리
np.savez()	Numpy 배열 객체 여러개를 파일에 저장	바이너리
np.load()	Numpy  배열 저장 파일로 부터 객체 로딩	바이너리
np.loadtxt()	텍스트 파일로부터 배열 로딩	텍스트
np.savetxt()	텍스트 파일에 Numpy 배열 객체 저장	텍스트

a2 = np.random.randint(1, 10, size = (5,5))
print(a2)
np.save('a', a2)
>>
[[1 9 6 5 9]
 [2 2 5 9 9]
 [8 9 2 9 4]
 [9 5 8 9 9]
 [4 6 4 8 8]]

!ls
>>
Python
-
a.npy

b2 = np.random.randint(1, 10, size = (5,5))
print(b2)
np.savez('ab', a2, b2)
>>
[[5 5 8 3 2]
 [8 1 4 8 5]
 [3 6 8 3 4]
 [6 6 5 4 5]
 [4 7 1 3 1]]

!ls
>>
Python
-
a.npy
ab.npz

npy = np.load('a.npy')
print(npy)
>>
[[1 9 6 5 9]
 [2 2 5 9 9]
 [8 9 2 9 4]
 [9 5 8 9 9]
 [4 6 4 8 8]]

npz = np.load('ab.npz')
print(npz.files)
print(npz['arr_0'])
print(npz['arr_1'])
>>
['arr_0', 'arr_1']
[[1 9 6 5 9]
 [2 2 5 9 9]
 [8 9 2 9 4]
 [9 5 8 9 9]
 [4 6 4 8 8]]
[[5 5 8 3 2]
 [8 1 4 8 5]
 [3 6 8 3 4]
 [6 6 5 4 5]
 [4 7 1 3 1]]

print(a2)
np.savetxt('a.csv', a2, delimiter= ',')
>>
[[1 9 6 5 9]
 [2 2 5 9 9]
 [8 9 2 9 4]
 [9 5 8 9 9]
 [4 6 4 8 8]]

!ls
>>
Python
-
a.csv
a.npy
ab.npz

!cat a.csv #텍스트 형태로 저장하게 돼서 데이터 타입 지정하지 못하고 저장
>>
1.000000000000000000e+00,9.000000000000000000e+00,6.000000000000000000e+00,5.000000000000000000e+00,9.000000000000000000e+00
2.000000000000000000e+00,2.000000000000000000e+00,5.000000000000000000e+00,9.000000000000000000e+00,9.000000000000000000e+00
8.000000000000000000e+00,9.000000000000000000e+00,2.000000000000000000e+00,9.000000000000000000e+00,4.000000000000000000e+00
9.000000000000000000e+00,5.000000000000000000e+00,8.000000000000000000e+00,9.000000000000000000e+00,9.000000000000000000e+00
4.000000000000000000e+00,6.000000000000000000e+00,4.000000000000000000e+00,8.000000000000000000e+00,8.000000000000000000e+00

- 텍스트 형태로 저장하게 돼서 데이터타입 지정하지 못하고 저장

csv = np.loadtxt('a.csv', delimiter=',')
print(csv) #저장할 때도 delimiter 지정, 불러올 때도 delimiter 지정해서 가져옴
>>
[[1. 9. 6. 5. 9.]
 [2. 2. 5. 9. 9.]
 [8. 9. 2. 9. 4.]
 [9. 5. 8. 9. 9.]
 [4. 6. 4. 8. 8.]]

- 저장할 때도 delimiter 지정, 불러올 때도 delimiter 지정해서 가져옴

print(b2)
np.savetxt('b.csv', b2, delimiter= ',', fmt = '%.2e', header = 'c1, c2, c3, c4, c5')
>>
[[5 5 8 3 2]
 [8 1 4 8 5]
 [3 6 8 3 4]
 [6 6 5 4 5]
 [4 7 1 3 1]]

!cat b.csv
>>
# c1, c2, c3, c4, c5
5.00e+00,5.00e+00,8.00e+00,3.00e+00,2.00e+00
8.00e+00,1.00e+00,4.00e+00,8.00e+00,5.00e+00
3.00e+00,6.00e+00,8.00e+00,3.00e+00,4.00e+00
6.00e+00,6.00e+00,5.00e+00,4.00e+00,5.00e+00
4.00e+00,7.00e+00,1.00e+00,3.00e+00,1.00e+00

csv = np.loadtxt('b.csv', delimiter=',')
print(csv)
>>
[[5. 5. 8. 3. 2.]
 [8. 1. 4. 8. 5.]
 [3. 6. 8. 3. 4.]
 [6. 6. 5. 4. 5.]
 [4. 7. 1. 3. 1.]]

 

---

 

참고 영상

https://youtu.be/mirZPrWwvao

---

Numpy 개념이 헷갈려서 한 번 정리해야겠다고 생각했는데 드디어… 

생각보다 너무 오래 걸렸지만 그래도 어느정도 머릿속에서 정리된 것 같아서 기분은 좋음!

다음은 판다스 다시 보기