급해서 간단히 쓰고 감;

아이디어 자체는 간단함. 1, 2, 3 ... 처럼 오름차순으로 보내야 하는 곳이 있고, 그 곳에 값들을 보내기 위해 다른 공간에 값들을 차곡차곡 쌓으면 되는 것임.

근데 생각할 점은

1) 그 값을 쌓는 공간에는 LIFO가 적용됨 -> 스택 사용 2) 다른 공간에 값을 차곡차곡 쌓긴 할 건데, 스택이니까 쌓인 순서대로만 나가야 됨. 근데? 보내야 하는 곳은 오름차순을 요구함! -> 스택에도 큰 수부터 차례대로 쌓여야 함. 이게 포인트

나는 근데 이거 보고 스택이다 스택!! 하고 신나서 당장 스택 2개를 질러버림,,, 사실 스택 하나여도 풀 수 있죠? 나가는 공간은 어떤 값들이 어떻게 나갔는지를 보관해야 할 필요는 없기 때문에 그냥 인덱스로만 관리해도 무방함ㅎㅎ

아무튼 간단하고 재미있는 스택 문제였다... 지문이 좀 이상해서 질문 게시판을 참조해야 되기는 했지만

어떤 개념을 쓰는 문제라고 해서 그 개념 쓸 생각에만 매몰되지 말자!

라는 좋은 경험을 얻었다...

먼저, total_bedrooms 특성에 값이 없는 경우가 있는데, 이를 수정해보자. 방법에는 다음과 같이 세 가지가 있다.

1. 해당 구역을 제거하기
2. 전체 특성을 삭제하기
3. 대체 : 누락된 값을 어떤 값으로 채우기

판다스의 dropana(), drop(), fillna() 메서드로 이런 작업을 간단하게 처리할 수 있다.

# housing.dropna(subset=["total_bedrooms"], inplace=True)  

# housing.drop("total_bedrooms", axis=1, inplace=True)  

median = housing["total_bedrooms"].median()  
housing["total_bedrooms"].fillna(median, inplace=True)

여기까지는 저번 파트에서 다루었던 내용이다.

세 번째 옵션이 누락된 값을 중간값으로 채우는 코드이다. 위와 같은 동작을 사이킷런의 SimpleImputer 클래스를 통해 할 수 있다. 이 클래스는 각 특성의 중간값을 저장하고 있어 유용하다. 또한, 훈련 세트뿐만 아니라 검증 세트와 테스트 세트 그리고 모델에 주입될 새로운 데이터에 있는 누락된 값을 대체할 수 있다.

다음과 같이 누락된 값을 특성의 중간값으로 대체하도록 지정하여 SimpleImputer의 객체를 생성한다.

from sklearn.impute import SimpleImputer  

imputer = SimpleImputer(strategy="median")

중간값은 수치형 특성에서만 계산될 수 있으므로 수치 특성만 가진 데이터 복사본을 생성한다.

housing_num = housing.select_dtypes(include=[np.number])

이후, imputer 객체의 fit() 메서드를 사용해 훈련 데이터에 적용할 수 있다.

imputer.fit(housing_num)

imputer은 각 특성의 중간값을 계산하여 그 결과를 객체의 statistics_ 속성에 저장한다. 이후, 학습된 impuer 객체를 사용해 훈련 세트에서 누락된 값을 학습된 중간값으로 바꿀 수 있다.

X = imputer.transform(housing_num)

누락된 값을 평균이나 가장 자주 등장하는 값, 상수로 바꾸는 것도 가능하다. 뒤 두 가지 방법은 수치가 아닌 데이터도 지원한다.

사이킷런 변환기는 판다스 데이터프레임이 입력되더라도 넘파이 배열이나 사이파이 희소 행렬을 출력한다. 따라서 imputer.transform(housing_num) 의 출력 또한 넘파이 배열이다.

type(X)

>> numpy.ndarray

현재 상태에서는 열 이름도 인덱스도 없기 때문에, 이를 데이터프레임으로 감싸서 열 이름과 인덱스를 복원할 수 있다.

housing_tr = pd.DataFrame(X, columns=housing_num.columns,  
                          index=housing_num.index)

텍스트와 범주형 특성 다루기

위에서는 수치형 특성만을 다뤘고, 이제는 텍스트 특성을 살펴보자.

housing_cat = housing[["ocean_proximity"]]  
housing_cat.head(8)

      ocean_proximity
13096        NEAR BAY
14973       <1H OCEAN
3785           INLAND
14689          INLAND
20507      NEAR OCEAN
1286           INLAND
18078       <1H OCEAN
4396         NEAR BAY

housing_cat.value_counts()

ocean_proximity
<1H OCEAN          7274
INLAND             5301
NEAR OCEAN         2089
NEAR BAY           1846
ISLAND                2
Name: count, dtype: int64

이를 통해, 이 특성은 범주형 특성임을 알 수 있다.

이 카테고리를 텍스트에서 숫자로 변환하기 위해 사이킷런의 OrdinalEncoder을 사용한다.

from sklearn.preprocessing import OrdinalEncoder  

ordinal_encoder = OrdinalEncoder()  
housing_cat_encoded = ordinal_encoder.fit_transform(housing_cat)

인코딩된 몇 개의 값을 확인하면 다음과 같다.

housing_cat_encoded[:8]

array([[3.],
       [0.],
       [1.],
       [1.],
       [4.],
       [1.],
       [0.],
       [3.]])

categories_ 인스턴스 변수를 사용해 카테고리 리스트를 얻을 수 있다. 범주형 특성마다 1D 카테고리 배열을 담은 리스트가 반환된다.

ordinal_encoder.categories_

[array(['<1H OCEAN', 'INLAND', 'ISLAND', 'NEAR BAY', 'NEAR OCEAN'],
       dtype=object)]

이런 표현 방식의 문제는 머신러닝 알고리즘이 가까이 있는 두 값을 떨어져 있는 두 값보다 더 비슷하다고 생각한다는 점이다. (숫자 상으로 비슷하면, 실제로는 전혀 다른 특징을 가진 값이어도 비슷하게 인식하게 된다.)

이러한 문제는 카테고리별 이진 특성을 만들어 해결한다. 카테고리가 <1H OCEAN일 때 한 특성이 1이고, 카테고리가 INLAND일 때 다른 한 특성이 1이 되는 식이다. 한 특성만 1이고 나머지는 0이므로 이를 원-핫 인코딩이라고 부른다. 새로운 특성을 더미 특성이라고도 부른다. 사이킷런은 범주 값을 원-핫 벡터로 바꾸기 위한 OneHotEncoder 클래스를 제공한다.

from sklearn.preprocessing import OneHotEncoder  

cat_encoder = OneHotEncoder()  
housing_cat_1hot = cat_encoder.fit_transform(housing_cat)

OneHotEncoder의 출력은 넘파이 배열이 아니라 사이파이 희소 행렬이다.

housing_cat_1hot

<16512x5 sparse matrix of type '<class 'numpy.float64'>'
    with 16512 stored elements in Compressed Sparse Row format>

희소 행렬은 0이 대부분인 행렬을 매우 효율적으로 표현한다. 내부적으로 0이 아닌 값과 그 위치만 저장한다. 이는 많은 메모리를 절약하고 계산 속도를 높여주는 효과를 가진다. 공식 documentation

대부분 희소 행렬을 보통의 2D 배열처럼 사용할 수 있지만, 넘파이 배열로 바꾸려면 toarray() 메서드를 호출해야 한다.

housing_cat_1hot.toarray()

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

상관관계 조사하기

모든 특성 간의 표준 상관계수를 corr() 메서드를 사용해 쉽게 계산할 수 있다.

corr_matrix["median_house_value"].sort_values(ascending=False)

median_house_value    1.000000
median_income         0.688380
total_rooms           0.137455
housing_median_age    0.102175
households            0.071426
total_bedrooms        0.054635
population           -0.020153
longitude            -0.050859
latitude             -0.139584
Name: median_house_value, dtype: float64

상관관계의 범위는 -1부터 1까지로, 1에 가까우면 강한 양의 상관관계, -1에 가까우면 강한 음의 상관관계를 가진다는 뜻이다.

판다스의 scatter_matrix 함수를 통해 숫자형 특성 간 산점도를 그려보는 것 또한 가능하다.

from pandas.plotting import scatter_matrix  

attributes = ["median_house_value", "median_income", "total_rooms",   
"housing_median_age"]  
scatter_matrix(housing[attributes], figsize=(12, 8))  
plt.show()

이 그림을 보았을 때, 중간 주택 가격을 예측하는 데 중간 소득이 가장 유용해보인다는 것을 발견할 수 있다. 이 산점도를 확대해보자.

이 그래프를 통해 알 수 있는 사실은 다음과 같다.

1. 상관관계가 매우 강하다.
   • 위쪽으로 향하는 경향이 보인다.
   • 포인트들이 너무 많이 퍼져 있지는 않다.
2. 가격의 한계값이 수평선으로 잘 보이는데, 이러한 형태가 다른 곳에서도 더 나타나므로 이상한 형태를 알고리즘이 학습하지 않도록 구역을 제거할 수 있다.

특성 조합으로 실험하기

특정 구역의 가구 당 방 개수가 몇 개인지, 방 당 침실 개수가 몇 개인지 등 여러 특성을 조합하여 새로운 특성을 만들 수 있다.

housing["rooms_per_house"] = housing["total_rooms"] / housing["population"]  
housing["bedrooms_ratio"] = housing["total_bedrooms"] / housing["total_rooms"]  
housing["population_per_house"] = housing["population"] / housing["households"]

median_house_value      1.000000
median_income           0.688380
rooms_per_house         0.202050
total_rooms             0.137455
housing_median_age      0.102175
households              0.071426
total_bedrooms          0.054635
population             -0.020153
population_per_house   -0.038224
longitude              -0.050859
latitude               -0.139584
bedrooms_ratio         -0.256397
Name: median_house_value, dtype: float64

기존의 다른 특성들에 비해 bedrooms_ratio, rooms_per_house 특성이 중간 주택 가격과의 상관관계가 높게 나타나는 것을 확인할 수 있다.

머신러닝 알고리즘을 위한 데이터 준비

머신러닝 알고리즘을 위해 데이터를 준비하는 과정은 함수를 만들어 자동화해야 하는데, 그 이유는 다음과 같다.

• 어떤 데이터셋에 대해서도 데이터 변환을 손쉽게 반복할 수 있음.
• 향후 프로젝트에 재사용 가능한 변환 라이브러리를 점진적으로 구축할 수 있음.
• 실제 시스템에서 알고리즘에 새 데이터를 주입하기 전에 이 함수를 사용해 변환할 수 있음.
• 여러 가지 데이터 변환을 쉽게 시도해볼 수 있고 어떤 조합이 가장 좋은지 확인하는 데 편리함.

데이터 정제

먼저, total_bedrooms 특성에 값이 없는 경우가 있는데, 이를 수정해보자. 방법에는 다음과 같이 세 가지가 있다.

1. 해당 구역을 제거하기
2. 전체 특성을 삭제하기
3. 대체 : 누락된 갓을 어떤 값으로 채우기

판다스의 dropana(), drop(), fillna() 메서드로 이런 작업을 간단하게 처리할 수 있다.

# housing.dropna(subset=["total_bedrooms"], inplace=True)  

# housing.drop("total_bedrooms", axis=1, inplace=True)  

median = housing["total_bedrooms"].median()  
housing["total_bedrooms"].fillna(median, inplace=True)

이 코드에서는 StratifiedShuffleSplit을 사용해 10개의 다른 계층 분할을 생성한다.

from sklearn.model_selection import StratifiedShuffleSplit

splitter = StratifiedShuffleSplit(n_splits=10, test_size=0.2, random_state=42)
strat_splits = []
for train_index, test_index in splitter.split(housing, housing["income_cat"]):
    strat_train_set_n = housing.iloc[train_index]
    strat_test_set_n = housing.iloc[test_index]
    strat_splits.append([strat_train_set_n, strat_test_set_n])

첫 번째 분할을 다음과 같이 사용할 수 있다.

strat_train_set, strat_test_set = strat_splits[0]

다음과 같은 방식으로 계층적 샘플링을 코드 한 줄로 불러오는 것도 가능하다.

strat_train_set, strat_test_set = train_test_split(housing, test_size=0.2, stratify=housing["income_cat"], random_state=42)

데이터 이해를 위한 탐색과 시각화

먼저, 다음과 같은 코드를 통해 지리 정보를 산점도로 만들어 시각화해보자.

housing.plot(kind="scatter", x="longitude", y="latitude", grid=True)
plt.xlabel("경도")
plt.ylabel("위도")
plt.show()

이 그래프에서, 데이터 포인트가 밀접된 영역을 확인해보자.

housing.plot(kind="scatter", x="longitude", y="latitude", grid=True, alpha=0.2)
plt.xlabel("logitude")
plt.ylabel("latitude")
plt.show()

다음으로는 구역의 인구와 주택가격까지 그림에 나타내보자.

housing.plot(kind="scatter", x="longitude", y="latitude", grid=True,
             s=housing["population"] / 100, label="population",
             c="median_house_value", cmap="jet", colorbar=True,
             legend=True, figsize=(10, 7))
plt.show()

hist() 메서드는 모든 숫자형 형태에 대한 히스토그램을 출력할 수 있다.

이를 통해 알 수 있는 사실은 다음과 같다.

• 중간 소득이 US 달러로 표시되어 있지 않다. 따라서, 그 단위를 통일하는 것이 필요하다.
• 중간 주택 연도와 중간 주택 가격 그래프의 오른쪽 값이 심하게 높아지면서 그래프가 끝나는 것으로 보아 최댓값과 최솟값이 한정되어 있음을 알 수 있다.
• 특성들의 스케일이 많이 다르다.
• 많은 히스토그램에서 오른쪽 꼬리가 더 길다. 이러한 형태는 일부 머신러닝 알고리즘에서 패턴을 찾기 어렵게 만든다.

테스트 세트 만들기

• 데이터 스누핑 편향 : 테스트 세트로 일반화 오차를 추정하여 매우 낙관적인 추정이 나오게 되는 것

다음과 같은 코드로 랜덤으로 테스트 세트를 만들 수 있다.

import numpy as np

def shuffle_and_split_data(data, test_ratio):
shuffled_indices = np.random.permutation(len(data)) # 괄호 안 숫자 범위로 생성된 배열을 무작위로 섞음.
test_set_size = int(len(data) * test_ratio)
test_indices = shuffled_indices[:test_set_size]
train_indices = shuffled_indices[test_set_size:]
return data.iloc[train_indices], data.iloc[test_indices]

하지만, 프로그램을 실행할 때마다 다른 테스트 세트가 생성된다는 문제점이 존재한다. 이를 해결하기 위해서는,

1. 처음 실행에서 테스트 세트를 저장하고 다음번 실행에서 불러들이기
2. 항상 같은 난수 인덱스가 생성되도록 np.random.permutation()을 호출하기 전에 난수 발생기의 초깃값을 지정하기

하지만 위 방법 또한 데이터셋이 업데이트된 경우 문제가 생긴다. 따라서, 샘플의 식별자를 사용하여 테스트 세트로 보낼지 말지를 결정할 수 있다.

from zlib import crc32

def is_id_in_test_set(identifier, test_ratio):
return crc32(np.int64(identifier).tobytes()) < test_ratio * 2 ** 32

def split_data_with_id_hash(data, test_ratio, id_column):
ids = data[id_column]
in_test_set = ids.apply(lambda id_: is_id_in_test_set(id_, test_ratio))
return data.loc[~in_test_set], data.loc[in_test_set]

위 방법을 통해 나눈 훈련 / 테스트 세트를 보면 다음과 같다.

사이킷런을 사용하면 위 과정을 간단히 구현할 수 있다. 가장 간단한 함수는 train_test_split으로, 난수 초깃값을 설정하는 기능과 행의 개수가 같은 여러 개의 데이터셋을 넘겨 동일한 인덱스를 기반으로 나누는 기능이 존재한다.

from sklearn.model_selection import train_test_split

train_set, test_set = train_test_split(housing, test_size=0.2, random_state=42)

앞서 본 샘플링은 순수한 랜덤 샘플링이다. 데이터셋이 충분히 크다면 괜찮지만, 그렇지 않다면 샘플링 편향이 생길 가능성이 크다. 이를 위해 계층적 샘플링이 존재한다.

• 계층적 샘플링 : 전체를 계층이라는 동질의 그룹으로 나누고, 테스트 세트가 전체를 대표할 수 있도록 각 계층에서 올바른 수의 샘플을 추출하는 것.

이를 위해 전체를 여러 개의 계층으로 나눈 뒤, 계층의 비율대로 전체에서 샘플링하는 것이 가능하다.

housing["income_cat"] = pd.cut(housing["median_income"],
                               bins=[0., 1.5, 3.0, 4.5, 6., np.inf],
                               labels=[1, 2, 3, 4, 5])

pandas.cut reference pandas.cut 함수는 특정 1차원 배열을 bins에 따라 해당 개수, 또는 해당 구간에 따라 분할한 뒤, 각 값들에 대해 해당하는 구간의 labels의 값을 부여한다.

2장에서는 캘리포니아 주택 가격 데이터셋을 활용해 머신러닝 프로젝트를 처음부터 끝까지 직접 진행해보면서 배우는 것을 목표로 한다.

큰 그림 보기

문제 정의

풀고자 하는 문제가 무엇인지 먼저 정의하는 것이 필요함. 그렇게 하여 문제 상황을 정확히 파악하고, 해당 문제에 적합한 시스템을 설계하게 됨. 지금 문제는 레이블된 훈련 샘플이 있고, 여러 특성을 통해 한 개의 값을 예측하므로 지도 학습, 단변량 회귀 문제가 됨.

성능 측정 지표 선택

회귀 문제에서는 일반적으로 평균 제곱근 오차, RMSE를 사용한다. $RMSE(X, h) = \sqrt{\frac{1}{m} \sum_{i=1}^{n} (h(x^{(i)}) - y^{(i)})^2}$

하지만, 이상치로 보이는 구역이 많은 경우, 평균 절대 오차, MAE를 사용하기도 한다. $MAE(X, h) = \frac{1}{m}\sum_{i=1}^{m}|h(x^{(i)})-y^{(i)}|$

둘 모두 예측값의 벡터와 타깃값의 벡터 사이의 거리를 재는 방식이다. 거리 측정에는 여러 방식을 사용할 수 있다.

• 유클리드 노름 : RMSE 계산과 같다. $l_2$ 노름이라고도 부른다.
• 맨해튼 노름 : 절댓값의 합을 계산한다. $l_1$ 노름이라고도 부른다.
• $l_k$ 노름 = $(|v_0|^k + |v_1|^k + ... + |v_n|^k)^{\frac{1}{k}}$

가정 검사

시스템에서 요구로 출력을 하고 있는 출력이 현재 개발하고자 하는 모델의 출력과 일치한지 (ex: 가정에서는 수치형을 출력하고자 하는데 범주형을 요구한다던가) 확인해야한다.

데이터 가져오기

데이터 다운로드

아래 코드를 실행하면 데이터를 다운로드 할 수 있다.

from pathlib import Path
import pandas as pd
import tarfile
import urllib.request

def load_housing_data():
    tarball_path = Path("datasets/housing.tgz")
    if not tarball_path.is_file():
        Path("datasets").mkdir(parents=True, exist_ok=True)
        url = "https://github.com/ageron/data/raw/main/housing.tgz"
        urllib.request.urlretrieve(url, tarball_path)
        with tarfile.open(tarball_path) as housing_tarball:
            housing_tarball.extractall(path="datasets")
    return pd.read_csv("datasets/housing/housing.csv")

housing = load_housing_data()

1. tarball_path에 있는 파일이 있는지 확인한다. 1-1. 만약 파일이 없다면, datasets 폴더를 만들고 그 폴더에 tgz 파일을 다운로드받은 뒤, 압축 해제를 한다.
2. 파일을 pandas DataFrame으로 읽어온 결과를 리턴한다.

데이터 구조 훑어보기

head() 메서드를 사용하면 데이터의 첫 다섯 행을 읽어올 수 있다.

info() 메서드는 데이터에 관한 간략한 설명을 보여준다. 특히, 전체 행 수, 각 특성의 데이터 타입, 널이 아닌 값의 개수를 확인하는 데 유용하다.

다음과 같은 정보를 알 수 있다.

• 전체 샘플 개수는 20640개이다.
• total_bedrooms는 20433개만 널값이 아니다. 즉, 나머지 207개는 이 특성을 가지고 있지 않다.
• ocean_proximity 필드를 제외한 모든 특성이 숫자형이다.

value_counts() 메서드는 어떤 카테고리가 있고, 각 카테고리마다 얼마나 많은 구역이 있는지 확인할 수 있다.

머신러닝이란?

• 명시적인 프로그래밍 없이 컴퓨터가 학습하는 능력을 갖추게 하는 연구 분야

• 훈련 세트 : 시스템이 학습하는 데 사용하는 샘플

• 훈련 사례 (샘플) : 각각의 훈련 데이터

• 모델 : 학습하고 예측을 만드는 부분

• 정확도 : 성능 측정 지표 중 하나, 분류 작업에 많이 사용됨

머신러닝을 사용하는 이유

• 기존의 프로그램에 비해 유지보수가 편리 : 복잡한 규칙이 필요하지 않음, 자동화 기능을 갖춤
• 전통적인 방식으로는 너무 복잡하거나 알려진 알고리즘이 없는 문제를 해결 가능 : ex) 음성 인식
• 데이터 마이닝 : 대용량의 데이터를 분석하여 숨겨진 패턴을 발견하는 것. 이처럼 머신러닝을 통해 새로운 지식을 배울 수 있음.

머신러닝 시스템의 종류

다양한 범주로 나눌 수 있음.

훈련 지도 방식

학습하는 동안의 지도 형태나 정보량에 따라 분류하는 방법.

• 지도 학습 ** : 훈련 데이터에 **레이블이라는 원하는 답이 포함되는 방법. ex) 분류, 회귀
• 비지도 학습 : 레이블이 없어 시스템이 아무런 도움 없이 학습해야 하는 방법.
• 준지도 학습 : 레이블이 일부만 있는 데이터를 다루는 학습 방법.
• 자기 지도 학습 : 레이블이 전혀 없는 데이터셋에서 레이블이 완전히 부여된 데이터셋을 생성하는 방법.
• 강화 학습 : 에이전트(학습하는 시스템)이 환경을 관찰하여 행동을 실행하고 그 결과로 보상 또는 벌점을 얻는 방식. 시간이 지나면서 가장 큰 보상을 얻기 위해 정책이라고 하는 최상의 전략을 스스로 학습함.

배치 학습과 온라인 학습

배치 학습

• 가용한 데이터를 모두 사용해 훈련시키는 방법.
• 오프라인 학습 : 시스템을 오프라인에서 훈련시킨 뒤 학습한 것을 적용하기만 함.
• 문제점 : 세상은 진화하는데 모델은 바뀌지 않고 그대로임. -> 모델 부패, 데이터 드리프트

온라인 학습

• 데이터를 순차적으로 한 개씩 또는 미니배치라고 부르는 작은 묶음 단위로 주입.
• 학습률 : 변화하는 데이터에 얼마나 빠르게 적응할지를 결정하는 파라미터.

사례 기반 학습과 모델 기반 학습

어떻게 일반화되는가에 따라 머신러닝 시스템을 분류함.

• 사례 기반 학습 : 시스템이 훈련 샘플을 기억함으로써 학습함.
• 모델 기반 학습 : 샘플들의 모델을 만들어 예측에 사용.

머신러닝의 주요 도전 과제

나쁜 모델과 나쁜 데이터의 사례로 나누어짐.

충분하지 않은 양의 훈련 데이터

• 대부분의 머신러닝 알고리즘이 잘 작동하려면 데이터가 아주 많아야 함.

대표성 없는 훈련 데이터

• 일반화가 잘 되려면 훈련 데이터가 일반화하고 싶은 새로운 사례를 잘 대표하는 것이 중요.
• 샘플링 잡음 : 우연에 의한 대표성 없는 데이터, 샘플이 작을 경우 생김.
• 샘플링 편향 : 대표성을 띠지 못하는 샘플을 의미.

낮은 품질의 데이터

• 훈련 오류가 오류, 이상치, 잡음으로 가득하다면 데이터 정제를 위해 많은 시간을 투자해야 함.

관련 없는 특성

• 훈련 데이터에 관련 없는 특성이 적고 관련 있는 특성이 충분해야 시스템이 학습할 수 있음.

• 훈련에 사용할 좋은 특성을 찾는 것을 특성 공학이라고 함.

  • 특성 선택 : 가지고 있는 특성 중 훈련에 가장 유용한 특성을 선택.
  • 특성 추출 : 특성을 결합하여 더 유용한 특성을 만듦.
  • 데이터 수집 : 새로운 데이터를 수집해 새 특성을 만듦.

훈련 데이터 과대적합

• 과대적합 : 모델이 훈련 데이터에는 너무 잘 맞지만 일반성이 떨어지는 경우
• 훈련 데이터의 양과 잡음에 비해 모델이 너무 복잡할 때 일어남.
• 규제를 통해 문제를 해결할 수 있음.

훈련 데이터 과소적합

• 모델이 너무 단순해서 데이터의 내제된 구조를 학습하지 못할 때 일어남.

테스트와 검증

• 훈련 데이터를 훈련 세트와 테스트 세트 두 개로 나누어 검증을 진행함.

  • 일반화 오차 : 새로운 샘플에 대한 오차 비율, 테스트 세트에서 모델을 평가함으로써 이 값에 대한 추정값을 얻음.

하이퍼파라미터 튜닝과 모델 선택

• 하이퍼파라미터 튜닝 과정에서 테스트 세트에 최적화된 모델이 만들어져 새로운 데이터에 잘 작동하지 않게 될 수 있음.

• -> 홀드아웃 검증을 사용.

  • 훈련 세트의 일부를 떼어내어 여러 후보 모델을 평가하고 가장 좋은 하나를 선택하는 방법.
  • 검증 세트 : 새로운 홀드아웃 세트
  • 교차 검증 : 검증 세트마다 나머지 데이터에서 훈련한 모델을 해당 검증 세트에서 평가하는 방법. 훨씬 정확한 성능을 측정할 수 있지만, 훈련 시간이 검증 세트의 개수에 비례해 늘어남.

클로저란?

• 함수 안에 내부 함수를 구현하고 그 내부 함수를 리턴하는 함수

ex) 클래스를 통한 구현 (클로저 X)

class Mul:
    def __init__(self, m):
        self.m = m

    def __call__(self, n):
        return self.m * n

if __name__ == "__main__":
    mul3 = Mul(3)
    mul5 = Mul(5)

    print(mul3(10)) # 30 출력
    print(mul5(10)) # 50 출력

• mul3 = Mul(3)에서 생성자를 통해 함수 내부의 m이 3으로 지정.
• mul3(10)을 통해 __call__ 메소드가 호출됨.

ex) 함수 안에 함수를 구현하는 방법 (클로저)

def mul(m):
    def wrapper(n):
        return m * n
    return wrapper

if __name__ == "__main__":
    mul3 = mul(3)
    mul5 = mul(5)

    print(mul3(10)) # 30 출력
    print(mul5(10)) # 50 출력

• 위와 같은 기능을 구현하고 있지만, 함수가 함수를 리턴하는 식으로 구현.

데코레이터란?

• 기존 함수를 바꾸지 않고 기능을 추가할 수 있게 만드는 클로저

ex)

import time

def elasped(original_func):
    def wrapper():
        start = time.time()
        result = original_func()
        end = time.time()
        print("함수 수행시간: %f 초" % (end - start))
        return result
    return wrapper

def myfunc():
    print("함수가 실행됩니다.")

decorated_myfunc = elasped(myfunc)
decorated_myfunc()

나의 의문 : 여기서 굳이 wrapper을 써서 클로저로 구현해야 하는 이유는? 사실 wrapper 아래 코드를 바로 함수에서 실행해도 작동은 동일할 텐데?

이유 : elasped를 데코레이터로 만들기 위해서. 아래의 데코레이터로써의 기능을 사용하기 위해서는 클로저로 구현해야 할 필요가 있음.

• 다음과 같이 @ 문자를 이용해 함수 위에 적용하여 사용할 수 있음.

@elasped
def myfunc():
    print("함수가 실행됩니다.")

myfunc() # 데코레이터가 위에 바로 붙었으므로 별도의 선언이 더 이상 필요하지 않음.

• 데코레이터와 기존 함수의 인자 개수가 일치하지 않을 경우 에러가 남

• 어떤 인자를 받든 작동하도록 *args와 **kwargs를 사용.

def elasped(original_func):
    def wrapper(*args, **kwargs): 
    ...

나의 의문 : 꼭 *args랑 **kwargs를 둘 다 써야 하나?

해답 : 꼭 그럴 필요는 없는데, 지금처럼 유연하게 어떤 인자가 들어와도 받을 수 있게 처리하는 것이 목적이라면 둘 다 써야 함. 지금의 경우에는 *args가 빠질 경우에는 문제가 생김. 위치 인자가 original_func로 들어오고 있고, *args가 그걸 받는 역할을 하는 인자이기 때문.

이터레이터와 제너레이터

이터레이터란?

• 이터러블 : 리스트와 같이 반복 구문에 적용할 수 잇는 객체
• 이터레이터 : next 함수 호출 시 계속 그다음 값을 리턴하는 객체

ex) 리스트를 이터레이터로 변환하고 next를 사용해 값 가져오기

a = [1, 2, 3]
ia = iter(a) # 모든 이터러블은 iter 함수를 통해 이터레이터로 변환 가능.

next(ia)
# 1
next(ia)
# 2
next(ia)
# 3
next(ia)
# StopIteration 예외 : 더 리턴할 값이 없으므로

ex) for을 사용해 이터레이터의 값 가져오기

a = [1, 2, 3]
ia = iter(ia)
for i in ia:
    print(i)
    # 1 2 3 출력
for i in ia:
    print(i)
    # 아무것도 출력 X, for이나 next로 값을 한 번 읽으면 다시 읽을 수 없는 이터레이터의 특징.

이터레이터 만들기

• class로 이터레이터를 만들 수 있음.
• __iter__과 __next__ 라는 2개의 메서드를 구현.

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.position = 0

    def __iter(self):
        return self

    def __next__(self):
        if self.position >= len(self.data):
            raise StopIteration
        result = self.data[self.position]
        self.position += 1
        return result

if __name__ == "__main__":
    i = MyIterator([1, 2, 3])
    for item in i:
        print(item)

• __iter__ : 이 메서드가 있는 클래스로 생성한 객체는 반복 가능한 객체가 됨. 반복 가능한 객체를 리턴해야 함.
• __next__ : __iter__이 있는 클래스는 반드시 __next__를 구현해야 함. 반복 가능한 객체의 값을 차례대로 반환하는 역할을 함.

제너레이터란?

• 이터레이터를 생성해 주는 함수
• next 함수 호출 시 그 값을 차례대로 얻을 수 있음.
• 차례로 결과를 반환하기 위해 yield 키워드 사용

def mygen():
    yield 'a'
    yield 'b'
    yield 'c'

if __name__ == "__main__" : 
    g = mygen()
    next(g)
    # a
    next(g)
    # b
    next(g)
    # c
    next(g)
    # StopIteration 예외

• yield를 만날 시 해당 값을 리턴하되, 현제 상태를 그대로 기억한 채로 멈춤.

제너레이터 표현식

def mygen():
    for i in range(1, 1000):
        result = i * i
        yield result

gen = mygen()

print(next(gen))
# 1
print(next(gen))
# 4
print(next(gen))
# 9

다음과 같은 제너레이터를 아래와 같이 튜플 표현식으로 간단하게 만들 수 있음.

gen = (i * i for i in range(1, 1000))

제너레이터 활용하기

import time

def longtime_job():
    print("job start")
    time.sleep(1)  # 1초 지연
    return "done"

다음과 같은 코드에서

list_job = [longtime_job() for i in range(5)]와 list_job = (longtime_job() for i in range(5))를 사용 가능.

위 : longtime_job()을 5번 실행해서 그 결과로 리스트를 만듦. -> 즉시 longtime_job() 5번 실행 아래 : 제너레이터 표현식. 즉 next로 list_job의 결과를 불러오면 그 때마다 실행되고 값을 리스트에 넣음. -> next할 때마다 longtime_job() 실행

파이썬 타입 어노테이션

동적 언어

• 동적 언어 : 프로그램 실행 중 변수의 타입을 바꿀 수 있는 언어. ex) 파이썬

a = 1
a = "1" # 타입을 실행 중 스트링으로 바꿈 -> 동적 언어

• 장점 : 유연한 코딩이 가능하므로 쉽고 빠른 개발 가능, 타입 체크를 위한 코드가 없으므로 깔끔한 소스 생성 가능
• 단점 : 프로젝트의 규모가 커질수록 타입을 잘못 사용해 버그가 생길 확률이 늘어남.

파이썬 타입 어노테이션

• 3.5버전부터 타입 어노테이션 기능이 도입됨.
• 타입에 대한 힌트를 알려주는 정도의 기능

# a와 b의 타입 : int, 리턴값의 타입 : int
def add(a: int, b: int) -> int:
    return a+b

mypy

• 더 적극적으로 파이썬 어노테이션을 사용할 수 있도록 돕는 라이브러리
• pip install mypy를 통해 설치 후 사용
• 아래와 같이 터미널에서 실행 시 결과를 출력함.

C:\doit>mypy typing_sample.py
typing_sample.py:5: error: Argument 2 to "add" has incompatible type "float"; expected "int"
Found 1 error in 1 file (checked 1 source file)

클래스는 자료형을 직접 만들 수 있는 도구다.
파이썬은 기본적으로 int, str 같은 자료형을 제공하지만, 사용자가 직접 자료형(클래스)을 정의할 수 있다.

클래스 정의하기

class 클래스이름:
def init(self):
# 생성자 (객체가 생성될 때 자동 실행됨)
수행할 문장

예시:

class FourCal:
def init(self, first, second):
self.first = first
self.second = second

객체 생성하기

a = FourCal(4, 2)

클래스 내부 함수 (메서드) 정의

class FourCal:
def init(self, first, second):
self.first = first
self.second = second

def add(self):
    return self.first + self.second

def mul(self):
    return self.first * self.second

def sub(self):
    return self.first - self.second

def div(self):
    return self.first / self.second

a = FourCal(4, 2)
a.add()  # 6
a.mul()  # 8
a.sub()  # 2
a.div()  # 2.0

생성자 (__init__) 이해하기

객체가 생성될 때 자동 호출되어 초기값을 설정함.

class Sample:
def init(self, value):
self.value = value

self의 의미

• 클래스 내 메서드는 반드시 첫 번째 인자로 self를 가짐
• self는 생성된 객체 자기 자신을 의미함
• 객체 내 변수 접근: self.변수

클래스에 함수 추가하기

class MoreFourCal(FourCal):
def pow(self):
return self.first ** self.second



a = MoreFourCal(2, 3)
a.pow()  # 8

상속

기존 클래스를 상속받아 새로운 클래스를 만들 수 있다.

class MoreFourCal(FourCal):
pass  # 기존 기능을 그대로 상속

메서드 오버라이딩 (재정의)

부모 클래스의 메서드를 자식 클래스에서 다시 정의할 수 있다.

class SafeFourCal(FourCal):
def div(self):
if self.second == 0:
return 0
else:
return self.first / self.second



a = SafeFourCal(4, 0)
a.div()  # 0

클래스 변수와 인스턴스 변수

• 클래스 변수: 클래스에 공유되는 변수
• 인스턴스 변수: 객체마다 따로 존재

  class Family:
  lastname = “김”
  

print(Family.lastname) # 김

a = Family() b = Family() print(a.lastname) # 김 print(b.lastname) # 김

Family.lastname = “박” print(a.lastname) # 박 print(b.lastname) # 박

※ 클래스 변수는 클래스 자체 또는 모든 인스턴스에서 공유됨

## 모듈 (Module)

모듈이란 **함수, 변수, 클래스** 등을 모아 놓은 **파이썬 파일(.py)** 을 말한다.  
필요할 때 import하여 사용할 수 있다.

---
### 모듈 만들기

예: `mod1.py` 파일을 만든다.
```python
def add(a, b):
return a + b

def sub(a, b):
return a - b

모듈 불러오기 (import)

import mod1
print(mod1.add(3, 4))  # 7
print(mod1.sub(4, 2))  # 2

또는 from을 사용해 직접 함수만 가져올 수 있다.

from mod1 import add
add(3, 4)  # 7

여러 함수 가져오기:

from mod1 import add, sub

전체 가져오기:

from mod1 import * # 권장되지 않음

모듈 이름 확인하기

모듈 내부에서 자신의 이름을 확인할 수 있다.

print(name)

직접 실행하면 __main__, import되면 파일명이 출력된다.

이를 활용해 테스트 코드를 작성할 수 있다:

def add(a, b):
return a + b

if name == “main”:
print(add(3, 4))

클래스가 포함된 모듈

예: mod2.py

class Calculator:
def init(self):
self.result = 0

def add(self, num):
    self.result += num
    return self.result

사용 예:

from mod2 import Calculator

cal1 = Calculator()
print(cal1.add(3))  # 3
print(cal1.add(4))  # 7

다른 위치에 있는 모듈 사용하기

• sys.path에 디렉토리 추가

  import sys
  sys.path.append(”/사용할/모듈/디렉토리”)

• 또는 환경 변수 PYTHONPATH에 디렉토리 등록

표준 모듈 (라이브러리)

파이썬은 다양한 표준 모듈을 제공한다.

예:

import math
print(math.pi)         # 3.141592…
print(math.sqrt(16))   # 4.0

import random
print(random.randint(1, 10))  # 1~10 사이 임의의 정수

외부 모듈

• pip을 사용해 설치

pip install 모듈이름

예:

pip install requests

사용 예:

import requests
res = requests.get(“https://example.com”)
print(res.status_code)

패키지 (Package)

패키지는 모듈을 계층적으로 관리할 수 있게 해주는 디렉터리 구조다.
패키지란, 여러 모듈을 담고 있는 폴더이다.

패키지 만들기

다음과 같은 디렉터리 구조를 만든다.

game/
├── init.py
├── sound/
│   ├── init.py
│   ├── echo.py
├── graphic/
│   ├── init.py
│   ├── render.py

• __init__.py 파일은 해당 디렉토리가 패키지임을 알리는 역할
• 파이썬 3.3 이상에서는 없어도 되지만, 있는 게 좋다

모듈 불러오기

import game.sound.echo
game.sound.echo.echo_test()

또는 하위 모듈을 직접 import 할 수도 있다:

from game.sound import echo
echo.echo_test()

또는 함수만 직접 import:

from game.sound.echo import echo_test
echo_test()

상대 경로로 import 하기

from . import echo ← 현재 디렉터리 기준
from ..sound import echo ← 부모 디렉터리 기준

상대 경로 import는 모듈이 패키지 내부에서 실행될 때만 사용 가능
직접 실행하면 ImportError 발생할 수 있음

init.py 사용

패키지 디렉터리에 __init__.py 파일을 만들어
패키지를 초기화하거나, 외부에 노출할 모듈을 지정할 수 있다.

예:

# game/sound/__init__.py
__all__ = ['echo']

이렇게 하면 from game.sound import * 시 echo만 import 된다.

예외 사항

import * 문법은 init.py에서 all 리스트로 허용된 것만 가져옴 이 외에는 사용을 권장하지 않음

패키지와 모듈 위치 설정

• 현재 파이썬이 모듈을 찾는 경로는 sys.path에 저장되어 있음
• 필요하면 경로를 추가해야 함

  import sys
  sys.path.append("/my/custom/path")

예외 처리 (Exception Handling)

프로그래밍 중 오류가 발생할 수 있는 부분을 처리하여 프로그램이 중단되지 않도록 만드는 방법.

기본 구조

try:
    실행할 코드
except 예외종류:
    예외 발생 시 실행할 코드

예시:

try:
    4 / 0
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")

여러 개의 except 문

try:
    a = [1, 2]
    print(a[3])
    4 / 0
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")
except IndexError:
    print("인덱스 오류입니다.")

→ 가장 먼저 발생한 예외만 처리된다.

하나의 except에서 여러 예외 처리

try:
    a = [1, 2]
    print(a[3])
except (ZeroDivisionError, IndexError):
    print("오류 발생!")

예외 메시지 확인하기 (as 사용)

try:
    4 / 0
except ZeroDivisionError as e:
    print(e)

출력: division by zero

finally 문

예외 발생 여부와 관계없이 항상 실행되는 블록

try:
    print("try 실행")
    1 / 0
except:
    print("except 실행")
finally:
    print("finally 실행")

→ 출력:

try 실행  
except 실행  
finally 실행

예외 발생시키기 (raise)

직접 예외를 발생시킬 수 있다.

def raise_error():
    raise NotImplementedError

raise_error()

사용자 정의 예외 만들기

class MyError(Exception):
    pass

def say_nick(nick):
    if nick == "바보":
        raise MyError()
    print(nick)

try:
    say_nick("바보")
except MyError:
    print("사용자 정의 예외 발생!")

예외 메시지 포함하기

class MyError(Exception):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return self.msg

try:
    raise MyError("오류가 발생했습니다.")
except MyError as e:
    print(e)

출력: 오류가 발생했습니다.

정리

• try ~ except: 예외 발생 시 처리
• except e: 예외 메시지 확인
• finally: 무조건 실행
• raise: 예외 강제 발생
• 사용자 정의 예외: Exception 상속

내장 함수 (Built-in Functions)

파이썬은 기본적으로 다양한 내장 함수를 제공한다.
외부 모듈 없이 언제든지 사용할 수 있다.

abs(x)

절댓값 반환

abs(-3)  # 3
abs(3.14)  # 3.14

all(iterable)

모든 요소가 참이면 True, 하나라도 거짓이면 False

all([1, 2, 3])  # True
all([1, 0, 3])  # False

any(iterable)

하나라도 참이면 True, 모두 거짓이면 False

any([0, "", None])  # False
any([0, "", 1])  # True

chr(i)

유니코드 정수 → 문자

chr(97)  # 'a'

dir([object])

객체가 가진 변수나 함수(속성) 목록 리턴

dir([1, 2, 3])  # list의 메서드 목록 출력

divmod(a, b)

a를 b로 나눈 몫과 나머지를 튜플로 반환

divmod(7, 3)  # (2, 1)

enumerate(iterable)

반복 가능한 자료형을 (index, 요소) 형태로 반환

for i, name in enumerate(['a', 'b', 'c']):
    print(i, name)

eval(expression)

문자열로 된 표현식을 실행한 결과 반환

eval("1 + 2")  # 3
eval("'hi' + 'world'")  # 'hiworld'

filter(function, iterable)

함수 조건을 만족하는 요소만 필터링

def is_positive(x):
    return x > 0

list(filter(is_positive, [1, -3, 2, 0, -5]))  # [1, 2]

hex(x)

정수를 16진수 문자열로 변환

hex(255)  # '0xff'

id(object)

객체의 고유 주소값 반환

a = 3
id(a)

input([prompt])

사용자 입력 받기 (문자열로 반환됨)

name = input("이름을 입력하세요: ")

int(x [, base])

문자열을 정수로 변환 (진수도 지정 가능)

int('3')       # 3
int('11', 2)   # 3

isinstance(object, class)

객체가 클래스의 인스턴스인지 검사

isinstance(3, int)  # True

len(s)

길이 반환

len("python")  # 6

list([iterable])

리스트로 변환

list("abc")  # ['a', 'b', 'c']

map(function, iterable)

함수를 반복 가능한 객체의 요소에 적용

def square(x):
    return x * x

list(map(square, [1, 2, 3]))  # [1, 4, 9]

max(iterable)

최댓값 반환

max([1, 2, 3])  # 3

min(iterable)

최솟값 반환

min([1, 2, 3])  # 1

open(filename, mode)

파일을 열어 파일 객체 반환

f = open("file.txt", 'r')

ord(c)

문자 → 유니코드 정수

ord('a')  # 97

pow(x, y)

x ** y와 같음

pow(2, 3)  # 8

range([start], stop[, step])

정수 시퀀스 생성

list(range(5))       # [0, 1, 2, 3, 4]
list(range(1, 10, 2))  # [1, 3, 5, 7, 9]

round(number[, ndigits])

반올림

round(3.14159, 2)  # 3.14

sorted(iterable[, key][, reverse])

정렬된 리스트 반환 (원본 변경 X)

sorted([3, 1, 2])  # [1, 2, 3]
sorted("zero")     # ['e', 'o', 'r', 'z']

str(object)

문자열로 변환

str(3)     # '3'
str(3.14)  # '3.14'

sum(iterable[, start])

합계 반환

sum([1, 2, 3])  # 6

tuple([iterable])

튜플로 변환

tuple([1, 2, 3])  # (1, 2, 3)

type(object)

객체의 자료형 반환

type("abc")  # <class 'str'>

zip(*iterables)

여러 iterable을 묶어서 튜플의 리스트로 반환

list(zip([1, 2], ['a', 'b']))  # [(1, 'a'), (2, 'b')]

표준 라이브러리

파이썬은 다양한 표준 라이브러리를 제공하며, import만 하면 바로 사용할 수 있다.

sys

시스템 관련 정보를 다루는 모듈

import sys

sys.argv        # 명령행 인수
sys.exit()      # 강제 종료
sys.path        # 모듈 검색 경로

예:

# hello.py
import sys
print(sys.argv)

명령어:
python hello.py arg1 arg2 → ['hello.py', 'arg1', 'arg2']

pickle

파이썬 객체를 파일에 저장하거나 불러올 때 사용

import pickle

f = open("test.txt", "wb")
data = {1: 'python', 2: 'you'}
pickle.dump(data, f)
f.close()

# 불러오기
f = open("test.txt", "rb")
data = pickle.load(f)
print(data)  # {1: 'python', 2: 'you'}

os

운영체제와 상호작용할 수 있는 기능 제공

import os

os.environ        # 환경 변수
os.getcwd()       # 현재 디렉토리
os.chdir("path")  # 디렉토리 이동
os.system("dir")  # 시스템 명령 실행

shutil

파일 복사 관련 기능 제공

import shutil

shutil.copy("src.txt", "dst.txt")

glob

파일 이름 리스트를 얻을 때 사용 (와일드카드 사용 가능)

import glob

glob.glob("*.py")  # 현재 폴더의 모든 .py 파일 리스트

tempfile

임시 파일과 디렉터리를 쉽게 만들 수 있음

import tempfile

f = tempfile.TemporaryFile()
f.write(b"Hello")
f.seek(0)
print(f.read())
f.close()

time

시간 관련 함수 제공

import time

time.time()             # 현재 시간 (timestamp)
time.localtime()        # struct_time
time.asctime()          # 보기 좋은 문자열 시간
time.sleep(1)           # 1초 대기

예: 1초 간격으로 5번 출력

for i in range(5):
    print(i)
    time.sleep(1)

calendar

달력 관련 기능 제공

import calendar

print(calendar.calendar(2025))
print(calendar.month(2025, 7))
calendar.isleap(2024)  # 윤년 여부

random

난수 생성 관련 함수 제공

import random

random.random()           # 0~1 사이 임의의 실수
random.randint(1, 10)     # 1~10 사이 정수
random.choice(['a', 'b']) # 리스트에서 임의 선택
random.shuffle([1, 2, 3]) # 리스트 섞기

webbrowser

웹 브라우저를 열 수 있음

import webbrowser

webbrowser.open("https://www.google.com")

외부 라이브러리

파이썬 설치 시 기본으로 제공되지 않는 라이브러리를 외부 라이브러리라고 하며, 사용 전 pip 도구로 설치해야 한다.
pip는 ‘핍’이라고 읽으며, 의존성 있는 패키지도 함께 설치해준다.

pip 사용법

• 설치:

  pip install SomePackage

• 제거:

  pip uninstall SomePackage

• 특정 버전 설치:

  pip install SomePackage==1.0.4

• 최신 버전 설치:

  pip install --upgrade SomePackage

• 설치된 패키지 목록 보기:

  pip list

예시 출력:

Package         Version
--------------- -------
amqp            2.1.4
celery          3.1.0
requests        2.31.0
...

Faker

설치

pip install Faker

기본 사용

from faker import Faker

fake = Faker()
fake.name()       # 'Matthew Estrada' 등
fake.address()    # '충청북도 수원시 잠실6길 ...'

• 한국어 데이터 사용:

  fake = Faker('ko-KR')
  fake.name()  # '김하은'

• 테스트용 데이터 30건 생성:

  test_data = [(fake.name(), fake.address()) for i in range(30)]

주요 메서드

sympy

수학식 기호화 및 방정식 풀이용 외부 라이브러리

설치

pip install sympy

예제: 일차방정식 풀이

from fractions import Fraction
import sympy

x = sympy.symbols("x")  # 미지수 x
f = sympy.Eq(x * Fraction('2/5'), 1760)  # x*(2/5) = 1760

result = sympy.solve(f)  # [4400]
remains = result[0] - 1760

print(f"남은 돈은 {remains}원입니다.")  # 2640

• sympy.symbols("x"): x라는 미지수 기호 생성
• sympy.Eq(a, b): a = b 형태 방정식 표현
• sympy.solve(): 방정식의 해 구하기
• fractions.Fraction: 유리수 정확히 표현

예제: 이차방정식 풀이

import sympy

x = sympy.symbols("x")
f = sympy.Eq(x**2, 1)
sympy.solve(f)  # [-1, 1]

예제: 연립방정식 풀이

import sympy

x, y = sympy.symbols("x y")
f1 = sympy.Eq(x + y, 10)
f2 = sympy.Eq(x - y, 4)
sympy.solve([f1, f2])  # {x: 7, y: 3}

• 미지수가 2개 이상인 경우 dict 형태로 반환됨

파이썬 함수의 구조

파이썬 함수의 구조는 다음과 같다.

def 함수_이름(매개변수):
    수행할_문장1
    수행할_문장2
    ...

C, Java와 같은 언어처럼 리턴값과 매개변수의 타입을 명시하지 않아도 된다.

여러 개의 입력값을 받는 함수 만들기

매개변수 이름 앞에 *를 붙이면 입력값을 모두 모아 튜플로 만들어준다.

>>> def add_many(*args): 
...     result = 0 
...     for i in args: 
...         result = result + i   # *args에 입력받은 모든 값을 더한다.
...     return result 

*가 붙은 매개변수만 함수의 인자로 사용할 수 있는 것은 아니다. 다음과 같은 형태로도 사용할 수 있다.

>>> def add_mul(choice, *args): 
...     if choice == "add":   # 매개변수 choice에 "add"를 입력받았을 때
...         result = 0 
...         for i in args: 
...             result = result + i 
...     elif choice == "mul":   # 매개변수 choice에 "mul"을 입력받았을 때
...         result = 1 
...         for i in args: 
...             result = result * i 
...     return result 

키워드 매개변수, kwargs

키워드 매개변수에는 이름 앞에 별 2개를 붙인다. 키워드 매개변수는 함수 내에서 딕셔너리가 되고, Key=Value 형태의 입력값이 딕셔너리에 저장된다.

>>> def print_kwargs(**kwargs):
...     print(kwargs)


>>> print_kwargs(a=1)
{'a': 1}
>>> print_kwargs(name='foo', age=3)
{'age': 3, 'name': 'foo'}

매개변수에 초깃값 미리 설정하기

아래와 같이 매개변수 자체에 초깃값을 설정해 함수 호출 시 값을 전달하지 않고도 기존에 저장된 값을 불러오도록 할 수 있다.

def hello(name, age, man=True):
    print("f'이름 : {name}, 나이 : {age}, 사람 여부 : {man}'")

# 둘 모두 같은 결과를 출력
hello("이채원", 24)
hello("이채원", 24, True)

lambda 예약어

def와 같은 역할을 하지만, def를 사용해야 할 정도로 복잡하지 않거나 def를 사용할 수 없는 곳에 사용한다.

다음과 같은 형태를 갖는다.

함수_이름 = lambda 매개변수1, 매개변수2, ... : 매개변수를_이용한_표현식

# 예
>>> add = lambda a, b: a+b
>>> result = add(3, 4)
>>> print(result)
7

사용자 입출력

input 사용하기

input 함수를 사용하면 사용자가 키보드로 입력한 모든 것을 문자열로 저장할 수 있다. 프롬프트를 띄우고 싶을 경우에는 원하는 문자열을 매개변수로 넘겨준다.

>>> number = input("숫자를 입력하세요: ")
숫자를 입력하세요:

파일 읽고 쓰기

open 함수

아래의 방법으로 open 함수를 사용해 여러 모드로 파일을 열 수 있다.

파일_객체 = open(파일_이름, 파일_열기_모드)

파일 열기 모드는 다음과 같다.

파일 쓰기

파일을 쓰기 위해서는 write 함수를 사용한다. 예제는 다음과 같다.

# write_data.py
f = open("C:/doit/새파일.txt", 'w')
for i in range(1, 11):
    data = "%d번째 줄입니다.\n" % i
    f.write(data)
f.close()

위 예제는 파일을 읽어올 때 w 모드로 읽어왔다. 위 방법으로 파일을 읽을 시에는 기존 파일의 내용이 전부 사라진다. 하지만 a 모드로 불러올 시, 기존 파일의 내용은 유지하면서 뒤에 덧붙여 새로운 내용을 쓸 수 있다.

파일을 읽는 여러 가지 방법

readline 함수 사용하기

readline 함수는 파일의 내용을 한 줄씩 읽는 함수이다. 다음과 같은 방법으로 파일의 모든 내용을 읽고 출력하는 프로그램을 작성할 수 있다.

# readline_all.py
f = open("C:/doit/새파일.txt", 'r')
while True:
    line = f.readline()
    if not line: break
    print(line)
f.close()

readlines 함수 사용하기

readlines는 파일의 모든 줄을 읽어 각각의 줄을 요소로 가지는 리스트를 리턴한다.

# readlines.py
f = open("C:/doit/새파일.txt", 'r')
lines = f.readlines()
for line in lines:
    print(line)
f.close()

read 함수 사용하기

read는 파일의 내용 전체를 문자열로 리턴한다.

# read.py
f = open("C:/doit/새파일.txt", 'r')
data = f.read()
print(data)
f.close()

파일 객체를 for문과 함께 사용하기

파일 객체와 for을 함께 사용하면 파일을 줄 단위로 읽을 수 있다.

# read_for.py
f = open("C:/doit/새파일.txt", 'r')
for line in f:
    print(line)
f.close()

with문과 함께 사용하기

위의 예제에서는 파일을 연 뒤(open()) 닫는 과정(f.close())를 반복했다. 파일을 닫을 필요 없이 연 뒤 모든 코드가 끝나면 자동으로 닫히게 할 수 있는 방법이 있다. with문을 사용하면 가능하다. 예제는 아래와 같다.

with open("foo.txt", "w") as f:
    f.write("Life is too short, you need python")

프로그램의 입출력

sys 모듈 사용하기

sys 모듈을 사용하면 프로그램을 실행할 때 인수를 전달하여 해당 인수를 불러오는 것이 가능하다.

# sys2.py
import sys
args = sys.argv[1:]
for i in args:
    print(i.upper(), end=' ')

위 예시는 프롬프트 상에서 프로그램이 실행될 때 받았던 인수를 넘겨받은 뒤 해당 인수를 모두 대문자로 변환하여 한 줄에 출력하는 코드이다.

여기서 sys.argv[1:]은 함수 이름을 제외한 모든 인수이다.

if 문은 조건에 따라 실행 흐름을 제어하는 구문이다.

기본 구조

if 조건문: 실행할 문장1 실행할 문장2

• 조건문이 참(True)이면 들여쓴 문장들이 실행됨
• 들여쓰기는 공백 4칸 또는 Tab으로 통일해야 함

예시

money = True if money: print(“택시를 타고 가라”) # 출력됨

if ~ else 문

else는 조건이 거짓(False) 일 때 실행된다.

money = False
if money:
print(“택시를 타고 가라”)
else:
print(“걸어가라”)  # 출력됨

if ~ elif ~ else 문

여러 조건 중 하나를 선택할 수 있다.

money = 2000
card = True

if money >= 3000:
print(“택시를 타고 가라”)
elif card:
print(“카드가 있으니 택시를 타고 가라”)  # 출력됨
else:
print(“걸어가라”)

• 조건을 위에서부터 차례로 검사하며,
• 첫 번째로 참인 조건이 실행되고, 나머지는 무시됨

조건에 사용되는 연산자

• 비교 연산자 : ==, !=, >, <, >=, <=
• 논리 연산자 : and, or, not

예시:

x = 3
y = 5

if x < y and x != 0:
print(“조건 만족”)  # 출력됨

조건문에 in, not in 사용

pocket = [‘paper’, ‘cellphone’, ‘money’]

if ‘money’ in pocket:
print(“택시를 타고 가라”)
else:
print(“걸어가라”)



if ‘card’ not in pocket:
print(“카드가 없다”)

pass 키워드

if 문에서 조건은 참이지만, 아직 구현할 내용이 없을 때 사용한다.

pocket = [‘paper’, ‘money’, ‘cellphone’]

if ‘money’ in pocket:
pass  # 아무것도 하지 않음
else:
print(“카드를 꺼내라”)

조건부 표현식

한 줄로 조건문을 작성할 수 있다.

‘참일 때의 값’ if 조건 else ‘거짓일 때의 값’

예시:

score = 70
message = “success” if score >= 60 else “failure”
print(message)  # 출력: success

좋아! 이번엔 위키독스 21번 문서 내용을 바탕으로, while 문을 빠짐없이 정리한 마크다운 코드 블록이야. 그대로 복붙해서 사용하면 돼:

반복문 (while 문)

while 문은 조건이 참인 동안 블록을 계속 반복 실행한다.

기본 구조

while 조건문: 반복 실행할 문장

조건문이 True인 동안 반복된다. 조건이 False가 되면 종료된다.

예시: 1부터 10까지 출력

i = 1
while i <= 10:
print(i)
i = i + 1

while 문에서 break 사용

break 문은 반복문을 강제로 종료할 때 사용된다.

coffee = 10
money = 300

while money:
print(“돈을 받았으니 커피를 줍니다.”)
coffee -= 1
print(f”남은 커피는 {coffee}개입니다.”)
if coffee == 0:
print(“커피가 다 떨어졌습니다. 판매를 중지합니다.”)
break

while 문에서 continue 사용

continue 문은 남은 문장을 건너뛰고 조건 검사로 바로 넘어감.

a = 0
while a < 10:
a += 1
if a % 2 == 0:
continue
print(a)  # 홀수만 출력됨

무한 루프 만들기

while True를 사용하면 무한 루프를 만들 수 있다. 반드시 break 등으로 종료 조건을 만들어야 함.

while True:
user_input = input(“종료하려면 q를 입력하세요: “)
if user_input == ‘q’:
break

실습 예시: 사용자에게 숫자를 입력받아 합계 출력

total = 0
i = 1

while i <= 1000:
if i % 3 == 0:
total += i
i += 1

print(total)  # 1부터 1000까지 3의 배수의 합

실습 예시: 별 출력

i = 0
while i < 5:
i += 1
print(’*’ * i)

# 출력

*

**

***

****

*****

반복문 (for 문)

for 문은 시퀀스(리스트, 튜플, 문자열 등) 안의 요소를 하나씩 꺼내면서 반복 실행한다.

기본 구조

for 변수 in 시퀀스:
실행할 문장

예시: 리스트 요소 출력

test_list = [‘one’, ‘two’, ‘three’]
for i in test_list:
print(i)

예시: 튜플을 이용한 for 문

a = [(1, 2), (3, 4), (5, 6)]
for (first, last) in a:
print(first + last)

for 문과 range 함수

range(n)은 0부터 n-1까지의 숫자 시퀀스를 만든다.

for i in range(5):
print(i)  # 0, 1, 2, 3, 4

• range(start, end) : start부터 end-1까지
• range(start, end, step) : step만큼 증가하며 반복

  for i in range(1, 10, 2):
  print(i)  # 1, 3, 5, 7, 9

예시: 1부터 10까지 합 구하기

result = 0
for i in range(1, 11):
result += i

print(result)  # 55

for 문과 len(), range() 함께 사용

리스트의 인덱스로 접근할 때 사용

marks = [90, 25, 67, 45, 80]

for i in range(len(marks)):
if marks[i] >= 60:
print(f”{i+1}번 학생은 합격입니다.”)
else:
print(f”{i+1}번 학생은 불합격입니다.”)

continue 문

조건에 맞지 않는 경우 실행을 건너뛴다.

marks = [90, 25, 67, 45, 80]

for i in range(len(marks)):
if marks[i] < 60:
continue
print(f”{i+1}번 학생 축하합니다. 합격입니다.”)

for 문과 리스트 컴프리헨션

리스트를 간결하게 생성하는 방법

a = [1, 2, 3, 4]
result = [num * 3 for num in a]
print(result)  # [3, 6, 9, 12]

조건문도 함께 사용할 수 있다.

result = [num * 3 for num in a if num % 2 == 0]
print(result)  # [6, 12]

그래서 문제도 알고리즘보다는 단순 구현에 집중된 문제를 주로 보려고 하고, 이 글에서도 파이썬의 어떤 요소를 사용해서 문제를 해결했는지를 설명하고자 한다.

그러면 시작

1920 - 수 찾기

수 찾기

뭐 다양한 방법이 있을 수 있을 것 같은 매우 단순한 문제인데... 일단 브루트포스는 안 통한다. 대충 계산해봐도 백 억 번 연산을 해야 하기도 하고 무엇보다... 전에 C로 브루트포싱 했다가 시간초과났다. ㅋ

그러면 바로 떠올릴 수 있는 건 크게 두 가지다.

1. Set
2. Binary Search

뭔가 알고리즘을 파고 싶으면 당연히 2를 고르겠지만 위에도 말했듯이 파이썬의 여러 문법에 적응하고자 하는 취지이기 때문에 1로 가보겠다. ㅎㅎ

n = input()
a = set(map(int, input().split()))

m = input()
b = map(int, input().split())

for i in b:
    if i in a :
        print(1)
    else:
        print(0)

여기서 볼 건 크게 두 가지이다.

1. input 방법

파이썬에서 한 줄을 통째로 input받고 이를 쪼개려면 split을 해야 한다. 그런데, split 함수를 사용하면 리스트에 들어가는 값들이 모두 문자열이 된다는 문제가 존재한다.

따라서 int 함수를 사용해서 리스트 안의 모든 원소들을 정수형으로 바꿔줘야 하는데, 이 과정에서 배열 전체에 함수를 적용할 수 있도록 하는 함수가 바로 map이다. 따라서 map(int, input().split())이라는 파이썬으로 백준을 풀어본 사람이라면 모두 본 적 있을 코드가 완성된다...ㅎ

거기에 한 술 더 떠서 a를 input 받을 때에는 map을 set 함수로 감싸주었다. set 함수는 list를 set으로 변환해주기 때문에, 원래 리스트였던 결과가 set으로 바뀌게 된다!

이걸 보니 자바스크립트 하면서 함수형 프로그래밍 어쩌구,, 때문에 너무나도 고통받았던 시기가 문득 떠오른다...^^ 요즘 언어들은 참... 외울 게 많은 것 같다.

2. in 문법

점프 투 파이썬은 아무래도 일반인들을 주로 대상으로 한 책이기 때문에 좀... 빠진 내용이 많은 것 같다. 이 책 말고 딴 걸로 할 걸 그랬나 후회 중이다.

c++을 예시로 들자면, 거기서는 set의 원소를 찾는 데 find를 사용한다. 하지만! 파이썬은 in 연산자가 기본적으로 제공된다. 해당하는 원소가 그 컨테이너에 존재하면 True, 아니면 False를 리턴하는 아주 편리한 연산자이다.

따라서 그냥 바로 이렇게 찾아주면 된다.

    if i in a :
        print(1)
    else:
        print(0)

그래서 사실 꼭 여기서 set 안 써도 될 것 같고...? 근데 set 쓰는 게 더 빠를 것 같기도 하고 모르겠다. 여기 set은 어떻게 구현된 건지까지는 몰라서... 그 background를 봐야 알 듯

따라서 전체 코드는 다음과 같다.

n = input()
a = set(map(int, input().split()))

m = input()
b = map(int, input().split())

for i in b:
    if i in a :
        print(1)
    else:
        print(0)

2822 - 점수 계산

점수 계산

얘는 소트다. 뭐... 간단하죠? 거기에 2차원 배열을 쓰까봤다.

이 문제를 처음 보고 c++이면 어떻게 풀었을까? 생각해봤다. 사실 비슷한 문제를 풀었었는데, 그 때 값과 인덱스를 pair로 묶어서 저장하고 리스트에 넣었던 기억이 떠올랐다.

그래서 똑같이 구현했는데, 대신 python은 pair 같은 자료형이 있을 필요 없이 그냥 리스트의 요소를 자유롭게 할 수 있기 때문에 리스트 안에 리스트를 넣는 식으로 해서 구현했다! 이런 점에서는 확실히 파이썬이 편하다.

거기에 정렬을 몇 번 했는데, 이건 별 거 없다. 알아둘 점은 크게 두 개다.

1. sort 함수 사용법 list의 method로 sort 함수가 존재한다.

주의 리턴으로 None이 나온다. 이게 뭔 소리냐면, 정렬 된 배열을 리턴하는 함수가 아니다!

list = list.sort()

이렇게 되면 list에 그냥 None이 대입돼 버린다.

list.sort()

이렇게 하면 별도의 대입 없이 바로 list가 정렬된 상태로 저장된다.

만약 역방향으로 정렬을 하고 싶다면, 다음과 같이 할 수 있다.

list.sort(reverse=True)

정렬의 경우, sorted 함수를 이용해서 다양한 요소를 기준으로 해서 정렬할 수도 있고, 아니면 아예 lambda를 가지고 완전 마음대로 커스텀도 가능하다. 이런 점 관련해서는 나중에 정리를 해... 보도록... 하겠다...^^ (언제가 될지는 모름)

그리고 사실 예상하기는 했는데, 이 경우처럼 2차원 배열을 딱히 아무 기준도 주지 않고 정렬하면 맨 앞 요소를 기준으로 해서 정렬된다! 참고할 것.

완성된 코드는 다음과 같다.

l = []
for i in range(8):
    t = int(input())
    l.append([t, i+1])

l.sort(reverse=True)

s = 0
ans = []
for i in range(5):
    s += l[i][0]
    ans.append(l[i][1])

print(s)
ans.sort()
for i in ans:
    print(i, end=' ')

소감은... 음 확실히 사람들이 코테 입문으로 파이썬을 많이 쓰는 이유를 알 것 같다. 정말 직관적이다. 그래서 코드짜기 편하다. 물론 적응이 되어야 그런 거긴 하다. 사실 난 아직도 c++이 조금 더 편한 것 같기는 하다. ㅋㅋㅋㅋㅜㅜㅜ 뭔가 c++ 뇌에서 파이썬으로 번역하는 듯한 느낌이 없지 않아 있다...

뭐 연습하다 보면 적응할 거라고 믿는다. 그러면 조금 더 어려운 문제도 풀 수 있겠지?

다음은 컨테이너 내장 함수 관련된 문제를 조금 더 보고 싶다. 빡센 정렬 문제도 좋고... 그렇게 해서 좀 적응되었다 싶으면 바로 골드 풀이로 가도록 하겠다.

파이썬에는 다음과 같은 자료형이 존재한다.

• 숫자형
• 문자열
• 리스트
• 튜플
• 딕셔너리
• 집합
• 불

여기서는 각각의 자료형에 대해서 설명한다.

숫자형

숫자형에는 다음과 같은 종류가 존재한다.

• 정수형
• 실수형 : 다음과 같은 표현이 가능하다.

  >>> a = 4.24E10
  >>> a = 4.24e-10

• 8진수와 16진수 : 각각 다음과 같이 표현한다.

  # 8진수
  >>> a = 0o177
  >>> print(a)
  127
  

16진수

a = 0x8ff b = 0xABC print(b) 2748

이러한 숫자형 자료형을 연산자를 통해 연산 가능하다. 연산자는 **산술 연산자**와 **복합 연산자**로 나뉜다. 

- 산술 연산자 : `+, -, *, /, ** (제곱), %, // (몫)`
- 복합 연산자 : `+=, -=, *=, /=, //=, %=, **=`

## 문자열

문자열은 `'`, `"`, `'''`, `"""`로 표현할 수 있다.

한 줄 문자열

a = ‘Hello’ b = “Python”

여러 줄 문자열

c = ‘’‘여러 줄 문자열’’’ d = “”“여러 줄 문자열”””

이러한 문자열은 연산자를 통해 연산 가능하다. 연산자는 **연결/반복 연산자**와 **포매팅 방법**으로 나뉜다.

- 연결 연산자 : `+` (문자열 이어 붙이기)
- 반복 연산자 : `*` (문자열 반복)
- 문자열 길이 구하기 : `len(문자열)`
- 문자열 인덱싱 : `"Python"[0]` → `'P'`, `"Python"[-1]` → `'n'`
- 문자열 슬라이싱 : `"Life is too short"[0:4]` → `'Life'`

문자열 포매팅에는 다음과 같은 방법이 있다.

- % 포매팅

“I eat %d apples.” % 3

- format() 메서드

“I eat {} apples”.format(3) “I ate {0} apples and {1} oranges”.format(3, 5)

- f-string (Python 3.6+)

name = “철수” age = 20 f”My name is {name} and I am {age} years old.”

문자열 관련 함수는 다음과 같다.

“hobby”.count(‘b’) # 2 “hobby”.find(‘b’) # 2 “hobby”.index(‘b’) # 2 “,”.join([‘a’,‘b’,‘c’]) # ‘a,b,c’ “hi”.upper() # ‘HI’ “HI”.lower() # ‘hi’ “ hi “.strip() # ‘hi’ “Life is short”.replace(“short”, “long”) # ‘Life is long’ “a:b:c:d”.split(’:’) # [‘a’, ‘b’, ‘c’, ‘d’]

## 리스트

리스트는 대괄호 `[]`로 감싸서 표현한다.

a = [1, 2, 3] b = [‘a’, ‘b’, ‘c’] c = [1, 2, [‘a’, ‘b’]] # 리스트 안에 리스트

리스트는 다양한 연산과 메서드를 사용할 수 있다.

- 인덱싱 : `a[0]` → `1`, `c[2][0]` → `'a'`
- 슬라이싱 : `a[1:]` → `[2, 3]`
- 덧셈 : `[1, 2] + [3, 4]` → `[1, 2, 3, 4]`
- 반복 : `[1, 2] * 2` → `[1, 2, 1, 2]`
- 길이 구하기 : `len(a)` → `3`

리스트 값 수정/삭제도 가능하다.

a = [1, 2, 3] a[2] = 4 # [1, 2, 4] del a[1] # [1, 4]

리스트 관련 함수는 다음과 같다.

a = [1, 3, 2]

a.append(4) # [1, 3, 2, 4] a.sort() # [1, 2, 3, 4] a.reverse() # [4, 3, 2, 1] a.index(3) # 1 a.insert(1, 100) # [4, 100, 3, 2, 1] a.remove(100) # [4, 3, 2, 1] a.pop() # [4, 3, 2] a.count(2) # 1 a.extend([5, 6]) # [4, 3, 2, 5, 6]

## 튜플

튜플은 리스트와 유사하지만 **수정, 삭제가 불가능한 자료형**이다. 소괄호 `()`를 사용한다.

t1 = (1, 2, 3) t2 = (‘a’, ‘b’, ‘c’) t3 = (1, 2, (‘a’, ‘b’))

요소가 1개인 튜플은 쉼표를 반드시 붙여야 한다.

t4 = (1,) # 올바른 튜플 t5 = (1) # 그냥 정수형

튜플도 인덱싱, 슬라이싱, 연산이 가능하다.

- 인덱싱 : `t1[0]` → `1`
- 슬라이싱 : `t1[1:]` → `(2, 3)`
- 덧셈 : `t1 + t2` → `(1, 2, 3, 'a', 'b', 'c')`
- 반복 : `t2 * 2` → `('a', 'b', 'c', 'a', 'b', 'c')`
- 길이 구하기 : `len(t1)` → `3`

하지만, 요솟값을 변경할 수 없기 때문에 sort, insert, remove, pop과 같은 내장 함수는 존재하지 않는다.

## 딕셔너리

딕셔너리는 **키(key)와 값(value)** 쌍으로 데이터를 저장하는 자료형이다. 중괄호 `{}`를 사용하며, 각 쌍은 `:`로 구분한다.

a = { ‘name’: ‘철수’, ‘age’: 20 } b = { 1: ‘one’, 2: ‘two’ } c = { ‘a’: [1, 2, 3] }

### 딕셔너리 사용 방법

- 값 참조 : `a['name']` → `'철수'`
- 새로운 항목 추가 : `a['school'] = 'ABC'`
- 기존 값 수정 : `a['age'] = 21`
- 항목 삭제 : `del a['name']`

### 딕셔너리 관련 함수

a = { ‘name’: ‘철수’, ‘age’: 20, ‘school’: ‘ABC’ }

a.keys() # dict_keys([‘name’, ‘age’, ‘school’]) a.values() # dict_values([‘철수’, 20, ‘ABC’]) a.items() # dict_items([(‘name’, ‘철수’), (‘age’, 20), (‘school’, ‘ABC’)]) a.get(‘name’) # ‘철수’ a.get(‘height’) # None (오류 발생 안 함) ‘name’ in a # True ‘height’ in a # False

a.clear() # 모든 항목 삭제

※ `get()`은 존재하지 않는 키에 접근해도 오류가 나지 않음. 기본값을 줄 수도 있음:  
`a.get('height', '없음')` → `'없음'`

## 집합 (Set)

집합은 **중복을 허용하지 않고**, **순서가 없는** 자료형이다. `set()` 함수나 중괄호 `{}`를 사용해 만든다.

s1 = set([1, 2, 3]) s2 = {1, 2, 3} s3 = set(“hello”) # 중복 제거됨 → {‘e’, ‘h’, ‘l’, ‘o’}

### 집합의 특징

- 중복 자동 제거
- 순서가 없어 인덱싱 불가 (리스트나 튜플로 변환 필요)

### 집합 연산

s1 = set([1, 2, 3, 4]) s2 = set([3, 4, 5, 6])

s1 & s2 # 교집합 → {3, 4} s1 | s2 # 합집합 → {1, 2, 3, 4, 5, 6} s1 - s2 # 차집합 → {1, 2} s1 ^ s2 # 대칭차집합 → {1, 2, 5, 6}

### 집합 관련 함수

s = set([1, 2, 3]) s.add(4) # 원소 추가 → {1, 2, 3, 4} s.update([5, 6]) # 여러 원소 추가 → {1, 2, 3, 4, 5, 6} s.remove(3) # 특정 원소 제거 → {1, 2, 4, 5, 6}

## 불

불 자료형은 `True`, `False` 두 가지 값만을 가진다. 첫 글자는 반드시 **대문자**로 써야 한다.

a = True b = False

### 비교 연산의 결과

비교 연산자는 항상 불 값을 반환한다.

1 < 2 # True 3 == 3 # True 1 != 2 # True 4 > 7 # False

### 불 연산자

- `and` : 둘 다 참일 때만 참
- `or` : 둘 중 하나라도 참이면 참
- `not` : 참 → 거짓, 거짓 → 참

True and False # False True or False # True not True # False not False # True

### 자료형의 참/거짓 판별

다음 값들은 **거짓(False)** 으로 취급된다.

- `None`
- `0` (정수형, 실수형 모두)
- `''` (빈 문자열)
- `[]`, `{}`, `()` (빈 리스트, 딕셔너리, 튜플)

그 외의 값들은 모두 참이다.

bool(0) # False bool(””) # False bool([]) # False bool(123) # True bool(“hello”) # True

---

## 배운 점

- 문자열 선언, 포매팅이 이렇게 다양하게 가능하구나... 특히 포매팅은 f-string 방식을 통해서 하는 코드를 많이 봤는데, 사실 아직도 잘 못 외웠다ㅎ 이번 기회에 제대로 사용할 수 있도록 익혀야겠다.
- 튜플, 딕셔너리, 셋 - 리스트는 아는데, 저 셋에 대해서는 이름만 알고 어떻게 선언하는지, 어떤 특징을 가지고 있는지 잘 몰랐다. 이번에 알게 되어서 상황에 따라서 잘 사용할 수 있을 것 같다. (상수 -> 튜플, map -> 딕셔너리 같은 식으로)
- 자료형의 참, 거짓 관련 부분에서 파이썬에서는 이런 규칙을 가지고 있다는 것을 배웠다. 이 또한 문제를 풀 때 잘 활용할 수 있을 것 같다.

Optuna란?

공식 사이트 Optuna는 최적화된 하이퍼파라미터를 찾아주는 프레임워크이다. 하이퍼파라미터 튜닝을 위해서는 Scikit-Learn에서 제공하는 GridSearchCV, RandomizedSearchCV와 같은 툴을 많이 사용한다. 하지만 이런 툴들은 그 알고리즘의 태생적 한계로 인해 튜닝에 있어 아주 긴 시간이 소요된다는 문제점이 존재한다. 물론 Optuna 또한 매우 빠른 것은 아니다. 이는 하이퍼파라미터 튜닝이라는 기법 자체가 결국 모든 케이스에 대해 실행해보고 비교해야 한다는 특성을 가지고 있기 때문이다. 하지만, Optuna는 위의 두 기법들과 비교해서는 훨씬 더 빠르다. 그리고, Pytorch, TensorFlow, Keras와 같은 메이저한 딥러닝 프레임워크에서 모두 사용 가능하다는 점도 아주 큰 장점이다.

현재 Optuna의 공식 사이트는 위 세 가지 점을 장점으로 내세우고 있다. 참고하면 좋을 듯 하다.

사용하기

Optuna의 사용을 위해서는 먼저 설치가 필요하다. 다른 패키지들과 같이 pip로 간단하게 설치할 수 있다.

pip install optuna

다음, Optuna의 하이퍼파라미터 튜닝은 objective 함수 안에서 이루어진다. 나는 튜닝을 위해 다음과 같은 함수를 만들었다.

def objective(trial):

    # 조정 원하는 파라미터 범위 선언
    depth = trial.suggest_int("depth", 2, 8)
    latent_dim = trial.suggest_int("latent_dim", 128, 512, step=64)
    num_latents = trial.suggest_int("num_latents", 64, 256, step=32)
    learning_rate = trial.suggest_loguniform("learning_rate", 1e-4, 1e-2)

    # 기기 및 모델, 옵티마이저, 손실함수 선언
    device = torch.device("cuda")
    model = PerceiverMNIST(depth=depth, latent_dim=latent_dim, num_latents=num_latents).to(device)
    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
    criterion = nn.CrossEntropyLoss()

    # 훈련
    model.train()
    total_loss = 0
    for images, labels in trainloader:
        images, labels = images.to(device), labels.to(device)
        optimizer.zero_grad()
        logits = model(images)
        loss = criterion(logits, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()

    return total_loss / len(trainloader)

나머지 부분은 일반적인 Pytorch의 훈련 loop와 동일하지만, 주목할 부분은 위의 파라미터 범위를 선언한 부분이다. 앞서 말했듯, 하이퍼파라미터 튜닝을 위해서는 결국 일일히 파라미터를 설정해서 결과를 내는 것이 필요하다. 이때 내가 파라미터를 어디서부터 어디까지 테스트할 것인지 그 범위를 설정해야 한다. 이를 위 코드의 앞부분이 설정하는 것이다.

위 코드에서 사용된 함수는 다음과 같다. suggest_int : 정수 범위를 정한다. 조정하고자 하는 파라미터의 이름과 시작, 끝을 인자로 준다. 만약 1 단위가 아니라 64, 32와 같은 단위로 숫자가 증가하도록 하고 싶다면 step=을 주면 된다. suggest_loguniform : 연속된 숫자의 범위를 정한다. 다만 이 함수는 이후 버전에서 삭제된다고 한다. 대신 suggest_float(..., log=True)를 사용하라고 한다.

위 코드에서는 depth, latent_dim, num_latents, learning_rate 네 개의 파라미터에 대해 튜닝을 시도하였다. 범위를 선언한 뒤 해당 범위로 모델 및 학습률을 설정하고, 훈련을 시켰다.

이를 실제로 실행하기 위해서는 다음과 같이 study를 생성한 다음, objective 함수를 인자로 주어 optimize를 수행해야 한다.

import optuna

study = optuna.create_study(direction="minimize")
study.optimize(objective, n_trials=30)

여기서 create_study()의 인자인 direction="minimize"는 objective 함수가 return하는 값이 감소하는 방향으로 최적화를 진행하겠다는 것을 의미한다. 여기서 위의 함수는 loss를 return하고 있기 때문에, 당연히 감소하도록 최적화하는 것이 맞다.

이렇게 study를 생성한 후, optimize 함수로 최적화를 수행한다. objective 함수와 n_trials를 인자로 준다. n_trials는 전체 시행 횟수를 의미한다.

코드를 실행하면 다음과 같이 trial이 시행되며 그 때의 최적 value와 파라미터, 그리고 지금까지 가장 좋은 값이 나왔던 trial을 보여준다.

[I 2025-03-06 07:07:39,857] Trial 0 finished with value: 0.26668225020182124 and parameters: {'depth': 7, 'latent_dim': 192, 'num_latents': 64, 'learning_rate': 0.0005968324834796224}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:09:11,290] Trial 1 finished with value: 3.8591011294227306 and parameters: {'depth': 7, 'latent_dim': 320, 'num_latents': 160, 'learning_rate': 0.005783782916666108}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:09:31,260] Trial 2 finished with value: 0.3522836375556616 and parameters: {'depth': 2, 'latent_dim': 128, 'num_latents': 128, 'learning_rate': 0.0001962797474825985}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:11:02,492] Trial 3 finished with value: 4.282872916789039 and parameters: {'depth': 7, 'latent_dim': 320, 'num_latents': 160, 'learning_rate': 0.0062681789918993406}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:12:53,767] Trial 4 finished with value: 1.0389763821782207 and parameters: {'depth': 5, 'latent_dim': 384, 'num_latents': 224, 'learning_rate': 0.0031583777405563137}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:13:21,763] Trial 5 finished with value: 0.3259865055694731 and parameters: {'depth': 3, 'latent_dim': 256, 'num_latents': 96, 'learning_rate': 0.00013326825932084483}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:13:45,325] Trial 6 finished with value: 0.3730849254169444 and parameters: {'depth': 4, 'latent_dim': 128, 'num_latents': 64, 'learning_rate': 0.0032579798046704542}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:18:05,079] Trial 7 finished with value: 8.307785088732553 and parameters: {'depth': 8, 'latent_dim': 512, 'num_latents': 256, 'learning_rate': 0.005633941542665712}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:18:39,135] Trial 8 finished with value: 0.2756429120068198 and parameters: {'depth': 8, 'latent_dim': 192, 'num_latents': 64, 'learning_rate': 0.000335277034681362}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:21:02,136] Trial 9 finished with value: 11.076749913791604 and parameters: {'depth': 8, 'latent_dim': 384, 'num_latents': 192, 'learning_rate': 0.0063976046053722925}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:22:25,992] Trial 10 finished with value: 0.2677588141255224 and parameters: {'depth': 6, 'latent_dim': 512, 'num_latents': 96, 'learning_rate': 0.0006167022115396635}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:23:49,837] Trial 11 finished with value: 0.2702346246228861 and parameters: {'depth': 6, 'latent_dim': 512, 'num_latents': 96, 'learning_rate': 0.00077167476845985}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:25:02,303] Trial 12 finished with value: 0.27797159841304014 and parameters: {'depth': 6, 'latent_dim': 448, 'num_latents': 96, 'learning_rate': 0.0008276816679701316}. Best is trial 0 with value: 0.26668225020182124.
[I 2025-03-06 07:25:31,583] Trial 13 finished with value: 0.25901897840483834 and parameters: {'depth': 5, 'latent_dim': 256, 'num_latents': 64, 'learning_rate': 0.0004322355545064367}. Best is trial 13 with value: 0.25901897840483834.
[I 2025-03-06 07:25:55,515] Trial 14 finished with value: 0.27312530935811463 and parameters: {'depth': 4, 'latent_dim': 192, 'num_latents': 64, 'learning_rate': 0.0016535293914112447}. Best is trial 13 with value: 0.25901897840483834.
[I 2025-03-06 07:26:40,226] Trial 15 finished with value: 0.2554813757209159 and parameters: {'depth': 5, 'latent_dim': 256, 'num_latents': 128, 'learning_rate': 0.0004002663484281009}. Best is trial 15 with value: 0.2554813757209159.
[I 2025-03-06 07:27:24,980] Trial 16 finished with value: 0.25565995413786186 and parameters: {'depth': 5, 'latent_dim': 256, 'num_latents': 128, 'learning_rate': 0.0003776580179276335}. Best is trial 15 with value: 0.2554813757209159.
[I 2025-03-06 07:28:03,775] Trial 17 finished with value: 0.2654680540221237 and parameters: {'depth': 4, 'latent_dim': 256, 'num_latents': 128, 'learning_rate': 0.0002610171011079572}. Best is trial 15 with value: 0.2554813757209159.
[I 2025-03-06 07:29:10,768] Trial 18 finished with value: 0.3302811196665647 and parameters: {'depth': 3, 'latent_dim': 384, 'num_latents': 192, 'learning_rate': 0.00010365658913629019}. Best is trial 15 with value: 0.2554813757209159.
[I 2025-03-06 07:29:55,467] Trial 19 finished with value: 0.2866133468489705 and parameters: {'depth': 5, 'latent_dim': 256, 'num_latents': 128, 'learning_rate': 0.0013988263583856568}. Best is trial 15 with value: 0.2554813757209159.
[I 2025-03-06 07:30:51,669] Trial 20 finished with value: 0.2745055094945119 and parameters: {'depth': 3, 'latent_dim': 320, 'num_latents': 192, 'learning_rate': 0.00020538133772138157}. Best is trial 15 with value: 0.2554813757209159.
[I 2025-03-06 07:31:48,387] Trial 21 finished with value: 0.25277498057449677 and parameters: {'depth': 5, 'latent_dim': 256, 'num_latents': 160, 'learning_rate': 0.00041984666204054915}. Best is trial 21 with value: 0.25277498057449677.
[I 2025-03-06 07:32:35,559] Trial 22 finished with value: 0.26705718970100983 and parameters: {'depth': 5, 'latent_dim': 192, 'num_latents': 160, 'learning_rate': 0.00041908016880449524}. Best is trial 21 with value: 0.25277498057449677.
[I 2025-03-06 07:33:22,563] Trial 23 finished with value: 0.27611159145244274 and parameters: {'depth': 4, 'latent_dim': 320, 'num_latents': 128, 'learning_rate': 0.0012366012560476457}. Best is trial 21 with value: 0.25277498057449677.
[I 2025-03-06 07:34:13,026] Trial 24 finished with value: 0.260062302501479 and parameters: {'depth': 6, 'latent_dim': 256, 'num_latents': 128, 'learning_rate': 0.0003121371654371933}. Best is trial 21 with value: 0.25277498057449677.
[I 2025-03-06 07:35:00,120] Trial 25 finished with value: 0.2908944913239748 and parameters: {'depth': 5, 'latent_dim': 192, 'num_latents': 160, 'learning_rate': 0.00017289120110738774}. Best is trial 21 with value: 0.25277498057449677.
[I 2025-03-06 07:35:48,746] Trial 26 finished with value: 0.25546947501992967 and parameters: {'depth': 4, 'latent_dim': 256, 'num_latents': 160, 'learning_rate': 0.0004696972031772631}. Best is trial 21 with value: 0.25277498057449677.
[I 2025-03-06 07:36:30,426] Trial 27 finished with value: 0.266836045512449 and parameters: {'depth': 4, 'latent_dim': 128, 'num_latents': 224, 'learning_rate': 0.0005274984910314277}. Best is trial 21 with value: 0.25277498057449677.
[I 2025-03-06 07:37:09,359] Trial 28 finished with value: 0.32742580597692017 and parameters: {'depth': 2, 'latent_dim': 320, 'num_latents': 160, 'learning_rate': 0.0020888611036553547}. Best is trial 21 with value: 0.25277498057449677.
[I 2025-03-06 07:37:47,981] Trial 29 finished with value: 0.25377385729332086 and parameters: {'depth': 3, 'latent_dim': 192, 'num_latents': 192, 'learning_rate': 0.0006198691658685506}. Best is trial 21 with value: 0.25277498057449677.

study가 종료된 후에는 최적 파라미터와 최적 value가 저장된다. study.best_params와 study.best_value로 각각 이 값을 확인할 수 있다.

따라서 위에서 얻은 최적 파라미터를 이용해 같은 모델로도 하이퍼파라미터를 조정하는 것만으로 더 좋은 결과를 얻을 수 있는 것이다.

마무리

이 글에서는 간단히 Optuna의 objective 함수를 설정하고, 이를 사용해 study를 실행하는 것까지만 다뤘지만, 실제로 Optuna의 기능은 이 외에도 더 많다.

Optuna를 더욱 강력하게 만들어주는 툴도 존재한다. Optuna Dashboard와 OptunaHub가 그것이다. Optuna Dashboard는 말 그대로 Optuna에서 수행한 결과를 시각화하여 확인할 수 있는 대시보드이다. 최적화 히스토리나 파라미터의 중요도와 같은 값들을 확인할 수 있다. OptunaHub는 유저들이 업로드한 feature를 자유롭게 사용할 수 있는 플랫폼이다. 유저들이 제작한 강력한 feature를 사용하여 튜닝 작업을 더욱 효과적으로 진행할 수 있다.

이렇게 이번 글에서는 Optuna의 대한 간단한 소개와 사용법, 그리고 연관된 툴까지 알아보았다. 이후에 더욱 다양한 기능들도 사용하여 연구에 큰 도움을 얻을 수 있으면 하는 바람이다.

CLIP이란?

FedCLIP에 대해 설명하기 위해서는 먼저 CLIP에 대해 간단히 알고 넘어갈 필요가 있습니다. CLIP은 2021년 OpenAI에서 공개한 이미지-텍스트 멀티모달 모델로, 논문은 다음 링크에 공개되어 있습니다. https://arxiv.org/abs/2103.00020 CLIP은 contrastive learning을 통해 학습을 진행합니다. (이름도 그래서 Contrastive Language-Image Pre-training의 줄임말) 논문의 이미지를 가지고 왔습니다. 각각 설정한 text encoder, image encoder를 통해 텍스트와 이미지를 넘기면(논문에서는 이미지에는 resnet과 vision transformer, 텍스트에는 transformer을 사용했다고 합니다) 텍스트와 이미지를 각각 벡터로 변환해줍니다. 그리고 두 벡터 쌍의 dot product를 구하면 그림과 같이 다양한 pair가 나오게 될 텐데, 여기서 색칠이 되어있는 각 텍스트와 이미지에 대응되는 pair에 가중치를 주어 학습을 시키는 것이 CLIP의 핵심입니다. 마찬가지로 논문에서 가지고 온 수도코드입니다. 보면 두 벡터의 닷 프로덕트를 구한 뒤 대응되는 pair의 cosine similarity는 크게, 그 외는 작게 만드는 것이 학습의 핵심입니다.

FedCLIP이란

현재 CLIP은 text-image 분야에서 SOTA 모델로 알려져 있는데요, 이 모델을 연합학습 환경에도 적용할 수 있다면 정말 좋지 않을까요? 하지만 CLIP은 어마어마하게 거대한 규모의 데이터를 통해 학습한 모델이기 때문에, 그 파라미터 수도 정말 많고, 따라서 리소스가 제한되는 연합학습 환경에서는 도입하기가 어렵다는 문제점이 있습니다. 따라서 FedCLIP은 CLIP을 연합학습 환경에 맞추어 미리 학습된 인코더는 그대로 사용하고, 대신 각 기기별로 어댑터를 학습해, 이를 통합하여 하나의 완성된 어댑터를 만드는 방식으로 이 문제를 해결하였습니다. FedCLIP의 학습은 다음 과정으로 진행됩니다.

1. 인코더를 통과시켜 T와 I를 얻는다.
2. I를 어댑터에 통과시켜 I* 를 얻는다. 그리고 CLIP과 같이 같은 쌍의 cosine similarity는 가깝게, 반대는 멀게 어댑터를 학습시킨다.
3. 얻은 어댑터를 서버로 전송한다.
4. 어댑터의 평균을 구한 뒤 해당 어댑터를 각 기기로 전송한다.
5. 이 과정을 반복한다.

이 때 사용하는 어댑터는 어텐션을 기반으로 한 AttAI라는 어댑터로, 하나의 완전연결층, Tahn 활성화 함수, 하나의 완전 연결층, 그리고 소프트맥스로 이루어져 있습니다. 미리 학습된 인코더를 사용하여 이미 충분히 학습된 검증된 자원을 사용하면서, 인코더를 기기마다 학습시킨 뒤 통합하고 분배하여 튜닝한다는 점이 흥미롭습니다. 어댑터라는 개념의 도입을 통해 기기에서도 CLIP을 통한 학습을 가능하게 했다니, 정말 재미있지 않나요?

참고로 여기서는 image에 adapter를 달았지만, text에 다는 것도 가능하다고 언급되어 있습니다. 해당 방식으로는 어떤 결과가 나올지도 궁금해지는 부분입니다.

코드 실행 준비

FedCLIP의 코드는 모두 깃헙을 통해 공개되어 있습니다. https://github.com/microsoft/PersonalizedFL/tree/main/fedclip 먼저, 파이썬 버전을 3.8.5로 맞춰줍니다. 기존에 설치되어 있는 파이썬을 삭제하고 싶지 않은 경우에는, virtualenv를 통해 가상환경을 설정하는 것이 가능합니다.

그 다음, 요구사항을 맞춰줍니다. 다음과 같은 요구사항을 맞춰줄 필요가 있습니다.

$ pip install ftfy regex tqdm
$ pip install git+https://github.com/openai/CLIP.git
$ pip install -r requirements.txt
$ pip install torch==1.10.1+cu111 torchvision==0.11.2+cu111 torchaudio==0.10.1 -f https://download.pytorch.org/whl/cu111/torch_stable.html

이 때, +cu111은 cuda가 설치되어 있는 윈도우즈에서만 설치가 가능합니다.

위 요구사항을 모두 설치한 뒤, 데이터셋을 다운로드 받습니다. 사용한 데이터셋은 PACS로, 물체 인식에 사용되는 데이터셋입니다. 4개의 sub-dataset과 7개의 class를 포함하고 있습니다.

wget https://wjdcloud.blob.core.windows.net/dataset/PACS.zip
unzip PACS.zip

리눅스 환경에서는 다음 명령어를 통해 설치하고 압축 해제가 가능합니다. 다만 윈도우즈에는 wget 명령어가 존재하지 않기 때문에, 해당 링크로 바로 접속하면 다운로드가 가능합니다.

이후 아래의 네 명령어를 각각 수행하는 것을 통해 직접 FedCLIP을 실행해볼 수 있습니다!

python methods/fed_at_clip.py --dataset pacs --mode FedAtImg --test_envs 0 --iters 200 --wk_iters 1 --lr 5e-05
python methods/fed_at_clip.py --dataset pacs --mode FedAtImg --test_envs 1 --iters 200 --wk_iters 1 --lr 5e-05
python methods/fed_at_clip.py --dataset pacs --mode FedAtImg --test_envs 2 --iters 200 --wk_iters 1 --lr 5e-05
python methods/fed_at_clip.py --dataset pacs --mode FedAtImg --test_envs 3 --iters 200 --wk_iters 1 --lr 5e-05

다음은 윈도우즈 환경에서 직접 FedCLIP을 실행하는 글을 가져오겠습니다!

둘 다 골드 5

입력 데이터의 수가 많기 때문에 스택을 이용해서 효율적으로 풀어야 하는 문제들이다. 조금 다르긴 한데 두 문제 다 결은 비슷해서... 하나 풀면 다른 하나도 풀 만 하다.

탑

나보다 왼쪽에 있는 탑 중에서 가장 가까운 나보다 높은 탑의 인덱스를 구하는 문제이다. 왼쪽의 탑 중 가장 가까운 탑을 선택하기 때문에, 탐색은 오른쪽에서 왼쪽 순서로 진행한다.

먼저 맨 오른쪽 탑 인덱스를 넣어준다. 그리고 왼쪽으로 한 칸씩 이동하면서 스택에 인덱스를 넣어줄 건데, 이 때 한 번 검사를 해주어야 한다. 바로 들어오는 인덱스의 탑의 높이가 현재 스택 탑의 탑 높이(ㅋ) 보다 높은지 확인하는 거다.

그래서 만약 새로 들어오는 게 더 높으면, 스택 탑의 정답을 새로운 인덱스로 저장을 해주고, 팝을 해준다. 이걸 스택 탑의 높이가 새로운 인덱스의 높이보다 더 높을 때까지 반복해준다. (같은 경우도 팝을 해 주어야 한다. 그래도 문제 조건을 만족하니까) 이러면 스택의 탑에는 계속해서 높은 원소가 남게 되니까, 더 높은 값을 찾을 수 있다.

코드는 다음과 같다.

//탑 - 골드 5

#include <iostream>
#include <stack>
#include <vector>

using namespace std;

int main() {
    int n;
    vector<int> h, ans;
    stack<int> s;
    cin >> n;
    h.assign(n+1, 0);
    ans.assign(n+1, 0);

    for (int i = 1; i <= n; i++) {
        cin >> h[i];
    }
    s.push(n);

    for (int i = n-1; i >= 1; i--) {
        while (!s.empty() && h[i] >= h[s.top()]) {
            ans[s.top()] = i;
            s.pop();
        }
        s.push(i);
    }
    for (int i = 1; i <= n; i++) {
        cout << ans[i] << ' ';
    }

}

참고로 이거 풀었을 때 segfault 떠서 대체 왜...? 했는데 스택이 비었을 때를 생각 안해서 그런 거였다. (새로 들어온 인덱스가 높이가 짱짱 높아서 스택에 있던 모든 원소를 날려버린 후에 스택 탑을 확인하려고 하면 아무래도 오류가 나겠지...?) 그래서 그거 고치니까 해결됐다!

옥상 정원 꾸미기

탑 풀고 다음은 이거 풀어야지~ 하고 생각만 하고 미루다가 스터디에서 추천받아서 풀게 된 문제이다. 탑 푼지 얼마 안 돼서 그나마 금방 풀었다ㅋㅋㅋ 아이디어가 거의 동일하기 때문에 뭐...

탑은 방향이 왼쪽이었다면 이건 오른쪽이고, 탑에서는 인덱스를 구하는 거였다면 이거는 나보다 낮은 탑의 개수를 구하는 문제이다.

이렇게 정리해보니까 더 비슷한 문제 같다. 아무래도... 그럴만도

마찬가지로 인덱스를 계속 넣어주는데, 나보다 높은 빌딩이 새로 들어오면 탑이 그 빌딩보다 높이가 높을 때까지 계속 팝해준다. 근데 여기서는 팝 해주면서 새로운 인덱스랑 나의 거리를 계산해서 정답에 더해준다. 그게 나랑 새로운 빌딩 사이에 존재하는 빌딩의 수니까~ 그리고 또 여기서는 오른쪽 방향을 보고 있기 때문에 탐색을 왼쪽부터 오른쪽 방향으로 해주어야 한다. 따라서 처음에 0번 인덱스를 넣고, 1에서부터 n-1까지 탐색을 진행한다.

이 문제의 또 다른 차이점은 스택을 다 집어넣고 마지막에도 한 번 더 처리를 해주어야 한다는 점이다. 위 과정이 끝나면 스택에 들어있는 원소들은 높이가 낮은 순서에서 높은 순서로 정렬된 채로 들어가있는 상태이다. 근데 탑이었으면 그냥 그 높은 원소들은 답이 0이고 끝이었을텐데(나보다 높은 원소가 앞에 하나도 없으니까. 팝이 안 됐다는 건 그 뜻이다) 여기서는 나보다 낮은 빌딩의 개수를 세어주는 것이 목적이기 때문에 또 계산을 해 주어야 한다.

따라서 맨 위에 있는 가장 높이가 낮은 빌딩의 인덱스를 기억을 해주고, 한 번 팝 한 다음에 스택이 빌 때까지 계속 팝을 한다. 그 때 정답에 저장한 인덱스랑 탑과의 거리를 또 계산해서 정답에 저장해준다. 그러면 끝~

// 옥상 정원 꾸미기 - 골드 5

#include <bits/stdc++.h>

using namespace std;

int n;
long long answer;
vector<int> h, ans;
stack<int> s;

void solve() {
    s.push(0);
    for (int i = 1; i < n; i++) {
        //다음 빌딩이 높이가 더 높거나 같으면 -> 더 높이가 높은 빌딩이 나올 때까지 pop, 확인할 수 있는 빌딩의 개수 계산 (두 인덱스 차 -1)
        while (!s.empty() && h[s.top()] <= h[i]) {
            answer += (i - s.top()) -1;
            s.pop();
        }
        s.push(i);
    }

    int t = s.top();
    s.pop();
    while (!s.empty()) {
        answer += (t - s.top());
        s.pop();
    }

}

int main() {
    cin >> n;
    h.assign(n, 0);
    ans.assign(n, 0);
    for (int i = 0; i < n; i++) {
        cin >> h[i];
    }

    solve();
    cout << answer;

}

고수들이 뭔가 문제 풀면 이렇게 다 전역변수로 빼고 main 코드도 solve 함수 하나 만들어서 거기에다가 다 쓰길래 따라해봤다ㅋㅋㅋㅋㅋㅋㅋㅋ

근데 얘도 처음 풀었을 때는 틀렸다... answer 범위 int로 해서 빌딩이 8만개까지 가능한데, 이게 내림차순으로 정렬되어있다고 생각하면 1+2+...+79999가 정답이니까... 굳이 계산을 하자면 약 32억. 무조건 오버플로우. 그래서 long long으로 안전하게 선언을 해주면 된다~

내가 스택 문제를 풀던 건 사실 이 문제를 해결하기 위해서였다. 오아시스 재결합 얘도 결국 입력 엄청 크고 높이 물어보는 거니까 비슷하긴 한데 모든 순서쌍을 구해야 하는 게 좀... 골치 아프다... 그래도 언젠가는 풀 수 있겠지?

요즘 들어서 골드 45 정도는 그래도 넉넉잡아서 1시간이면 풀 수 있는 정도로 올라온 것 같다. ㅎㅎ 좀 더 노력해서 플래 문제 건들여볼 수 있을 정도로 실력을 키워봐야겠다

둘이 뭔가가 다르긴 했는데 지금은 기억이 잘 안 난다. 근데 아무튼 중요한 건 사실상 같은 문제라 하나 풀고도 두 문제를 맞춘 것과 같은 효과를 낼 수 있다는 것(!) 그것도 심지어 골드 5(!!!) 완전히 남는 장사일 수 밖에 없다.

풀이 자체는 간단히 투 포인터를 이용해서 할 수 있다. 먼저 모든 원소를 소트한 뒤, 맨 왼쪽과 오른쪽에 포인터를 세팅해둔다. 그러면서 한 칸 한 칸씩 포인터를 옮기면서 두 포인터가 가리키고 있는 원소들의 합을 구하는 것이다. 만약 그 합이 0보다 크다면, 양수의 크기를 줄여야 하므로 오른쪽 포인터를 이동시키고, 반대라면 음수의 크기를 키워야 하므로 왼쪽 포인터를 이동시킨다. (이것이 가능한 것은 앞에서 원소를 소트해뒀기 때문이다. 만약 정렬되어 있지 않다면 이 방법을 사용할 수 없다.

이 과정을 반복하면서 합을 계산하고, 그 합이 만약 0과 가장 가까웠던 값보다 더 가깝다면 최소값을 갱신하고, 해당 원소를 저장한다. 이 과정을 두 포인터가 교차될 때까지 반복한다.

정답을 얻은 코드는 다음과 같다.

//두 용액 - 골드 5

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

int a_l, a_r, min_char = 2*1e9;

void findMin(const vector<int>& arr) {
    int l = 0, r = arr.size() - 1;

    while (l < r) {
        int sum = arr[l] + arr[r];
        if (abs(min_char) > abs(sum)) {
            min_char = sum;
            a_l = arr[l];
            a_r = arr[r];
        }

        if (sum > 0) {
            r--;
        } else {
            l++;
        }
    }
}

int main() {
    int n;
    vector<int> arr;
    cin >> n;
    arr.assign(n, 0);

    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    sort (arr.begin(), arr.end());

    findMin(arr);

    cout << a_l << ' ' <<  a_r;

}

이거랑은 별개로, 같은 문제인데 이번에는 용액 3개를 가지고 푸는 버전도 존재한다. 세 용액

아무래도 이 문서가 도움이 될 것 같다. triplet sum

보면 세 가지 방법을 알려주는데, 하나는 브루트포싱이라 뭐... 의미가 없고, 하나는 투 포인터, 마지막은 해싱이다.

투 포인터 방법도 근데 뭐 크게 다른 건 없는 게, 왼쪽에 원소를 하나 고정해 둔 다음에 그 오른쪽 원소들을 위에서 투 포인터로 푼 것처럼 옮겨가면서 가운데에서 만날 때까지 하고, 그 다음 왼쪽 원소를 한 칸 오른쪽으로 옮겨서 또 하고, 또 왼쪽 원소를 오른쪽으로 옮기고... 의 반복이다. 원소가 n개라고 할 때, 왼쪽 원소를 옮기는 게 O(N)이고, 또 포인터 연산이 O(N) 걸리니까 시간복잡도는 O(N^2)가 될 것이다. 그래도 다항식 시간으로 끊기니까 다행인가...

세 번째 방법은 엄밀히 말하면 위 문제를 푸는 데 사용할 만한 방법은 아니고, 그냥 뭐... 위랑 대단하게 다를 건 없다. 차이라면 뭐 원소 찾느라 set 쓴다? 근데 이것도 이 문제에서는 0이 되는 케이스를 찾는 게 아니라 0이랑 가까운 케이스를 찾는 거라서... 일일히 또 탐색하면 n^3 되니까 걍 투 포인터 변형으로 푸는 게 나을 것 같다.

아무튼 그렇다. 이 문제도 한 번쯤 풀어봐야겠다. 대신 인풋 범위 보니까 2개까지는 21억 안 넘는데 3개부터는 넘을 수 있으니까 자료형 좀 주의하고.

발상은 간단하다. 정말 0번 채널부터 해서 모든 채널을 일일히 확인해보는 것이다. 채널 번호를 하나 줄인 뒤, 그 번호에 고장난 버튼의 숫자가 들어있는지 확인, 들어있지 않다면 버튼을 누르는 횟수를 계산, 이 것을 채널 번호가 0이 될 때까지 반복한다. 반대로, 채널 번호를 위로 올린 뒤, 확인하고, 100만이 될 때까지 반복하면 위의 범위까지 모두 검사한 것이 된다.

여기서 100만까지 검사를 하는 이유는, N의 범위가 50만까지이기 때문이다. 채널 번호가 50만일 경우, 그보다 작은 채널 번호 중에서 가장 차이가 많이 나는 것은 0번 채널이다. 이 때의 차이는 50만이다. 따라서 그만큼 차이가 나는 100만번 채널까지 검사를 해 주는 것이다. 그 이상이 되면 무슨 값이든 0일 때보다는 버튼을 누르는 횟수가 많아져서, 절대 정답이 될 수가 없다.

이걸 일일히 검사해도 될 것이라고 판단하게 된 것은 애초에 검사해야하는 채널의 범위가 0부터 100만으로 굉장히 작기 때문이다. 이 문제의 제한시간은 2초이고, c++ 기준 2초면 2억 개의 계산을 할 수 있기 때문에 한 채널을 검사할 때 2억 / 100만 = 200개의 연산을 할 수가 있는데, 딱 생각해봐도 그 정도 연산은 한 채널 검사에 필요하지 않는다. 따라서 시간은 널널하다고 바로 판단이 가능하다. 시간 복잡도를 생각해보면, 언제나 100만 번 연산을 수행한다고 생각하면 될 것 같다. 채널 수에 비례해서 연산 수가 변화하는 게 아니라 언제나 고정이라 뭐라고 표기를 해야 할 지 애매하다...

for (int i = 0; i < l; i++) {
       if (broken.find(s[i] - '0') != broken.end()) continue;
}
cnt = min(abs(t - n) + l, cnt);

맨 처음에 코드를 짤 때 이렇게 썼는데, 내가 원하는 결과는 만약 고장난 버튼을 저장한 set broken에서 s[i]를 찾으면 break하고 다음 루프롤 돌아가는 것이었지만, s[i]을 찾아도 계속 find를 해서 당황했었다. 근데... 그게 당연하다... 무슨 break도 아니고 continue를 걸었으니 당연히 무시하고 다음 루프를 돌겠지... 그리고 여기서 continue를 걸어야 되는 루프는 이 루프가 아니라 얘를 감싸고 있는 채널 번호를 줄이거나 늘리는 루프이다. 따라서 저 부분은 만약 s[i]를 찾았을 시 flag를 true로 해준 뒤 break한 뒤, flag가 true일 경우 for을 감싼 루프를 continue해서 cnt를 계산하지 않도록 해주었다.

참고로 여기서 고장난 버튼이 채널 번호에 포함되어 있을 때 cnt를 계산해주지 않는 이유는, 그 채널에 접근하는 것이 불가능하기 때문이다. (당연)

//리모컨 - 골드 5

#include <iostream>
#include <set>
#include <cmath>
#include <string>

using namespace std;

#define MAX_CH 500000

int main() {
    int n, m, t, cnt = 0;
    char temp;
    bool flag = false;
    set<int> broken;
    cin >> n >> m;

    cnt = abs(100-n);

    if (!m) {
        int l = to_string(n).length();
        cout << min(l, cnt);
        return 0;
    }
    for (int i = 0; i < m; i++) {
        cin >> t;
        broken.insert(t);
    }



    t = n;
    while (t > 0) {
        t--;
        string s = to_string(t);
        int l = s.length();
        for (int i = 0; i < l; i++) {
            if (broken.find(s[i] - '0') != broken.end()) {
                flag = true;
                break;
            }
        }
        if (flag) {
            flag = false;
            continue;
        }
        cnt = min(abs(t - n) + l, cnt);
    }

    t = n;
    while (t < MAX_CH * 2) {
        t++;
        string s = to_string(t);
        int l = s.length();
        for (int i = 0; i < l; i++) {
            if (broken.find(s[i] - '0') != broken.end()) {
                flag = true;
                break;
            }
        }
        if (flag) {
            flag = false;
            continue;
        }
        cnt = min(abs(t - n) + l, cnt);
    }
    cout << cnt;
}

그렇게 해서 이렇게 제출을 했는데... 틀렸다!

이유는 간단했다. 나는 채널 번호가 n이면 0n-1, n+1MAX_CH까지만 검사를 했지, 정작 n일 때 검사를 하지를 않았다. 근데 n일 때도 cnt가 최소가 되는 것이 가능하다. 뭐 채널 번호가 1234인데 고장난 버튼은 0567 이러면 그냥 1234 누르는 게 최소니까...

이런 멍청한 실수를 했다는 사실을 깨닫고 바로 수정했다. 숫자를 늘리는 루프 앞에서 t를 n-1로 해주었다. 이러면 루프에 들어갔을 때 t가 n이 되니까 n일 때도 검사를 하게 된다.

결과적으로 정답을 얻은 코드는 다음과 같다.

//리모컨 - 골드 5

#include <iostream>
#include <set>
#include <cmath>
#include <string>

using namespace std;

#define MAX_CH 500000

int main() {
    int n, m, t, cnt = 0;
    char temp;
    bool flag = false;
    set<int> broken;
    cin >> n >> m;

    cnt = abs(100-n);

    if (!m) {
        int l = to_string(n).length();
        cout << min(l, cnt);
        return 0;
    }
    for (int i = 0; i < m; i++) {
        cin >> t;
        broken.insert(t);
    }



    t = n;
    while (t > 0) {
        t--;
        string s = to_string(t);
        int l = s.length();
        for (int i = 0; i < l; i++) {
            if (broken.find(s[i] - '0') != broken.end()) {
                flag = true;
                break;
            }
        }
        if (flag) {
            flag = false;
            continue;
        }
        cnt = min(abs(t - n) + l, cnt);
    }

    t = n-1;
    while (t < MAX_CH * 2) {
        t++;
        string s = to_string(t);
        int l = s.length();
        for (int i = 0; i < l; i++) {
            if (broken.find(s[i] - '0') != broken.end()) {
                flag = true;
                break;
            }
        }
        if (flag) {
            flag = false;
            continue;
        }
        cnt = min(abs(t - n) + l, cnt);
    }
    cout << cnt;
}

계산을 얼추 해보고 브루트포스로도 충분히 풀린다는 점을 캐치하면 간단한 구현으로 풀 수 있는 간단한 문제였다.

나는 내가 재귀를 정말 못한다고 생각했었음... 그래서 재귀를 잘해지기 위해서 재귀 문제만 골라서 쭉 풀고 하던 시절도 있었음... (이건 글도 썼는데 이 블로그 말고 딴 데다 써서.. 나중에 완성되면 올림)

예를 들어서 정말 유명한 재귀 문제 별 찍기 10 PS를 하는 사람이라면 모두 한 번쯤은 풀어봤을 그 유명한 문제임

전에 이 문제를 풀어보려고 했었는데... 마찬가지로 재귀를 더럽게 못했던 나는 좀 끄적끄적만 거리다가 완전히 엉망인 결과가 나와서 던졌던 기억이 있다 이유는 모르겠지만 코드가 안 남아있네 지웠나... 아무튼

그리고 까마득하게 이 문제를 잊고 지내다가 오늘 백준 단계별에서 재귀를 풀다가 만난 이 문제 칸토어 집합

한 번 손대봐야겠다고 생각은 하고 있었어서 마침 오늘 만난 김에 해결해버려야겠다고 생각했다

// 칸토어 집합 - 실버 3

#include <iostream>
#include <cmath>
#include <algorithm>

using namespace std;

void makeCantor(string& str, int l, int r) {
    if (l >= r) return;
    int len = (r - l) / 3 + 1;
    fill(str.begin() + l + len, str.begin() + r - len + 1, ' ');
    makeCantor(str, l, l+len-1);
    makeCantor(str, r-len+1, r);
}

int main() {
    int n;
    while (cin >> n) {
        string answer (pow(3, n), '-');
        makeCantor(answer, 0, pow(3, n) - 1);
        cout << answer << '\n';
    }
}

결과적으로는 매우 유익했던 것 같음 string 생성자 중에 저렇게 변수명 (길이, 문자) 해서 자동으로 채워주는 게 있다는 것도 배웠고 fill 함수도 처음 써봤고... pow 함수도 써보고... 그리고 이 문제를 어떻게 접근해야 될지를 되게 고민했었는데 이번에는 운좋게도 보자마자 떠올랐음. 길이를 삼등분을 해주고 그 만큼을 공백문자로 채워준 다음에, 그러면 양 옆 두 부분이 남으니까 그 부분을 또 삼등분을 하고... 남은 두 부분을 또 삼등분... 또... 이렇게 재귀적으로 나눠주면 됨! 전보다 재귀가 많이 익숙해진 기분이 듬... 재귀 특훈의 성과가 이렇게 보이는 것 같다

그래서 이제는 별 찍기 문제를 풀었다는 말을... 해야겠지요...? 맥락상ㅋㅋㅋㅋ

그냥 이 문제는... 칸토어 집합을 2차원으로 확장한 버전이라고 할 수 있음. 딱 그게 전부임. ㅋㅋ 진짜 그냥 칸토어에서는 가로로 삼등분해서 공백 넣어준 거를 여기서는 가로 세로를 둘 다 삼등분해서 공백을 넣어주면... 그걸로 끝

근데 이제 여기서 sub-problem이 칸토어는 2개가 생기는데 여기는 8개가 생김... 이유는 생각해보면 알거라고 생각함^^ 그래서 그게 좀 귀찮았음... 이건 뭔가 더 좋은 방법이 있지 않을까 싶은데 나중에 한 번 찾아봄ㅋㅋㅋ

//별 찍기 - 10 - 골드 5

#include <iostream>
#include <vector>

using namespace std;

typedef pair<int, int> pi;

void makePattern(vector<vector<char>>& arr, pi l, pi r) {
    int len = (r.first - l.first + 1) / 3;
    if (!len) return;

    for (int i = l.first + len; i < r.first -len + 1; i++) {
        for (int j = l.second + len; j < r.second -len + 1; j++) {
            arr[i][j] = ' ';
        }
    }

    makePattern(arr, l, {l.first + len - 1, l.second + len - 1});
    makePattern(arr, {l.first + len, l.second}, {r.first - len, l.second + len - 1});
    makePattern(arr, {r.first - len +1, l.second}, {r.first, l.second + len - 1});

    makePattern(arr, {l.first, l.second + len}, {l.first + len - 1, r.second - len});
    makePattern(arr, {r.first - len +1, l.second + len}, {r.first, r.second - len});

    makePattern(arr, {l.first, r.second - len + 1}, {l.first + len - 1, r.second});
    makePattern(arr, {l.first + len, r.second-len+1}, {r.first - len, r.second});
    makePattern(arr, {r.first - len + 1, r.second - len + 1}, r);

}

int main() {
    int n;
    vector<vector<char>> arr;
    cin >> n;
    arr.assign(n, vector<char> (n, '*'));

    makePattern(arr, {0, 0}, {n-1, n-1});

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << arr[i][j];
        }
        cout << '\n';
    }
}

아무튼 전보다 발전한 거 같아서 매우 뿌듯했다!

집합 연산

MySQL에서는 각 테이블을 집합, 그리고 그 안의 데이터 하나하나를 집합의 원소로 간주할 수 있다. 따라서 집합 연산을 통해 두 테이블 간의 연관관계를 이용하여 원하는 데이터를 추출하는 것이 가능하다.

• UNION 합집합을 구하기 위해서는 UNION 연산자를 사용한다. 예를 들어서, a 테이블과 b 테이블에서 합집합을 구하기 위해서는 다음과 같이 작성한다.

  SELECT * FROM a
  UNION
  SELECT * FROM b;

  이때, 세미콜론은 b 뒤에만 붙여주어야 한다. 두 개의 명령을 UNION으로 합치는 것이기 때문에, 중간에 명령이 끝나면 합집합 연산이 제대로 수행되지 않는다.

정렬을 하기 위해 ORDER BY 구를 사용할 때는 두 번째 명렁에만 붙여준다. 이 때, 기준으로 정렬하고자 하는 열의 이름이 서로 다른 경우는 as를 사용하여 이름을 통일시킨 후 사용하면 된다.

• UNION ALL UNION 연산의 결과는 DISTINCT를 적용시킨 것처럼 중복되는 결과는 제거된 채로 출력이 된다. 만약 중복되는 결과까지도 출력하고 싶다면, UNION ALL 연산자를 사용하면 된다.

교집합과 차집합은 MySQL에서는 지원되지 않는다.

테이블 결합

집합 연산은 세로 방향으로 데이터가 늘어나거나 줄어들지만, 테이블 결합은 가로 방향으로 데이터가 늘어난다. 이는 곱집합 연산을 생각하면 되는데, 만약 테이블 x와 y가 존재한다면 x의 요소에 y의 요소를 붙여서 새로운 집합을 생성하는 것이다.

• 교차결합 SELECT 구에서 테이블을 두 개 지정하면 자동으로 이 둘은 곱집합으로 계산된다.

  SELECT * FROM A, B;

  이렇게 작성하면 A와 B의 곱집합, 즉 교차결합을 한 결과가 출력된다. 이 때의 결과는 UNION은 자료가 세로로 길어지지만, 교차결합은 자료가 가로로 길어진다는 점에서 차이가 있다.

• 내부결합 두 개의 테이블 뿐만 아니라 원하는 만큼 무한정의 테이블을 교차결합을 통해 계산할 수 있다. 단, 이러면 테이블이 너무 거대해지기 때문에 보통은 내부결합을 더 많이 사용한다.

• 기본키* : 테이블에서 유일한 값을 가지는 열을 말한다. 예를 들어 상품코드와 같은 것이 기본키가 될 수 있다.

내부결합을 하는 방법에는 두 가지가 있다. 하나는 교차집합을 한 뒤 WHERE을 사용하여 원하는 조합을 검색하는 방법이고, 다른 하나는 INNER JOIN 키워드를 사용하여 결합하는 것이다. 전자의 방법은 구식으로 취급되고, 최근은 INNER JOIN을 이용한 결합을 보통 사용한다.

SELECT 상품.상품명, 재고수.재고수 FROM 상품, 재고수
    WHERE 상품.상품코드 = 재고수.상품코드
        AND 상품.상품분류 = '식료품';

이 코드는 구식 방법으로 상품과 재고수 테이블에서 둘의 상품코드가 같고, 상품분류가 식료품인 데이터를 상품명과 재고수 열만 출력하는 명령어이다.

같은 명령어를 INNER JOIN을 사용하여 출력하면 다음과 같다.

SELECT 상품.상품명, 재고수.재고수
    FROM 상품 INNER JOIN 재고수
        ON 상품.상품코드 = 재고수.상품코드
    WHERE 상품.상품분류 = '식료품';

FROM에서 두 개의 테이블을 바로 넣어서 교차결합을 하는 것이 아니라, 두 테이블 사이에 INNER JOIN 명령어를 넣어준다. 그리고 결합조건을 뒤에 ON을 사용하여 지정한다.

• 외부결합 외부결합 또한 교차결합으로 결합 조건을 지정하여 검색한다는 점은 같지만, 여기서는 어느 한 쪽에만 존재하는 데이터행을 어떻게 다룰지를 변경 가능하다는 점이 다르다.

  만약 왼쪽에만 존재하는 데이터행을 사용하고 싶다면, LEFT JOIN 명령어를 사용하면 된다. 이 때, 오른쪽 테이블에는 존재하지 않는 데이터는 NULL로 표시되게 된다. 반대로 오른쪽에 있는 데이터를 기준으로 하기 위해서는 RIGHT JOIN 명령어를 사용한다.

관계형 모델

MySQL과 같은 관계형 데이터베이스는 관계형 모델을 기반으로 작성되었다. 따라서 관계형 모델에 대해 살펴보는 것이 관계형 데이터베이스를 더 깊게 이해하는 데 도움을 준다. 단, 둘에서 사용하는 용어는 일치하지 않는다.

• 관계형 모델 관계형 모델의 기본적인 요소는 릴레이션이다. 이 때, 릴레이션은 SQL의 테이블을 말한다. 각 릴레이션에는 속성이 존재하는데, 이는 SQL의 열과 같다. 그리고 튜플도 존재하는데, 이는 SQL의 행과 같다.
• 관계대수 릴레이션은 튜플의 집합이며, 릴레이션에 대한 연산이 집합에 대한 연산에 대응된다는 이론을 관계대수라고 한다.

릴레이션에서의 연산을 SQL의 연산과 일대일 대응시킬 수 있다. 합집합은 UNION, 차집합은 EXCEPT, 교집합은 INTERSECT, 곱집합은 CROSS JOIN, 선택은 WHERE, 투영은 SELECT, 결합은 내부결합에 해당된다.

8장 - 데이터베이스 설계

데이터베이스 설계

데이터베이스를 설계한다는 것은 데이터베이스의 스키마 내에 테이블, 인덱스, 뷰 등의 데이터베이스 객체를 정의하는 것을 말한다. 데이터베이스를 설계할 때에는 다음과 같은 것들을 정의해야 한다.

• 논리명과 물리명 열이나 테이블의 이름을 지어도 SQL 명령에는 제약이 존재하기 때문에 이름을 물리명과 논리명으로 나누는 경우가 존재한다. 논리명은 실제로 테이블을 부를 때 사용하는 이름이고, 물리명은 테이블을 작성할 때 사용하는 이름이다.
• 자료형 수치형 데이터를 저장하는 것이 필요할 때에는 수치형으로 지정하면 된다. 반대로 이름과 같이 알파벳이 들어가는 데이터를 저장할 때에는 문자열형을 사용하면 된다.
• 고정길이와 가변길이 만약 제조번호처럼 자리수가 고정되어 있는 데이터를 저장할 때에는 고정길이를 사용하면 된다. 반대로, 입력되는 문자열의 변동폭이 클 때에는 가변길이를 사용한다.
  • 기본키 상품코드처럼 분명한 기본키가 존재한다면 좋지만, 만약 그런 열이 존재하지 않는다면 자동증가 열을 사용하여 기본키로 지정할 수 있다. MySQL에서는 AUTO_INCREMENT를 지정하는 것으로 자동증가 열을 설정할 수 있다.

ER 다이어그램

ER 다이어그램이란 엔티티 간의 관계를 나타내는 도식이다. UML의 클래스 다이어그램을 생각하면 이해하기 편하다. 실제로 표현하는 방식도 클래스 다이어그램과 유사하다.

정규화

정규화는 테이블을 올바른 형태로 변경하고 분할하는 것을 의미한다. 정규화에는 여러가지 단계가 존재하는데, 이 책에는 세 번째 단계까지 설명하고 있다.

제1정규형

관계형 데이터베이스의 테이블에는 하나의 셀에 하나의 값만 저장할 수 있다. 따라서 제1정규형에서는 먼저 반복되는 데이터를 세로 방향으로 늘리게 된다. 그 이후, 테이블에 중복되는 값이 존재하므로, 테이블을 분해하는 과정도 이루어진다.

따라서 제1정규형의 과정은 크게 테이블 분할과 기본키 지정으로 이루어져 있다고 말할 수 있다.

제2정규형

이후 정규화에서는 중복되는 부분을 찾아내어 테이블로 분할해 나가는데, 이 때 기본키에 의해 특정되는 열과 그렇지 않은 열로 나누는 과정을 제2정규형이라고 한다. 어려운 말로는, 함수종속성을 찾아내서 테이블을 분할하는 것을 제2정규화라고 한다.

제3정규형

기본키 이외의 부분에서 중복이 없는지를 조사한 후, 테이블을 분할하는 것을 제3정규형이라고 한다.

이와 같이 정규화를 하는 이유는 '하나의 데이터는 한 곳에 있어야 한다'는 규칙을 지키기 위함이다. 데이터가 한 곳에 저장되어 있다면, 수정이 필요할 때에 그 부분만 수정하면 되므로 편리하다.

트랜잭션

트랜잭션은, 깃을 사용할 때 커밋이 수정하는 족족 올라가는 것이 아니라 먼저 stage에 올려둔 다음에 한꺼번에 모아서 커밋하는... 그런 과정을 생각하면 된다. 트랜잭션을 사용해 테이블을 수정하면 만약 데이터 수정 중 에러가 발생했을 시 롤백하여 모든 수정을 초기화 할 수 있어 편리하다.

MySQL에서 트랜젝션을 시작하기 위해서는 다음과 같은 명령을 사용하면 된다.

START TRANSACTION

이 명령을 사용하면 자동커밋이 꺼지고 이후 COMMIT이나 ROLLBACK 명령을 사용해야만 그 수정한 내용이 적용되거나 사라진다.