---

F37.101 컴퓨팅 기초: 처음 만나는 컴퓨팅(First Adventures in Computing)

---

Chapter 10. Numpy

학습목표와 기대효과

• 학습목표

  • 배열을 생성해보고 다뤄보자.

  • 배열과 리스트의 차이를 알아보자.

  • Shallow copy와 Deep Copy를 이해하자.

• 기대효과

  • 다수의 데이터를 저장하기 위해 적절한 자료형을 선택할 수 있고 다룰 수 있다.

배열(Array)

• numpy는 Number와 python의 합성어이다.

• 행렬이나 대규모 다차원 배열을 쉽고 빠르게 처리할 수 있도록 하는 파이썬 라이브러리이며, 간단한 기능부터 계산과학 분야의 복잡한 연산을 지원하기 위한 기능들까지 포함되어 있다.

• numpy의 배열에는 모두 동일한 자료형만 저장이 가능하다.

• numpy를 사용하기 위해서는 import로 모듈을 불러와야한다.

• 공공연한 약속처럼 numpy 모듈은 보통 np라는 별칭으로 불리운다.

• 별칭은 as라는 키워드를 사용하여 만든다.

import numpy as np

1-D array(벡터) 생성하기

• 1차원 배열부터 만들어보자.

• numpy모듈에서는 배열을 생성하는 다양한 방법을 지원한다.

  • numpy 모듈의 array()를 통해 배열을 만들 수 있다.

  • numpy 모듈의 arange()를 통해 배열을 만들 수 있다.

np.array(리스트 or range())
np.arange(start, end, step)

ar1 = np.array([10,25,36,41,59])
ar11 = np.array(range(10))
ar111 = np.arange(1,6)

2-D array(매트릭스, 행렬) 생성하기

• 2차원 배열은 행(Row)과 열(Column)로 구성되어 있다.

• 아래 그림은 엑셀 또는 스프레드 시트에서의 행과 열을 보여주고 있다.

• 행은 가로 방향으로 줄을 세운 것이며, 열은 세로 방향으로 줄을 세운 것이다.

• 위 그림에서는 행은 숫자1부터, 열은 알파벳 A부터 시작하고 있으나 numpy 배열에서 행렬은 항상 0부터 시작한다.

• 2차원 배열은 array()에 중첩 리스트를 넣어주거나, arange()로 1차원 배열을 만든 후 배열모양을 바꿔주는 reshape()을 통해서 2차원 배열을 생성할 수 있다.

np.array([리스트 of 리스트])
np.arange(start,end,step).reshape(row, column)

• 여기서 row는 행의 개수, column은 열의 개수이다.

ar2 = np.array([[1,2,3], [4,5,6], [7,8,9], [10,11,12]])
ar22 = np.arange(1,13).reshape(4,3)

• 이때 column을 -1로 써주면 각 행에 들어갈 데이터의 개수를 똑같이 적용해준다. 이를 위해서는 배열 원소의 개수와 row*column의 개수가 같아야 한다.

ar222 = ar2.reshape(3,-1)

3-D array(텐서) 생성하기

• 3차원 배열은 면(page), 행, 열을 가진다.

• 생성하는 방법은 2차원 배열과 유사하지만 리스트가 3번 중첩된다.

np.array([리스트 of 리스트 of 리스트])
np.arange(start,end,step).reshape(page, row, column)

ar3 = np.array([[[1,2,3], [4,5,6]],
                [[7,8,9], [10,11,12]]])
ar33 = np.arange(1,13).reshape(2,2,3)

😄3차원 배열 생성하기

다음과 같은 배열을 생성하시오.

[[[100  90  80]
  [ 70  60  50]]

 [[ 15  25  35]
  [ 45  55  65]]

 [[ 11  22  33]
  [ 44  55  66]]]

• 배열의 구성, 차수 등의 정보를 확인하기 위해서는 다음과 같은 변수를 쓸 수 있다.

배열명.ndim
배열명.shape
배열명.size

• ndim: 배열의 축 또는 차원의 개수

• shape: 배열의 모양이며, (m,n)형식으로 나타난다.

• size: 배열 원소의 개수. shape내의 원소의 크기의 곱과 같다. 즉 shape의 m*n은 size와 같다.

print(ar3.ndim)
print(ar3.shape)
print(ar3.size)

3
(2, 2, 3)
12

Numpy의 응용

• numpy로 만든 배열은 다양한 목적을 위해 사용되지만 선형 그래프를 그리기 위해 배열을 활용하는 하나의 예를 보도록 하자.

• 그래프를 그리기 위한 수식은 다음과 같다.

\(y=2x^2-3x+1\)

• 파이썬으로 그래프를 그리기 위해서는 matplotlib.pyplot 모듈을 불러와야 한다.

• matplotlib.pyplot 모듈은 보통 plt라는 별칭으로 불리운다.

• plt의 plot()은 선형그래프를 그리는 함수이다.

• 파이썬에서는 그래프를 그렸다고 해서 화면에 바로 보여주지 않는다. plt.show()는 그래프를 화면에 보여주는 함수이다.

plt.plot(x축 데이터, y축 데이터)

import matplotlib.pyplot as plt
x = np.arange(0, 5, 0.1)
y = 2*(x**2)-3*x+1
plt.plot(x, y)
plt.show()

<Figure size 640x480 with 1 Axes>

Vectorization operation

1차원으로 묶은 수를 수학에서 벡터(vector)라고 한다. 벡터연산은 벡터의 동일 인덱스에 위치한 원소들끼리 연산을 수행하는 기능이다. numpy에서는 사칙연산, 논리연산, 비교연산에 대해 모두 벡터연산을 지원한다.

• 모든 사칙연산에 대해 벡터연산을 한다.

a = np.array([1,2,3])
b = np.array([4,5,6])
print(a+b)
print(a-b)
print(a*b)
print(a/b)

[5 7 9]
[-3 -3 -3]
[ 4 10 18]
[0.25 0.4  0.5 ]

• 행렬끼리 연산할때 크기가 다른 경우 이를 자동으로 확대해 주는 기능을 브로드캐스팅이라고 한다.

• 즉, 두 배열의 모양이 다를 때, 작은 배열의 차원을 자동으로 늘려서 큰 배열과 맞춘 뒤 연산해준다.

ar0 = np.arange(12).reshape(4, 3)
ar1 = np.arange(3)
ar2 = np.arange(4).reshape(4, 1)
print(ar0, '\n\n', ar1, '\n\n', ar2)

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

 [0 1 2] 

 [[0]
 [1]
 [2]
 [3]]

ar0 + ar1

array([[ 0,  2,  4],
       [ 3,  5,  7],
       [ 6,  8, 10],
       [ 9, 11, 13]])

ar0 + ar2

array([[ 0,  1,  2],
       [ 4,  5,  6],
       [ 8,  9, 10],
       [12, 13, 14]])

• 모든 비교연산에 대해 벡터연산을 한다.

print(b>10)
print((b%2)==1)

[False False False]
[False  True False]

• 모든 논리연산에 대해 벡터연산을 한다. 그러나 and, or, not 연산자 기호를 쓰지 않는다.

  • and는 &,

  • or는 |,

  • not은 ~로 쓴다.

• 기호 이외에 별도의 논리적인 연산을 할 수 있는 함수(logical_and(), logical_or(),logical_not()…)도 존재한다.

a = np.array([160,175,157])
c = np.array(['여','여','남'])
print((a>162) | (c=='여'))

[ True  True False]

배열과 리스트의 비교

• 얼핏 비슷해 보이지만 완전히 기능이 다른 리스트(list)와 배열(array)의 차이를 간단히 비교해보자.

• 리스트와 배열의 생성에서,

  • 리스트는 정수, 실수, 문자열, 리스트 등 다양한 자료형을 하나의 리스트에 담을 수 있다.

  • 배열은 동일한 자료형만 하나의 배열에 담을 수 있다.

  • 타입은,

    • 리스트는 list 타입이다.

    • 배열은 numpy.ndarray 타입이다.

  • 출력형태

    • 리스트는 대괄호안에 콤마(,)로 아이템을 구분한다.

    • 배열은 대괄호안에 구분기호 없이 공백으로만 원소를 구분한다.

its_list = ['바나나', '딸기', 100, 5.5,['BTS', '블랙핑크']]
its_array = np.array([1, 2, 3.0])
its_array1 = np.array([1, 2, '3.0'])
its_array2 = np.array([1, 2, None])
print(its_list)
print(its_array)
print(its_array1)
print(its_array2)
print(type(its_list), type(its_array), type(its_array1), type(its_array2))

['바나나', '딸기', 100, 5.5, ['BTS', '블랙핑크']]
[1. 2. 3.]
['1' '2' '3.0']
[1 2 None]
<class 'list'> <class 'numpy.ndarray'> <class 'numpy.ndarray'> <class 'numpy.ndarray'>

• 리스트와 배열에 곱셈연산을 해보았을 때,

  • 리스트에서 곱셈은 리스트를 이어 붙이는 concatenate이다. 즉, 각 원소에 곱셈을 하지 않는다.

  • 배열은 각 원소에 벡터연산을 한다.

print(its_list*2)
print('========')
print(its_array*2)

['바나나', '딸기', 100, 5.5, ['BTS', '블랙핑크'], '바나나', '딸기', 100, 5.5, ['BTS', '블랙핑크']]
========
[2. 4. 6.]

• 리스트와 배열의 메서드

  • 리스트와 배열은 자료형이 다르므로 지원하는 메서드의 종류도 다르다.

  • 예를 들어, 리스트에서는 mean, argmax, round 등의 메소드를 지원하지 않는다. 그 이유는 리스트에는 다양한 자료형을 저장할 수 있는데 예를 들어, 문자열의 평균, 최댓값, 소수점 처리를 할 수 없기 때문이다.

    • mean: 평균

    • argmax: 최댓값 인덱스

    • round: 숫자를 지정한 자리수로 반올림

    • …

• 리스트와 배열의 연산속도

  • 리스트와 배열의 연산속도를 확인해보자.

  • 억개의 숫자에 대해서 2를 곱했다.

  • 결과를 보면 배열(array)가 10배 이상 빠르다.

  • 배열은 동일한 자료형만 저장하므로 데이터 저장에 필요한 저장공간이 일정하며 연속적이다. 따라서 메모리 주소 측면에서 인덱스를 통해 빠르게 데이터에 접근할 수 있다.

  • 반면, 리스트는 다양한 자료형을 저장할 수 있어서 필요한 저장공간이 일정하지 않으며, 메모리 활동공간도 연속적이지 않다. 인덱스를 갖지만 이는 몇 번째 데이터인가 정도를 의미한다.

import time
a = list(range(10 ** 8))

start = time.time()
[i *2 for i in a]
end = time.time()
print(f'리스트 실행시간: {end - start}')

a = np.array(range(10 ** 8))
start = time.time()
a * 2
end = time.time()
print(f'배열 실행시간: {end - start}')

인덱싱

• 1차원 배열을 인덱싱하는 것은 리스트와 동일하다.

ar=np.arange(12)
print(ar, '\n\n===결과===')
print(ar[5])

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

===결과===
5

• 2차원 배열을 인덱싱하는 방법은 대괄호를 연속하여 쓰고 인덱스를 각각 넣거나 하나의 대괄호에 콤마로 구분하여 인덱스를 넣어준다.

- 배열명[행인덱스][열인덱스]
- 배열명[행인덱스,열인덱스]

• ar[1][2]와 같이 대괄호를 연속하여 쓰면 가장 앞 대괄호부터 인덱싱 하여 나온 결과를 가지고 다음 대괄호의 인덱싱을 차례대로 한다. 즉, 앞의 대괄호를 통해 나온 결과가 작업범위의 대상이 된다.

• ar[1,2]와 같이 하나의 대괄호안에 행과 열을 콤마로 구분하면 작업범위가 배열 전체를 대상으로 한다.

ar=np.arange(12).reshape(4,3)
print(ar, '\n\n===결과===')
print(ar[1][2])
print(ar[1,2])

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

===결과===
5
5

슬라이싱

• 슬라이싱의 경우에는 대괄호를 연속으로 사용하는 것과 하나의 대괄호에 콤마로 나열하는 것의 결과가 다를 수도 있다.

ar=np.arange(12).reshape(3,4)
print(ar)
print('\n\n===연속된 대괄호 결과===')
print(ar[1:][1:])
print('\n\n===하나의 대괄호 결과===')
print(ar[1:, 1:])

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


===연속된 대괄호 결과===
[[ 8  9 10 11]]


===하나의 대괄호 결과===
[[ 5  6  7]
 [ 9 10 11]]

• 위의 코드에서 ar[1:]의 결과는 아래와 같다.

 [[ 4  5  6  7]
 [ 8  9 10 11]]

• 이 결과를 대상으로 두번째 대괄호 [1:]을 슬라이싱한다. 결과는 [ 8 9 10 11]가 슬라이싱 된다.

• 반면, ar[1:, 1:]는 ar 전체를 대상으로 작업하므로 행은 1행부터 끝까지, 그 범위에서 열이 1열부터 끝까지를 슬라이싱한다.

배열의 유용한 함수들I

• 배열을 생성할 때 사용할 수 있는 몇 가지 유용한 함수를 살펴본다.

  • zeros()

  • ones()

  • np.random

  • linspace()

  • transpose()

zeros()

• zeros(): 0으로 구성된 배열을 생성한다. 주로 배열을 0으로 초기화할 때 사용한다.

ar_zero = np.zeros((3,6))
print(ar_zero)

[[0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0.]]

ones()

• ones(): 1로 구성된 배열을 생성한다. 마찬가지로 주로 배열을 1로 초기화할 때 사용한다.

ar_one = np.ones((3,6))
print(ar_one)

[[1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]]

np.random

• 0 ≤ 실수 < 1로 채우기: np.random.random(배열의크기)

• a ≤ 실수 < b로 채우기: np.random.uniform(a, b, 배열의크기)

• a ≤ 정수 < b로 채우기: np.random.randint(a, b, 배열의크기)

print(np.random.random((2,5)))

[[0.88890769 0.51143429 0.61791567 0.92002254 0.53936553]
 [0.37061313 0.04275031 0.68025905 0.88263387 0.6792356 ]]

print(np.random.uniform(3.5, 4, (3,2)))

[[3.85264176 3.80483267]
 [3.92970749 3.66426214]
 [3.81421581 3.96043566]]

print(np.random.randint(-5, 5, (2,3,4)))

[[[ 0 -5 -2 -4]
  [ 0 -1  3 -1]
  [-5 -5 -4 -5]]

 [[-3 -3 -1 -3]
  [-1 -4 -3  3]
  [ 3  4  2  1]]]

• 랜덤하게 생성한 수를 가진 2차원 배열로 산포도 그래프를 그려보자.

• 산포도 그래프는 plt.scatter()로 그릴 수 있다.

• 대부분의 함수들은 많은 옵션들을 가지고 있고 scatter()함수 또한 옵션이 많다. help(plt.scatter)로 옵션을 확인해보기 바란다.

plt.scatter(x축 좌표, y축 좌표)

import matplotlib.pyplot as plt

rd_num = np.random.randint(0,100,(50,2))
plt.scatter(rd_num[:,0], rd_num[:, 1],s=100)
plt.show()

linspace()

• linspace(): 일정한 간격으로 등분한 배열을 생성한다.

np.linspace(start,end,개수)

print(np.linspace(0,15,4))

[ 0.  5. 10. 15.]

• linspace()로 생성한 배열을 선형 그래프의 y축의 값을 생성하는데 사용해보자.

rd_num = np.random.randint(0,700000,(25,))
rd_num1 = np.random.randint(800,2000,(25,))
plt.scatter(rd_num, rd_num1,s=50)

x = np.linspace(100000, 700000, 100)
y = 0.0012*x+700
plt.plot(x, y, ls='dashed', color='g')
plt.show()

transpose()

• transpose(): 행과 열을 교체한다. 배열명.T도 가능하다.

np.transpose(배열명)
배열명.T

ar= np.arange(10).reshape(2,5)
print(ar)
print('\n\n===결과===')
print(ar.T)

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


===결과===
[[0 5]
 [1 6]
 [2 7]
 [3 8]
 [4 9]]

배열의 유용한 함수들II

배열을 다룰 때 사용할 수 있는 몇 가지 유용한 함수를 살펴본다.

• where()

• max(), min()

• argmax(), argmin()

• sum(), mean(), median()

• var(), std()

• unique()

• abs()

• sin(), cos()

• dot()

where()

where(): 조건에 만족하는 인덱스를 반환하거나, 조건에 따라 값을 다르게 적용시킨다.

np.where(조건, True일때 적용값, False일때 적용값)

# 문자열 배열 (성별 데이터)
gender = np.array(['남자', '여자', '남자', '여자', '남자'])
print(gender)
print('\n\n===결과===')
gender_numeric = np.where(gender == '남자', 0, 1)
print(gender_numeric)

['남자' '여자' '남자' '여자' '남자']


===결과===
[0 1 0 1 0]

column_stack()

np.column_stack(): 1차원 배열 여러 개를 열 단위로 합쳐서 2차원 배열로 만들어 준다.

# 점수 배열 (예: 시험 점수)
scores = np.array([85, 90, 78, 92, 88])

# 열 방향으로 합치기 (1차원 → 2차원 변환)
combined = np.column_stack((gender_numeric, scores))

print(combined)

[[ 0 85]
 [ 1 90]
 [ 0 78]
 [ 1 92]
 [ 0 88]]

min(), max()

• np.min(): 최솟값을 반환한다.

• np.max(): 최댓값을 반환한다.

# 최솟값, 최댓값
print(combined)
print('\n\n===결과===')
print(np.min(combined[:, 1:]))
print('\n\n===결과===')
print(np.max(combined[:, 1:]))

[[ 0 85]
 [ 1 90]
 [ 0 78]
 [ 1 92]
 [ 0 88]]


===결과===
78


===결과===
92

argmin(), argmax()

• argmin(): 최솟값 인덱스를 반환한다.

• argmax(): 최댓값 인덱스를 반환한다.

print(np.argmin(combined[:, 1:]))
print(np.argmax(combined[:, 1:]))

2
3

sum(), mean(), median()

• np.sum(배열명): 합을 반환한다.

• np.mean(배열명): 평균을 반환한다.

• np.median(배열명): 중간값을 반환한다. 이 때 옵션 axis를 통해 결과를 구하고자 하는 축을 명시해 줄 수 있다.

  • axis=0: 행을 따라 집계(세로 방향)

  • axis=1: 열을 따라 집계(가로 방향)

print(combined)
print('\n\n===결과===')
print(np.sum(combined[:, 1:]))
print(np.mean(combined[:, 1:]))
print(np.median(combined[:, 1:]))

[[ 0 85]
 [ 1 90]
 [ 0 78]
 [ 1 92]
 [ 0 88]]


===결과===
433
86.6
88.0

ar= np.arange(1,31,2).reshape(3,5)
print(ar)
print('\n\n===결과===')
print(np.sum(ar, axis=0))
print(np.sum(ar, axis=1))

[[ 1  3  5  7  9]
 [11 13 15 17 19]
 [21 23 25 27 29]]


===결과===
[33 39 45 51 57]
[ 25  75 125]

😄아래 값들의 평균을 백분율로 소수점 2자리까지 나타내시오. 소수점을 구할때는 round()함수를 사용하세요.

np.array([0.83333333, 0.76404494, 0.85393258, 0.82022472, 0.86516854,0.80898876, 0.80898876, 0.7752809 , 0.84269663, 0.82022472])

• 데이터를 소수점 n자리까지 나타내는 방법

  • 데이터.round(n)

  • np.round(데이터,n)

var(), std()

• np.var(): 분산을 구한다.

• np.std(): 표준편차를 구한다.

ar=np.random.uniform(1,100,80)
print(ar)
print('\n\n===결과===')
print(np.var(ar))
print(np.std(ar))

[61.15443276  5.1916588   2.69980104 57.36662744 98.28507116 16.32277576
 92.23525961 57.97153464 13.54341839 88.36196388 24.23658132 73.37069464
 14.89501213 78.42120069 70.1854252  89.92380907 68.28570372 22.4513462
 58.2135244  51.05532001 32.46167077 86.26659832 81.24239442 55.93199192
 79.91760531 56.88564624 14.45909547 96.32432359 79.29156732 73.33342076
 38.50709661 97.3920509  10.50657443 46.36477415 59.29510415 31.5001885
 76.51506906 43.87484924 29.3975596  94.18291917 56.3952613  67.87816564
 24.79055244 79.3396185  80.78986427 35.85312994 73.98010667  3.97786957
 68.32476898 98.91751437 49.05207953 95.65614865 88.60736896 53.8800092
 94.59694038 36.97851437 44.10701109 40.93317322 72.20910665 20.76389662
 64.89879313 23.84995655 66.16617994 77.20294221  8.85210127 87.61857474
  9.80089984 61.77656335 56.11413921 24.98175278 98.52178736 37.96447809
 88.98820493 94.86694728 76.85694418 54.74857887 69.60643049 80.87165221
 73.21420396 12.57258197]


===결과===
796.1964635698172
28.21695347782636

unique()

• np.unique(): 중복값을 제거하여 1차원으로 반환한다.

ar = np.random.randint(-10, 10, (2,5))
print(ar)
print('\n\n===결과===')
print(np.unique(ar))

[[ -6  -6  -6   7   6]
 [  5   3 -10   9  -8]]


===결과===
[-10  -8  -6   3   5   6   7   9]

abs()

• np.abs(): 절대값을 구한다.

ar = np.random.randint(-10, 10, (2,5))
print(ar)
print('\n\n===결과===')
print(np.abs(ar))

[[ 1  2 -4  8  6]
 [-9  9 -1 -7  0]]


===결과===
[[1 2 4 8 6]
 [9 9 1 7 0]]

dot()

• np.dot(a, b): 행렬의 곱(내적)을 구한다.

• a@b와 같이 @ 기호로 나타내기도 한다.

• 두 행렬 A의 열의 개수와 행렬 B의 행의 개수가 같을 때 행렬 A의 제 i행의 각 원소와 행렬 B의 제 j열의 각 원소를 그 순서대로 곱하여 더한 것을 (i,j)원소로 하는 행렬을 두 행렬 A와 B의 곱이라고 한다.

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

===b===
[[ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]

[[1*3 + 2*5 + 3*7 + 4*9 + 5*11],
 [1*4 + 2*6 + 3*8 + 4*10 + 5*12]

 [6*3 + 7*5 + 8*7 + 9*9 +10*11],
 [6*4 + 7*6 + 8*8 + 9*10 + 10*12]]

a = np.arange(1,11,1).reshape(2,5)
b = np.arange(3,13,1).reshape(5,2)
print('===a===')
print(a)
print('\n\n===b===')
print(b)
print('\n\n===결과===')
print(a@b)

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


===b===
[[ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]


===결과===
[[125 140]
 [300 340]]

파일저장 savetxt() , 읽어오기 loadtxt

• np.savetxt(파일명, 배열명): 배열을 텍스트 파일로 저장한다.

• np.loadtxt(파일명): 파일을 배열로 불러온다.

np.savetxt('File123.txt', ar)
ar=np.loadtxt('File123.txt')
print(ar)

Shallow Copy vs. Deep Copy

리스트, 딕셔너리, 집합, 배열 등의 데이터를 복사해서 복사된 데이터를 가지고 작업하기를 원할 때가 있다. 이들은 모두 mutable 데이터타입이고, 이들 데이터를 복사할 때의 문제점과 방법을 알아보자.

데이터를 복사하는 방법에는 세 가지가 있다.

• 일반복사: 원조변수와 복사변수가 같은 메모리를 참조

• Shallow Copy : 원조변수와 복사변수가 다른 메모리를 참조하나 2차원 이상인 경우 동일 메모리를 참조

• Deep Copy : 복사변수는 새로운 메모리를 할당하여 독립적으로 생성

일반복사

• cp_a = a와 같은 복사할 수 있다.

• 그러나 이와 같은 복사의 문제는 복사 배열의 데이터를 작업을 하면 원조 배열의 데이터도 똑같이 작업된다는 것이다.

• 그 이유는 복사변수와 원조변수가 같은 메모리 주소를 참조하기 때문이다.

• 다음 코드를 통해 확인해보자.

• 리스트, 딕셔너리, 집합, 배열 각각에 변수 a, b, c, d를 정의하였다.

a=[1,2,3,[10,20,30]] #리스트
b={'a':1, 'b':2, 'c':[10,20,30]} #딕셔너리
c={1,2,3,(10,20,30)} # 집합
d=np.array([[1,2,3],[10,20,30]])
print('Origin Data===================')
print(f'리스트: {a}')
print(f'딕셔너리: {b}')
print(f'집합: {c}')
print(f'배열: {d}')

Origin Data===================
리스트: [1, 2, 3, [10, 20, 30]]
딕셔너리: {'a': 1, 'b': 2, 'c': [10, 20, 30]}
집합: {1, 2, 3, (10, 20, 30)}
배열: [[ 1  2  3]
 [10 20 30]]

• 위에서 정의한 변수 a, b, c, d를 변수 a1, b1, c1,d1에 각각 복사하였다.

a1=a
b1=b
c1=c
d1=d
print('Copy Data=============')
print(f'리스트: {a1}')
print(f'딕셔너리: {b1}')
print(f'집합: {c1}')
print(f'배열: {d1}')

Copy Data=============
리스트: [1, 2, 3, [10, 20, 30]]
딕셔너리: {'a': 1, 'b': 2, 'c': [10, 20, 30]}
집합: {1, 2, 3, (10, 20, 30)}
배열: [[ 1  2  3]
 [10 20 30]]

• 복사한 변수 a1, b1, c1, d1의 값의 일부를 수정하였다.

a1[1]=100
b1['b']=100
c1.update((5,6,7))
d1[0][1]=100

• 원조변수 a, b, c, d와 복사변수 a1, b1, c1, d1을 출력해보면, 원조변수의 값까지 수정된 것을 확인할 수 있다.

print('Copy Data 수정 후 origin data=============')
print(f'리스트: {a}')
print(f'딕셔너리: {b}')
print(f'집합: {c}')
print(f'배열: {d}')

print('\nCopy Data 수정 후 copy data=============')
print(f'리스트: {a1}')
print(f'딕셔너리: {b1}')
print(f'집합: {c1}')
print(f'배열: {d1}')

Copy Data 수정 후 origin data=============
리스트: [1, 100, 3, [10, 20, 30]]
딕셔너리: {'a': 1, 'b': 100, 'c': [10, 20, 30]}
집합: {1, 2, 3, 5, 6, 7, (10, 20, 30)}
배열: [[  1 100   3]
 [ 10  20  30]]

Copy Data 수정 후 copy data=============
리스트: [1, 100, 3, [10, 20, 30]]
딕셔너리: {'a': 1, 'b': 100, 'c': [10, 20, 30]}
집합: {1, 2, 3, 5, 6, 7, (10, 20, 30)}
배열: [[  1 100   3]
 [ 10  20  30]]

• 원조변수와 복사변수의 ID가 동일한지 알아보기 위해 is 연산자를 사용하여 확인해볼 수 있다.

• is 연산자는 메모리 주소 즉 객체의 ID가 동일한지 확인하는 연산자이다.

• 값이 동일한지 확인하는 것은 ==를 사용하고, ID가 동일한지 확인하기 위해서는 is 연산자를 사용한다.

print(a is a1)
print(b is b1)
print(c is c1)
print(d is d1)

True
True
True
True

copy() 메서드(shallow copy)

• 원조데이터가 수정되는 것을 방지하기 위해서는 copy() 메서드를 사용해보자.

• 리스트, 딕셔너리, 집합, 배열 각각에 변수 a, b, c, d를 정의하였다.

a=[1,2,3,[10,20,30]] #리스트
b={'a':1, 'b':2, 'c':[10,20,30]} #딕셔너리
c={1,2,3,(10,20,30)} # 집합
d=np.array([[1,2,3],[10,20,30]])
print('Origin Data===================')
print(f'리스트: {a}')
print(f'딕셔너리: {b}')
print(f'집합: {c}')
print(f'배열: {d}')

Origin Data===================
리스트: [1, 2, 3, [10, 20, 30]]
딕셔너리: {'a': 1, 'b': 2, 'c': [10, 20, 30]}
집합: {1, 2, 3, (10, 20, 30)}
배열: [[ 1  2  3]
 [10 20 30]]

• 이번에는 copy() 메서드를 사용하여 복사하였다.

a1=a.copy()
b1=b.copy()
c1=c.copy()
d1=d.copy()
print('Copy Data=============')
print(f'리스트: {a1}')
print(f'딕셔너리: {b1}')
print(f'집합: {c1}')
print(f'배열: {d1}')

Copy Data=============
리스트: [1, 2, 3, [10, 20, 30]]
딕셔너리: {'a': 1, 'b': 2, 'c': [10, 20, 30]}
집합: {1, 2, 3, (10, 20, 30)}
배열: [[ 1  2  3]
 [10 20 30]]

• 복사한 변수 a1, b1, c1, d1의 값의 일부를 수정하였다.

a1[1]=100
b1['b']=100
c1.update((5,6,7))
d1[0][1]=100

• 원조변수 a, b, c, d와 복사변수 a1, b1, c1, d1을 출력해보면, 원조변수의 값은 그대로 유지되고, 복사변수의 값만 수정된 것을 확인할 수 있다.

print('Copy Data 수정 후 origin data=============')
print(f'리스트: {a}')
print(f'딕셔너리: {b}')
print(f'집합: {c}')
print(f'배열: {d}')
print('\nCopy Data 수정 후 copy data=============')
print(f'리스트: {a1}')
print(f'딕셔너리: {b1}')
print(f'집합: {c1}')
print(f'배열: {d1}')

Copy Data 수정 후 origin data=============
리스트: [1, 2, 3, [10, 20, 30]]
딕셔너리: {'a': 1, 'b': 2, 'c': [10, 20, 30]}
집합: {1, 2, 3, (10, 20, 30)}
배열: [[ 1  2  3]
 [10 20 30]]

Copy Data 수정 후 copy data=============
리스트: [1, 100, 3, [10, 20, 30]]
딕셔너리: {'a': 1, 'b': 100, 'c': [10, 20, 30]}
집합: {1, 2, 3, 5, 6, 7, (10, 20, 30)}
배열: [[  1 100   3]
 [ 10  20  30]]

• 또한 원조변수 a, b, c, d와 복사변수 a1, b1, c1, d1가 서로 다른 ID를 갖고 있는 것을 확인할 수 있다.

print(a is a1)
print(b is b1)
print(c is c1)
print(d is d1)

False

False
False
False

• 하지만 결론부터 말하면 리스트안에 리스트이거나, 딕셔너리안에 리스트가 있는 경우 이를 수정했을 때 여전히 원조변수의 값이 같이 수정되는 문제가 발생한다.

a=[1,2,3,[10,20,30]]
b={'a':1, 'b':2, 'c':[10,20,30]}
c=np.array([{'a':[1,2]},{'b':[1,2]},{'c':[1,2]}])

a[3]의 값이 [10,20,30]리스트이다.

b[‘c’]의 값이 [10,20,30]리스트이다.

c의 각 값들이 리스트이다.

a=[1,2,3,[10,20,30]]
b={'a':1, 'b':2, 'c':[10,20,30]}
c=np.array([{'a':[1,2]},{'b':[1,2]},{'c':[1,2]}])

a1=a.copy()
b1=b.copy()
c1=c.copy()

a1[3][0]='here'
b1['c'][0]='here'
c1[0]['a'][0]=100

• 원본 데이터와 복사 데이터가 모두 수정된 것을 확인할 수 있다.

print(a, a1)
print(b, b1)
print(c, c1)

[1, 2, 3, ['here', 20, 30]] [1, 2, 3, ['here', 20, 30]]
{'a': 1, 'b': 2, 'c': ['here', 20, 30]} {'a': 1, 'b': 2, 'c': ['here', 20, 30]}
[{'a': [100, 2]} {'b': [1, 2]} {'c': [1, 2]}] [{'a': [100, 2]} {'b': [1, 2]} {'c': [1, 2]}]

Deepcopy()

• Deep copy는 복사변수의 값을 작업(수정, 삭제, 추가 등)해도 원본변수의 값이 작업되지 않는다.

import copy
a=[1,2,3,[10,20,30]]
b=copy.deepcopy(a)
b[3][0] = 100
print(a)
print(b)

[1, 2, 3, [10, 20, 30]]
[1, 2, 3, [100, 20, 30]]

마무리

• 데이터를 저장할 때에는 어떠한 자료구조에 저장할 것인지를 먼저 생각해야 한다.

• 자료구조에는 데이터의 수정, 삽입, 추가, 삭제가 자유로운 가변 데이터 타입과 한번 만들고 나면 수정, 삽입, 추가, 삭제 할 수 없는 불변 데이터 타입이 있다.

• 모듈 numpy는 대규모 다차원 배열을 쉽고 빠르게 처리할 수 있도록 하는 파이썬 라이브러리이다.

• NumPy는 워낙 함수가 많고 기능이 깊어서, 2시간 수업만으로 전부 다루기 어렵다. 오늘 배운 배열 생성, 연산, 유용한 함수 정도만 익혀도 데이터 다루는 감을 잡을 수 있다. 이후엔 필요할 때 하나씩 찾아서 익히면 충분하다.

• numpy 모듈의 배열(array)과 리스트는 벡터연산 제공 여부와 메모리 접근 속도 측면에서 많은 차이가 있다.

• shallow copy(얕은 복사)와 deep copy(깊은 복사)의 차이를 이해하고 복사하여 사용할 때 주의해야 한다.

---

F37.101 컴퓨팅 기초: 처음 만나는 컴퓨팅(First Adventures in Computing) 서울대학교 학부대학 변해선

---