Python_Numpy

1. 넘파이(Numpy)

• 수학, 과학 계산용 패키지
• 자료구조(ndarray)를 제공한다. 파이썬의 list 보다 속도가 빠름, 적은 메모리를 사용한다

1-1.Ndarray(하나의 자료구조)

 

●핵심 기능은 다차원 배열인 'ndarray'로, 동일한 타입의 요소들로 구성된 n차원의 배열(자료구조).

Python의 '리스트'와 비슷한 구조이나 빠른 속도, 적은 메모리의 사용, 연속적인 저장의 특징이 있음.

→ 데이터에 효율적인 접근과 연산을 가능케 함

list1 = [1,2,3,4]
list2 = [[1,2,3,4],[5,6,7,8]]


ndarr1 = np.array([1,2,3,4])
print(ndarr1)
print(type(ndarr1)) # ndarray = n dimension array


# 리스트를 ndarray 로 변환하는 방법
ndarr1 =np.array(list1)
ndarr2 =np.array(list2)
print(list1)
print(list2)

1-2.ndarray의 data type

●ndarray는 n dimension array의 약어로, 'n차원 배열'이라는 의미임.

리스트랑 달리 타입은 numpy.ndarry이다.

 

 

1-3 ndarray 슬라이싱

ndarr1 = np.array(['🍊','🥭','🍇','🐥','🍈','🍋'])
ndarr1

=========================================================
array(['🍊', '🥭', '🍇', '🐥', '🍈', '🍋'], dtype='<U1')

# shape -> ndarray 에 있는 데이터의 차원크기 반환
# 6행,1차원
ndarr1.shape
=========================================================
(6,)


#인덱싱
print(ndarr1[0])
print(ndarr1[1])
print(ndarr1[2])
print(ndarr1[3])
print(ndarr1[4])
=========================================================
🍊
🥭
🍇
🐥
🍈

#슬라이싱
print(ndarr1[0:3])
print(ndarr1[:5])
print(ndarr1[2:])
=========================================================
['🍊' '🥭' '🍇']
['🍊' '🥭' '🍇' '🐥' '🍈']
['🍇' '🐥' '🍈' '🍋']

1-4. Fancy 인덱싱
●범위가 아닌 특정 idnex의 집합의 값들을 선택해서 추출하고 싶을 떄 사용

 

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



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


# 0번행 1번행 전부 불러오기
ndarr2d[[0,1],:]
========================================================
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

1-5.Boolean 인덱싱
●조건에 대한 필터링을 통해 Boolean 값을 이용한 색인을 사용

ndarr1 = np.array(['🍊','🥭','🍇','🍓','🍈'])
selValue = [True,False,True,True,False]
ndarr1[selValue]
====================================================
array(['🍊', '🍇', '🍓'], dtype='<U1')



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


ndarr2d[ndarr2d > 7]
====================================================
array([ 8,  9, 10, 11, 12])

 

 

2.행렬 연산

 

2-1.연산자

● 덧셈,뺄셈, 곱셈, 나눗셈은 shape가 같아야함
● 연산의 대한 결과는 같은 position 끼리 연산됨
● 내적은 맞닿는 shape가 같아야 함
● 내적은 떨어져 있는 shape 가 결과 행렬이 됨

 

 

a = np.array([[1,2,3],
             [2,3,4]])

b = np.array([[3,4,5],
              [1,2,3]])
a.shape,b.shape
=======================================
((2, 3), (2, 3))


# 덧셈 연산
a+b
=======================================
array([[4, 6, 8],
       [3, 5, 7]])
       
#뺼셈 연산
a-b
=======================================
array([[-2, -2, -2],
       [ 1,  1,  1]])

#나눗셈
a/b
=======================================
array([[0.33333333, 0.5       , 0.6       ],
       [2.        , 1.5       , 1.33333333]])


# dot product(행렬곱, 내적)
a = np.array([[1,2,3],
              [1,2,3],
              [2,3,4]])

b = np.array([[1,2],
              [3,4],
              [5,6]])

a.shape, b.shape
=======================================
((3, 3), (3, 2))


np.dot(a,b)
=======================================
array([[22, 28],
       [22, 28],
       [31, 40]])

2-2.arange
● 순차적인 값을 생성할 때 사용

 

 

arr1 =range(1,11)
arr1
==========================================
range(1, 11)


for i in arr1:
  print(i,end= ' ')
==========================================

1 2 3 4 5 6 7 8 9 10 


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


for i in arr2:
  print(i,end=' ')
==========================================
1 2 3 4 5 6 7 8 9 10

 

2-3.sort

ndarr1 = np.array([1,10,5,7,2,4,3,6,8,9])
np.sort(ndarr1)
=========================================
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])



ndarr1
=========================================
array([ 1, 10,  5,  7,  2,  4,  3,  6,  8,  9])



# 문자열 역순으로 출력하기
str1 ='Python'
print(str1[:]) # 모든 문자 슬라이싱
print(str1[::]) # print(str1[::1]) => 1: 정방향 
print(str1[::-1])
print(str1[4:1:-1]) # 4번 인덱스부터 1직전까지 역순으로 가져오기 
print(str1[4::-1]) # 4번부터 역순으로  0까지 가져오기
=========================================
Python
Python
nohtyP
oht
ohtyP


np.sort(ndarr1)[::-1]
=========================================
array([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]])
ndarr2d.shape
=========================================
(3, 4)


# axis=0 행으로 정렬,앞에 있는 숫자 기준
np.sort(ndarr2d,axis=0) 
=========================================
array([[ 3,  1,  4,  2],
       [ 5,  6,  7,  8],
       [11, 10, 12,  9]])
       
       
# axis=1 열으로 정렬,열끼리 
np.sort(ndarr2d,axis=1)     
=========================================
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]])
       
       

#축의 마지막 방향 axis= -1
np.sort(ndarr2d, axis=-1)
=========================================
array([[ 9, 10, 11, 12],
       [ 1,  2,  3,  4],
       [ 5,  6,  7,  8]])

 2-4 숫자의 단일연산

 

a = np.array([[1,2,3],
              [4,5,6]])
#덧셈
a+3  
========================================
array([[4, 5, 6],
       [7, 8, 9]])
     
     
     
#뺄셈
a-3
========================================
array([[-2, -1,  0],
       [ 1,  2,  3]])
       
       
#나눗셈
a/3
========================================
array([[0.33333333, 0.66666667, 1.        ],
       [1.33333333, 1.66666667, 2.        ]])
       
       
b =np.array([[3,3,3],
             [3,3,3]])
a+b
========================================
array([[4, 5, 6],
       [7, 8, 9]])