[์ฝ๋ฉ ๊ธฐ์ด] ํ์ด์ฌ - ๋ฆฌ์คํธ(list)์ ๋ฐฐ์ด(array) & ๋ํ์ ์ธ ๋ฐฐ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ, Numpy์ ๋ํด์!
์์ผ๋ก ๋ํ์ ์ธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ธ ํ์ด์ฌ์ ๋ํด์ ๊ธฐ์ด๋ถํฐ ์ ๋ฆฌํ๋ ์๊ฐ์ ๊ฐ์ ธ๋ณด๋ ค๊ณ ํ๋ค!!
์ค๋์ ๋ฐ์ดํฐ๊ณผํ์์ ๋ง์ด ์ฌ์ฉํ๋ ๊ธฐ๋ณธ์ ์ธ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ธ ๋ฆฌ์คํธ์ ๋ฐฐ์ด์ ๋ํด์ ๊ณต๋ถํ๊ณ , ์์ฃผ์์ฃผ ๋ง์ด ๋ค์ด๋ณด์๋ ํ์ด์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ธ Numpy์ ๋ํด์ ํนํ๋ ๋ ์์๋ณด๋ ค๊ณ ํ๋ค.
๋ฆฌ์คํธ List
ํ์ด์ฌ์ ๊ธฐ๋ณธ ๋ด์ฅ ์๋ฃํ์ผ๋ก, ๋ค์ํ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ ์๋ ๋์ดํ ๋ฐ์ดํฐ ๊ตฌ์กฐ.
(+) ์ ์ฐ์ฑ์ด ๋์. ๋ค์ํ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํจ. ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ผ๋ก ํฌ๊ธฐ๊ฐ ์กฐ์ ๊ฐ๋ฅํจ.
(-) ๋ฐฐ์ด๋ณด๋ค๋ ์ฐ์ฐ ์๋๊ฐ ๋๋ฆผ
์์ : 1๋ถํฐ 10๊น์ง ๋ฐฐ์ด๋ data๋ผ๋ ๋ฆฌ์คํธ
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
์์ : ๋ค์ํ ํ์ ์ ๋ฆฌ์คํธ
my_list = [1, "apple", 3.14, True]
์์ : ๋ฆฌ์คํธ์ ๋ฆฌ์คํธ (2์ฐจ์ ๋ฆฌ์คํธ)
2_list = [[1, a], [3, c], [5, e]]
์ธ๋ฑ์ค index
๋ฆฌ์คํธ์ ๋ฐฐ์ด์ ์์น๋ฅผ ์ ํํ๋ ๋ฐฉ๋ฒ์ ์๋ฏธํจ. ์ฒซ๋ฒ์งธ ์์๋ ์ธ๋ฑ์ค 0์์ ๊ธฐ์ตํ ๊ฒ.
์์ : data ๋ผ๋ ๋ฆฌ์คํธ์ ๋ค์ฏ๋ฒ์งธ ์ํ์ ์ ํํ๊ณ ์ถ์
์ ๋ต : data[4]
์ฌ๋ผ์ด์ฑ slicing
์ฝ๋ก (:) ์ ๊ฐ์ด๋ฐ ๋๊ณ ์ธ๋ฑ์ค์ ๋ฒ์๋ฅผ ์ง์ ํ์ฌ ์ฌ๋ฌ ๊ฐ์ ์์๋ฅผ ์ ํํ๋ ๊ฒ. ๋๋ฒ์งธ ์ธ๋ฑ์ค์ ์์๋ ํฌํจ๋์ง ์๋๋ค๋ ๊ฒ์ ๊ธฐ์ตํ ๊ฒ. ๋ง์ง๋ง ์์๊น์ง ํฌํจํ ๊ฒฝ์ฐ ๋๋ฒ์งธ ์ธ๋ฑ์ค๋ ์๋ตํด๋ ๋จ
์์ : data ๋ผ๋ ๋ฆฌ์คํธ์ ์ฒซ๋ฒ์งธ๋ถํฐ ๋ค์ฏ๋ฒ์งธ๊น์ง์ ์ํ์ ์ ํํ๊ณ ์ถ์
์ ๋ต : data[0:5]
์์ : data ๋ผ๋ ๋ฆฌ์คํธ์ ์ธ๋ฒ์งธ๋ถํฐ ๋ง์ง๋ง๊น์ง์ ์ํ์ ์ ํํ๊ณ ์ถ์
์ ๋ต : data[2: ]
๋ฐฐ์ด Array
๋์ผํ ๋ฐ์ดํฐ ํ์ ์ ์ฐ์์ ์ผ๋ก ๋์ดํ ๋ฐ์ดํฐ ๊ตฌ์กฐ
(+) ๋น ๋ฅธ ๋ฐ์ดํฐ ์ ๊ทผ๊ณผ ์ฐ์ฐ์ด ๊ฐ๋ฅํจ.
(-) ๋์ผํ ๋ฐ์ดํฐ ํ์ ๋ง ์ ์ฅ ๊ฐ๋ฅํจ.
์์: 1์ฐจ์ ๋ฐฐ์ด
1_list = [1, 2, 3, 4, 5]
์์: 2์ฐจ์ ๋ฐฐ์ด(ํ๋ ฌ)
2_list = [[1, 2], [3, 4], [5, 6]]
๋ฐฐ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ : ๋ํ์ด numpy
๋ฐฐ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๋ฐฐ์ด์ ๋ ๋น ๋ฅด๊ณ ํจ์จ์ ์ผ๋ก ๋ค๋ฃจ๊ธฐ ์ํ ๊ธฐ๋ฅ๋ค์ ์ ๊ณตํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ด๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก ๋ฐฐ์ด์ ์์ฑํ๊ณ ๋ณํํ๋ฉฐ, ์ํ์ ์ฐ์ฐ์ ๋ํ ๊ธฐ๋ฅ, ๋ฐ์ดํฐ ์ฌ๋ผ์ด์ฑ๊ณผ ํํฐ๋ง ๊ธฐ๋ฅ, ๊ทธ๋ฆฌ๊ณ ํต๊ณ์ ์ ํ๋์ ๊ธฐ๋ฅ๋ค์ ํฌํจํ๊ณ ์๋ค.
ํ์ด์ฌ์ ๋ํ์ ์ธ ๋ฐฐ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ์๋ "Numpy", "Pandas", "SciPy" ๋ฑ์ด ์๋ค. ๋ฅ๋ฌ๋ ํ๋ ์์ํฌ์ธ TensorFlow๋ ๊ณ ์ฐจ์ ๋ฐฐ์ด์ธ Tensor๋ฅผ ์ฒ๋ฆฌํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ผ๋ ์ ์์ ๋ฐฐ์ด๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ผ๊ณ ํ ์ ์๋ค.
Numpy๋ ๋ฐฐ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ผ๋ฉด Pandas๋ Table ํํ์ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ๊ฐํํ numpy ๊ธฐ๋ฐ ํด์ด๋ผ๊ณ ํ ์ ์๋ค. SciPy๋ Numpy ๊ธฐ๋ฐ์ด๊ธฐ๋ ํ์ง๋ง ๋ณด๋ค ๋ ๋ณต์กํ ์ํ์ ๊ธฐ๋ฅ์ ์ ๊ณตํ๊ณ ์๋ค.
ํ์ด์ฌ์ ๊ธฐ๋ณธ์ ์ธ ์๋ฃํ์ธ ๋ฆฌ์คํธ๋ก 2์ฐจ์ ๋ฐฐ์ด๊น์ง๋ ๋ง๋ค ์ ์์ง๋ง ์ฐจ์์ด ๋ ์๋ก ํํํ๊ธฐ๊ฐ ๋ ์ด๋ ค์์ง๋ค. ๋ํ์ด๋ ์ด๋ฐ ๊ณ ์ฐจ์์ ๋ฐฐ์ด์ ์์ฝ๊ฒ ๋ง๋ค ์ ์๋ ๋๊ตฌ๋ค์ ์ ๊ณตํ๋ค. ๋ค์์ ๋ํ์ ์ธ Numpy์ ๋ฉ์๋์ attribute๋ค์ ์ ๋ฆฌํ ํ์ด๋ค.
Method / Attribute | ๊ธฐ๋ฅ | ์์ | ๊ฒฐ๊ณผ |
array() | ๋ฆฌ์คํธ๋ฅผ NumPy ๋ฐฐ์ด๋ก ๋ณํ | np.array([1, 2, 3]) | [1 2 3] |
shape | ๋ฐฐ์ด์ ๊ตฌ์กฐ(์ฐจ์) ํ์ธ | arr.shape | (3,) * 3๊ฐ์ ์์๋ฅผ ๊ฐ์ง 1์ฐจ์ ๋ฐฐ์ด |
dtype | ๋ฐ์ดํฐ ํ์ ํ์ธ | arr.dtype | int64 |
reshape() | ๋ฐฐ์ด์ ์ฐจ์ ๋ณ๊ฒฝ | arr.reshape(2, 3) | [[1 2 3], [4 5 6]] |
arange() | ์ผ์ ํ ๊ฐ๊ฒฉ์ ์ซ์ ์์ฑ | np.arange(0, 10, 2) np.arange(6) |
[0 2 4 6 8] [0, 1, 2, 3, 4, 5] |
linspace() | ๊ตฌ๊ฐ์ ๊ท ๋ฑํ๊ฒ ๋๋ ๊ฐ ์์ฑ | np.linspace(0, 1, 5) | [0. 0.25 0.5 0.75 1.] |
zeros() | 0์ผ๋ก ์ฑ์์ง ๋ฐฐ์ด ์์ฑ | np.zeros((2, 3)) | [[0. 0. 0.], [0. 0. 0.]] |
ones() | 1๋ก ์ฑ์์ง ๋ฐฐ์ด ์์ฑ | np.ones((3,)) | [1. 1. 1.] |
eye() | ๋จ์ ํ๋ ฌ ์์ฑ | np.eye(3) | [[1. 0. 0.], [0. 1. 0.], [0. 0. 1.]] |
random.rand() | 0~1 ์ฌ์ด์ ๋์ ๋ฐฐ์ด ์์ฑ | np.random.rand(2, 2) | [[0.56, 0.12], [0.78, 0.34]] *0์์ 1 ์ฌ์ด 2๊ฐ ์ํ, 2๊ฐ ์์ |
random.randint() | ์ง์ ๋ฒ์ ๋ด ์ ์ ๋์ ์์ฑ | np.random.randint(0, 10, size=(2, 3)) | [[3, 7, 1], [5, 9, 0]] *0์์ 10 ์ฌ์ด 2๊ฐ ์ํ, 3๊ฐ ์์ |
sum() | ๋ฐฐ์ด ์์์ ํฉ๊ณ | arr.sum() | 15 *arr = [1, 2, 3, 4, 5] ์ผ ๋ |
mean() | ๋ฐฐ์ด ์์์ ํ๊ท | arr.mean() | 3.0 *arr = [1, 2, 3, 4, 5] ์ผ ๋ |
max() / min() | ์ต๋๊ฐ ๋ฐ ์ต์๊ฐ ๋ฐํ | arr.max(), arr.min() | 5, 1 *arr = [1, 2, 3, 4, 5] ์ผ ๋ |
argmax() | ์ต๋๊ฐ์ ์ธ๋ฑ์ค ๋ฐํ | arr.argmax() | 4 (์ต๋๊ฐ 5์ ์ธ๋ฑ์ค) *arr = [1, 2, 3, 4, 5] ์ผ ๋ |
sort() | ๋ฐฐ์ด ์ ๋ ฌ | np.sort([3, 1, 4, 2]) | [1 2 3 4] |
concatenate() | ๋ฐฐ์ด ๊ฒฐํฉ : ์ฒซ๋ฒ์งธ ์ฐจ์์ ๋ฐ๋ผ ๋ฐฐ์ด์ ์ฐ๊ฒฐํจ. | np.concatenate(([1, 2], [3, 4])) | [1 2 3 4] |
hstack() / vstack() / colum_stack() |
์ํ์ผ๋ก ํฉ์นจ /์์ง์ผ๋ก ํฉ์นจ / ์ด ๊ธฐ์ค์ผ๋ก ์๋ ํจ์ |
np.hstack((a, b)) np.vstack((a, b)) np.column_stack((a,b)) |
[1 2 3 4] [[1 2], [3 4]] [[1, 3], [2, 4]] *a= [1, 2], b=[3, 4] |
unique() | ์ค๋ณต ์ ๊ฑฐ ํ ๊ณ ์ ๊ฐ ๋ฐํ | np.unique([1, 2, 2, 3, 4, 4, 5]) | [1 2 3 4 5] |
where() | ์กฐ๊ฑด์ ๋ฐ๋ผ ์ธ๋ฑ์ค ๋๋ ๊ฐ ๋ฐํ | np.where(arr > 2) | (array([2, 3, 4]),) |
transpose() | ๋ฐฐ์ด์ ์ฐจ์์ ์ ์น (ํ↔์ด) | arr.T | [[1 4], [2 5], [3 6]] |
dot() | ํ๋ ฌ ๊ณฑ์ ์ํ | np.dot(A, B) | [[19 22], [43 50]] |
flatten() | ๋ค์ฐจ์ ๋ฐฐ์ด์ 1์ฐจ์์ผ๋ก ๋ณํ | arr.flatten() | [1 2 3 4 5 6] |
์ฌ๊ธฐ์ ์ฌ์ฉ ๊ฐ๋ฅํ ํ๋ค์ด๋ค!
- arrange() ํจ์๋ arange(N) ์ฒ๋ผ ์ ์๊ฐ๋ง ๋ฃ์ผ๋ฉด 0๋ถํฐ N-1๊น์ง 1์ฉ ์ฆ๊ฐํ๋ ๋ฐฐ์ด์ ๋ง๋ ๋ค.
- seed() : ๋๋ค ํจ์๋ค ์ค์ ์คํํ ๋๋ง๋ค ๋ค๋ฅธ ๊ฒฐ๊ณผ๋ฅผ ๋ง๋๋๋ฐ, ์ผ๊ด๋ ๊ฒฐ๊ณผ๋ฅผ ์ํ๋ฉด ์ด๊ธฐ์ ๋๋ค์๋(Random seed)๋ฅผ ๋์ผํ ์ซ์๋ก ์ง์ ํ๋ฉด ๋๋ค. np.random.seed(N) ์ด๋ฐ์์ผ๋ก ์ง์ ํ๋ฉด ๋๋ค.
- random() ์ค random.shuffle() ํจ์๋ ์ฃผ์ด์ง ๋ฐฐ์ด์ ๋ฌด์์๋ก ์๋๋ค.
- stack()๋ฅ์ ํจ์๋ค์ด ์์ฑํ๋ ๊ฒฐ๊ณผ๋ ํํ ํํ์ด๋ค. ์ฌ๊ธฐ์ ํํ์ ๋ฆฌ์คํธ์ ์ ์ฌํ์ง๋ง, ํ๋ฒ ๋ง๋ค์ด์ง ํํ์ ์์ ์ด ์๋๋ค๋ ํน์ฑ์ ๊ฐ์ง๋ค.
๋ํ์ด๋ ๋ง์ ํ์ด์ฌ์ ๊ณผํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ฌ์ฉํ๋ ํ์ค ๋ฐ์ดํฐ์ด๊ธฐ ๋๋ฌธ์ ๋ฐ๋์ ์๊ณ ์๋๊ฒ ์ข์ ๊ฒ ๊ฐ๋ค!
์์ผ๋ก ๋ํ์ด์ ํ์ฉ๊ณผ ๋ํ์ด๋ฅผ ์ด์ฉํ ๋ค์ํ ๊ณผํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ํด์ ๋ ๊ณต๋ถํ๊ณ ํฌ์คํ ํด๋ณด๊ฒ ๋ค.
์ถ์ฒ: ํผ์๊ณต๋ถํ๋ ๋จธ์ ๋ฌ๋/๋ฅ๋ฌ๋ (ํ๋น๋ฏธ๋์ด, ๋ฐํด์ )