All About NumPy

NumPy

NumPy 특징

1) Numerical Python의 약자
2) 고성능 과학 계산용 패키지로 강력한 N차원 배열 객체
3) 범용적 데이터 처리에 사용 가능한 다차원 컨테이너
4) 정교한 브로드캐스팅(braodcasting) 기능
5) 파이썬의 자료형 list와 비슷하지만, 더 빠르고 메모리를 효율적으로 관리
6) 반복문 없이 데이터 배열에 대한 처리를 지원하여 빠르게 편리
7) 데이터 과학 도구에 대한 생태계의 핵심을 이루고 있다.

import numpy as np
np.__version__ 
#1.23.5

배열 생성

리스트로 배열 만둘가

a1 = np.array([1,2,3,4,5])
print(a1)
print(type(a1))
print(a1.shape)
print(a1[0], a1[1], a1[2], a1[3], a1[4])
a1[0] = 4
a1[1] = 5
a1[2] = 6
print(a1)
#[1 2 3 4 5]
#<class 'numpy.ndarray'>
#(5,)
#1 2 3 4 5
#[4 5 6 4 5]

a2 = np.array([[1,2,3], [4,5,6], [7,8,9]])
print(a2)
print(a2.shape)
print(a2[0,0], a2[1,1], a2[2,2])
#[[1 2 3]
#[4 5 6]
#[7 8 9]]
#(3, 3)
#1 5 9

a3 = np.array([ [  [1, 2, 3], [4, 5, 6], [7, 8, 9]],
               [ [1, 2, 3], [4, 5, 6], [7, 8, 9]],
               [[1, 2, 3], [4, 5, 6], [7, 8, 9] ] ])
print(a3)
print(a3.shape)
#[[[1 2 3]
#  [4 5 6]
#  [7 8 9]]
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]]
#(3, 3, 3)

배열 생성 및 초기화

zeros() : 모든 요소를 0으로 초기화

np.zeros(10)
#array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

ones() : 모든 요소를 1로 초기화

np.ones((3,3))
# array([[1., 1., 1.],
#       [1., 1., 1.],
#       [1., 1., 1.]])

full() : 모든 요소를 지정한 값으로 초기화

np.full((3,3), 1.23)
#array([[1.23, 1.23, 1.23],
#1.23, 1.23, 1.23],
#[1.23, 1.23, 1.23]])

eye() : 단위행렬(identity matrix) 생성
주 대각선의 원소가 모두 1이고 나머지 원소는 모두 0인 정사각 행렬

np.eye(3)
#array([[1., 0., 0.],
#       [0., 1., 0.],
#       [0., 0., 1.]])

tri() : 삼각행렬 생성

np.tri(3)
#array([[1., 0., 0.],
#[1., 1., 0.],
#[1., 1., 1.]])

empty() : 초기화되지 않은 배열 생성
초기화가 없어서 배열 생성 비용이 저렴하고 빠르다
초기화되지 않아서 기존 메모리 위치에 존재하는 값이 있다.

np.empty(10)
#array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])

_like() : 지정한 배열과 shape가 같은 행렬 생성
np.zeros_like()
np.ones_like()
np.full_like()
np.empty_like()

print(a1)
np.zeros_like(a1)
#[4 5 6 4 5]
#array([0, 0, 0, 0, 0])

print(a2)
np.ones_like(a2)
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#array([[1, 1, 1],
#       [1, 1, 1],
#       [1, 1, 1]])

print(a3)
np.full_like(a3, 10)
#[[[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]]
#array([[[10, 10, 10],
#        [10, 10, 10],
#        [10, 10, 10]],
#
#       [[10, 10, 10],
#        [10, 10, 10],
#        [10, 10, 10]],
#
#       [[10, 10, 10],
#        [10, 10, 10],
#        [10, 10, 10]]])

생성한 값으로 배열 생성

arange() : 정수 범위로 배열 생성

np.arange(0,30,2)
#array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28])

linspace : 범위 내에서 균등 간격의 배열 생성

np.linspace(0,1,5)
#array([0.  , 0.25, 0.5 , 0.75, 1.  ])

logspace() : 범위 내에서 균등 간격으로 로그 스케일로 배열 생성

np.logspace(0.1, 1, 20)
#array([ 1.25892541,  1.40400425,  1.565802  ,  1.74624535,  #1.94748304,
#        2.1719114 ,  #2.42220294,  2.70133812,  #3.0126409 ,  3.35981829,
#       3.74700446,  #4.17881006,  4.66037703,  #5.19743987,  5.79639395,
#       6.46437163,  7.2093272 ,  8.04013161,  8.9666781 , 10.        ])

랜덤값으로 배열 생성

seed : 난수 발생을 위한 시드(seed) 지정
permutation : 순서를 임의로 바꾸거나 임의의 순열 반환
shuffle : 리스트나 배열의 순서를 뒤섞임
random : 랜덤한 수의 배열 생성
rand : 균등 분포에서 표본 추출
randint : 주어진 최소/최대 범위의 난수 추출
randn : 표준편차 1, 평균값이 0인 정규분포의 표본추출
binomial : 이항분포에서 표본 추출
normal : 정규분포(가우시안)에서 표본 추출
beta : 베타분포에서 표본 추출
chisquare : 카이제곱분포에서 표본 추출
gamma : 감마분포에서 표본 추출
uniform : 균등(0,1) 분포에서 표본 추출
random.random() : 랜덤한 수의 배열 생성

np.random.random((3,3))
#array([[0.97362438, 0.79071331, 0.7541677 ],
#       [0.07039216, 0.22119432, 0.07174502],
#       [0.88198976, 0.69561844, 0.50031773]])

random.randint() : 일정 구간의 랜덤 정수의 배열 생성

np.random.randint(0,10,(3,3))
#array([[5, 8, 9],
#       [7, 6, 6],
#      [8, 9, 1]])

random.normal() : 정규분포(noraml distribution)를 고려한 랜덤한 수의 배열 생성
평균 = 0, 표준편차 = 1, 3X3 배열

np.random.normal(0,1,size=(3,3))
#array([[ 1.05738708, -0.27564867,  0.08636845],
#       [ 0.01450482, -0.82758042, -0.7823833 ],
#       [ 1.28356991, -0.50697408, -0.13174434]])

random.rand() : 균등 분포(uniform distribution)를 고려한 랜덤한 수의 배열 생성

np.random.rand(3,3)
#array([[0.89933411, 0.81755712, 0.18663516],
#       [0.1055646 , 0.91110735, 0.3826107 ],
#       [0.80153325, 0.84635329, 0.0590714 ]])

random.randn() : 표준 정규 분포(standard normal distribution)를 고려한 랜덤한 수의 배열 생성

np.random.randn(3,3)
#array([[-0.22559865,  1.71736471, -1.16924287],
#       [ 0.5989845 , -0.10458543, -0.06512013],
#       [ 0.4061729 ,  1.16729747, -0.17396654]])

표준 데이터 타입

bool_ : 바이트로 저장된 불리언(Boolean)으로 True 또는 False 값을 가진다.
int_ : 기본 정수(Integer) 타입
intc : C언어에서 사용되는 int와 동일(일반적으로 int32 또는 int64
intp : 인덱싱에서 사용되는 정수 (C 언어에서 ssize_t와 동일, 일반적으로 int32 또는 int64
int8 : 바이트(Byte) (-128~127)
int16 : 정수(-32768~32767)
int32 : 정수(-2147483648 ~ 2147483647)
int64 : 정수(-922337203910~922...)
uint8 : 부호 없는 정수(0~255)
uint16 : 부호 없는 정수(0~65535)
uint32 : 부호 없는 정수(0~4294967...)
unit64 : 부호 없는 정수(0~184467440737...)
float16 : 반정밀 부동 소수점(Half precision float) : 부호 비트, 5비트, 10비트 가수
float32 : 단정밀 부동 소수점(Single precision float) : 부호 비트, 8비트 지수, 23비트 가수
float64 : 배정밀 부동 소수점(Double precision float) : 부호 비트, 11비트 지수, 52비트 가수
float_ : float64를 줄여서 표현
complex64 : 복소수(Complex number), 두 개의 32비트 부동 소수점으로 표현
complex128 : 복소수, 두 개의 64비트 부동 소수점으로 표현
complex_ : complex128를 줄여서 표현

np.zeros(20, dtype=int)
# array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

np.ones((3,3), dtype=bool)
#array([[ True,  True,  True],
#       [ True,  True,  True],
#       [ True,  True,  True]])

np.full((3,3), 1.0, dtype=float)
#array([[1., 1., 1.],
#       [1., 1., 1.],
#      [1., 1., 1.]])

날짜/시간 배열 생성

Y : 연
M : 월
W : 주
D : 일
h : 시
m : 분
s : 초
ms : 밀리초
ns : 나노초
ps : 피코초
fs : 팸토초
as : 아토초

date = np.array('2023-12-28', dtype=np.datetime64)
date
# array('2023-12-28', dtype='datetime64[D]')

date + np.arange(12)
#array(['2023-12-28', '2023-12-29', '2023-12-30', '2023-12-31',
#       '2024-01-01', '2024-01-02', '2024-01-03', '2024-01-04',
#       '2024-01-05', '2024-01-06', '2024-01-07', '2024-01-08'],
#      dtype='datetime64[D]')

datetime = np.datetime64('2024-01-15 13:00')
datetime
# numpy.datetime64('2024-01-15T13:00')

datetime = np.datetime64('2021-04-23 12:00:12.34', 'ns')
datetime
# numpy.datetime64('2021-04-23T12:00:12.340000000')

배열 조회

배열 속성 정보

def array_info(array):
  print(array)
  print("ndim", array.ndim)
  print("shape", array.shape)
  print("dtype", array.dtype)
  print("size", array.size)
  print("itemsize", array.itemsize)
  print("nbytes", array.nbytes)
  print("strides", array.strides)

array_info(a1)
#[4 5 6 4 5]
#ndim 1
#shape (5,)
#dtype int64
#size 5
#itemsize 8
#nbytes 40
#strides (8,)

array_info(a2)
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#ndim 2
#shape (3, 3)
#dtype int64
#size 9
#itemsize 8
#nbytes 72
#strides (24, 8)

array_info(a3)
#[[[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]]
#ndim 3
#shape (3, 3, 3)
#dtype int64
#size 27
#itemsize 8
#nbytes 216
#strides (72, 24, 8)

인덱싱(Indexing)

print(a1)
print(a1[0])
print(a1[2])
print(a1[-1])
print(a1[-2])
#[4 5 6 4 5]
#4
#6
#5
#4

print(a2)
print(a2[0,0])
print(a2[0,2])
print(a2[1,1])
print(a2[2,-1])
#[[1 2 3]
#[4 5 6]
#[7 8 9]]
#1
#3
#5
#9

print(a3)
print(a3[0,0,0])
print(a3[1,1,1])
print(a3[2,2,2])
print(a3[2,-1,-1])
#[[[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]]
#1
#5
#9
#9

슬라이싱 slicing

슬라이싱 구문 : a[start:stop:stop]
기본값 : start=0, stop=ndim, step=1

print(a1)
print(a1[0:2])
print(a1[0:])
print(a1[:1])
print(a1[::2])
print(a1[::-1])
#[4 5 6 4 5]
#[4 5]
#[4 5 6 4 5]
#[4]
#[4 6 5]
#[5 4 6 5 4]

print(a2)
print(a2[1])
print(a2[1, :])
print(a2[:2, :2])
print(a2[1:, ::-1])
print(a2[::-1, ::-1])
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#[4 5 6]
#[4 5 6]
#[[1 2]
# [4 5]]
#[[6 5 4]
# [9 8 7]]
#[[9 8 7]
# [6 5 4]
# [3 2 1]]

불리언 인덱싱(Boolean Indexing)

배열 각 요소의 선택 여부를 불리언(True or False)로 지정
True 값인 인덱스의 값만 조회

print(a1)
bi = [False, True, True, False, True]
print(a1[bi])
bi = [True, False, True, True, False]
print(a1[bi])
#[4 5 6 4 5]
#[5 6 5]
#[4 6 4]

print(a2)
bi = np.random.randint(0,2, (3,3), dtype=bool)
print(bi)
print(a2[bi])
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#[[False False False]
# [False  True  True]
# [False  True  True]]
#[5 6 8 9]

팬시 인덱싱(Fancy Indexing)

print(a1)
print(a1[0], a1[2])
ind = [0,2]
print(a1[ind])
ind = np.array([[0,1], [2,0]])
print(a1[ind])
#[4 5 6 4 5]
#4 6
#[4 6]
#[[4 5]
# [6 4]]

print(a2)
row = np.array([0,2])
col = np.array([1,2])
print(a2[row, col])
print(a2[row, :])
print(a2[:, col])
print(a2[row,1])
print(a2[2,col])
print(a2[row, 1:])
print(a2[1:, col])
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#[2 9]
#[[1 2 3]
# [7 8 9]]
#[[2 3]
# [5 6]
# [8 9]]
#[2 8]
#[8 9]
#[[2 3]
# [8 9]]
#[[5 6]
# [8 9]]

배열 값 삽입/수정/삭제/복사

배열 값 삽입

insert() : 배열의 특정 위치에 값 삽입
axis를 지정하지 않으면 1차원 배열로 변환
추가할 방향을 axis로 지정
원본 배열 변경없이 새로운 배열 반환

print(a1)
b1 = np.insert(a1, 0, 10)
print(b1)
print(a1)
c1 = np.insert(a1, 2, 10)
print(c1)
#[4 5 6 4 5]
#[10  4  5  6  4  5]
#[4 5 6 4 5]
#[ 4  5 10  6  4  5]

print(a2)
b2 = np.insert(a2, 1, 10, axis=0)
print(b2)
c2 = np.insert(a2, 1, 10, axis=1)
print(c2)
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#[[ 1  2  3]
# [10 10 10]
# [ 4  5  6]
# [ 7  8  9]]
#[[ 1 10  2  3]
# [ 4 10  5  6]
# [ 7 10  8  9]]

배열 값 수정

배열의 인덱싱으로 접근하여 값 수정

print(a1)
a1[0] = 1
a1[1] = 2
a1[2] = 3
print(a1)
a1[:1] = 9
print(a1)
i = np.array([1,3,4])
a1[i] = 0
print(a1)
a1[i] += 4
print(a1)
#[9 2 3 4 5]
#[1 2 3 4 5]
#[9 2 3 4 5]
#[9 0 3 0 0]
#[9 4 3 4 4]

print(a2)
a2[0,0] = 1
a2[1,1] = 2
a2[2,2] = 3
a2[0] = 1
print(a2)
a2[1:, 2] = 9
print(a2)
row = np.array([0,1])
col = np.array([1,2])
a2[row, col] = 0
print(a2)
#[[1 1 1]
# [4 2 9]
# [7 8 9]]
#[[1 1 1]
# [4 2 9]
# [7 8 3]]
#[[1 1 1]
# [4 2 9]
# [7 8 9]]
#[[1 0 1]
# [4 2 0]
#[7 8 9]]

배열 값 삭제

delete() : 배열의 특정 위치에 값 삭제
axis를 지정하지 않으면 1차원 배열로 반환
삭제할 방향을 axis로 지정
원본 배열 변경없이 새로운 배열 반환

print(a1)
b1 = np.delete(a1, 1)
print(b1)
print(a1)
#[9 4 3 4 4]
#[9 3 4 4]
#[9 4 3 4 4]

print(a2)
b2 = np.delete(a2, 1, axis=0)
print(b2)
c2 = np.delete(a2, 1, axis=1)
print(c2)
#[[1 0 1]
# [4 2 0]
# [7 8 9]]
#[[1 0 1]
# [7 8 9]]
#[[1 1]
# [4 0]
# [7 9]]

배열 복사

리스트 자료형과 달리 배열의 슬라이스는 복사본이 아니다.

print(a2)
print(a2[:2, :2])
a2_sub = a2[:2, :2]
print(a2_sub)
a2_sub[:,1] = 0
print(a2_sub)
print(a2)
#[[1 0 1]
# [4 2 0]
#[7 8 9]]
#[[1 0]
# [4 2]]
#[[1 0]
# [4 2]]
#[[1 0]
# [4 0]]
#[[1 0 1]
# [4 0 0]
# [7 8 9]]

copy : 배열이나 하위 배열 내의 값을 명시적으로 복사

print(a2)
a2_sub_copy = a2[:2, :2].copy()
print(a2_sub_copy)
a2_sub_copy[:,1] = 1
print(a2_sub_copy)
print(a2)
#[[1 0 1]
# [4 0 0]
# [7 8 9]]
#[[1 0]
# [4 0]]
#[[1 1]
# [4 1]]
#[[1 0 1]
# [4 0 0]
# [7 8 9]]

배열 변환

배열 전치 및 축 변경

print(a2)
print(a2.T)
#[[1 2 3]
# [4 5 6]
#[7 8 9]]
#[[1 4 7]
# [2 5 8]
# [3 6 9]]

print(a3)
print(a3.T)
#[[[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]]
#[[[1 1 1]
#  [4 4 4]
#  [7 7 7]]
#
# [[2 2 2]
#  [5 5 5]
#  [8 8 8]]
#
# [[3 3 3]
#  [6 6 6]
#  [9 9 9]]]

print(a2)
print(a2.swapaxes(1,0))
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#[[1 4 7]
# [2 5 8]
# [3 6 9]]

print(a3)
print(a3.swapaxes(0,1))
print(a3.swapaxes(1,2))
#[[[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
#
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]]
#[[[1 2 3]
#  [1 2 3]
#  [1 2 3]]
#
# [[4 5 6]
#  [4 5 6]
#  [4 5 6]]
#
# [[7 8 9]
#  [7 8 9]
#  [7 8 9]]]
#[[[1 4 7]
#  [2 5 8]
#  [3 6 9]]
#
# [[1 4 7]
#  [2 5 8]
#  [3 6 9]]
#
# [[1 4 7]
#  [2 5 8]
#  [3 6 9]]]

배열 재구조화

reshape : 배열의 형상을 변경

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

newaxis() : 새로운 축 추가

print(n1)
print(n1[np.newaxis, :5])
print(n1[:5, np.newaxis])
#[1 2 3 4 5 6 7 8 9]
#[[1 2 3 4 5]]
#[[1]
# [2]
# [3]
# [4]
# [5]]

배열 크기 변경

배열 모양만 변경

n2 = np.random.randint(0,10,(2,5))
print(n2)
n2.resize((5,2))
print(n2)
#[[0 9 2 2 6]
# [0 8 9 3 7]]
#[[0 9]
# [2 2]
# [6 0]
# [8 9]
# [3 7]]

배열 크기 증가
남은 공간은 0으로 채워진다.

n2 = np.resize(n2, (5, 5))
print(n2)
# n2.resize((5,5)) #강의에 쓰던 코드이며 오류가 발생하여 위코드로 사용
# print(n2)
#[[0 9 2 2 6]
# [0 8 9 3 7]
# [0 9 2 2 6]
# [0 8 9 3 7]
# [0 9 2 2 6]]

배열 크기 감소
포함되지 않은 값은 삭제된다.

n2 = n2.copy()
n2.resize((3, 3))
print(n2)
# n2.resize((3,3)) #강의에 쓰던 코드이며 오류가 발행하여 위 코드로 사용
# print(n2)
#[[0 9 2]
# [2 6 0]
# [8 9 3]]

배열 추가

append() : 배열의 끝에 값 추가

a2 = np.arange(1,10).reshape(3,3)
print(a2)
b2 = np.arange(10,19).reshape(3,3)
print(b2)
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#[[10 11 12]
# [13 14 15]
# [16 17 18]]

axis 지정이 없으면 1차원 배열 형태로 변형되어 결합

c2 = np.append(a2, b2)
print(c2)
output
#[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18]

axis를 0으로 지정
shape[0]을 제외한 나머지 shape은 같아야 한다.

c2 = np.append(a2, b2, axis=0)
print(c2)
#[[ 1  2  3]
# [ 4  5  6]
# [ 7  8  9]
# [10 11 12]
# [13 14 15]
# [16 17 18]]

axis를 1로 지정
shape[1]을 제외한 나머지 shape은 같아야 한다.

c2 = np.append(a2, b2, axis=1)
print(c2)
#[[ 1  2  3 10 11 12]
# [ 4  5  6 13 14 15]
# [ 7  8  9 16 17 18]]

배열 연결

concatenate() : 튜플이나 배열의 리스트를 인수로 사용해 배열 연결

a1 = np.array([1,3,5])
b1 = np.array([2,4,6])
np.concatenate([a1, b1])
# array([1, 3, 5, 2, 4, 6])

c1 = np.array([7,8,9])
np.concatenate([a1, b1, c1])
# array([1, 3, 5, 2, 4, 6, 7, 8, 9])

a2 = np.array([[1,2,3],
              [4,5,6]])
np.concatenate([a2, a2])
#array([[1, 2, 3],
#       [4, 5, 6],
#       [1, 2, 3],
#       [4, 5, 6]])

a2 = np.array([[1,2,3],
              [4,5,6]])
np.concatenate([a2, a2], axis =1)
#array([[1, 2, 3, 1, 2, 3],
#       [4, 5, 6, 4, 5, 6]])

vstack() : 수직 스택(horizontal stack), 1차원으로 연결

np.vstack([a2, a2])
#array([[1, 2, 3],
#       [4, 5, 6],
#       [1, 2, 3],
#       [4, 5, 6]])

hstack() : 수평 스택(horizontal stack), 2차원으로 연결

np.hstack([a2, a2])
#array([[1, 2, 3, 1, 2, 3],
#       [4, 5, 6, 4, 5, 6]])

dstack() : 깊이 스택(depth stack), 3차원으로 연결

np.dstack([a2, a2])
#array([[[1, 1],
#        [2, 2],
#        [3, 3]],
#
#       [[4, 4],
#        [5, 5],
#        [6, 6]]])

stack() : 새로운 차원으로 연결

np.stack([a2, a2])
#array([[[1, 2, 3],
#        [4, 5, 6]],
#
#      [[1, 2, 3],
#        [4, 5, 6]]])

배열 분할

split() : 배열 분할

a1 = np.arange(0,10)
print(a1)
b1, c1 = np.split(a1, [5])
print(b1,c1)
b1, c1, d1, e1, f1 =np.split(a1, [2,4,6,8])
print(b1, c1, d1, e1, f1)
#[0 1 2 3 4 5 6 7 8 9]
#[0 1 2 3 4] [5 6 7 8 9]
#[0 1] [2 3] [4 5] [6 7] [8 9]

vsplit() : 수직 분할, 1차원으로 분할

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

hsplit() : 수평 분할, 2차원으로 분할

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

dsplit() : 깊이 분할, 3차원으로 분할

a3 = np.arange(1,28).reshape(3,3,3)
print(a3)
b3, c3 = np.dsplit(a3, [2])
print(b3)
print(c3)
#[[[ 1  2  3]
#  [ 4  5  6]
#  [ 7  8  9]]
#
# [[10 11 12]
#  [13 14 15]
#  [16 17 18]]
#
# [[19 20 21]
#  [22 23 24]
#  [25 26 27]]]
#[[[ 1  2]
#  [ 4  5]
#  [ 7  8]]
#
# [[10 11]
#  [13 14]
#  [16 17]]
#
# [[19 20]
#  [22 23]
#  [25 26]]]
#[[[ 3]
#  [ 6]
#  [ 9]]
#
# [[12]
#  [15]
#  [18]]
#
# [[21]
#  [24]
#  [27]]]

배열 연산

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

브로드캐스팅(Broadcasting)

import numpy as np
a1 = np.array([1,2,3])
print(a1)
print(a1+5)
#
a2 = np.arange(1,10).reshape(3,3)
print(a2)
print(a1+a2)
#
b2 = np.array([1,2,3]).reshape(3,1)
print(b2)
print(a1+b2)
#[1 2 3]
#[6 7 8]
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#[[ 2  4  6]
# [ 5  7  9]
# [ 8 10 12]]
#[[1]
# [2]
# [3]]
#[[2 3 4]
# [3 4 5]
# [4 5 6]]

산술 연산(Arithmetric Operators)

a1 = np.arange(1,10)
print(a1)
print(a1+1)
print(np.add(a1, 10))
print(a1-2)
print(np.subtract(a1,10))
print(-a1)
print(np.negative(a1))
print(a1 * 2)
print(np.multiply(a1, 2))
print(a1/2)
print(np.divide(a1,2))
print(a1//2)
print(np.floor_divide(a1,2))
print(a1 ** 2)
print(np.power(a1,2))
print(np.mod(a1,2))
#[1 2 3 4 5 6 7 8 9]
#[ 2  3  4  5  6  7  8  9 10]
#[11 12 13 14 15 16 17 18 19]
#[-1  0  1  2  3  4  5  6  7]
#[-9 -8 -7 -6 -5 -4 -3 -2 -1]
#[-1 -2 -3 -4 -5 -6 -7 -8 -9]
#[-1 -2 -3 -4 -5 -6 -7 -8 -9]
#[ 2  4  6  8 10 12 14 16 18]
#[ 2  4  6  8 10 12 14 16 18]
#[0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5]
#[0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5]
#[0 1 1 2 2 3 3 4 4]
#[0 1 1 2 2 3 3 4 4]
#[ 1  4  9 16 25 36 49 64 81]
#[ 1  4  9 16 25 36 49 64 81]
#[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)
print(a1 + b1)
print(a1 - b1)
print(a1 * b1)
print(a1 / b1)
print(a1 // b1)
print(a1 ** b1)
print(a1 % b1)
#[1 2 3 4 5 6 7 8 9]
#[9 7 2 2 2 2 5 9 1]
#[10  9  5  6  7  8 12 17 10]
#[-8 -5  1  2  3  4  2 -1  8]
#[ 9 14  6  8 10 12 35 72  9]
#[0.11111111 0.28571429 1.5        2.         2.5        3.
# 1.4        0.88888889 9.        ]
#[0 0 1 2 2 3 1 0 9]
#[        1       128         9        16        25        36     16807
# 134217728         9]
#[1 2 1 0 1 0 2 8 0]

a2 = np.arange(1,10).reshape(3,3)
print(a2)
b2 = np.random.randint(1,10, size=(3,3))
print(b2)
print(a2 + b2)
print(a2 - b2)
print(a2 * b2)
print(a2 / b2)
print(a2 // b2)
print(a2 ** b2)
print(a2 % b2)
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#[[3 8 1]
# [1 2 4]
# [1 3 2]]
#[[ 4 10  4]
# [ 5  7 10]
# [ 8 11 11]]
#[[-2 -6  2]
# [ 3  3  2]
# [ 6  5  7]]
#[[ 3 16  3]
# [ 4 10 24]
# [ 7 24 18]]
#[[0.33333333 0.25       3.        ]
# [4.         2.5        1.5       ]
# [7.         2.66666667 4.5       ]]
#[[0 0 3]
# [4 2 1]
# [7 2 4]]
#[[   1  256    3]
# [   4   25 1296]
# [   7  512   81]]
#[[1 2 0]
# [0 1 2]
# [0 2 1]]

절대값 함수(Absolute Function)

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

a1 = np.random.randint(-10,10, size=5)
print(a1)
print(np.absolute(a1))
print(np.abs(a1))
#[-5  3  7  8  1]
#[5 3 7 8 1]
#[5 3 7 8 1]

제곱/제곱근 함수

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

print(a1)
print(np.square(a1))
print(np.sqrt(a1))
#[-5  3  7  8  1]
#[25  9 49 64  1]
#[       nan 1.73205081 2.64575131 2.82842712 1.        ]
#<ipython-input-14-4e034cb7ea92>:3: RuntimeWarning: invalid value encountered in sqrt
#  print(np.sqrt(a1))

지수와 로그 함수 (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))
#[6 2 6 1 5]
#[403.42879349   7.3890561  403.42879349   2.71828183 148.4131591 ]
#[64.  4. 64.  2. 32.]
#[36  4 36  1 25]

print(a1)
print(np.log(a1))
print(np.log2(a1))
print(np.log10(a1))
#[6 2 6 1 5]
#[1.79175947 0.69314718 1.79175947 0.         1.60943791]
#[2.5849625  1.         2.5849625  0.         2.32192809]
#[0.77815125 0.30103    0.77815125 0.         0.69897   ]

삼각 함수(Trigonometrical Function)

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)

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))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#54 54
#[20  8 26] [20  8 26]
#[23 19 12] [23 19 12]

cumsum(): 누적합 계산

print(a2)
print(np.cumsum(a2))
print(np.cumsum(a2, axis=0))
print(np.cumsum(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#[ 9 14 23 32 34 42 44 45 54]
#[[ 9  5  9]
# [18  7 17]
# [20  8 26]]
#[[ 9 14 23]
# [ 9 11 19]
# [ 2  3 12]]

diff(): 차분 계산

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

prod(): 곱 계산

print(a2)
print(np.prod(a2))
print(np.prod(a2, axis=0))
print(np.prod(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#1049760
#[162  10 648]
#[405 144  18]

cumprod(): 누적곱 계산

print(a2)
print(np.cumprod(a2))
print(np.cumprod(a2, axis=0))
print(np.cumprod(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#[      9      45     405    3645    7290   58320  116640  116640 1049760]
#[[  9   5   9]
# [ 81  10  72]
# [162  10 648]]
#[[  9  45 405]
# [  9  18 144]
# [  2   2  18]]

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

print(a2)
b2 = np.ones_like(a2)
print(b2)
print(np.dot(a2,b2))
print(np.matmul(a2,b2))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#[[1 1 1]
# [1 1 1]
# [1 1 1]]
#[[23 23 23]
# [19 19 19]
# [12 12 12]]
#[[23 23 23]
# [19 19 19]
# [12 12 12]]

tensordot(): 텐서곱 계산

print(a2)
print(b2)
print(np.tensordot(a2, b2))
print(np.tensordot(a2, b2, axes=0))
print(np.tensordot(a2, b2, axes=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#[[1 1 1]
# [1 1 1]
# [1 1 1]]
#54
#[[[[9 9 9]
#   [9 9 9]
#   [9 9 9]]
#
#  [[5 5 5]
#   [5 5 5]
#   [5 5 5]]
#
#  [[9 9 9]
#   [9 9 9]
#   [9 9 9]]]
#
#
# [[[9 9 9]
#   [9 9 9]
#   [9 9 9]]
#
#  [[2 2 2]
#   [2 2 2]
#   [2 2 2]]
#
#  [[8 8 8]
#   [8 8 8]
#   [8 8 8]]]
#
#
# [[[2 2 2]
#   [2 2 2]
#   [2 2 2]]
#
#  [[1 1 1]
#   [1 1 1]
#   [1 1 1]]
#
#  [[9 9 9]
#   [9 9 9]
#   [9 9 9]]]]
#[[23 23 23]
# [19 19 19]
# [12 12 12]]

cross(): 벡터곱

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

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

print(a2)
print(b2)
print(np.inner(a2,b2))
print(np.outer(a2,b2))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#[[1 1 1]
# [1 1 1]
# [1 1 1]]
#[[23 23 23]
# [19 19 19]
# [12 12 12]]
#[[9 9 9 9 9 9 9 9 9]
# [5 5 5 5 5 5 5 5 5]
# [9 9 9 9 9 9 9 9 9]
# [9 9 9 9 9 9 9 9 9]
# [2 2 2 2 2 2 2 2 2]
# [8 8 8 8 8 8 8 8 8]
# [2 2 2 2 2 2 2 2 2]
# [1 1 1 1 1 1 1 1 1]
# [9 9 9 9 9 9 9 9 9]]

mean(): 평균 계산

print(a2)
print(np.mean(a2))
print(np.mean(a2, axis=0))
print(np.mean(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#6.0
#[6.66666667 2.66666667 8.66666667]
#[7.66666667 6.33333333 4.        ]

std(): 표준 편차 계산

print(a2)
print(np.std(a2))
print(np.std(a2, axis=0))
print(np.std(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#3.2998316455372216
#[3.29983165 1.69967317 0.47140452]
#[1.88561808 3.09120617 3.55902608]

var(): 분산 계산

print(a2)
print(np.var(a2))
print(np.var(a2, axis=0))
print(np.var(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#10.88888888888889
#[10.88888889  2.88888889  0.22222222]
#[ 3.55555556  9.55555556 12.66666667]

min(): 최소값

print(a2)
print(np.min(a2))
print(np.min(a2, axis=0))
print(np.min(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#1
#[2 1 8]
#[5 2 1]

max(): 최대값

print(a2)
print(np.max(a2))
print(np.max(a2, axis=0))
print(np.max(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#9
#[9 5 9]
#[9 9 9]

argmin(): 최소값 인덱스

print(a2)
print(np.argmin(a2))
print(np.argmin(a2, axis=0))
print(np.argmin(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#7
#[2 2 1]
#[1 1 1]

argmax(): 최대값 인덱스

print(a2)
print(np.argmax(a2))
print(np.argmax(a2, axis=0))
print(np.argmax(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#0
#[0 0 0]
#[0 0 2]

median(): 중앙값

print(a2)
print(np.median(a2))
print(np.median(a2, axis=0))
print(np.median(a2, axis=1))
#[[9 5 9]
# [9 2 8]
# [2 1 9]]
#8.0
#[9. 2. 9.]
#[9. 8. 2.]

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='nearest'))
print(np.percentile(a1, [0,20,40,60,80,100], interpolation='midpoint'))
#
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='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 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]

all()

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

비교 연산(Comparison Operators)

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

a2 = np.arange(1,10).reshape(3,3)
print(a2)
print(np.sum(a2))
print(np.count_nonzero(a2>5))
print(np.sum(a2 > 5))
print(np.sum(a2 > 5, axis = 0))
print(np.sum(a2 > 5, axis = 1))
print(np.any(a2 > 5))
print(np.any(a2 > 5, axis = 0))
print(np.any(a2 > 5, axis = 1))
print(np.all(a2 > 5))
print(np.all(a2 > 5, axis = 0))
print(np.all(a2 > 5, axis = 1))
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#45
#4
#4
#[1 1 2]
#[0 1 3]
#True
#[ True  True  True]
#[False  True  True]
#False
#[False False False]
#[False False  True]

a1 = np.array([1,2,3,4,5])
print(a1)
a2 = np.array([1,2,3,3,4])
print(a2)
print(np.isclose(a1, a2))
#[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)

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)])
#
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))
print(a1)
print(a1.sort())
print(a1)
#[3 7 4 1 7 4 6 8 7 5]
#[1 3 4 4 5 6 7 7 7 8]
#[3 7 4 1 7 4 6 8 7 5]
#[3 0 2 5 9 6 1 4 8 7]
#[3 7 4 1 7 4 6 8 7 5]
#None
#[1 3 4 4 5 6 7 7 7 8]

a2 = np.random.randint(1,10,size=(3,3))
print(a2)
print(np.sort(a2, axis=0))
print(np.sort(a2, axis=1))
#[[2 7 2]
# [6 1 2]
# [5 1 7]]
#[[2 1 2]
# [5 1 2]
# [6 7 7]]
#[[2 2 7]
# [1 2 6]
# [1 5 7]]

부분 정렬

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

a1 = np.random.randint(1,10,size=10)
print(a1)
print(np.partition(a1,3))
#[1 6 6 4 5 6 7 2 3 5]
#[1 2 3 4 5 6 7 6 6 5]

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

배열 입출력

a2 = np.random.randint(1,10,size=(5,5))
print(a2)
np.save("a", a2)
#[[5 5 6 4 5]
# [9 9 8 6 5]
# [7 4 9 6 1]
# [8 6 3 3 8]
# [6 1 9 2 4]]

!ls
#a.npy  sample_data

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

!ls  
#ab.npy	ab.npz	a.npy  sample_data  

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

!ls
#ab.npy	ab.npz	a.npy  sample_data

npy = np.load("a.npy")
print(npy)
#[[5 5 6 4 5]
# [9 9 8 6 5]
# [7 4 9 6 1]
# [8 6 3 3 8]
# [6 1 9 2 4]]

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

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

!ls  
#ab.npy	ab.npz	a.csv  a.npy  sample_data  

!cat a.csv
#5.000000000000000000e+00,5.000000000000000000e+00,6.000000000000000000e+00,4.000000000000000000e+00,5.000000000000000000e+00
#9.000000000000000000e+00,9.000000000000000000e+00,8.000000000000000000e+00,6.000000000000000000e+00,5.000000000000000000e+00
#7.000000000000000000e+00,4.000000000000000000e+00,9.000000000000000000e+00,6.000000000000000000e+00,1.000000000000000000e+00
#8.000000000000000000e+00,6.000000000000000000e+00,3.000000000000000000e+00,3.000000000000000000e+00,8.000000000000000000e+00
#6.000000000000000000e+00,1.000000000000000000e+00,9.000000000000000000e+00,2.000000000000000000e+00,4.000000000000000000e+00

csv = np.loadtxt("a.csv", delimiter=',')
print(csv)
#[[5. 5. 6. 4. 5.]
# [9. 9. 8. 6. 5.]
# [7. 4. 9. 6. 1.]
# [8. 6. 3. 3. 8.]
# [6. 1. 9. 2. 4.]]

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

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

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