ํ๋ค์ค์ ๋ํ์ด
1. ํ๋ค์ค
ํ๋ค์ค๋?
๋ฐ์ดํฐ(์ ๋ณด)๋ฅผ ์ ๋ฆฌํ๊ณ ๋ค๋ฃจ๊ธฐ ์ฝ๊ฒ ๋์์ฃผ๋ ๋๊ตฌ์ด๋ค.
์๋ฅผ ๋ค์ด, ํ(table)๋ ์์ ํ์ผ์ฒ๋ผ ์ฌ๋ฌ ์ค๊ณผ ์นธ์ผ๋ก
์ด๋ค์ง ์ ๋ณด๋ฅผ ์ปดํจํฐ์์ ๋ค๋ฃจ๊ณ ์ถ์ ๋ ์ฌ์ฉํ๋ค.
ํ๋ค์ค๋ ๋ฌด์์ผ๊น?
ํ๋ค์ค๋ ๋ฐ์ดํฐ๋ฅผ ๊น๋ํ๊ฒ ์ ๋ฆฌํ๊ณ , ํ์ํ ๋ถ๋ถ๋ง ๊ณจ๋ผ๋ด๊ฑฐ๋ ๊ณ์ฐํ๋ ๊ฑธ ์ฝ๊ฒ ํด์ฃผ๋ ํ๋ก๊ทธ๋จ์ด๋ค.
์ฑ ์ ์์์ ์์ ํ์ผ์ ๋ณด๋ ๊ฒ์ฒ๋ผ, ํ๋ค์ค๋ฅผ ์ด์ฉํ๋ฉด ํ์ด์ฌ ์์์ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ์ ์๋ค.
ํ๋ค์ค๊ฐ ํ ์ ์๋ ์ผ
- ์ ๋ณด๋ฅผ ๋ถ๋ฌ์ค๊ธฐ : ์์ ํ์ผ, CSVํ์ผ์ ๋ถ๋ฌ์ ํ์ด์ฌ์์ ์ธ ์ ์๋ค.
- ์ ๋ณด ๋ณด๊ธฐ : ํ๊ฐ ๋๋ฌด ํฌ๋ค๋ฉด, ์ฒ์ ๋ช ์ค๋ง์ ๋ณด๊ฑฐ๋ ํ์ํ ๋ถ๋ถ๋ง ๊ณจ๋ผ ๋ณผ ์ ์๋ค.
- ํ์ํ ๋ถ๋ถ๋ง ๊ณจ๋ผ๋ด๊ธฐ : ์๋ฅผ ๋ค์ด, ์ฌ๋์ ์ ์ฅ์ ๊ธฐ๋กํ ํ๊ฐ ์์ ๋, ํค๊ฐ 180cm ์ด์์ธ ์ฌ๋์ ๋ฐ์ดํฐ๋ง ๊ณจ๋ผ๋ผ ์ ์๋ค.
- ๊ณ์ฐํ๊ธฐ : ํ๊ท , ํฉ๊ณ ๊ฐ์ ๊ณ์ฐ๋ ํ ์ ์๋ค.
# ๋ฐ์ดํฐ ๋ถ๋ฌ์ค๊ธฐ
df = pd.read_csv("data.csv") # CSV ํ์ผ ๋ถ๋ฌ์ค๊ธฐ
df = pd.read_excel("data.xlsx") # ์์
ํ์ผ ๋ถ๋ฌ์ค๊ธฐ
# ํ์ํ ๋ฐ์ดํฐ๋ง ๋ณด๊ธฐ
print(df['์ ์']) # ์ ์ ์ด ๋ฐ์ดํฐ๋ง ๋ณด๊ธฐ
print(df[df['์ ์'] > 80]) # ํน์ ์กฐ๊ฑด(>80)์ ๋ง์กฑํ๋ ํ๋ง ๋ณด๊ธฐ
# ๋ฐ์ดํฐ ์์ฝ๊ณผ ๊ณ์ฐ
print(df['์ ์'].mean)) #ํ๊ท ์ ์
print(df['์ ์'].sum)) # ์ ์ ์ดํฉ
print(df['์ ์'].max)) # ์ต๊ณ ์ ์
print(df.describe()) # ๋ฐ์ดํฐ ์ ์ฒด ํต๊ณ(ํ๊ท , ํ์คํธ์ฐจ, ์ต๋/์ต์๊ฐ ๋ฑ) ํ์ธ
# ๋ฐ์ดํฐ ์ ๋ ฌํ๊ธฐ
sorted_df = df.sort_values(by = '์ ์', ascending = False) # ์ ์ ๊ธฐ์ค์ผ๋ก ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
print(sorted_df)
# ๋ฐ์ดํฐ ์์ ํ๊ธฐ
df.at[0, '์ ์'] = 95 # ํน์ ์
(์ฒซ๋ฒ์งธ ์ค)์ ๊ฐ(์ ์)์ ๋ณ๊ฒฝ
df['ํฉ๊ฒฉ ์ฌ๋ถ'] = df['์ ์'] > 80 # ์ด/์นธ ์ ์ ๋ฐ์ดํฐ(80์ ์ด์ ํฉ๊ฒฉ)๋ฅผ ์ถ๊ฐ
# ๋ฐ์ดํฐ ์ ๋ฆฌํ๊ธฐ
df = df.fillna(0) # ๋น์นธ์ 0์ผ๋ก ์ฑ์ฐ๊ธฐ
df = df.dropna() # ๋น์นธ์ด ์๋ ์ค ์ญ์
df = df.drop_duplicates() # ์ค๋ณต ๋ฐ์ดํฐ ์ญ์
# ๋ฐ์ดํฐ ํฉ์น๊ธฐ
merged_df = pd.concat([df1, df2]) # ์ฌ๋ฌ ํ๋ฅผ ํ๋๋ก ํฉ์น๊ธฐ
merged_df = pd.merge(df1, df2, on = '์ด๋ฆ') # ๊ณตํต๋ ์ด(์ด๋ฆ ์ด) ๊ธฐ์ค์ผ๋ก ํฉ์น๊ธฐ(like SQL JOIN)
# ๋ฐ์ดํฐ ์ ์ฅํ๊ธฐ
df.to_csv("cleaned_data.csv", index = False) # CSV ํ์ผ๋ก ์ ์ฅ
df.to_excel("cleaned_data.xlsx", index = False) # ์์
ํ์ผ๋ก ์ ์ฅ
# ๋ฐ์ดํฐ ๋ถ์ํ๊ธฐ
grouped = df.groupby('๋ฐ')['์ ์'].mean # ๋ฐ ๋ณ ํ๊ท ์ ์ ๊ตฌํ๊ธฐ
print(grouped)
ํ๋ค์ค๋ฅผ ์ฌ์ฉํ๋ ์ด์
๋ฐ์ดํฐ๊ฐ ์์ฃผ ๋ง๊ณ , ๋ณต์กํ๊ฒ ์ฝํ์๋ค๋ฉด ์ฌ๋์ด ์ผ์ผ์ด ์ ๋ฆฌํ๊ธฐ ์ด๋ ต๋ค.
ํ์ง๋ง ํ๋ค์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๋ช ์ค์ ์ฝ๋๋ง์ผ๋ก ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ฝ๊ฒ ์ป์ ์ ์๋ค.
ํนํ, ์ํ์ด๋ ๊ณผํ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋๋ฐ ์ ์ฉํ๋ค.
ํ๋ค์ค ์ฌ์ฉ ์์
์๋์ ๊ฐ์ ํ๊ฐ ์๋ค๊ณ ๊ฐ์ ํด๋ณด์.
์ด๋ฆ | ์ ์ |
์ฒ ์ | 85 |
์ํฌ | 90 |
๋ฏผ์ | 78 |
์์ง | 95 |
์ด๊ฒ์ ํ์ด์ฌ์์ ํ๋ค์ค๋ฅผ ์ฌ์ฉํด ๋ค๋ฃฌ๋ค๋ฉด:
import pandas as pd
# ๋ฐ์ดํฐ๋ฅผ ๋ง๋ค์ด๋ณด์
data = {'์ด๋ฆ' : ['์ฒ ์', '์ํฌ', '๋ฏผ์', '์์ง'], '์ ์' : [85, 90, 78, 95]}
df = pd.DataFrame(data) # ๋ฐ์ดํฐํ๋ ์์ด๋ผ๋ ํ๋ฅผ ๋ง๋ค์ด์ค๋ค
print(df) # ํ๋ฅผ ์ถ๋ ฅํ๋ค
๊ฒฐ๊ณผ๋:
์ด๋ฆ ์ ์
0 ์ฒ ์ 85
1 ์ํฌ 90
2 ๋ฏผ์ 78
3 ์์ง 95
80์ ๋์ ์ฌ๋๋ง ๊ณจ๋ผ๋ณด๊ธฐ:
high_scores = df[df['์ ์'] > 80] # ์ ์๊ฐ 80์ ๋ณด๋ค ํฐ ์ฌ๋์ ๋ฐ์ดํฐ๋ง ๊ณจ๋ผ์ค๋ค
print(high_scores)
๊ฒฐ๊ณผ:
์ด๋ฆ ์ ์
0 ์ฒ ์ 85
1 ์ํฌ 90
3 ์์ง 95
์ฝ๊ฒ ์ ๋ฆฌํ์๋ฉด,
1. ๋ฐ์ดํฐ๋ฅผ ์ ๋ฆฌํ๋ค
2. ํ์ ์๋ ๊ฑด ์ง์ด๋ค
3. ๊ณ์ฐ๊ธฐ๋ฅผ ๋์ ํ์ฌ ๊ณ์ฐํ๋ค
4. ํ์ํ ๋ฐ์ดํฐ๋ง ๋ฝ์๋ธ๋ค
ํ๋ค์ค์ ๋ํ์ด
2. ๋ํ์ด
๋ํ์ด๋?
ํ์ด์ฌ์์ ์ซ์ ๋ฐ์ดํฐ๋ฅผ ๋น ๋ฅด๊ณ ํจ์จ์ ์ผ๋ก ๋ค๋ฃฐ ์ ์๋๋ก
๋์์ฃผ๋ ๋๊ตฌ์ด๋ค.
๋ฐ์ดํฐ๋ฅผ ์ ๋ฆฌํ๊ณ , ๊ณ์ฐํ๊ณ , ๋ถ์ํ ๋ ๋ง์ด ์ฐ์ธ๋ค.
ํนํ, ์ํ ๊ณ์ฐ๊ณผ ๋ฐฐ์ด(array)์ ๋ค๋ฃจ๋๋ฐ ๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค.
๋ํ์ด๋ ๋ฌด์์ ํ ์ ์๋?
๋ํ์ด๋ ์ซ์ ๋ฐ์ดํฐ ๊ณ์ฐ์ ์ ๋ฌธ๊ฐ์ด๊ณ , ํ๋ ์ผ์ ์๋์ ๊ฐ๋ค:
- ๋ฐฐ์ด(array) ๋ง๋ค๊ธฐ์ ๋ค๋ฃจ๊ธฐ : ๋ฐฐ์ด์ ์์ ํ์ฒ๋ผ ์ซ์๊ฐ ์ค๊ณผ ์นธ์ผ๋ก ์ ๋ฆฌ๋ ๋ฐ์ดํฐ์ด๋ค.
- ๋ณต์กํ ์ํ ๊ณ์ฐ : ๋ง์ , ๊ณฑ์ , ํ๊ท ๊ณผ ๊ฐ์ ๊ฐ๋จํ ๊ณ์ฐ๋ถํฐ, ํ๋ ฌ(matrix) ์ฐ์ฐ๊ณผ ๊ฐ์ ๊ณ ๊ธ ๊ณ์ฐ๊น์ง ๊ฐ๋ฅํ๋ค.
- ๋ฐ์ดํฐ ์ฒ๋ฆฌ ์๋ : ์ผ๋ฐ ํ์ด์ฌ ์ฝ๋๋ณด๋ค ํจ์ฌ ๋น ๋ฅด๊ฒ ๋ฐ์ดํฐ๋ฅผ ๊ณ์ฐํ ์ ์๋ค.
๋ํ์ด๋ฅผ ์จ์ผ ํ๋ ์ด์
- ๋น ๋ฅด๋ค : ๋ํ์ด๋ ์ปดํจํฐ์ ์ซ์ ๊ณ์ฐ ์๋๋ฅผ ์ต๋ํ ํ์ฉํ๊ธฐ ๋๋ฌธ์, ํฐ ๋ฐ์ดํฐ๋ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌํ ์ ์๋ค.
- ํจ์จ์ ์ด๋ค : ์ผ๋ฐ ๋ฆฌ์คํธ๋ณด๋ค ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๊ฒ ์ฌ์ฉํ๋ฉด์ ๋ ๋ง์ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ์ ์๋ค.
- ์ํ ๊ธฐ๋ฅ์ด ๊ฐ๋ ฅํ๋ค : ๋ณต์กํ ๊ณ์ฐ์ ๋ช ์ค์ ์ฝ๋๋ก ํด๊ฒฐ ๊ฐ๋ฅํ๋ค.
๋ํ์ด์์ ์ฌ์ฉํ๋ ๋ฐฐ์ด(array)์ด๋?
๋ํ์ด์ ๋ฐฐ์ด(array)์ ํ์ด์ฌ์ ๋ฆฌ์คํธ์ ๋น์ทํ๊ฒ ์๊ฒผ์ง๋ง, ํจ์ฌ ๋ ๊ฐ๋ ฅํ๋ค:
- ํ์ด์ฌ ๋ฆฌ์คํธ๋ ๋ฐ์ดํฐ๋ฅผ ํ๋์ฉ ์ฒ๋ฆฌํ์ง๋ง, ๋ํ์ด ๋ฐฐ์ด์ ํ๊บผ๋ฒ์ ๊ณ์ฐ์ด ๊ฐ๋ฅํ๋ค.
- ๋ํ์ด ๋ฐฐ์ด์ ํ๊ฐ์ง ๋ฐ์ดํฐ ํ์ ๋ง ์ ์ฅํ ์ ์์ด์ ๋ ๋น ๋ฅด๊ณ ํจ์จ์ ์ด๋ค.
import numpy as np
# ํ์ด์ฌ ๋ฆฌ์คํธ
list_data = [1, 2, 3, 4, 5]
# ๋ํ์ด ๋ฐฐ์ด
array_data = np.array([1, 2, 3, 4, 5])
# ๋ฆฌ์คํธ๋ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๊ณ์ฐ
list_squared = [x ** 2 for x in list_data]
print(list_data) # [1, 4, 9, 16, 25]
# ๋ํ์ด๋ ํ ์ค๋ก ๊ฐ๋ฅ
array_squared = array_data ** 2
print(array_squared) # [1 4 6 9 16 25]
๋ํ์ด์ ์ฃผ์ ๊ธฐ๋ฅ
1) ๋ฐฐ์ด ์์ฑ : ๋ํ์ด๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐฐ์ด์ ์ฝ๊ฒ ๋ง๋ค ์ ์๋ค.
import numpy as np
# ๊ธฐ๋ณธ ๋ฐฐ์ด
arr = np.array([1, 2, 3, 4])
print(arr) # [1 2 3 4]
# 0์ผ๋ก ์ฑ์์ง ๋ฐฐ์ด
zeros = np.zeros((2, 3)) # 2ํ 3์ด ๋ฐฐ์ด
print(zeros)
# 1๋ก ์ฑ์์ง ๋ฐฐ์ด
ones = np.ones((3, 3)) # 3ํ 3์ด ๋ฐฐ์ด
print(ones)
# 1๋ถํฐ 10๊น์ง์ ์ซ์๋ก ์ฑ์ด ๋ฐฐ์ด
range_arr = np.arange(1, 11)
print(range_arr) # [1 2 3 4 5 6 7 8 9 10]
2) ๋ฐฐ์ด ํฌ๊ธฐ ๋ฐ๊พธ๊ธฐ : ๋ํ์ด์์๋ ๋ฐฐ์ด์ ๋ชจ์(ํฌ๊ธฐ)์ ์ฝ๊ฒ ๋ฐ๊ฟ ์ ์๋ค.
arr = np.arange(1, 7) # [1 2 3 4 5 6]
reshaped = arr.reshape((2, 3)) # 2ํ 3์ด๋ก ๋ฐ๊พธ๊ธฐ
print(reshaped)
3) ์ํ ์ฐ์ฐ : ๋ํ์ด๋ ๋ฐฐ์ด์ ์ง์ ์ํ ์ฐ์ฐ์ ํ ์ ์๋ค.
arr = np.array([1, 2, 3, 4])
# ๋ชจ๋ ์์์ ์ํ ์ฐ์ฐ
print(arr + 10) # [11 12 13 14]
print(arr * 2) # [2 4 6 8]
# ๋ฐฐ์ด๋ผ๋ฆฌ ์ฐ์ฐ
arr2 = np.array([10, 20, 30, 40])
print(arr + arr2) # [11 22 33 44]
# ํ๊ท , ํฉ๊ณ, ์ต๋/์ต์๊ฐ
print(arr.mean()) # ํ๊ท : 2.5
print(arr.sum()) # ํฉ๊ณ: 10
print(arr.max()) # ์ต๋๊ฐ: 4
print(arr.min()) # ์ต์๊ฐ: 1
4) ํน์ ์กฐ๊ฑด์ ๋ฐ์ดํฐ ์ ํ : ๋ํ์ด๋ฅผ ์ฌ์ฉํ๋ฉด ์กฐ๊ฑด์ ๊ฑธ์ด์ ์ํ๋ ๋ฐ์ดํฐ๋ง ๊ณจ๋ผ๋ผ ์ ์๋ค.
arr = np.array([10, 15, 20, 25, 30])
# 20๋ณด๋ค ํฐ ๊ฐ๋ง ์ ํ
filtered = arr[arr > 20]
print(filtered) # [25 30]
5) ๋๋ค ๋ฐ์ดํฐ ์์ฑ : ๋ํ์ด๋ก ์์์ ๋ฐ์ดํฐ๋ฅผ ๋ง๋ค ์ ์๋ค.
# 0๊ณผ 1 ์ฌ์ด์ ๋๋ค ์ซ์
random_nums = np.random.random((2, 3))
print(random_nums)
# ์ ์ ๋ฒ์์ ๋๋ค ์ซ์
random_ints = np.random.randint(1, 10, size = (3, 3)) # 1~9 ์ฌ์ด์ ์ ์
print(random_ints)
6) ํ๋ ฌ ์ฐ์ฐ : ๋ํ์ด๋ ์ํ์์ ์ฐ์ด๋ ํ๋ ฌ(matrix)์ ๋ค๋ฃจ๋๋ฐ ์ต์ ํ ๋์ด์๋ค.
# ๋ ํ๋ ฌ ๊ณฑํ๊ธฐ
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
result = np.dot(matrix1, matrix2) # ํ๋ ฌ ๊ณฑ
print(result)
๋ฐฐ์ด(Array) ์์ฑ ๋ฐ ๋ค๋ฃจ๊ธฐ
๋ํ์ด์ ํต์ฌ์ ๋ฐฐ์ด(array)์ด๋ค. ๋ฐฐ์ด์ ๋ฐ์ดํฐ๋ฅผ ํ๊ณผ ์ด๋ก ํํํ ํํ๋ก, ์ซ์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์๋ค.
๋ฐฐ์ด์์ฑ
- np.array(): ๋ฆฌ์คํธ๋ ํํ์ ๋ฐฐ์ด๋ก ๋ณํ
- np.zeros(): ๋ชจ๋ ๊ฐ์ด 0์ธ ๋ฐฐ์ด ์์ฑ
- np.ones(): ๋ชจ๋ ๊ฐ์ด 1์ธ ๋ฐฐ์ด ์์ฑ
- np.empty(): ์ด๊ธฐํ๋์ง ์์ ๋ฐฐ์ด ์์ฑ
- np.arange(): ํน์ ๊ฐ๊ฒฉ์ผ๋ก ์ซ์๋ฅผ ์์ฑ
- np.linspace(): ์์๊ณผ ๋ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ผ์ ๊ฐ๊ฒฉ์ ์ซ์ ์์ฑ
๋ฐฐ์ด ์์ฑ ํ์ธ
- array.shape: ๋ฐฐ์ด์ ํฌ๊ธฐ(ํ, ์ด) ํ์ธ
- array.ndim: ๋ฐฐ์ด์ ์ฐจ์ ํ์ธ (1D, 2D, 3D ๋ฑ)
- array.size: ๋ฐฐ์ด์ ์ด ์์ ๊ฐ์
- array.dtype: ๋ฐฐ์ด์ ์ ์ฅ๋ ๋ฐ์ดํฐ ํ์
๋ฐฐ์ด ์กฐ์
๋ฐฐ์ด ๋ชจ์ ๋ณ๊ฒฝ
- array.reshape(): ๋ฐฐ์ด์ ๋ชจ์์ ๋ณ๊ฒฝ (์: 1D-> 2D)
- array.flatten(): ๋ค์ฐจ์ ๋ฐฐ์ด์ 1์ฐจ์์ผ๋ก ๋ณํ
- array.transpose(): ๋ฐฐ์ด์ ํ๊ณผ ์ด์ ๋ฐ๊ฟ
๋ฐฐ์ด ๊ฒฐํฉ๊ณผ ๋ถ๋ฆฌ
- np.concatenate(): ๋ฐฐ์ด์ ์ด์ด๋ถ์ด๊ธฐ
- np.stack(): ์๋ก์ด ์ถ์ ์ถ๊ฐํ์ฌ ๋ฐฐ์ด ๊ฒฐํฉ
- np.split(): ๋ฐฐ์ด์ ์ฌ๋ฌ ์กฐ๊ฐ์ผ๋ก ๋๋๊ธฐ
์ํ ์ฐ์ฐ
๋ํ์ด๋ ๋ฐฐ์ด์ ์์์ ๋ํด ์ํ ์ฐ์ฐ์ ํจ์จ์ ์ผ๋ก ์ํํ๋ค.
๊ธฐ๋ณธ ์ฐ์ฐ
- ๋ฐฐ์ด ๊ฐ์ ๋ง์ ( + ), ๋บ์ ( - ), ๊ณฑ์ ( * ), ๋๋์ ( / )
- ์ง์ ๊ณ์ฐ: np.exp(), ์ ๊ณฑ๊ทผ: np.sqrt()
- ์ผ๊ฐ ํจ์: np.sin(), np.cos(), np.tan()
ํต๊ณ ๊ณ์ฐ
- np.mean(): ํ๊ท ๊ฐ
- np.sum(): ํฉ๊ณ
- np.min(), np.max(): ์ต์๊ฐ, ์ต๋๊ฐ
- np.median(): ์ค๊ฐ๊ฐ
- np.std(): ํ์ค ํธ์ฐจ
- np.var(): ๋ถ์ฐ
์กฐ๊ฑด ๊ธฐ๋ฐ ์์
๋ํ์ด๋ ์กฐ๊ฑด์ ํ์ฉํ ๋ฐ์ดํฐ ํํฐ๋ง๊ณผ ์ฐ์ฐ์ ๊ฐ๋ ฅํ๋ค.
- ์กฐ๊ฑด ์ ํ: array[array > 10] -> ๋ฐฐ์ด์์ ๊ฐ์ด 10๋ณด๋ค ํฐ ์์๋ง ์ ํ
- np.where(condition, x, y): ์กฐ๊ฑด์ ๋ฐ๋ผ ๊ฐ์ ์ ํ
๋๋ค ๋ฐ์ดํฐ ์์ฑ
๋ํ์ด๋ ๋๋ค ์ซ์์ ๋ฐฐ์ด์ ์์ฑํ๋ ๊ธฐ๋ฅ๋ ์ ๊ณตํ๋ค.
- np.random.random(): 0๊ณผ 1 ์ฌ์ด์ ๋๋ค ์ค์ ์์ฑ
- np.random.randint(): ํน์ ๋ฒ์์ ๋๋ค ์ ์ ์์ฑ
- np.random.normal(): ์ ๊ท๋ถํฌ์์ ๋๋ค ๊ฐ ์์ฑ
ํ์ผ ์ ์ถ๋ ฅ
- np.loadtxt():
- np.savetxt():
- np.save() ์ np.load(): ๋ํ์ด ์ ์ฉ ํ์ผ ํ์(.npy)์ผ๋ก ์ ์ฅ/์ฝ๊ธฐ
์ ํ๋์ ๋ฐ ํ๋ ฌ ์ฐ์ฐ
๋ํ์ด๋ ํ๋ ฌ ์ฐ์ฐ๊ณผ ์ ํ๋์ ๊ณ์ฐ์ ์ ํฉํ๋ค.
- np.dot(): ํ๋ ฌ ๊ณฑ์
- np.linalg.inv(): ํ๋ ฌ์ ์ญํ๋ ฌ
- np.linalg.det(): ํ๋ ฌ์ ํ๋ ฌ์
- np.linalg.eig(): ๊ณ ์ ๊ฐ๊ณผ ๊ณ ์ ๋ฒกํฐ ๊ณ์ฐ
๋ฐฐ์ด์ ์ ๋ ฌ ๋ฐ ๊ฒ์
- np.sort(): ๋ฐฐ์ด ์ ๋ ฌ
- np.argsort(): ์ ๋ ฌ๋ ๋ฐฐ์ด์ ์ธ๋ฑ์ค ๋ฐํ
- np.argmax(), np.argmin(): ์ต๋๊ฐ/์ต์๊ฐ์ ์์น ๋ฐํ
๋ฐฐ์ด์ ๋ ผ๋ฆฌ ์ฐ์ฐ
- np.all(): ๋ชจ๋ ์กฐ๊ฑด์ด True์ธ์ง ํ์ธ
- np.any(): ์กฐ๊ฑด ์ค ํ๋๋ผ๋ True์ธ์ง ํ์ธ
- np.logical_and(), np.logical_or(): ๋ ผ๋ฆฌ ์ฐ์ฐ ์ํ
๋น ๋ฅธ ๊ณ์ฐ์ ์ํ ๋ธ๋ก๋์บ์คํ
๋ํ์ด๋ ํฌ๊ธฐ๊ฐ ๋ค๋ฅธ ๋ฐฐ์ด์ ์ฐ์ฐํ ๋ ์๋์ผ๋ก ํฌ๊ธฐ๋ฅผ ๋ง์ถฐ ๊ณ์ฐํ๋ค.
a = np.array([1, 2, 3])
b = np.array([[10], [20], [30]])
result = a + b # ์๋์ผ๋ก ํฌ๊ธฐ๋ฅผ ๋ง์ถฐ ๋ํ๊ธฐ
๋ํ์ด๋?
1. ๋ฐ์ดํฐ ๋ถ์: ๋๋์ ๋ฐ์ดํฐ๋ฅผ ๋น ๋ฅด๊ฒ ๊ณ์ฐํ๊ณ ๋ค๋ฃฐ ๋
2. ์ํ, ๊ณผํ ๊ณ์ฐ: ๋ณต์กํ ํ๋ ฌ ์ฐ์ฐ, ํต๊ณ ๊ณ์ฐ ๋ฑ์ ์ ํฉ
3. AI/๋จธ์ ๋ฌ๋: ๋ชจ๋ธ์ ํ๋ จํ๊ฑฐ๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌํ ๋ ๊ธฐ๋ณธ ๋๊ตฌ๋ก ์ฌ์ฉ
'Back End ๐ฒ > Python ๐ป' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[241213] ์ฐ์ฐ์์ ์ด์ง๋ฒ (1) | 2024.12.13 |
---|---|
[241212] ํ์ด์ฌ VSCode ๋ก ๊ฐ์ํ๊ฒฝ ์ค์ ๋ฐ ๋ณ์ ๋ณต์ต (4) | 2024.12.12 |
[241126] ํ์ด์ฌ class ๋ณต์ต (0) | 2024.11.26 |
[241125] ์ธ๊ณต์ง๋ฅ์ ์ํ ํ์ด์ฌ 4์ฃผ์ฐจ-1~2 ๊ฐ์ (1) | 2024.11.25 |
[241122] ์ธ๊ณต์ง๋ฅ์ ์ํ ํ์ด์ฌ 3์ฃผ์ฐจ-1~3 ๊ฐ์ (2) | 2024.11.22 |