넘파이 (NumPy)

넘파이

 

넘파이(NumPy)는 Python에서 수치 계산과 데이터 분석을 효율적으로 수행하기 위해 사용되는 대표적인 라이브러리이다. 특히 다차원 배열(Array) 객체를 중심으로 동작하며, 대용량 데이터를 빠르고 메모리 효율적으로 처리할 수 있도록 설계되어 있다. 일반 Python 리스트보다 훨씬 빠른 연산 속도를 제공하며, 벡터 연산, 행렬 계산, 통계 처리, 선형대수, 난수 생성 등 다양한 수학 기능을 지원한다.

# 설치
pip install numpy
# 또는
python -m pip install numpy

ndarray

 

NumPy의 ndarray(N-dimensional array)는 NumPy의 핵심 자료구조로, 동일한 자료형(dtype)을 가지는 데이터를 다차원 형태로 저장하고 빠르게 연산할 수 있도록 만든 배열 객체이다. 일반 Python 리스트보다 메모리 사용량이 적고 연산 속도가 매우 빠르며, 벡터 연산과 브로드캐스팅 기능을 통해 반복문 없이도 대량의 데이터를 효율적으로 처리할 수 있다.

import numpy as np

ndarr1 = np.array([1, 2, 3, 4])
print(ndarr1)              # [1 2 3 4]
print(type(ndarr1))        # <class 'numpy.ndarray'>
print(type(ndarr1[0]))     # <class 'numpy.int64'>

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

# 리스트를 ndarray로 변환

list1 = [1, 2, 3, 4]
ndarr1 = np.array(list1)
print(ndarr1)         # [1 2 3 4]
print(type(ndarr1))   # <class 'numpy.ndarray'>

# ndarray를 리스트로 변환

list2 = ndarr1.tolist()
print(list2)         # [1, 2, 3, 4]
print(type(list2))   # <class 'list'>

ndarr1 = np.array([1, 2, 3, 4])
print(ndarr1)             # [1 2 3 4]
print(type(ndarr1))       # <class 'numpy.ndarray'>
print(type(ndarr1[0]))    # <class 'numpy.int64'>
print(type(ndarr1[1]))    # <class 'numpy.int64'>
print(type(ndarr1[2]))    # <class 'numpy.int64'>
print(type(ndarr1[3]))    # <class 'numpy.int64'>    
# 모두 int일때는 int로

ndarr2 = np.array([1, 2, 3.14, 4])
print(ndarr2)             # [1.   2.   3.14 4.  ]
print(type(ndarr2))       # <class 'numpy.ndarray'>
print(type(ndarr2[0]))    # <class 'numpy.float64'>
print(type(ndarr2[1]))    # <class 'numpy.float64'>
print(type(ndarr2[2]))    # <class 'numpy.float64'>
print(type(ndarr2[3]))    # <class 'numpy.float64'>  
# int, float이 섞여있을땐 더 큰 범위인 float으로

ndarr3 = np.array([1, 2, 3.14, True])
print(ndarr3)             # [1.   2.   3.14 1.  ]
print(type(ndarr3))       # <class 'numpy.ndarray'>
print(type(ndarr3[0]))    # <class 'numpy.float64'>
print(type(ndarr3[1]))    # <class 'numpy.float64'>
print(type(ndarr3[2]))    # <class 'numpy.float64'>
print(type(ndarr3[3]))    # <class 'numpy.float64'>
# int, float, bool이 섞여있을땐 float

ndarr4 = np.array(['1', 2, 3.14, True])
print(ndarr4)             # ['1' '2' '3.14' 'True']
print(type(ndarr4))       # <class 'numpy.ndarray'>
print(type(ndarr4[0]))    # <class 'numpy.str_'>
print(type(ndarr4[1]))    # <class 'numpy.str_'>
print(type(ndarr4[2]))    # <class 'numpy.str_'>
print(type(ndarr4[3]))    # <class 'numpy.str_'>
# int, float, bool, str이 섞여있을땐 가장 큰 범위인 str

인덱싱과 슬라이싱

 

넘파이의 ndarray는 리스트와 유사하게 인덱싱과 슬라이싱을 지원한다.

# 2차원 배열
ndarr2d = np.array([[1, 2, 3, 4],
                    [5, 6, 7, 8],
                    [9, 10, 11, 12]])
print(ndarr2d)
print(ndarr2d.shape)

# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
# (3, 4)

# 0행 가져오기
print(ndarr2d[0, :])
print(ndarr2d[0,])
print(ndarr2d[0])

# [1 2 3 4]
# [1 2 3 4]
# [1 2 3 4]

# 0열 가져오기
print(ndarr2d[:, 0])

# [1 5 9]

# fancy indexing
ndarr1 = np.array([10, 15, 2, 8, 20, 90, 85, 44, 23, 32])
idx = [2, 5, 9]
print(ndarr1[idx]) # ndarr1[[2, 5, 9]]

# [ 2 90 32]

ndarr2d = np.array([[1, 2, 3, 4], 
                    [5, 6, 7, 8], 
                    [9, 10, 11, 12]])
print(ndarr2d[[0, 1], :])

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

# logical indexing
ndarr1 = np.array(['🍓', '🍉', '🍌', '🍒', '🍑'])
sel = [True, False, True, True, False]  # 전체 데이터의 숫자와 bool 데이터의 숫자가 동일해야 함.
ndarr1[sel]

# array(['🍓', '🍌', '🍒'], dtype='<U1')

ndarr2d = np.array([[1, 2, 3, 4],
                    [5, 6, 7, 8],
                    [9, 10, 11, 12]])

print(ndarr2d > 7)          
print(ndarr2d[ndarr2d > 7])

# [[False False False False]
#  [False False False  True]
#  [ True  True  True  True]]
# [ 8  9 10 11 12]

행렬 연산

 

넘파이에서는 다차원 배열인 ndarray를 사용하여 행렬 연산을 수행할 수 있다. 행렬 연산은 선형 대수와 관련이 깊어, 데이터 과학, 머신러닝, 통계 등 다양한 분야에서 사용된다.

선형 대수

선형 대수는 벡터와 행렬을 사용해 공간과 변환을 다루는 수학의 한 분야이다. 쉽게 말해, 여러 숫자를 체계적으로 배열한 벡터(리스트 같은 것)와 행렬(숫자가 격자로 배열된 표)을 이용해 데이터를 표현하고 조작하는 방법이다. 선형 대수는 컴퓨터 그래픽스, 머신러닝, 물리학, 공학 등 다양한 분야에서 사용된다. 예를 들어, 사진에서 색상을 조정하거나, 로봇이 움직일 경로를 계산하거나, AI가 데이터를 분석하는 데도 선형 대수가 필요하다.

스칼라(Scalar)

스칼라는 하나의 숫자만으로 이루어진 가장 기본적인 데이터 형태이다. 방향(direction)이나 구조(shape)는 없고 오직 크기(magnitude)만 가지며, 일반적인 정수나 실수 값이 모두 스칼라에 해당한다.

벡터(Vector)

벡터는 여러 개의 숫자가 1차원으로 나열된 구조이며, 크기와 방향을 함께 표현하는 데이터다. 수학에서는 화살표 개념으로 사용되며, 프로그래밍에서는 1차원 배열 형태로 표현된다. 예를 들어 [1, 2, 3]은 3차원 벡터다. NumPy에서는 보통 1차원 ndarray 형태로 다루며, 벡터 간에는 덧셈, 내적(dot product), 크기 계산 등의 연산을 수행할 수 있다.

1. 행렬

ndarr3 = np.array([[1, 2, 3],
                   [1, 2, 3],
                   [2, 3, 4]])
ndarr4 = np.array([[1, 2],
                   [3, 4],
                   [5, 6]])
                   
                   
print(ndarr3 @ ndarr4)  # 행렬 곱셈

# [[22 28]
#  [22 28]
#  [31 40]]

# 내적: 두 벡터를 곱해서 하나의 숫자(스칼라)를 만드는 연산
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

print(np.dot(a, b)) # 1*4+2*5+3*6

정렬

 

NumPy의 np.sort() 함수는 배열을 정렬하는 데 사용된다. 이 함수는 기본적을 원래 배열을 변경하지 않고 정렬된 배열의 복사본을 반환한다.

ndarr1 = np.array([1, 10, 5, 7, 2, 4, 3, 6, 8, 9])
print(ndarr1)
print(np.sort(ndarr1)) # 오름차순 정렬
print(ndarr1) # 원래 배열은 그대로
print(np.sort(ndarr1)[::-1]) # 내림차순 정렬

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

ndarr2d = np.array([[11, 10, 12, 9],
                    [3, 1, 4, 2],
                    [5, 6, 7, 8]])
print(ndarr2d.shape)       # (3, 4)
np.sort(ndarr2d, axis=0) 
# 모든 행의 1열만 보고 오름차순 정렬 / axis=0 은 행을 가리킴 > 행 단위 sort
# array([[ 3,  1,  4,  2],
#        [ 5,  6,  7,  8],
#        [11, 10, 12,  9]])

np.sort(ndarr2d, axis=1) 
# 각 행을 오름차순으로 정렬 / axis=1 은 열을 가리킴 > 열 단위 sort       
# array([[ 9, 10, 11, 12],
#        [ 1,  2,  3,  4],
#        [ 5,  6,  7,  8]])

np.sort(ndarr2d, axis=1)[:, ::-1]
# array([[12, 11, 10,  9],
#        [ 4,  3,  2,  1],
#        [ 8,  7,  6,  5]])

np.sort(ndarr2d, axis=-1)
# array([[ 9, 10, 11, 12],
#        [ 1,  2,  3,  4],
#        [ 5,  6,  7,  8]])