[Python] Numpy 배열

Numpy 라이브러리 불러오기

In [1]:

import numpy as np

 

1차원 배열(ndarray) 만들기

In [2]:

list1 = [1, 2, 3, 4, 5]
# np의 배열 생성 함수
arr = np.array(list1)
arr

Out[2]:

array([1, 2, 3, 4, 5])

 

2차원 배열(array) 만들기

In [3]:

list2 = ([1, 2, 3],[4, 5, 6]) #2차원 리스트 생성
arr2 = np.array(list2)       #2차원 리스트로 2차원 배열 생성
arr2

Out[3]:

array([[1, 2, 3],
       [4, 5, 6]])

 

배열의 크기 확인

In [4]:

# shape : 배열의 크기
print(arr.shape)
print(arr2.shape)

(5,)
(2, 3)

In [5]:

# size : 배열의 총 요소 개수
arr.size

Out[5]:

5

In [6]:

# ndim : 배열의 차원
arr.ndim

Out[6]:

1

In [7]:

# dtype : 배열의 타입 확인
arr.dtype

Out[7]:

dtype('int32')

 

3차원 배열 만들기

 

In [8]:

list3 = [[1, 2],[3, 4]],[[5, 6],[7, 8]]
arr3 = np.array(list3)
arr3
# 배열의 크기
print( '배열의 크기 :', arr3.shape)
print( '배열의 요소 개수 :', arr3.size)
print( '배열의 차원 :', arr3.ndim)

배열의 크기 : (2, 2, 2)
배열의 요소 개수 : 8
배열의 차원 : 3

 

array 생성

특정 값으로 배열 생성

In [9]:

# 0값으로 채워진 배열 생성
# np.zeros((행, 열))
np.zeros( (2,4) )

Out[9]:

array([[0., 0., 0., 0.],
       [0., 0., 0., 0.]])

In [10]:

# 1값으로 채워진 배열 생성
# np.ones((행, 열))
np.ones( (4,3) )

Out[10]:

array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

In [11]:

# 내가 원하는 값으로 채워진 배열 생성
# np.full( (행, 열), 원하는 값 )
np.full( (3, 3), 7 )

Out[11]:

array([[7, 7, 7],
       [7, 7, 7],
       [7, 7, 7]])

 

범위 배열 생성

In [12]:

# 특정 범위(range)의 값으로 배열생성
list1 = []
for i in range(1, 51):
    list1.append(i)
list1
np.array(list1)

Out[12]:

array([ 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, 28, 29, 30, 31, 32, 33, 34,
       35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50])

In [13]:

# 특정 범위(range)의 값으로 배열생성
arange_arr = np.arange(1, 51)
arange_arr

Out[13]:

array([ 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, 28, 29, 30, 31, 32, 33, 34,
       35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50])

 

난수 배열 생성하기

In [14]:

# 랜덤값 생성하기 1 - 0~1 사이 실수값으로 구성
np.random.rand(2, 3)

Out[14]:

array([[0.01651611, 0.11890547, 0.55742153],
       [0.44579388, 0.32231553, 0.2004309 ]])

In [15]:

# 랜덤값 생성하기 2 
# (시작, n-1) 사이의 랜덤한 정수 1개 생성
np.random.randint(3, 10)

Out[15]:

3

In [16]:

# size= 을 통해 배열 크기 지정
np.random.randint(3, 10, size=(2,3))

Out[16]:

array([[8, 7, 9],
       [8, 7, 7]])

In [17]:

# 타입 지정하여 배열 생성
arr_type = np.array([1.2, 3.4, 5.6, 7.2] , dtype='int')
arr_type

Out[17]:

array([1, 3, 5, 7])

In [18]:

# 배열의 타입 변경 - astype()
arr_type.astype('float')

Out[18]:

array([1., 3., 5., 7.])

 

array 연산

In [19]:

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

Out[19]:

[1, 2, 3, 4, 5, 6]

In [20]:

list3 = []

for i in range(len(list1)):
    list3.append(list1[i] + list2[i])
list3

Out[20]:

[5, 7, 9]

In [21]:

# array는 기본적으로 요소별 연산을 진행한다.
arr1 = np.array(list1)
arr2 = np.array(list2)

print(arr1 + arr2)
print(arr1 * arr2)

[5 7 9]
[ 4 10 18]

 

인덱싱, 슬라이싱

인덱싱

In [22]:

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

Out[22]:

array([[1, 2, 3],
       [4, 5, 6]])

In [23]:

# 행 인덱싱
arr[ 0 ]

Out[23]:

array([1, 2, 3])

In [24]:

# array에서 3 인덱싱
arr[ 0 ][ 2 ]

Out[24]:

3

In [25]:

arr[ 0 , 2 ]

Out[25]:

3

 

슬라이싱

In [26]:

# np.arange(시작, 끝, 증가량)
# 디폴트 - ( 0, 작성 필요, 1)
arr1 = np.arange(10)
arr1

Out[26]:

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [27]:

np.arange(2, 10, 2)

Out[27]:

array([2, 4, 6, 8])

In [28]:

# 슬라이싱
arr1

Out[28]:

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [29]:

arr1[2:6]

Out[29]:

array([2, 3, 4, 5])

In [30]:

arr2 = np.arange(50)

In [31]:

arr2

Out[31]:

array([ 0,  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, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49])

In [32]:

# 2차원 범위 배열 생성
# reshape : 배열의 크기를 다시 지정
arr2 = np.arange(50).reshape( 5, 10 )

In [33]:

# 2차원 배열 슬라이싱
# [ 행의 범위, 열의 범위 ]
arr2[ :2 , : ]

Out[33]:

array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]])

In [34]:

arr2[ : ,  0 ]

Out[34]:

array([ 0, 10, 20, 30, 40])

In [35]:

arr2[ : , 4:8 ]

Out[35]:

array([[ 4,  5,  6,  7],
       [14, 15, 16, 17],
       [24, 25, 26, 27],
       [34, 35, 36, 37],
       [44, 45, 46, 47]])

In [36]:

arr2[ :4 , :3 ]

Out[36]:

array([[ 0,  1,  2],
       [10, 11, 12],
       [20, 21, 22],
       [30, 31, 32]])

In [37]:

#21 가져오기
arr2[ 2,1 ]

Out[37]:

21

In [38]:

# 21, 32 한 번에 가져오기
arr2[ [2, 3] , [1, 2] ]

Out[38]:

array([21, 32])

 

BMI 실습

In [39]:

# np.loadtxt( "파일명.확장자" )
# delimiter : 구분 기호
data = np.loadtxt('height_weight.txt', delimiter=',')
data

Out[39]:

array([[175.2, 180.3, 175. , 169.2, 185.2, 188. , 177.6, 178.2, 177. ,
        179. ],
       [ 65.6,  88. ,  79.2,  69.3,  55. ,  71.2,  73. ,  68.9,  74. ,
         82. ]])

 

In [40]:

# 1. data 에서 키와 몸무게를 나누기
height = data[ 0 ]
weight = data[ 1 ]

In [41]:

# 2. 키(height 변수)를 cm -> m 단위로 바꾸기!
# 1cm = 0.01m
height_m = height * 0.01

In [42]:

# 3. BMI 지수 구하기 (이미지 참고)

In [43]:

bmi = weight / (height_m*height_m)

In [44]:

bmi

Out[44]:

array([21.37153104, 27.07018468, 25.86122449, 24.20652885, 16.03543423,
       20.14486193, 23.14392095, 21.69720651, 23.62028791, 25.59220998])

 

Boolean 색인

In [45]:

score = np.array( [70,95,100,80,60,20] )
bool_li = [True, False, False, True, True, False]
score[bool_li]

Out[45]:

array([70, 80, 60])

In [46]:

score + 3

Out[46]:

array([ 73,  98, 103,  83,  63,  23])

In [47]:

score - 3

Out[47]:

array([67, 92, 97, 77, 57, 17])

In [48]:

score * 3

Out[48]:

array([210, 285, 300, 240, 180,  60])

In [49]:

bool_arr = score >= 60

In [50]:

bool_arr

Out[50]:

array([ True,  True,  True,  True,  True, False])

In [51]:

score[score>=60]

Out[51]:

array([ 70,  95, 100,  80,  60])

 

함수

In [52]:

# 합계구하기
score = np.array([70,95,100,80,60,20])
print( score.sum() )
print( np.sum(score) )

425
425

In [53]:

# 평균구하기
score = np.array([70,95,100,80,60,20])
print( score.mean() )
print( np.mean(score) )

70.83333333333333
70.83333333333333

 

영화 평점데이터 연산

In [54]:

# userId, itemId, rating, timestamp
ratings = np.loadtxt('ratings.txt', delimiter=',', dtype = np.int64)
ratings

Out[54]:

array([[        1,      1193,         5, 978300760],
       [        1,       661,         3, 978302109],
       [        1,       914,         3, 978301968],
       ...,
       [     6040,       562,         5, 956704746],
       [     6040,      1096,         4, 956715648],
       [     6040,      1097,         4, 956715569]], dtype=int64)

In [55]:

print(ratings.ndim)
print(ratings.shape)
print(ratings.size)

2
(1000209, 4)
4000836

In [56]:

# 전체 평점 평균 구하기
rating = ratings[ :,2]
rating.mean()

Out[56]:

3.581564453029317

In [57]:

# userId가 1인 user의 평점 평균 구하기
b = ratings[:,0] == 1
ratings[b,2].mean()

Out[57]:

4.188679245283019

In [58]:

print(ratings.shape)
print(ratings[:,0].shape)
test = ratings[:,0]==1
print(test.shape)

(1000209, 4)
(1000209,)
(1000209,)

In [59]:

# userId가 5인 user의 평점 평균 구하기
ratings[ratings[:,0]==5, 2].mean()

Out[59]:

3.1464646464646466

In [60]:

# 고유한 요소 1개씩 남겨서 배열 생성
unique_id = np.unique(ratings[:, 0])

li = []
for user_id in unique_id :
    b = ratings[:,0] == user_id
    user_mean = ratings[b, 2].mean()
    li.append([user_id, user_mean])

In [61]:

li[:]

Out[61]:

[[1, 4.188679245283019],
 [2, 3.7131782945736433],
 [3, 3.9019607843137254],
 [4, 4.190476190476191],
 [5, 3.1464646464646466],
 [6, 3.9014084507042255],
 [7, 4.32258064516129],
 [8, 3.884892086330935],
 [9, 3.7358490566037736],
 [10, 4.114713216957606],
 [11, 3.2773722627737225],
 [12, 3.8260869565217392],
 [13, 3.388888888888889],
 [14, 3.32],
 [15, 3.3233830845771144],
 [16, 3.0285714285714285],
 [17, 4.075829383886256],
 [18, 3.6491803278688524],
 [19, 3.5725490196078433],
 [20, 4.083333333333333],
 [21, 2.909090909090909],
 [22, 3.0673400673400675],
 [23, 3.3157894736842106],
 [24, 3.948529411764706],
 [25, 3.7411764705882353],
 [26, 2.96],
 [27, 4.171428571428572],
 [28, 3.7570093457943927],
 [29, 3.5833333333333335],
 [30, 3.488372093023256],
 [31, 3.73109243697479],
 [32, 3.625],
 [33, 3.498721227621483],
 [34, 3.8658536585365852],
 [35, 3.54040404040404],
 [36, 4.199430199430199],
 [37, 3.69811320754717],
 [38, 3.58],
 [39, 3.564516129032258],
 [40, 3.4479166666666665],
 [41, 3.48],
 [42, 3.74025974025974],
 [43, 4.125],
 [44, 3.6321243523316062],
 [45, 2.946127946127946],
 [46, 4.219512195121951],
 [47, 3.909090909090909],
 [48, 3.068561872909699],
 [49, 3.712962962962963],
 [50, 3.0697674418604652],
 ...]

In [62]:

ratings[:, 0].shape

Out[62]:

(1000209,)

In [63]:

# ItemId별 평점 평균 구하기
unique_item = np.unique(ratings[:, 1])

li = []
for item_id in unique_item:
    c = ratings[:, 1] == item_id
    item_mean = ratings[c, 2].mean()
    li.append([item_id, item_mean])

In [65]:

li[:]

Out[65]:

[[1, 4.146846413095811],
 [2, 3.20114122681883],
 [3, 3.01673640167364],
 [4, 2.7294117647058824],
 [5, 3.0067567567567566],
 [6, 3.8787234042553194],
 [7, 3.410480349344978],
 [8, 3.014705882352941],
 [9, 2.656862745098039],
 [10, 3.5405405405405403],
 [11, 3.7938044530493706],
 [12, 2.3625],
 [13, 3.2626262626262625],
 [14, 3.542483660130719],
 [15, 2.458904109589041],
 [16, 3.7932551319648096],
 [17, 4.027544910179641],
 [18, 3.337579617834395],
 [19, 2.480719794344473],
 [20, 2.5375],
 [21, 3.6238938053097347],
 [22, 3.3492063492063493],
 [23, 2.857142857142857],
 [24, 3.1794871794871793],
 [25, 3.6510204081632653],
 [26, 3.53],
 [27, 2.9344262295081966],
 [28, 4.055865921787709],
 [29, 4.062034739454094],
 [30, 3.6486486486486487],
 [31, 3.1134751773049647],
 [32, 3.945731303772336],
 [33, 3.0],
 [34, 3.8914905768132497],
 [35, 3.3142857142857145],
 [36, 3.9579741379310347],
 [37, 3.5],
 [38, 2.8214285714285716],
 [39, 3.6233480176211454],
 [40, 3.933333333333333],
 [41, 3.958677685950413],
 [42, 2.8687782805429864],
 [43, 3.4457831325301207],
 [44, 2.787781350482315],
 [45, 3.4246323529411766],
 [46, 3.108433734939759],
 [47, 4.106420404573439],
 [48, 2.9764397905759163],
 [49, 3.740740740740741],
 [50, 4.517106001121705],
 ...]