• 관련 링크

내용이 생각보다 길어서, 2번 또는 3번에 나눠서 포스팅 할 예정입니다. 가이드에서 나온 설명에는 부족한 점이 있어서 추가 내용을 포함하여 정리중입니다.

Jupyter lab, VsCode를 통한 ipynb 파일 기준으로 작성했습니다.

목차

1. Object Creation (객체 생성)
2. Viewing Data (데이터 확인하기)
3. Selection (선택)

먼저, 필요한 패키지를 설치해줍니다. pandas, numpy, matplotlib를 설치하는데, import 전에 pip install을 통해 설치해주어야 합니다. VSCode에서 터미널을 통해 설치해 줄 수 있습니다.

$ pip install pandas
$ pip install numpy
$ pip install matplotlib

설치가 완료되었으면 패키지를 불러옵니다. 일반적으로 각 패키지는 pd, np, plt라는 이름으로 불러옵니다.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

1. Object Creation (객체 생성)

Pandas는 값을 가지고 있는 리스트를 통해 Series를 만들고, 정수로 만들어진 인덱스를 기본값으로 불러옵니다.

s = pd.Series([1, 3, 5, np.nan, 6, 8])

s

Output:

0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

• Series: pandas에서 사용하는 1차원 데이터 구조입니다. 배열처럼 사용되며, 인덱스를 가집니다. DataFrame의 한 열(column)이라고 보시면 되겠습니다.

• np.nan: NaN 값, 즉 값이 없는 결측 데이터입니다.

• dtype: 데이터 타입(data type) 입니다. int64, float64, bool, datetime64 등이 있습니다.

datatime 인덱스와 레이블(Label)이 있는 column을 가지고 있는 numpy 배열을 전달하여 데이터프레임을 생성합니다.

dates = pd.date_range('20250123', periods=6)

dates

Output:

DatetimeIndex(['2025-01-23', '2025-01-24', '2025-01-25', '2025-01-26',
               '2025-01-27', '2025-01-28'],
              dtype='datetime64[ns]', freq='D')

• periods를 설정하면, 입력한 날짜부터 n일차 까지의 날짜를 차례대로 생성합니다.

df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))

df

Output:

                   A         B         C         D
2025-01-23  0.470623 -1.544299 -0.359713  0.341314
2025-01-24 -0.989620 -0.296540  0.083644 -1.485904
2025-01-25  0.602569 -0.716880  0.785357  0.572783
2025-01-26 -0.621514 -0.318548 -1.075782  2.061741
2025-01-27 -1.626353 -1.416525 -0.516248 -1.631344
2025-01-28 -0.817248  1.168349 -0.803450 -1.352421

• 각 row의 인덱스를 날짜 순서대로, column은 A, B, C, D로 하는 DataFrame을 생성합니다.
• np.random.randn(row, column): 행(row)과 열(column)의 개수만큼 행렬을 생성하며, 각 칸마다 정규분포에서 난수를 생성합니다. 대부분 -3에서 3사이의 값입니다.

Series와 같은 것으로 변환될 수 있는 객체들의 dictionary로 구성된 데이터프레임을 만듭니다. 각 Key는 column을, Value는 칸에 맞는 값이 할당됩니다. row는 기본 인덱스로 지정이되며, 따로 설정해주고 싶은 경우는 pd.DataFrame.from_dict() 등을 통해 가능하다고 하네요.

df2 = pd.DataFrame({
    'A': 1.,
    'B': pd.Timestamp('20250123'),
    'C': pd.Series(1, index=list(range(4)), dtype='float32'),
    'D': np.array([3] * 4, dtype='int32'),
    'E': pd.Categorical(["test", "traing", "test", "traint"]),
    'F': 'foo'
})

df2

Output:

     A          B    C  D       E    F
0  1.0 2025-01-23  1.0  3    test  foo
1  1.0 2025-01-23  1.0  3  traing  foo
2  1.0 2025-01-23  1.0  3    test  foo
3  1.0 2025-01-23  1.0  3  traint  foo

• pd.Timestamp: 날짜와 시간 정보를 포함하는 객체입니다.
• pd.Categorical: 메모리 최적화를 위해 유한한 범주의 값을 나타내는 객체입니다. 보통 문자열이나 정수로 표현하고, 데이터를 압축하기 때문에 메모리 사용량을 줄여 대규모 데이터에 유리하다고 합니다.

DataFrame의 결과물의 column은 다양한 데이터 타입(dtpyes)으로 구성됩니다.

df2.dtypes

Output:

A          float64
B    datetime64[s]
C          float32
D            int32
E         category
F           object
dtype: object

2. Viewing Data (데이터 확인하기)

DataFrame의 가장 윗 줄과 마지막 줄을 확인하고 싶을 때에 사용하는 방법은 다음과 같습니다.

• 괄호 안에는 숫자가 들어갈 수도 있고 안 들어갈 수도 있습니다.
• 숫자가 들어간다면, 윗 / 마지막 줄의 특정 줄을 불러올 수 있습니다.
• 숫자가 들어가지 않는다면, 기본값은 5로 처리됩니다.

df.tail(3) # 끝에서 마지막 3줄
df.tail() # 끝에서 마지막 5줄

Output:

                   A         B         C         D
2025-01-24 -0.989620 -0.296540  0.083644 -1.485904
2025-01-25  0.602569 -0.716880  0.785357  0.572783
2025-01-26 -0.621514 -0.318548 -1.075782  2.061741
2025-01-27 -1.626353 -1.416525 -0.516248 -1.631344
2025-01-28 -0.817248  1.168349 -0.803450 -1.352421

• 해당 Output은 둘째 줄 코드인 df.tail()의 결과로, 뒤에서부터 5개의 row를 불러옵니다.

df.head() # 처음에서 5줄

Output:

                   A         B         C         D
2025-01-23  0.470623 -1.544299 -0.359713  0.341314
2025-01-24 -0.989620 -0.296540  0.083644 -1.485904
2025-01-25  0.602569 -0.716880  0.785357  0.572783
2025-01-26 -0.621514 -0.318548 -1.075782  2.061741
2025-01-27 -1.626353 -1.416525 -0.516248 -1.631344

• 위에서부터 5개의 row를 불러옵니다.

df.tail(3)

Output:

                   A         B         C         D
2025-01-26 -0.621514 -0.318548 -1.075782  2.061741
2025-01-27 -1.626353 -1.416525 -0.516248 -1.631344
2025-01-28 -0.817248  1.168349 -0.803450 -1.352421

• 뒤에서부터 3개의 row를 불러옵니다.

인덱스 (index), 열 (column) 그리고 numpy 데이터에 대한 세부 정보를 봅니다.

df.index

Output:

DatetimeIndex(['2025-01-23', '2025-01-24', '2025-01-25', '2025-01-26',
               '2025-01-27', '2025-01-28'],
              dtype='datetime64[ns]', freq='D')

• index를 통해 각 row를 구분하는 인덱스의 배열을 불러올 수 있습니다.
• freq: DatatimeIndex가 있는 경우 출력되는 시간 주기(frequency) 입니다.
  뒤에 붙는 문자열은 다음과 같습니다.
  • D: 일 단위 (Daily)
  • W: 주 단위 (Weekly)
  • M: 월 단위 (Month-End)
  • Q: 분기 단위 (Quarter-End)
  • Y or A: 연 단위 (Year-End)
  • H: 시간 단위 (Hourly)
  • T: or min 분 단위 (Minute)
  • S: 초 단위 (Second)

df.columns

Output:

Index(['A', 'B', 'C', 'D'], dtype='object')

• colums를 통해 column의 배열을 불러올 수 있습니다.

df.values

Output:

array([[ 0.47062305, -1.54429928, -0.3597129 ,  0.34131384],
       [-0.98961962, -0.29653974,  0.08364368, -1.48590371],
       [ 0.60256886, -0.71687987,  0.78535709,  0.57278294],
       [-0.62151395, -0.31854779, -1.0757822 ,  2.06174073],
       [-1.62635282, -1.41652459, -0.51624819, -1.63134446],
       [-0.81724815,  1.16834876, -0.80344996, -1.35242074]])

• values를 통해 DataFrame의 모든 값을 2차원 배열의 형태로 불러올 수 있습니다.

describe()는 데이터의 대략적인 통계적 정보 요약을 보여줍니다.

df.describe()

Output:

              A         B         C         D
count  6.000000  6.000000  6.000000  6.000000
mean  -0.496924 -0.520740 -0.314365 -0.248972
std    0.869657  0.983132  0.667768  1.484700
min   -1.626353 -1.544299 -1.075782 -1.631344
25%   -0.946527 -1.241613 -0.731650 -1.452533
50%   -0.719381 -0.517714 -0.437981 -0.505553
75%    0.197589 -0.302042 -0.027195  0.514916
max    0.602569  1.168349  0.785357  2.061741

• count: column의 유효값(결측값이 아닌 값)의 개수
• mean: column의 평균값
• std: column의 표준편차 (데이터의 분산 정도)
• min: column의 최솟값
• 25%: column의 1사분위수 (데이터의 하위 25% 지점)
• 50%: column의 중앙값 (데이터의 50% 지점, 2사분위수 또는 중위수)
• 75%: column의 3사분위수 (데이터의 상위 25%를 제외한 하위 75% 지점)
• max: column의 최댓값

데이터를 전치합니다.

df.T

Output:

   2025-01-23  2025-01-24  2025-01-25  2025-01-26  2025-01-27  2025-01-28
A    0.470623   -0.989620    0.602569   -0.621514   -1.626353   -0.817248
B   -1.544299   -0.296540   -0.716880   -0.318548   -1.416525    1.168349
C   -0.359713    0.083644    0.785357   -1.075782   -0.516248   -0.803450
D    0.341314   -1.485904    0.572783    2.061741   -1.631344   -1.352421

• row와 column이 뒤집힌 것을 볼 수 있습니다.

sort_index()에서 axis = 0인 경우 행(row)을 기준으로 정렬하고, axis = 1인 경우 열(column)을 기준으로 정렬합니다.

df.sort_index(axis=1, ascending=False)

Output:

                   D         C         B         A
2025-01-23  0.341314 -0.359713 -1.544299  0.470623
2025-01-24 -1.485904  0.083644 -0.296540 -0.989620
2025-01-25  0.572783  0.785357 -0.716880  0.602569
2025-01-26  2.061741 -1.075782 -0.318548 -0.621514
2025-01-27 -1.631344 -0.516248 -1.416525 -1.626353
2025-01-28 -1.352421 -0.803450  1.168349 -0.817248

• ascending: 정렬 기준을 나타냅니다. False는 내림차순, True는 오름차순을 기준으로 정렬합니다.
  default 값은 False 입니다.
• 해당 결과는 column을 내림차순으로 정렬했으므로, 알파벳이 큰 D부터 작은 A까지 정렬되었습니다.

값 별로 정렬합니다.

df.sort_values(by='B')

Output:

                   A         B         C         D
2025-01-23  0.470623 -1.544299 -0.359713  0.341314
2025-01-27 -1.626353 -1.416525 -0.516248 -1.631344
2025-01-25  0.602569 -0.716880  0.785357  0.572783
2025-01-26 -0.621514 -0.318548 -1.075782  2.061741
2025-01-24 -0.989620 -0.296540  0.083644 -1.485904
2025-01-28 -0.817248  1.168349 -0.803450 -1.352421

• B를 기준으로 각 row를 내림차순 합니다.

3. Selection (선택)

Python 및 Numpy의 선택과 설정을 위한 표현들은 직관적이고 코드 작성을 위한 작업에 유용합니다. .at, .iat, .loc, .iloc가 pandas에 최적화되어 있기 때문에 사용하는 것을 추천한다고 합니다.

Getting (데이터 얻기)

df.A와 동일한 Series를 생성하는 단일 column을 선택합니다.

df['A']

Output:

2025-01-23    0.470623
2025-01-24   -0.989620
2025-01-25    0.602569
2025-01-26   -0.621514
2025-01-27   -1.626353
2025-01-28   -0.817248
Freq: D, Name: A, dtype: float64

• 해당 결과의 데이터 구조는 Series 입니다.

슬라이싱을 통해 row를 선택할 수 있습니다.

df[0:3]

Output:

                   A         B         C         D
2025-01-23  0.470623 -1.544299 -0.359713  0.341314
2025-01-24 -0.989620 -0.296540  0.083644 -1.485904
2025-01-25  0.602569 -0.716880  0.785357  0.572783

• 0번째 인덱스('20250123')부터 2번째 인덱스('20250125')까지의 row를 불러옵니다.

df['20250123':'20250125']

Output:

                   A         B         C         D
2025-01-23  0.470623 -1.544299 -0.359713  0.341314
2025-01-24 -0.989620 -0.296540  0.083644 -1.485904
2025-01-25  0.602569 -0.716880  0.785357  0.572783

• 직접 입력한 범위의 row를 불러옵니다. 숫자 인덱스와는 다르게 뒤의 범위를 포함합니다.

Selection by Label (Label을 통한 선택)

Label을 사용하여 횡단면을 얻습니다.

df.loc[dates[0]]

Output:

A    0.470623
B   -1.544299
C   -0.359713
D    0.341314
Name: 2025-01-23 00:00:00, dtype: float64

• 결과의 데이터 구조는 Series 입니다.
• 0번째 인덱스('20250123')의 각 column에 대한 정보입니다.
• loc: Label을 기준으로 데이터를 불러옵니다.

Label을 사용하여 여러 축의 데이터를 얻습니다.

df.loc[:, ['A', 'B']]

Output:

                   A         B
2025-01-23  0.470623 -1.544299
2025-01-24 -0.989620 -0.296540
2025-01-25  0.602569 -0.716880
2025-01-26 -0.621514 -0.318548
2025-01-27 -1.626353 -1.416525
2025-01-28 -0.817248  1.168349

• 결과의 데이터 구조는 DataFrame 입니다.
• loc에서는 콤마(,)를 기준으로 row, column을 나타내는데 :은 모든 행을, ['A', 'B']는 'A'와 'B' column을 나타냅니다.
• 이렇게 row와 column의 범위를 모두 지정해주면 2차원 데이터 구조인 DataFrame을, 하나만 지정하면 1차원 데이터 구조인 Series 타입의 결과를 얻게됩니다.
  (범위를 지정해야 2차원이고, 값 하나만 지정하면 1차원입니다. 아래와 비교하면 이해하기 편합니다.)

양쪽 종단점을 포함한 Label 슬라이싱을 불러옵니다.

df.loc['20250123':'20250125', ['A','B']]

Output:

                   A         B
2025-01-23  0.470623 -1.544299
2025-01-24 -0.989620 -0.296540
2025-01-25  0.602569 -0.716880

• row와 column를 지정한 만큼 불러옵니다.

반환되는 객체의 차원을 줄입니다.

df.loc['20250123', ['A','B']]

Output:

A    0.470623
B   -1.544299
Name: 2025-01-23 00:00:00, dtype: float64

• 하나의 row에 대한 결과를 불러오기 때문에, Series 타입입니다.

스칼라 값을 얻습니다.

df.loc[dates[0], 'A']

Output:

0.47062305067298715

• dates[0]에 해당하는 인덱스(row)와 A에 해당하는 column이 교차하는 지점의 위치에 대한 스칼라 값입니다.
  이 값을 통해 무엇을 하는지는 아직 잘 모르겠습니다.. 나중에 쓸 일이 있으면 추가하겠습니다!

스칼라 값을 더 빠르게 구하는 방법입니다.

df.at[dates[0], 'A']

Output:

0.47062305067298715

• at: 단일 값인 스칼라값에만 접근합니다. loc는 여러 개의 값을 선택할 수 있지만 at은 하나의 값만 선택하기 때문에 스칼라 값을 구하는 경우에 더 빠릅니다.

Selection by Position (위치로 선택하기)

넘겨받은 정수의 위치(인덱스)를 기준으로 선택합니다. loc가 인덱스의 특정 값을 통해 범위를 지정했다면, iloc는 인덱스 위치(배열의 0번째 인덱스와 같이)로 접근합니다.

df.iloc[3]

Output:

A   -0.621514
B   -0.318548
C   -1.075782
D    2.061741
Name: 2025-01-26 00:00:00, dtype: float64

• 인덱스의 3번째 값인 20250126에 대한 Series 데이터입니다.

정수로 표기된 슬라이스들을 통해, Python/Numpy와 유사하게 작동합니다.

df.iloc[3:5, 0:2]

Output:

                   A         B
2025-01-26 -0.621514 -0.318548
2025-01-27 -1.626353 -1.416525

• row의 3번째 인덱스부터 4번째 인덱스, column의 0번째 인덱스부터 1번째 인덱스까지의 DataFrame 데이터입니다.

정수로 표기된 위치값의 리스트들을 통해, Python/Numpy의 스타일과 유사해집니다.

df.iloc[[1,2,4],[0,2]]

Output:

                   A         C
2025-01-24 -0.989620  0.083644
2025-01-25  0.602569  0.785357
2025-01-27 -1.626353 -0.516248

• 범위가 아닌 특정 row의 인덱스 위치를 리스트에 담아 불러올 수 있습니다.

명시적으로 행을 나누고자 하는 경우입니다.

df.iloc[1:3,:]

Output:

                   A        B         C         D
2025-01-24 -0.989620 -0.29654  0.083644 -1.485904
2025-01-25  0.602569 -0.71688  0.785357  0.572783

• row의 1번째 인덱스부터 2번째 인덱스, 모든 column의 DataFrame 데이터입니다.

명시적으로 열을 나누고자 하는 경우입니다.

df.iloc[:,1:3]

Output:

                   B         C
2025-01-23 -1.544299 -0.359713
2025-01-24 -0.296540  0.083644
2025-01-25 -0.716880  0.785357
2025-01-26 -0.318548 -1.075782
2025-01-27 -1.416525 -0.516248
2025-01-28  1.168349 -0.803450

• 위와 동일하며, 범위만 다릅니다.

명시적으로 (특정한) 값을 얻고자 하는 경우입니다.

df.iloc[1,1]

Output:

-0.29653974092309904

• [20250124, B]에 대한 스칼라 값입니다.

스칼라 값을 빠르게 얻는 방법 입니다. (위와 동일)

df.iat[1,1]

Output:

-0.29653974092309904

• loc, at에서의 차이와 같습니다.

Boolean Indexing

데이터를 선택하기 위해 단일 열의 값을 사용합니다.

df[df.A > 0]

Output:

                   A         B         C         D
2025-01-23  0.470623 -1.544299 -0.359713  0.341314
2025-01-25  0.602569 -0.716880  0.785357  0.572783

• A가 0보다 큰 데이터만 필터링한 데이터입니다.

Boolean 조건을 충족하는 DataFrame에서 값을 선택합니다.

df[df > 0]

Output:

                   A         B         C         D
2025-01-23  0.470623       NaN       NaN  0.341314
2025-01-24       NaN       NaN  0.083644       NaN
2025-01-25  0.602569       NaN  0.785357  0.572783
2025-01-26       NaN       NaN       NaN  2.061741
2025-01-27       NaN       NaN       NaN       NaN
2025-01-28       NaN  1.168349       NaN       NaN

• 모든 데이터 중, 0보다 큰 경우에만 값을 표시하고, 아닌 경우는 NaN을 표시합니다.

필터링을 위한 메소드 isin()을 사용합니다.

df2 = df.copy()

df2['E'] = ['one', 'one', 'two', 'three', 'four', 'three']

df2

Output:

                   A         B         C         D      E
2025-01-23  0.470623 -1.544299 -0.359713  0.341314    one
2025-01-24 -0.989620 -0.296540  0.083644 -1.485904    one
2025-01-25  0.602569 -0.716880  0.785357  0.572783    two
2025-01-26 -0.621514 -0.318548 -1.075782  2.061741  three
2025-01-27 -1.626353 -1.416525 -0.516248 -1.631344   four
2025-01-28 -0.817248  1.168349 -0.803450 -1.352421  three

• 지정한 데이터가 들어있는 column E를 추가합니다.

df2[df2['E'].isin(['two', 'four'])]

Output:

                   A         B         C         D     E
2025-01-25  0.602569 -0.716880  0.785357  0.572783   two
2025-01-27 -1.626353 -1.416525 -0.516248 -1.631344  four

• E column 중, 값이 two와 four인 데이터의 row를 불러옵니다.

Setting (설정)

새 column을 설정하면 데이터가 인덱스 별로 자동 정렬됩니다.

s1 = pd.Series([1, 2, 3, 4, 5, 6], index = pd.date_range('20250123', periods=6))

s1

Output:

2025-01-23    1
2025-01-24    2
2025-01-25    3
2025-01-26    4
2025-01-27    5
2025-01-28    6
Freq: D, dtype: int64

• 새로운 데이터를 가진 column을 생성합니다.

위에서 생성한 데이터를 F라는 column에 넣어 추가합니다.

df['F'] = s1

Label에 의해 값을 설정합니다.

df.at[dates[0], 'A'] = 0

• [20250123, A]의 값을 0으로 바꿉니다.

위치에 의해 값을 설정합니다.

df.iat[0, 1] = 0

• [20250123, B]의 값을 0으로 바꿉니다.

Numpy 배열을 사용한 할당에 의해 값을 설정합니다.

df.loc[:, 'D'] = np.array([5] * len(df))

• D column의 모든 값을 5로 바꿉니다.

위 설정대로 작동한 결과입니다.

df

Output:

                   A         B         C    D  F
2025-01-23  0.000000  0.000000 -0.359713  5.0  1
2025-01-24 -0.989620 -0.296540  0.083644  5.0  2
2025-01-25  0.602569 -0.716880  0.785357  5.0  3
2025-01-26 -0.621514 -0.318548 -1.075782  5.0  4
2025-01-27 -1.626353 -1.416525 -0.516248  5.0  5
2025-01-28 -0.817248  1.168349 -0.803450  5.0  6

• 정상적으로 바뀌었습니다.

where 연산을 설정한다.

df2 = df.copy()

df2[df2 > 0] = -df2

• 값이 0보다 큰 데이터를 음수로 바꿉니다.

df2

Output:

                   A         B         C    D  F
2025-01-23  0.000000  0.000000 -0.359713 -5.0 -1
2025-01-24 -0.989620 -0.296540 -0.083644 -5.0 -2
2025-01-25 -0.602569 -0.716880 -0.785357 -5.0 -3
2025-01-26 -0.621514 -0.318548 -1.075782 -5.0 -4
2025-01-27 -1.626353 -1.416525 -0.516248 -5.0 -5
2025-01-28 -0.817248 -1.168349 -0.803450 -5.0 -6

이번 포스팅에서는 3번째 목차까지 다루었습니다. 다음 포스팅에서는 아마 6번째나 7번째 목차까지 다룰 것 같네요. at, iat, loc, iloc가 헷갈렸었는데, 이번 공부를 통해 많이 이해하게 되었습니다! 페이지의 제목은 pandas 10분 다루기인데, 10시간으로 바꿔야하는게 아닌가 생각이되네요..

Vimtutor

1.1) 커서 움직이기

h, j, k, l를 통해 커서를 움직일 수 있다.

• h: 커서를 왼쪽으로 움직인다.
• j: 커서를 아래쪽으로 움직인다.
• k: 커서를 위쪽으로 움직인다.
• l: 커서를 오른쪽으로 움직인다.

1.2) 빔을 시작하고 끝내기

ESC 키를 눌러 명령 모드로 빠져나올 수 있다.

• q! + ENTER: 바뀐 내용을 저장하지 않고 편집기를 빠져나간다.

쉘 프롬프트가 보인다면, 다시 vimtutor로 돌아오기 위해 다음과 같이 입력한다.

• vimtutor + ENTER or vimtutor ko(한국어버전) + ENTER

1.3) 텍스트 편집 - 지우기

명령 모드에서 x를 누르면 커서가 위치한 곳의 글자를 지울 수 있다.

1.4) 텍스트 편집 - 삽입

명령 모드에서 i를 누르면 텍스트를 입력할 수 있다.

텍스트를 지울 수는 없다.

1.5) 텍스트 편집 - 추가

명령 모드에서 a를 누르면 텍스트를 추가할 수 있다.

텍스트를 지울 수 있다.

1.6) 파일 편집

명령모드에서 :wq를 이용하여 파일을 저장하고 빠져나갈 수 있다.

1 요약

1. h, j, k, l: 커서를 움직인다.
   • h: 왼쪽
   • j: 아래쪽
   • k: 위쪽
   • l: 오른쪽
2. vim + FILENAME + ENTER: 쉘 프롬프트에서 vim을 시작한다.
3. ESC + :q! + ENTER: 수정한 내용을 무시한 채로 vim에서 빠져나간다. ESC + :wq + ENTER: 수정한 내용을 저장한 후 vim에서 빠져나간다.
4. x: 명령 모드에서 커서가 위치한 곳의 글자를 지운다.
5. i: 명령 모드에서 커서 앞에 텍스트를 삽입한다. a: 명령 모드에서 문장 뒤에 텍스트를 추가한다.

2.1) 삭제 명령

한 단어를 끝까지 지우려면 dw라고 치면 된다.

• . 또는 공백을 기준으로 지운다.

2.2) 다른 삭제 명령

d$라고 치면 그 줄 끝까지 지워진다.

2.3) 명령과 적용 대상에 대해

삭제 명령 d의 형식은 다음과 같다. d 대상

• d: 지우는 명령이다.
• 대상: 아래에 제시된 대상에 대해 명령을 수행한다.

적용 가능한 대상의 종류

• w: 커서에서 그 단어의 끝까지 지운다. (공백 포함)
• e: 커서에서 그 단어의 끝까지 지운다. (공백을 포함하지 않음)
• $: 커서에서 그 줄의 끝까지 지운다.

2.4) 대상에 반복 적용하기

대상 이전에 숫자를 넣어주면 그 만큼 반복된다.

• 숫자 + w: 커서를 숫자만큼 단어 뒤로 옮깁니다.
• 숫자 + e: 커서를 뒤로 숫자만큼 단어의 끝으로 옮깁니다.
• 0: 문장의 시작부분으로 움직인다.

2.5) 삭제에 반복 적용하기

명령과 숫자를 함께 사용하면 그만큼 반복 수행된다. 위에서 삭제 명령과 대상의 조합과 같이, 대상 이전에 횟수를 넣어 더 많이 삭제할 수 있다. d 횟수 대상

• d + 숫자 + w: 커서에서부터 숫자만큼 단어를 삭제한다.

2.6) 줄 전체 조작하기

dd를 입력하면 줄 전체를 지운다. 횟수 + dd 로 여러 줄을 지울 수 있다.

2.7) 취소 명령

u를 누르면 마지막 명령이 취소되며, U는 줄 전체를 수정한다.

• U는 한 라인 내 모든 수정 사항이 되돌려진다.
• CTRL + R: 마지막 취소 작업을 다시 실행, 즉 이전에 되돌린 내용을 복원한다. u로 취소한 변경 사항을 CTRL + R로 취소된 변경 사항을 되돌릴 수 있다.

2 요약

1. dw: 커서가 위치한 곳부터 단어의 끝까지 지운다.

2. d$: 커서가 위치한 곳부터 줄 끝까지 지운다.

3. dd: 줄 전체를 지운다.

4. 숫자 + w: 횟수와 함께 대상을 반복시킨다.

5. 명령 모드에서 내리는 명령의 형식은 다음과 같다.

   [횟수] 명령 대상 or 명령 [횟수] 대상

   • 횟수: 그 명령을 몇 번 반복할 것인가
   • 명령: 어떤 명령을 내릴 것인가
   • 대상: 명령이 동작할 대상, 예를 들어 w (단어), $ (줄의 끝) 등

6. 0: 커서를 문장 맨 앞으로 옮긴다.

7. u: 이전 행동을 취소한다. U: 한 줄에서 수정한 것을 모두 취소한다. CTRL-R: 취소한 것을 다시 실행한다.

• https://www.acmicpc.net/problem/13397

시간 복잡도

• 두 수 차의 최댓값은 k, 배열의 크기가 n -> $O(n log k)$
• 두 수 차의 최댓값은 9,999이고, 배열 크기의 최댓값은 5,000이므로 시간은 충분하다.

문제 접근법

문제의 풀이가 너무 이해가 안가서 아주 자세하게 알아보았습니다.

• 이분탐색의 시작값(start)은 모든 수가 같다는 가정 하에 0이다.
• 이분탐색의 끝값(end)은 배열의 최댓값에서 최솟값을 뺀 값이다.
  (구간의 차이가 가장 큰 값을 이분탐색의 끝값으로 시작한다.)
• 이분탐색을 통해 중간값(mid)를 구한다.
• 중간값은 구간의 점수의 최댓값-최솟값을 한 것 중 최댓값의 마지노선이다.
• 이 중간값이 최적의 값인지를 계산하는 함수(is_valid())를 실행한다.
  • 해당 함수는 새로운 중간값(mid)으로 새로운 구간들을 구한다.
  • 현재 중간값으로 구하는 구간들의 최소(min_num)와 최대(max_num)를 초기화한다.
  • 수를 차례대로 탐색하면서 구간을 구하기 때문에, 구간의 개수(count)를 1로 초기화한다.
  • 수를 차례대로 탐색한다.
    • 최댓값과 최솟값을 계속 비교하며 갱신한다.
    • 현재 구간의 최댓값에서 최솟값을 뺐을 때, 그 값이 중간값보다 크면 새로운 구간을 만들어야 한다.
    • 새로운 구간을 만들면 구간의 개수(count)가 증가하기 때문에 count + 1을 한다.
    • 또한, 새로운 구간이 현재 수(num)부터 시작되기 때문에 최솟값(min_num)과 최댓값(max_num)을 현재 수로 초기화 한다.
    • 구간의 개수가 m을 넘어가면 현재 중간값(mid)는 최적의 값이 아니기 때문에 False를 반환한다.
    • 모든 수를 탐색한 후, 구간의 개수가 m 이하면 True를 반환한다.
• 현재 중간값(mid)이 최적의 값(is_valid() == True)인 경우, 현재 중간값을 결과값(ans)에 저장하고 끝값(end)을 mid - 1로 변경한다.
  (현재 중간값으로 m개 이하의 수를 만드는 것이 가능해도, 그 이하에서 최적화된 수가 나올 수 있기 때문)
• 최적의 값이 아닌(is_valid() == False) 경우, 구간이 m개보다 많다는 뜻이기 때문에 시작값(start)을 mid + 1로 변경한다.

• 즉, is_valid()가 True라는 뜻은 현재의 중간값(mid)으로 m개 이하의 구간이 생기기 때문에, 중간값(mid)는 적정한 값이다.

• 이 중간값(mid) 중 최솟값을 구하는 것이 문제의 요구사항이다.

• 중간값(mid)을 줄이고 다시 구간나누기 실행

• is_valid()가 Flase라는 뜻은 현재의 중간값(mid)으로 m개 초과의 구간이 생기기 때문에, 중간값(mid)이 너무 작다는 뜻이다.

• 한 구간의 최댓값 - 최솟값의 마지노선이 작아 구간이 많이 생긴다.

• 중간값(mid) 증가

코드

# BOJ
# G4 - 13397(구간 나누기 2)

import sys
input = sys.stdin.readline    

n, m = map(int, input().split())
nums = list(map(int, input().split()))
start, end = 0, max(nums) - min(nums)
ans = 0

def is_valid(mid):
    min_num = max_num = nums[0]
    cnt = 1

    for num in nums:
        min_num = min(min_num, num)
        max_num = max(max_num, num)
        if max_num - min_num > mid:
            cnt += 1
            min_num = max_num = num
            if cnt > m:
                return False

    return True

while start <= end:
    mid = (start + end) // 2

    if is_valid(mid):
        ans = mid
        end = mid - 1
    else:
        start = mid + 1

print(ans)

파이썬으로 작업을 진행할 때, 외부 패키지를 잘 사용하는 것이 중요합니다. 파이썬은 다양한 기능들을 지원하는 패키지들이 많고, 이를 통해 원하는 비즈니스 로직에 집중할 수 있습니다. 패키지 관리를 하는 방법엔 무엇이 있는지 알아보도록 하겠습니다.

pip(Python Package Installer)

pip는 Python의 공식 패키지 관리 도구

• Python 2.7.9 및 3.4 이상에서 기본적으로 제공
• PyPI에서 패키지를 설치하고 관리

주요 기능

패키지 설치 pip install 명령어를 사용하여 PyPI에서 패키지를 설치합니다.

패키지 업데이트 pip install —upgrade 명령어를 사용하여 설치된 패키지를 최신 버전으로 업데이트합니다.

패키지 제거 pip uninstall 명령어를 사용하여 설치된 패키지를 제거합니다.

의존성 관리 pip freeze 명령어로 프로젝트에서 사용된 패키지들의 버전 정보를 requirements.txt 로 보내거나 해당 파일을 사용하여 의존성 설치를 합니다.

사용법

# 패키지 설치
$ pip install <PACKAGE_NAME>

# 특정 버전의 패키지 설치
$ pip install <PACKAGE_NAME>==<VERSION>

# 설치된 패키지 목록 보기
$ pip list

# 의존성 목록을 requirements.txt로 저장
$ pip freeze > requirements.txt

# requirements.txt에 있는 모든 패키지 설치
$ pip install -r requirements.txt

pip의 한계

의존성 충돌 해결

• pip는 종속성 버전 충돌을 해결하는데 어려움을 겪을 수 있습니다.
• 여러 패키지가 서로 다른 버전의 동일한 의존성을 요구하는 경우 충돌이 발생할 수 있습니다.

프로젝트 설정 관리 부족

• pip는 프로젝트별 가상 환경 관리나 프로젝트 설정을 명확히 하지 않음 이는 다른 패키지 관리 도구들이 해결하려는 문제

pdm(Python Development Master)

pdm은 pip의 기능을 확장하여 Python 패키지 관리 및 의존성 관리를 좀 더 효율적으로 해결하기위한 도구

• pdm은 PEP 518을 준수. PEP는 Python의 코딩 규약, 공식 문서
• pyproject.toml을 사용하여 프로젝트의 설정 및 의존성 관리를 통합적으로 처리

주요 기능

PEP 518 지원 pyproject.toml을 기반으로 의존성 및 설정 관리합니다.

빠른 의존성 해결 pip보다 더 빠르고, 효율적으로 의존성을 해결을 제공합니다.

의존성 그룹화 의존성을 default, dev, optional 그룹으로 나누어 관리합니다. → 개발 환경과 프로덕션 환경을 분리하는 데 유용합니다.

가상 환경 관리 프로젝트에 맞는 가상 환경을 자동으로 생성하고 관리할 수 있습니다.

단일 파일로 설정 관리 pyproject.toml 파일만 있으면 프로젝트 설정과 의존성 모두 관리 가능

사용법

# pdm 설치
$ pip install pdm

# 프로젝트 초기화 (pyproject.toml 파일 생성)
$ pdm init

# 패키지 설치
# 여러 개의 패키지를 공백을 주고 입력하면 한 번에 여러 개의 패키지 추가 가능
$ pdm add <PACKAGE_NAME>

# 개발용 의존성 추가
$ pdm add --dev <PACKAGE_NAME>

# 패키지 제거
$ pdm remove <PACKAGE_NAME>

# 의존성 설치
$ pdm install

# 의존성 목록 보기
$ pdm list

# 프로젝트의 의존성 내보내기 (requirements.txt 형식으로 보내기)
pdm export -f requirements > requirements.txt

pip와 pdm의 차이점

사용

pip 사용

• 프로젝트가 간단하고, 복잡한 의존성 해결이나 패키지 관리가 필요하지 않거나, pyproject.toml 과 같은 새로운 시스템에 익숙하지 않은 경우 사용해도 충분합니다.

pdm 사용

• pyproject.toml 기반의 의존성 관리와 가상 환경 관리가 필요하거나, 최신 표준을 따르려는 경우 사용하기 좋습니다.
• 빠르고 효율적인 의존성 해결, 다양한 의존성 그룹화 및 명확한 프로젝트 설정 관리를 원할 때 유용합니다.
• 대규모 프로젝트나 개발 환경과 프로덕션 환경을 분리하여 관리하고 싶은 경우 사용하기 좋습니다.

Key

키는 테이블 내에서 데이터를 구별하고 식별할 수 있는 역할을 하는 속성이다.

• 키는 데이터 무결성을 보장하고, 테이블 간의 관계를 정의하는 데 사용된다.
• 데이터베이스에서 키는 행 또는 데이터 항목을 고유하게 식별하는 데 중요한 역할을 한다.

키 설계에서 중요한 개념

유일성

유일성은 데이터베이스에서 키가 각 행(레코드)를 고유하게 식별할 수 있도록 보장하는 속성이다.

• 각 키 값은 테이블 내에서 유일해야 하며, 중복되지 않도록 해야 한다.
• 유일성이 보장되어야만 데이터 간에 혼동을 피할 수 있고, 정확한 조회가 가능하다.

최소성

최소성은 키를 구성하는 컬럼(속성)들이 불필요한 요소를 포함하지 않도록 해야 한다는 속성이다.

• 키를 구성하는 컬럼들 중 어떤 컬럼을 제외해도 여전히 유일성을 유지할 수 있으면, 해당 컬럼은 키에 포함될 필요가 없다.
• e.g. 학생을 구별할 때, [학생 번호, 이름, 수강 과목]의 컬럼이 있으면 [학생 번호]만으로 학생을 구별할 수 있으므로 이는 최소성을 만족하고, 키로 사용하는 것이 좋다.
• 최소성은 후보키의 중요한 속성으로, 후보키는 가능한 적은 수의 컬럼으로 데이터를 고유하게 식별할 수 있어야 한다. -> 키의 크기를 최소화해야 한다.

RDBMS에서 키를 사용하는 이유

• 데이터의 고유 식별 및 중복 방지
• 데이터 무결성 및 참조 무결성 보장
• 데이터 검색 성능 향상
• 테이블 간 관계 정의

키의 종류

• 기본키(Primary Key)
• 후보키(Candidate Key)
• 대체키(Alternate Key)
• 외래키(Foreign Key)
• 복합키(Composite Key)
• 수퍼키(Super Key)

기본키(Primary Key)

기본키는 테이블에서 각 행을 고유하게 식별하는 데 사용되는 키이다.

• 유일성과 최소성, Not-NULL을 보장한다.
  • NULL값을 가질 수 없다.
• 후보키 중에서 메인으로 선정되는 키이다.
• 행을 식별할 때 기준이 되는 반드시 필요한 키이다.

기본키를 위한 조건

1. 값의 변동이 잦지 않은 후보키여야 한다.
2. NULL값을 가질 수 있는 속성이 포함된 후보키가 아니어야 한다.
3. 후보키 중 단순한 키여야 한다.
4. 하나의 테이블에는 반드시 하나의 기본키만 존재한다.

예시

CREATE TABLE Student (
    id INT PRIMARY KEY, -- 기본키
    name VARCHAR(100),
    email VARCHAR(100),
    age INT
);

후보키(Candidate Key)

후보키는 테이블에서 각 행을 고유하게 식별할 수 있는 여러 키 후보이다.

• 유일성과 최소성을 보장한다.
• 기본키는 후보키 중에서 선택되며, 선택되지 않은 후보키는 대체키이다.

예시

CREATE TABLE Student (
    id INT PRIMARY KEY, -- 기본키
    name VARCHAR(100),
    email VARCHAR(100), -- 후보키(대체키)
    age INT
);

대체키(Alternate Key)

대체키는 기본키로 선택되지 않은 후보키이다.

• 유일성과 최소성을 보장한다.
• 예시는 위와 같다.

외래키(Foreign Key)

외래키는 다른 테이블의 기본키를 참조하여 두 테이블 간의 관계를 설정하는 키이다.

• 최소성을 보장한다.
  (외래키가 참조하는 부모 테이블의 기본키 또는 고유키(UNIQUE)는 유일성을 보장한다.)
• 외래키는 부모 테이블의 기본키나 고유키를 참조하므로, 최소성이 이미 보장된다.
• 외래키를 설정하지 않아도 되지만, 데이터 무결성 때문에 설정하는 경우가 많다.
• e.g. 아래의 예시에서 Student의 id를 변경시키는 경우, Student_Subject 테이블에 참조되어 있는 student_id가 함께 변경되어야 하기 때문이다.

예시

CREATE TABLE Subject (
    id INT PRIMARY KEY,
    name VARCHAR(100)
);

CREATE TABLE Student (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100),
    age INT
);

CREATE Student_Subject (
    student_id INT,
    subject_id INT,
    FOREIGN KEY (student_id) REFERENCES Student(id), -- 외래키
    FOREIGN KEY (subject_id) REFERENCES Subject(id), -- 외래키
    PRIMARY KEY (student_id, subject_id)
);

복합키(Composite Key)

복합키는 두 개 이상의 컬럼을 결합한 키이다.

• 유일성을 보장한다.
• 단일 컬럼으로는 데이터의 유일성을 보장할 수 없을 때, 컬럼들을 조합하여 사용한다.
• e.g. 아래의 예시에서 order_id와 product_id 모두 있어야 상품을 구분할 수 있으므로, 복합키로 만들어 고유한 행을 식별할 수 있도록 한다.

예시

CREATE TABLE OrderDetails (
    order_id INT,
    product_id INT,
    quanrity INT,
    PRIMARY KEY (order_id, product_id) -- 복합키
);

수퍼키(Super Key)

수퍼키는 테이블에서 한 개 이상의 컬럼을 포함하고, 그 조합이 각 행을 고유하게 식별할 수 있게 해주는 키이다.

• 유일성을 보장한다.
• 모든 후보키는 수퍼키이지만, 수퍼키는 불필요한 컬럼을 포함할 수 있다.
  (최소성을 보장하지 않는다.)
• 아래의 예시에서 id와 이름의 조합은 수퍼키로 사용할 수 있지만, id만으로도 유일성을 만족하므로 수퍼키이지만 후보키로 사용될 수 없다.

예시

CREATE TABLE Student (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    age INT,
    UNIQUE (id, name) -- 수퍼키
);

면접 대비 질문

Q 1)
기본키(Primary Key)와 복합 키(Composite Key)를 설명해보세요.

A 1)
기본키는 테이블에서 각 행을 고유하게 식별하는데 사용되는 키이며, 유일성과 최소성을 보장합니다.
테이블에는 기본키를 반드시 하나만 가지고 있어야 하며, NULL이거나 수정 및 업데이트가 불가능합니다.

복합키는 두 개 이상의 컬럼을 결합한 키이며, 유일성을 보장합니다.
단일 컬럼으로 유일성을 보장할 수 없는 경우, 두 개 이상의 컬럼을 결합하여 사용합니다.

• https://school.programmers.co.kr/learn/courses/30/lessons/150369

시간 복잡도

• n만큼의 반복 * m만큼의 왕복 횟수 -> $O(n \cdot m)$
• n의 최댓값은 100,000이고, m의 최댓값은 50(원소의 최댓값이 50이고 cap의 최솟값이 1이기 때문에 최대 50번 반복)이기 때문에 충분하다.

문제 접근법

• 최소 이동 거리를 위해서는 가장 먼 곳 부터 배달을 해야한다.
• 가장 먼 곳 부터 배달할 상자의 개수와 회수할 상자의 개수를 따로 계산한다.
  (현재 위치에 배달할 상자나 회수할 상자가 남아 있는 경우, 한 번 더 왕복해야 하기 때문에 이를 위해서 둘을 따로 둔다.)
• 현재 위치의 이전 위치에 있는 집들은 어짜피 경로에 있기 때문에 고려하지 않고 뒤에서부터 탐색한다.

1. 현재 배달할 상자의 개수와 수거할 상자의 개수를 저장할 변수를 초기화한다.
2. 가장 먼 집부터 탐색을 시작한다.
   2-1. 현재 위치에 배달할 상자의 개수를 1번에서 초기화한 변수에 더한다. 2-2. 현재 위치에서 회수할 상자의 개수를 1번에서 초기화한 변수에 더한다. 2-3. 두 변수가 0 이하가 될 때 까지 최대 개수인 cap을 빼고, 왕복한 거리를 총 이동 거리에 더한다.
   (한 번 왕복하면 cap만큼 상자를 배달하고 회수할 수 있기 때문에, 1 이상의 수가 남으면 한 번 더 왕복해야 하기 때문)
3. 총 이동 거리를 출력한다.

코드

# Programmers
# Lv.2 - 택배 배달과 수거하기

def solution(cap, n, deliveries, pickups):
    ans = 0
    delivery = 0
    pickup = 0

    for i in range(n - 1, -1, -1):
        delivery += deliveries[i]
        pickup += pickups[i]

        while (delivery > 0 or pickup > 0):
            delivery -= cap
            pickup -= cap
            ans += (i + 1) * 2

    return ans

• https://school.programmers.co.kr/learn/courses/30/lessons/172927

시간 복잡도

• dfs를 돌며 3번씩 k번 반복 -> $O(3^k)$
• k의 최댓값은 15이기 때문에 시간은 충분하다.
• 3^15 = 14,348,907

문제 접근법

1. 광물을 5개 단위로 배열에 담아 2차원 배열로 만든다.
2. 백트래킹을 통해 모든 경우의 수를 계산한다.
   2-1. 모든 광물을 캤거나 곡괭이를 다 쓴 경우, 최솟값을 비교하여 변경한다.
   2-2. 현재 캐야 할 광물들을 캘 때 필요한 피로도를 각 곡괭이마다 계산한다.
   2-3. 2-2에서 계산한 피로도를 더한 후, 사용한 곡괭이의 수를 줄이고 캐야 할 광물의 인덱스를 늘려 백트래킹을 계속 한다.

코드

# Programmers
# Lv.2 - 광물 캐기

d = {'diamond': [1, 5, 25], 'iron': [1, 1, 5], 'stone': [1, 1, 1]}
ans = 15 * 25 * 50

def calculate(pick, minerals):
    cnt = 0
    for mineral in minerals:
        cnt += d[mineral][pick]
    return cnt

def dfs(i, dia, iron, stone, minerals, total):
    if i == len(minerals) or (dia + iron + stone) == 0:
        global ans
        ans = min(ans, total)
        return

    if dia:
        dfs(i + 1, dia - 1, iron, stone, minerals, total + calculate(0, minerals[i]))
    if iron:
        dfs(i + 1, dia, iron - 1, stone, minerals, total + calculate(1, minerals[i]))
    if stone:
        dfs(i + 1, dia, iron, stone - 1, minerals, total + calculate(2, minerals[i]))

def solution(picks, minerals):
    minerals_sep = [minerals[i: i + 5] for i in range(0, len(minerals), 5)]
    dfs(0, picks[0], picks[1], picks[2], minerals_sep, 0)

    return ans

• https://school.programmers.co.kr/learn/courses/30/lessons/148653

시간 복잡도

• n만큼의 반복 -> $O(n)$

문제 접근법

• 자릿수 대로 탐색하며 다음과 같은 조건을 확인해야 한다.
  • 현재 자릿수가 5인가? -> -1을 5번 누르거나 +1을 5번 누르거나 횟수는 같지만, +1을 5번 누르면 다음 자릿수가 바뀌므로 확인해주어야 한다.

1. 층수를 각 자릿수마다 나누어 계산하기 위해 배열로 변환한다.
2. 자릿수를 뒤에서부터 차례대로 탐색한다. 2-1. 현재 자릿수가 5면서 다음 자릿수가 5미만이거나 현재 자릿수가 5 미만인 경우, 현재 자릿수를 총 버튼 수에 더한다.
   2-2. 아닌 경우, 10에서 현재 자릿수를 뺀 수를 총 버튼 수에 더하고, 다음 자릿수를 1 증가시킨다.
3. 탐색 범위에서 제외된 첫 자릿수는 6 이상이면 10에서 빼고 1을 더하고 아닌 경우 현재 자릿수를 총 버튼 수에 더한다.

코드

def solution(storey):
    storey = list(map(int, str(storey)))
    ans = 0

    for i in range(len(storey) - 1, 0, -1):
        if (storey[i] == 5 and storey[i - 1] < 5) or storey[i] < 5:
            ans += storey[i]
        else:
            ans += 10 - storey[i]
            storey[i - 1] += 1
    ans += 10 - storey[0] + 1 if storey[0] > 5 else storey[0]

    return ans

• https://school.programmers.co.kr/learn/courses/30/lessons/340212

시간 복잡도

• n만큼의 반복 + 이분탐색 범위(m) -> $O(n \log m)$
• n의 최대값은 300,000이고 m의 최대 범위는 100,000이기 때문에 시간은 충분하다.
• $\log 100,000$ 의 값은 약 17이다.

문제 접근법

• 이분탐색

1. diffs에서 가장 작은 값과 가장 큰 값을 각각 이분탐색의 시작, 끝 범위로 정한다.
2. 이분탐색을 시작한다.
   2-1. 중간값을 구한다. -> 현재 레벨
   2-2. 현재 레벨로 모든 퍼즐의 수행 시간을 나타낼 변수를 정의한다.
   2-3. 모든 퍼즐을 탐색한다.
   ㅤㅤ2-3-1. 이전 퍼즐 시간은 현재 퍼즐의 인덱스가 0인 경우는 0, 나머지는 현재 인덱스 이전의 시간으로 정한다.
   ㅤㅤ2-3-2. 문제의 조건에 맞게 현재 퍼즐과 현재 난이도에 맞는 수행 시간을 모두 더한다.
   2-4. 현재 모든 퍼즐의 수행 시간이 제한 시간보다 큰 경우, 현재 레벨을 정답으로 설정 후 이분탐색의 끝 범위를 중간값 - 1로 해준다.
   ㅤㅤ-> 최소 레벨을 구해야 하기 때문에, 제한 시간을 넘지 않으면 레벨을 점점 줄여나간다.
   2-5. 현재 모든 퍼즐의 수행 시간이 제한 시간보다 작은 경우, 이분탐색의 시작 범위를 중간값 + 1로 해준다.
3. 레벨을 출력한다.

코드

# Programmers
# Lv.2 - 퍼즐 게임 챌린지

def solution(diffs, times, limit):
    start, end = min(diffs), max(diffs)
    level = 0

    while start <= end:
        mid = (start + end) // 2
        total = 0

        for i in range(len(diffs)):
            time_prev = times[i - 1] if i else 0
            total += (diffs[i] - mid) * (times[i] + time_prev) + times[i] if diffs[i] > mid else times[i]

        if total <= limit:
            level = mid
            end = mid - 1
        else:
            start = mid + 1

    return level

• https://www.acmicpc.net/problem/20922

시간 복잡도

• n만큼 순회(r) + 최대 n만큼 순회(l) -> $O(n)$
• n의 최대값이 200,000이므로 충분하다.

문제 접근법

1. 현재 범위의 수를 카운트 하기 위한 딕셔너리를 정의한다.
2. 시작과 끝 숫자를 나타낼 두 변수를 정의한다.(초기엔 모두 0)
3. 끝 숫자가 n이 될 때 까지 순회한다.
   3-1. 끝 숫자의 개수가 k개 미만인 경우, 끝 숫자의 카운트를 증가시키고 현재 끝 숫자를 1 늘려준 후 시작부터 끝의 범위를 구한다. 3-2. 끝 숫자의 개수가 k개 이상인 경우, 시작 숫자의 카운트를 감소시키고 현재 시작 숫자를 1 늘려준다.
4. 3-1에서 구했 던 범위 중 가장 큰 범위를 출력한다.

코드

# BOJ
# S1 - 20922(겹치는 건 싫어)

import sys
from collections import defaultdict
input = sys.stdin.readline

n, k = map(int, input().split())
nums = list(map(int, input().split()))
cnt = defaultdict(int)
l, r = 0, 0
ans = 0

while r < n:
    if cnt[nums[r]] < k:
        cnt[nums[r]] += 1
        r += 1
        ans = max(ans, r - l)
    else:
        cnt[nums[l]] -= 1
        l += 1

print(ans)

• https://www.acmicpc.net/problem/2018

시간 복잡도

• 최대 n만큼의 반복 -> $O(n)$

문제 접근법

1. 시작과 끝 숫자를 나타낼 두 변수를 정의한다.(초기엔 모두 0)
2. 시작부터 끝까지의 합을 나타낼 변수를 정의한다.
3. 끝 숫자가 n에 다다를 때 까지 다음과 같은 과정을 반복한다.
   3-1. 총 합이 n보다 작다면, 끝 숫자를 1 증가시키고 합에 더한다.
   3-2. 총 합이 n보다 크다면, 시작 숫자를 합에서 빼고 시작 숫자를 1 증가시킨다.
   3-3. 총 합이 n과 같다면, 카운트를 1 증가시키고 끝 숫자도 1 증가시킨다.

코드

# BOJ
# S5 - 2018(수들의 합 5)

import sys
input = sys.stdin.readline

n = int(input())
l, r = 0, 0
total = 0
ans = 0

while r <= n:
    if total < n:
        r += 1
        total += r
    elif total > n:
        total -= l
        l += 1
    else:
        ans += 1
        r += 1
        total += r

print(ans)

이번 포스팅은 데이터베이스의 핵심 개념을 간단하게 정리한 글입니다.
해당 글은 DB, DBMS에 관한 개념과 특징만 다루고, 이와 함께 꼭 알아야 할 SQL, DB 자료구조(e.g. 인덱스) 등의 개념은 따로 작성 예정입니다.

DataBase

데이터베이스(DataBase, DB)란, 여러 사람에 의해 공유되어 사용될 목적으로 통합하여 관리되는 데이터의 집합이다.

논리적으로 연관된 하나 이상의 데이터의 집합으로, 이를 고도로 구조화하여 검색 및 갱신의 효율을 높인다.
특정 다수의 이용자들에게 필요한 정보를 제공하거나, 특정 조직 내에서 필요로 하는 정보를 체계적으로 축적하고 제공한다.
데이터베이스는 데이터의 구조와 특성에 따라 매우 단순하거나 복잡할 수 있다.
DBMS를 통해서 관리된다.

데이터(화물)은 데이터베이스(창고)에 저장되고, DBMS(관리자)는 화물을 창고에 적재하거나 창고에서 이용자로 보내주는 등의 역할을 한다.

DB의 특징

• 동시 공유: 다수의 사용자가 동시에 같은 내용의 데이터를 이용할 수 있어야 한다.
• 계속적인 변화: 새로운 데이터의 삽입, 삭제, 갱신으로 항상 최신의 데이터를 유지해야 한다.
• 실시간 접근성: 데이터베이스는 사용자의 요청에 즉시 처리하고 응답해야 한다.
• 내용에 의한 참조: 데이터베이스에 있는 데이터를 참조할 때, 사용자가 요구하는 데이터 내용으로 찾아야 한다.

DBMS

DBMS(DataBase Management System)란, 데이터베이스를 관리하고 운영하는 소프트웨어이다.

데이터를 파일 단위로 직접 관리하면, 적은 수는 무리 없이 사용할 수 있다.
하지만, 데이터 수가 증가하여 관리해야 할 파일이 늘어나면 한계에 부딪힌다.
따라서, DBMS를 활용하여 데이터를 데이터베이스로 정리하여 효율적으로 데이터를 통제하고 관리할 수 있다.

DBMS는 데이터를 저장, 검색, 수정, 삭제하는 작업을 효율적으로 처리한다.

DBMS의 기능

• 중복 제어: 동일한 데이터가 여러 위치에 중복 저장되는 현상을 방지한다.
• 접근 통제: 사용자마다 다양한 권한을 부여하고, 권한에 따라 데이터에 대한 접근을 제어한다.
• 인터페이스 제공: 사용자에게 SQL 및 GUI, CLI 등 다양한 인터페이스를 제공한다.
• 관계 표현: 서로 다른 데이터간의 다양한 관계를 표현할 수 있는 기능을 제공한다.
• 무결성 제약 조건: 무결성에 관한 제약 조건을 정의/검사하는 기능을 제공한다.
• (데이터베이스는 반드시 무결성 제약 조건을 통과한 데이터만을 저장해야 한다.)*
  (NoSQL의 경우, 제한적으로 중복 제어나 무결성이 무시되기도 한다.)

DBMS의 종류

DBMS는 데이터를 관리하는 모든 시스템의 큰 틀이고, 유형에는 대표적으로 관계형 DBMS인 RDBMS, 비관계형 DBMS인 NoSQL이 있다.

RDBMS

데이터를 테이블 형식으로 저장하고, 테이블 간 관계를 기반으로 데이터를 관리한다.
외래 키를 사용하여 테이블 간 join을 통해 여러 테이블의 데이터를 결합하여 가져올 수 있다.
ACID 원칙을 준수한다.

Atomicity(원자성): 트랜잭션은 모두 수행되거나 전혀 수행되지 않아야 한다.
Consistency(일관성): 트랜잭션이 완료되면 데이터베이스는 일관된 상태를 유지해야 한다.
Isolation(격리성): 동시에 실행되는 트랜잭션은 서로 간섭하지 않아야 한다.
Durability(지속성): 트랜잭션 완료 후 데이터는 영구적으로 저장되어야 한다.

MySQL, PostgreSQL, Oracle 등이 RDBMS에 해당한다.

장점

• 정해진 스키마에 따라 데이터를 저장하여 명확한 데이터 구조를 보장한다.
• 데이터 정합성* -> 데이터들의 값이 서로 일치하는 상태
• 데이터를 중복 없이 한 번만 저장한다.
• 데이터 무결성* -> 데이터가 처리되는 모든 과정에서 변경되거나 손상되지 않고 완전성, 정확성, 일관성을 유지하는 특성

단점

• 시스템이 커질수록 join이 많아져 쿼리가 복잡해진다.
• 성능 향상을 위한 Scale-up만 지원한다.

• Scale-out이 불가능하고, 비용이 기하급수적으로 커질 수 있다.

• 스키마로 인해 데이터가 유연하지 않다.

• 스키마가 변경될 경우 번거로워진다.

사용하는 경우

• 데이터 구조가 명확하고 변경될 여지가 없으며, 스키마가 중요한 경우에 사용한다.
• 중복된 데이터가 없기 때문에, 관계를 맺고 있는 데이터가 자주 변경이 이루어지는 시스템에 적합하다.

NoSQL

빅데이터의 등장으로 인해 데이터와 트래픽이 엄청나게 증가함에 따라 등장했다.
-> RDBMS는 빅데이터를 처리하기 위해 장비 업그레이드(Scale-up)을 하고 비용이 많이 든다.
NoSQL은 이런 RDBMS의 단점을 극복하고 데이터의 분산 저장(Scale-out)을 목표로 한다.

데이터를 문서, 키-값, 그래프 등 다양한 형식으로 데이터를 관리한다.

장점

• 스키마가 없어 유연하고 자유로운 데이터 구조를 가지고 있다.

• 데이터 조정과 새로운 필드 추가가 자유롭다.

• 성능 향상을 위해 Scale-up/Scale-out이 모두 가능하다.

• 데이터 분산이 용이하고, RDBMS에 비해 대용량의 데이터를 저장할 수 있다.

단점

• 데이터 정합성을 보장하지 않기 때문에, 데이터 구조를 결정하기 어려울 수 있다.
• 데이터의 중복이 발생 가능하며, 중복된 데이터가 변경될 경우 모든 컬렉션에서 수정해야 한다.

사용하는 경우

• 정확한 데이터 구조를 알 수 없고 데이터가 변경/확장될 수 있는 경우에 사용한다.
• 데이터의 수정이 많이 이루어지지 않는 시스템에 적합하다.
• 데이터를 분산해서 저장(Scale-out)해야 할 만큼 대용량의 데이터를 저장하는 경우에 적합하다.

두 유형의 주요 차이

면접 대비 질문

Q 1)
DB의 특징은?

A 1)
동계실내(동시 공유, 계속적인 변화, 실시간 접근성, 내용에 의한 참조)

• 동시 공유: 다수의 사용자가 같은 데이터를 동시에 이용할 수 있어야 한다.
• 계속적인 변화: 새로운 데이터의 삽입, 삭제, 갱신으로 항상 최신의 상태를 유지해야 한다.
• 실시간 접근성: 데이터베이스는 사용자의 요청에 즉시 처리하고 응답해야 한다.
• 내용에 의한 참조: 데이터베이스에 있는 데이터에 참조할 때, 사용자가 요구하는 데이터 내용으로 찾아야 한다.

Q 2)
DBMS란?

A 2)
데이터베이스를 관리하는 시스템으로, 사용자가 효율적으로 데이터베이스에 데이터를 저장, 검색, 수정, 삭제할 수 있도록 해준다.

Q 3)
RDBMS와 NoSQL의 차이점은?

A 3)
RDBMS는 고정된 스키마와 중복 없는 데이터로 정합성과 무결성을 보장하고, Scale-up만 지원한다.
NoSQL은 유연한 스키마와 중복 허용으로 확장성에 강하며, Scale-out 또한 지원한다.

Q 4)
트랜잭션의 ACID 원칙이란?

A 4)

• Atomicity(원자성): 트랜잭션은 모두 수행되거나 전혀 수행되지 않아야 한다.
• Consistency(일관성): 트랜잭션이 완료되면 데이터베이스는 일관된 상태를 유지해야 한다.
• Isolation(격리성): 동시에 실행되는 트랜잭션은 서로 간섭하지 않아야 한다.
• Durability(지속성): 트랜잭션 완료 후 데이터는 영구적으로 저장되어야 한다.

참조

• https://aws.amazon.com/ko/what-is/database/#:~:text=%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4%EB%8A%94%20%EC%A0%84%EC%9E%90%EC%A0%81%EC%9C%BC%EB%A1%9C%20%EC%A0%80%EC%9E%A5,%EB%B0%8F%20%ED%8E%B8%EC%A7%91%ED%95%A0%20%EC%88%98%20%EC%9E%88%EC%8A%B5%EB%8B%88%EB%8B%A4.
• https://namu.wiki/w/%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4
• https://hongong.hanbit.co.kr/%EB%8D%B0%EC%9D%B4%ED%84%B0%EB%B2%A0%EC%9D%B4%EC%8A%A4-%EC%9D%B4%ED%95%B4%ED%95%98%EA%B8%B0-databasedb-dbms-sql%EC%9D%98-%EA%B0%9C%EB%85%90/

• https://www.acmicpc.net/problem/21921

시간 복잡도

• 최대 n만큼의 반복 -> $O(n)$
• n의 최대값이 250,000 이므로 충분하다.

문제 접근법

1. 입력 받은 방문자들의 총 합이 0이라면 바로 SAD를 출력하고 종료한다.
2. 처음부터 x번째 까지 방문자의 합을 구한다.
3. 딕셔너리를 정의하고 2번에서 구한 합을 key로 하여 value를 1로 설정한다. (value는 개수)
4. 1번 인덱스부터 x명씩 윈도우 슬라이딩을 한다.
   4-1. 2번에서 구한 합으로부터 시작하여, 왼쪽에 있는 방문자를 빼고 오른쪽에 있는 방문자를 더한다.
   4-2. 4-1에서 계산한 값을 딕셔너리의 key로 하여 value를 1씩 추가한다.
5. 딕셔너리에서 가장 큰 key를 구한다.(합이 가장 큰 경우)
6. 해당 key와 value를 출력한다.

코드

# BOJ
# S3 - 21921(블로그)

import sys
from collections import defaultdict
input = sys.stdin.readline

n, x = map(int, input().split())
visitors = list(map(int, input().split()))

if sum(visitors) == 0:
    print("SAD")
else:
    total = sum(visitors[:x])
    results = defaultdict(int)
    results[total] += 1

    for i in range(1, n - x + 1):
        total = total - visitors[i - 1] + visitors[i + x - 1]
        results[total] += 1

    max_visitors = max(results)

    print(max_visitors)
    print(results[max_visitors])

• https://www.acmicpc.net/problem/20440

시간 복잡도

• n만큼의 반복 + 최대 n만큼의 탐색 + 최대 n크기로 정렬 -> $O(n)$

문제 접근법

• 접근 방법이 안떠올라서 구글링 -> 참조1, 참조2

1. 딕셔너리에 모기의 입퇴장 시간을 기록한다. -> 입장 시간: +1, 퇴장 시간: -1
2. 가장 많은 시간의 모기 수, 현재의 모기 수, 답이 될 입퇴장 시간을 초기화한다.
3. 정확한 정답을 위한 flag를 초기화한다. -> flag가 없는 경우, 퇴장 시간이 뒤로 밀릴 수 있다.
   (최대치로 증가했다 감소하는 패턴이 반복되면, 퇴장시간이 마지막 패턴의 감소하는 시간이 될 수 있기 때문)
4. 딕셔너리를정렬하여 가장 처음부터 탐색한다.
   4-1. 현재 모기 수에 현재 키에 해당하는 값(현재 시간의 모기 수)을 더한다.
   4-2. 현재 모기 수가 가장 많은 시간의 모기 수보다 크다면 갱신을 해준 후, 입장 시간을 현재 시간으로 설정하고 flag를 True로 체크해준다.
   4-3. 현재 모기 수가 가장 많은 시간의 모기 수보다 작으면서 flag가 True면, 퇴장 시간을 현재 시간으로 설정하고 flag를 False로 체크해준다.

정리

• 모기의 정보가 들어있는 시간만을 차례대로 탐색하면서, 모기의 수가 최대가 되는 시간을 입장 시간으로 갱신하고 최대치에서 감소하는 시간을 퇴장 시간으로 갱신한다.
• 같은 패턴이 여러 번 반복되어도 가장 빠른 시간대의 구간만을 출력해야 하기 때문에 flag가 필요하다.

코드

# BOJ
# G3 - 20440(🎵니가 싫어 싫어 너무 싫어 싫어 오지 마 내게 찝쩍대지마🎵 - 1)

import sys
from collections import defaultdict
input = sys.stdin.readline

n = int(input())
d = defaultdict(int)

for _ in range(n):
    s, e = map(int, input().split())
    d[s] += 1
    d[e] -= 1

max_mos, now_mos = 0, 0
tem, txm = 0, 0
flag = False

for i in sorted(d.keys()):
    now_mos += d[i]
    if now_mos > max_mos:
        max_mos = now_mos
        tem = i
        flag = True
    elif now_mos < max_mos and flag:
        txm = i
        flag = False

print(max_mos)
print(tem, txm)

• https://www.acmicpc.net/problem/15724

시간 복잡도

• n * m만큼 반복 + k만큼 반복 -> $O(nm + k)$
• n, m의 최대값은 1024, k는 10만이기 때문에 충분하다.

문제 접근법

• 접근 방법이 안떠올라서 구글링 -> 참조1, 참조2
• 푸는 방법 자체는 2차원 배열의 구간합이다.

1. 2차원 배열의 누적합을 구하기 위해선, 다음과 같은 공식을 통해 각 열마다 누적합을 구해준다. $dp[i][j] = area[i-1][j-1] + dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1]$
2. k만큼 반복하며 좌표 입력을 받는다.
3. 2차원 배열의 구간합을 구하기 위해선, 다음과 같은 공식을 통해 원하는 구간의 합을 구해준다. $dp[i][j] - dp[x-1][j] - dp[i][y-1] + dp[x-1][y-1]$

코드

# BOJ
# S1 - 15724(주지수)

import sys
input = sys.stdin.readline

n, m = map(int, input().split())
people = [list(map(int, input().split())) for _ in range(n)]
dp = [[0] * (m + 1) for _ in range(n + 1)]

for i in range(1, n + 1):
    for j in range(1, m + 1):
        dp[i][j] = people[i - 1][j - 1] + dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1]

for _ in range(int(input())):
    x1, y1, x2, y2 = map(int, input().split())
    print(dp[x2][y2] - dp[x1 - 1][y2] - dp[x2][y1 - 1] + dp[x1 - 1][y1 - 1])

• https://www.acmicpc.net/problem/2851

시간 복잡도

• 최대 n만큼의 반복문을 탐색하기 때문에, $O(n)$.
• n의 최대 값은 10이기 때문에, 제한시간 조건에 충분히 부합한다.

문제 접근법

1. 10개의 버섯을 차례대로 탐색한다.
2. 탐색하면서 현재 버섯의 점수를 계속 더한다.
3. 점수가 100일 경우, 즉시 반복문을 종료한다.
4. 점수가 100보다 큰 경우, 처음부터 현재 점수까지 더한 값과 이전 점수까지만 더한 값을 비교한다. 4-1. 현재 점수까지 더한 값이 이전 점수까지만 더한 값보다 100과의 차이가 큰 경우, 이전 점수까지만 더한 값을 반환하고 출력한다.

코드

# BOJ
# B1 - 2851(슈퍼마리오)

def getABS(n):
    return abs(100 - n)

def solution(mushrooms) -> int:
    ans = 0

    for mushroom in mushrooms:
        ans += mushroom

        if ans == 100:
            break
        if ans > 100 and getABS(ans) > getABS(ans - mushroom):
            ans -= mushroom
            break

    return ans

mushrooms = [int(input()) for _ in range(10)]
result = solution(mushrooms)

print(result)

서버 관련은 초짜라 로컬에서 계속 127.0.0.1, localhost 입력하면서 왜 안되지?? 만 수도 없이 내뱉으며 삽질했습니다ㅠ

FastAPI로 서버 열기

FastAPI 공식 문서

FastAPI란? FastAPI는 현대적이고, 빠르며(고성능), 파이썬 표준 타입 힌트에 기초한 Python의 API를 빌드하기 위한 웹 프레임워크입니다. - 공식 문서 -

FastAPI는 Django, Flask와 같은 파이썬 프레임워크입니다. 빠르고, 쉽고, API에 최적화 되어있기 때문에 급상승 중인 웹 애플리케이션 프레임워크라고 합니다.

FastAPI의 특징

• 빠른 성능

  FastAPI는 비동기 처리와 빠른 성능을 자랑합니다. 다른 Python 프레임워크에 비해 성능이 뛰어나며, Google의 gRPC나 Node.js와 같은 빠른 프레임워크와 비슷한 속도를 보여줍니다.

• 자동화된 API 문서화

  API를 자동으로 문서화해줍니다. 기본적으로 Swagger UI와 ReDoc을 제공하여 API를 쉽게 테스트하고 문서화할 수 있습니다. OpenAPI 표준을 기반으로 한 문서화가 자동으로 생성됩니다.

• 타이핑 지원

  타이핑 힌트를 통해 코드의 가독성과 안정성을 높이고, 자동으로 입력 값 검증을 할 수 있습니다. 예를 들어, 요청 파라미터나 바디의 데이터 타입을 명확하게 정의할 수 있습니다.

• 비동기 프로그래밍 지원

  async/await 구문을 사용하여 비동기 요청을 처리할 수 있습니다. 이를 통해 더 많은 동시 요청을 처리할 수 있게 되어 성능이 높아집니다.

• 데이터 검증

  Pydantic을 사용하여 요청받은 데이터를 자동으로 검증합니다. 예를 들어, 클라이언트가 전송한 JSON 데이터를 Python 객체로 자동 변환하고, 타입 검사 및 유효성 검사도 수행됩니다.

• 편리한 개발

  코드 작성 시 바로 자동으로 문서화되고, 디버깅 시 오류 메시지와 타이핑 정보를 잘 제공합니다. 이로 인해 개발자가 오류를 빠르게 찾고 수정할 수 있습니다.

이 외에도, 공식 문서가 아주 잘 되어있다는 장점 또한 있습니다.

이 포스팅은 해당 공식 문서에서 설명하는 과정 중 서버를 여는 과정까지만 진행했습니다.

서버 세팅 과정

1. 파이썬 설치

FastAPI가 파이썬 프레임워크이기 때문에, 파이썬을 먼저 리눅스에 설치해주어야 합니다. 한 줄이면 금방 끝납니다.

sudo apt install python3

2. venv 설치

venv는 Virtual Environment의 약자로, UTM과 같은 가상환경입니다. venv를 통해 여러 개의 파이썬 패키지를 독립적으로 관리할 수 있는 것이죠. 즉, 로컬(맥) 위에 가상환경(리눅스 기반) 위에 가상환경(파이썬 패키지)처럼 실행되는 것입니다. 이것도 한 줄이면 금방 끝납니다.

sudo apt install python3-venv

3. 파이썬 가상환경 생성

파이썬 가상환경을 만들어줍니다. 가장 뒤에 있는 문자가 가상환경 이름입니다. 해당 명령어를 통해 venv라는 이름의 파이썬 가상환경을 생성하는 것이죠.

python3 -m venv venv

이후 ls를 입력하면 venv 라는 폴더가 새로 생겨있습니다. 생성할 때 정한 이름으로 폴더가 생성됩니다.

4. 파이썬 가상환경 활성화

가장 앞의 venv는 생성한 가상환경 폴더입니다. 해당 명령어를 통해 활성화시켜줍니다.

source ./venv/bin/activate

활성화 시키면 다음 사진과 같이 입력 줄의 가장 앞에 가상환경의 이름이 붙습니다.

비활성화를 위해선 단어 하나만 입력해주면 됩니다.

deactivate

5. FastAPI 설치

이제 파이썬 기반의 환경이므로, pip를 통해 나머지를 설치해주도록 합시다. 해당 과정 부터는 FastAPI 공식 사이트에서 그대로 따라하실 수 있습니다.

pip install fastapi

6. uvicorn 설치

FastAPI에서 필수적으로 사용되는 uvicorn을 설치합니다. uvicorn에 대한 내용은 해당 블로그에서 확인하실 수 있습니다.

그냥 pip install uvicorn을 해도 되지만, 최소한의 파일로 작동할 수 있게 하기 위해 다음과 같이 합니다.

pip install "uvicorn[standard]"

7. main.py 생성

서버를 실행시키기 위한 파이썬 파일을 생성합니다. 해당 명령어를 통해 파일을 생성하시면 됩니다.

vi main.py

main.py에는 다음과 같은 내용을 입력하고 저장합니다.

from fastapi import FastAPI # fastapi 클래스를 불러옵니다. 

app = FastAPI() # FastAPI 클래스를 바탕으로 app이란 인스턴스를 만듭니다. 

@app.get("/") # GET 메소드로 가장 루트 url로 접속할 경우
async def root(): # root() 함수를 실행하고
    return {"message": "Hello World"} # Hello World란 메시지를 반환합니다.

8. 서버 실행

해당 명령어를 통해 서버를 실행합니다.

main: main.py 파일 app: main.py에서 생성한 FastAPI 객체 --reload: 코드가 변경된 후 서버 재시작(개발 환경에서만 사용)

uvicorn main:app --reload

해당 코드를 실행하면 다음과 같은 내용이 나옵니다.

그럼 이제 주소창에 127.0.0.1:8000을 넣으면 {"message" :"Hello World"} 와 같은 내용이 출력되겠..

지 라는 생각을 하면 당연히 안됩니다!! (로컬-로컬, VM-VM(동일)은 일반적으로 됩니다.) 로컬호스트에 대한 개념을 몰라서 이거 해결하느라 몇시간 삽질한거였습니다..

(IP는 대충 예시로 다르다는 것을 표현하였습니다.) 로컬과 가상환경은 다른 IP 주소를 가지고 있기 때문에, localhost나 127.0.0.1로는 접속할 수 없습니다.

해당 과정을 해결하기 위해 해당 블로그와 GPT의 힘을 빌려 해결하였습니다.

결론은 가상환경의 IP와 로컬의 IP가 다르기 때문에 로컬호스트로는 접속이 불가능한 것이었고, 이를 위해 가상환경에서 네트워크 세팅을 하여 외부에서도 접속이 가능하도록 만들어 주어야 했습니다.

해당 블로그의 해결과정과 조금 다른 점은 yaml 파일의 이름이었습니다. 저는 50-cloud-init.yaml 이라는 파일이었어요. ls /etc/netplan 명령어를 통해 파일 이름을 확인하고 수정해야 합니다!

변경 사항을 모두 적용했다면 다음과 같은 명령어로 서버를 열어주셔야 합니다. 0.0.0.0을 주소창에 치는 것이 아닌, 설정해준 고정 IP를 입력하셔야 합니다!! (이것도 모르고 0.0.0.0:8000 입력하면서 또 삽질 계속했습니다.)

uvicorn main:app -reload --host 0.0.0.0 -- port 8000

결과적으로 다음과 같이 실행되며 정상적으로 로컬에서 가상환경의 서버로 접속이 성공했습니다!

• 로컬 웹페이지

• 가상환경 리눅스

• 생성된 API 문서(Swagger UI) 주소창 포트번호 뒤에 /docs를 추가하면 나오는 페이지입니다.

마치며

정말 오랜만에 만져보는 리눅스였고, 서버 열기였습니다. 시간이 오래 지난 것도 있지만, 전공 수업을 열심히 듣고 기억했더라면 좀 더 빠르고 쉽게 하지 않았을까 싶네요.. 과거를 반성하고 오늘의 삽질을 발판 삼아 열심히 공부해야겠습니다!!

참조

https://typingdog.tistory.com/106

https://velog.io/@chosj1526/UTM-ubuntu-%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC-%EC%B6%94%EA%B0%80-%EB%B0%8F-%EA%B3%A0%EC%A0%95-ip-%ED%95%A0%EB%8B%B9%ED%95%98%EA%B8%B0

https://blog.iamwhatiam.co.kr/215

https://devocean.sk.com/blog/techBoardDetail.do?ID=165922&boardType=techBlog

https://www.hanbit.co.kr/channel/category/category_view.html?cms_code=CMS5997817104

https://wikidocs.net/162345

들어가기에 앞서, 리눅스 환경에서 개발을 원하시는 경우 세팅하는 방법이 여러가지가 있습니다.

첫 번째는, 가상환경(UTM, VirtualBox 등)에 Ubuntu 직접 설치가 있습니다. 제가 이 방법으로 설치하였습니다.

두 번째는, 브라우저에서 손쉽게 가상환경을 실행하는 것입니다. groomide의 대쉬보드, AWS의 Cloud9, GDP의 Cloud Engine 등과 같이 브라우저에서 리눅스를 이용하는 것입니다. 해당 방법은 구글링을 하면 금방 따라하실 수 있습니다.

제 OS는 작성일 기준으로 다음과 같습니다.

기종: MacBook Pro 14 칩: Apple M3 Pro 메모리: 18GB macOS: Sonoma 14.4.1

설치하려고 하는 Ubuntu는 Desktop용이 아닌 Server용입니다. GUI(Graphic User Interface)가 아닌 CLI(Command Line Interface)로 리눅스를 사용해보려 합니다. 무슨 차이냐면, 터미널과 같이 아이콘 클릭이 아닌 커맨드 입력으로 모든 작업을 진행할 계획입니다. (관련 직종 현업자 분들이 이와 같은 과정을 추천해주셨습니다.)

가상환경(UTM) 및 Ubuntu 설치 과정은 해당 블로그 를 보고 3번 과정, Ubuntu Desktop의 전까지만 따라했습니다. CLI로 공부를 할 것이라면 이후부터 필요하지 않습니다!

여기서 주의해야 할 점은 다음과 같습니다.

애플 실리콘 기반이기 때문에, Ubuntu Server for ARM 을 다운받으셔야 합니다. 그렇지 않으면 가상 환경에서 다음 사진과 같은 에러가 발생하게 됩니다. 다운 링크: Ubuntu Server for ARM

설치 과정 블로그에선 UTM을 깃허브에서 설치하고 있지만, 사이트에서 직접 설치하셔도 됩니다. 다운 링크: UTM

세팅이 끝나면 다음과 같이 맥의 터미널처럼 명령어들을 입력할 수 있습니다!

이 이후로는 리눅스 명령어 공부, 파이썬 설치 및 환경 세팅, 파이썬 서버 실행하기 등등을 해보려고 합니다!

지난 포스팅 Class vs Struct (1)

Class의 메모리 관리는 힙 영역에서 ARC에 의해 이루어지고, Struct의 메모리 관리는 스택 영역에서 LIFO 방식으로 알아서 된다고 알고 있습니다.

ARC에 대한 자세한 내용은 길기 때문에 ARC에 대한 포스팅을 따로 하고, 이번 포스팅에서는 참조 카운트 계산과 메모리 영역에서 어떻게 이루어지는지 간단하게 시각화하여 나타낼 예정입니다. 또한, 클래스 프로퍼티를 가지고 있는 클래스와 구조체를 비교하여 참조가 어떻게 이루어지는지도 알아볼 예정입니다.

먼저, 지난 포스팅에서 설명했던 클래스는 참조 타입이고 구조체는 값 타입이라고 했었습니다. 이를 비교하기 위한 아주 기본적인(다들 알고 계신) 코드는 이렇습니다.

• 주소값 출력 함수

func address(_ object: AnyObject) {
    print(Unmanaged.passUnretained(object).toOpaque())
}

값 타입 vs 참조 타입

Class

• 클래스 생성

class ExamplaryClass {
    var a: Int

    init(a: Int) {
        self.a = a
    }

    func updateA(_ a: Int) {
        self.a = a
    }
}

let exampleClass = ExamplaryClass(a: 10)
let reference = exampleClass

• 참조 확인

print(exampleClass.a) // 10
print(reference.a) // 10

두 값 모두 10이 출력됩니다.

exampleClass.updateA(20)

print(exampleClass.a) // 20
print(reference.a) // 20

exampleClass의 a를 20으로 업데이트하면, 두 값 모두 20이 출력됩니다. reference는 exampleClass와 같은 클래스 인스턴스에 대한 참조를 가지고 있기 때문입니다.

reference.updateA(30)

print(exampleClass.a) // 30
print(reference.a) // 30

반대로 reference의 a를 30으로 업데이트해도 두 값 모두 30이 출력됩니다.

address(exampleClass) // 0x0000600001801000
address(reference) // 0x0000600001801000

둘의 참조된 주소값을 확인하면 동일하게 나옵니다. 이것이 참조 타입인 클래스의 특징입니다.

메모리에선 최종적으로 다음과 같이 할당되어 있습니다.

Struct

• 구조체 생성

struct ExamplaryStruct {
    var a: Int

    mutating func updateA(_ a: Int) {
        self.a = a
    }
}

var exampleStruct = ExamplaryStruct(a: 10)
var copy = exampleStruct

클래스와 다른 점이 두 가지가 있습니다. 첫 번째는 updateA() 메서드의 앞에 붙은 mutating 키워드 입니다. Swift에서 값 타입은 기본적으로 내부에서 인스턴스를 변경할 수 없기 때문에, mutating 키워드를 통해 변경할 수 있도록 해주어야 합니다.

두 번째는 let이 아닌 var 입니다. 클래스는 참조 타입이므로, let으로 선언해도 인스턴스의 내부 프로퍼티를 변경할 수 있습니다. (프로퍼티가 var인 경우) let은 인스턴스에 대한 참조가 변하지 않는다는 표현일 뿐, 인스턴스의 프로퍼티는 수정할 수 있다는 것을 의미합니다. 반면에 구조체는 값 타입이므로, let으로 선언하면 인스턴스 뿐만 아니라 내부 프로퍼티도 모두 수정할 수 없습니다.

exampleStruct.updateA(20)

print(exampleStruct.a) // 20
print(copy.a) // 10

exampleStruct의 a값을 20으로 변경하면, exampleStruct의 a만 변경됩니다. 구조체는 클래스와 다르게 값 타입이므로, copy는 exampleStruct와 동일한 인스턴스를 가리키는 참조 값이 아닌 새로운 복사본이기 때문입니다.

copy.updateA(30)

print(exampleStruct.a) // 20
print(copy.a) // 30

copy의 a값을 변경하면, 위와 같은 이유로 copy의 a값만 변경됩니다.

address(exampleStruct) // Error
address(copy) // Error

구조체는 클래스와 다르게 값 타입이기 때문에, 특정 인스턴스를 가리키는 참조(포인터)가 없어 해당 코드를 실행할 수 없습니다. 그렇기 때문에 뒤에 나올 CFGetRetainCount() 또한 실행할 수 없습니다.

메모리에선 최종적으로 다음과 같이 할당되어 있습니다.

참조 카운트

ARC가 힙 영역에서 참조 카운트를 계산해서 카운트가 0이 되면 인스턴스를 메모리 상에서 해제합니다. 코드와 함께 참조 카운트가 어떻게 계산되는지 알아보도록 하겠습니다.

참조 카운트를 확인하기 위해서는 CFGetRetainCount() 라는 함수를 사용해주면 됩니다.

해당 함수에 대한 정의는 공식문서에서 다음과 같이 나와있습니다.

Core Foundation 객체의 참조 카운트를 반환합니다.

특정 객체의 현재 참조 카운트가 몇인지 나타내줍니다. 하지만, 클래스 하나를 생성하고 바로 참조 카운트를 해당 함수를 통해 출력하면 2가 나옵니다. 함수 호출 시, 일시적으로 1이 증가하여 출력되어서 그런 것 같습니다.

클래스가 아닌 구조체는 힙 영역에 존재하지 않기 때문에 사용할 수 없습니다.

• 클래스 생성

class AClass {
    var bClass: BClass? = nil

    init() {
        print("AClass 메모리 할당")
    }

    deinit {
        print("AClass 메모리 해제")
    }
}

class BClass {
    var aClass: AClass? = nil

    init() {
        print("BClass 메모리 할당")
    }

    deinit {
        print("BClass 메모리 해제")
    }
}

var a: AClass? = AClass() // AClass 메모리 할당
var b: BClass? = BClass() // BClass 메모리 할당

생성자를 통해 메모리 할당 시점을 출력하도록 했기 때문에, a와 b를 생성하면 각 클래스의 생성자가 호출됩니다.

• 참조 카운트 확인

print(CFGetRetainCount(a)) // 2
print(CFGetRetainCount(b)) // 2

위에서 설명했듯이, AClass는 a, BClass는 b가 각각 하나씩 참조하고 있어 참조 카운트가 1입니다. CFGetRetainCount()를 통해 호출했기 때문에 2로 출력됩니다.

• 메모리 주소 확인

address(a!) // 0x00006000023100c0
address(b!) // 0x00006000023106a0

현재 시점의 메모리 할당을 시각적으로 표현하면 이런 식으로 되어있겠네요.

그럼 각 클래스의 프로퍼티에 다음과 같이 서로의 클래스를 넣어주면 어떻게 될까요?

a?.bClass = b
b?.aClass = a

print(CFGetRetainCount(a)) // 3
print(CFGetRetainCount(b)) // 3

각각 3이 출력됩니다. 기존의 참조 카운트 값에서 서로를 힙 영역에서 다시 참조하기 때문에 1씩 증가합니다.

address(a!.bClass!) // 0x00006000023106a0
address(b!.aClass!) // 0x00006000023100c0

메모리 주소를 보면 서로를 참조하고 있는 것을 알 수 있습니다.

다음과 같이 말이죠.

a = nil
b = nil

print(CFGetRetainCount(a)) // Error
print(CFGetRetainCount(b)) // Error

a와 b를 메모리 상에서 해제하였기 때문에 CFGetRetainCount()를 해주면 포인터가 존재하지 않아 에러가 발생합니다.

또한, 이 상태에서 a와 b를 nil로 하여 메모리 해제를 시켜주려 해도 완전히 해제되지 않습니다. AClass의 bClass는 BClass를, BClass의 aClass는 AClass를 아직 참조하고 있기 때문입니다.

정상적으로 모두 메모리에서 해제가 되었다면 nil을 대입하였을 때, deinit에서 구현한 텍스트가 출력되어야 하지만 출력되지 않는 것을 보면 알 수 있죠.

메모리 상에선 다음과 같습니다. 아직 서로를 참조하고 있어 참조 카운트가 1씩 존재하기 때문에, 0이 되어야 메모리에서 완전히 해제해주는 ARC는 이들을 가만히 내비둡니다.

따라서, 메모리 상에서 완전히 이들을 해제해주고 싶다면 다음과 같은 과정을 거쳐야 합니다.

a?.bClass = nil
b?.aClass = nil

print(CFGetRetainCount(a)) // 2
print(CFGetRetainCount(b)) // 2

a = nil // AClass 메모리 해제
b = nil // BClass 메모리 해제

이를 강한 참조(Strong Reference)라고 합니다. 각 프로퍼티를 먼저 메모리에서 해제를 해 준 다음 자신의 메모리를 해제해 주어야 완전하게 참조 카운트가 0이 됩니다.

이를 피하기 위해 weak var 또는 unowned var를 통해 약한 참조를 해주어야 합니다만, 강한 참조, 약한 참조 등은 ARC에 대한 포스팅을 할 때 다시 다뤄볼 예정입니다. 이번 포스팅에서는 그냥 참조 카운트가 이런 식으로 이루어진다 라고 생각하면 될 것 같습니다.

조금 더 복잡한 참조 카운트

그럼 조금 더 복잡한 구조로 예시를 확인해보겠습니다.

class DummyClass { }

class ExamplaryClass {
    let dummyClass1 = DummyClass()
    let dummyClass2 = DummyClass()
    let dummyClass3 = DummyClass()
}

struct ExamplaryStruct {
    let dummyClass1 = DummyClass()
    let dummyClass2 = DummyClass()
    let dummyClass3 = DummyClass()
}

다음과 같이 특정 클래스가 있고, 해당 클래스를 프로퍼티로 여러개 가진 클래스와 구조체가 있습니다. 여기서 여러 객체를 생성하고 각 참조 카운트와 주소를 확인해 보면 어떻게 될까요??

클래스를 포함한 클래스

let examplaryClass = ExamplaryClass()
let reference1 = examplaryClass
let reference2 = examplaryClass
let reference3 = examplaryClass

ExamplaryClass를 참조하는 examplaryClass 하나를 생성하고 이를 같이 참조하는 3개의 참조를 생성했습니다.

print(CFGetRetainCount(examplaryClass)) // 5
print(CFGetRetainCount(examplaryClass.dummyClass1)) // 2
print(CFGetRetainCount(examplaryClass.dummyClass2)) // 2
print(CFGetRetainCount(examplaryClass.dummyClass3)) // 2

참조 카운트는 다음과 같습니다. 1씩 빼면 4, 1, 1, 1인 것이죠.

examplaryClass의 경우, ExamplaryClass 인스턴스를 생성할 때 1 증가. -> 0 + 1 = 1 reference1, 2, 3에서 참조 할 때 각각 1씩 증가. -> 1 + 3 = 4 이렇게 참조 카운트는 4가 됩니다.

각 dummyClass의 경우, ExamplaryClass 인스턴스를 생성할 때 이미 새로운 서로 다른 DummyClass 인스턴스를 3개 생성하기 때문에 각 참조 카운트는 1입니다.

그럼, 주소값을 확인 해볼까요?

address(examplaryClass) // 0x0000600001568510
address(reference1) // 0x0000600001568510
address(reference2) // 0x0000600001568510
address(reference3) // 0x0000600001568510

address(examplaryClass.dummyClass1) // 0x00006000026cc040
address(reference2.dummyClass1) // 0x00006000026cc040

address(reference1.dummyClass2) // 0x00006000026cc050
address(reference3.dummyClass2) // 0x00006000026cc050

examplaryClass, reference모두 같은 인스턴스를 참조하고 있죠.

dummyClass들에 대한 참조 또한 같은 더미 클래스라면 같은 주소값을 가지고 있습니다. 같은 인스턴스를 참조하고, 해당 인스턴스가 가진 더미 클래스들도 그 더미 클래스의 인스턴스를 참조하고 있기 때문입니다. 말로 설명하기 보다는 그림으로 이해하는게 더 빠를 것 같네요.

메모리 상에서는 이렇게 되어있습니다.

클래스를 포함한 구조체

let examplaryStruct = ExamplaryStruct()
let copy1 = examplaryStruct
let copy2 = examplaryStruct
let copy3 = examplaryStruct

ExamplaryStruct 값을 가진 examplaryStruct 하나를 생성하고 이의 복사본 3개를 생성했습니다.

print(CFGetRetainCount(examplaryStruct)) // Error
print(CFGetRetainCount(examplaryStruct.dummyClass1)) // 5
print(CFGetRetainCount(examplaryStruct.dummyClass2)) // 5
print(CFGetRetainCount(examplaryStruct.dummyClass3)) // 5

첫 번째 출력문은 실행할 수 없습니다. CFGetRetainCount()에 대한 정의를 설명할 때, 구조체는 사용할 수 없다고 써놓았죠?

여기서는 클래스와 확연하게 다른 점이 보입니다. 각 더미클래스의 참조 카운트가 4라는 점인데요. 왜 이렇게 되는지 알아보도록 합시다.

examplaryStruct를 생성할 때, dummyClass1, 2, 3을 가진 구조체를 하나 생성합니다. 더미 클래스들은 서로 다른 객체이기 때문에, 각각 다른 DummyClass에 대한 참조를 가지고 있습니다. 즉, ExamplaryStruct는 3개의 DummyClass 인스턴스에 대한 참조를 가진 구조체로써 스택 영역에 저장되는 것입니다.

copy 1, 2, 3은 구조체 이므로 값 타입이며, examplaryStruct의 복사본입니다. 스택 영역에 examplaryStruct와 동일한 구조체를 복사하여 저장됩니다. 이 구조체이 가지고 있는 더미 클래스들 또한 원본과 같은 참조를 가지고 있습니다.

따라서, examplaryStruct, copy1, 2, 3에 있는 각각의 더미 클래스들은 모두 3개의 더미클래스에 대한 참조인 것이죠. 그렇기 때문에 참조 카운트가 4인 것입니다.

메모리 상에는 다음과 같이 나타날 것입니다.(조금 눈아프지만 이렇게밖에 표현 못해서 죄송합니다..)

실제 개발에서는 이보다 더 복잡한 상황도 많을 것이라 예상됩니다. 따라서, 클래스 및 클로저 등을 사용하는 경우, 참조를 적절하게 활용하고 계산하여 메모리 누수를 최대한 방지해야겠죠?

마치며

이번 포스팅은 저도 처음 공부할 때, 참조 카운트 증가와 해제가 헷갈렸습니다. 특히, 구조체 속 클래스와 클래스 속 클래스에서 머리가 좀 아팠습니다. 하지만 직접 그림을 그려가며 공부해보니 이해가 잘 되더라구요. 다음에 앱을 개발하며 메모리 누수를 생각해야 할 때 그림을 그려가며 메모리 방지를 위해 노력해야겠다 생각했습니다 ㅎㅎ..

Class vs Struct에 대한 포스팅은 아직 끝나지 않았습니다.. 3번째는 클래스와 구조체가 어떤 상황에서 조금 더 빠른지 몇 가지 실험을 할 예정입니다.

참조

https://ios-development.tistory.com/1464 https://stackoverflow.com/questions/24058906/printing-a-variable-memory-address-in-swift https://docs.swift.org/swift-book/documentation/the-swift-programming-language/methods/ https://developer.apple.com/documentation/corefoundation/1521288-cfgetretaincount?language=objc

먼저, Class와 Struct는 모두 사용자 정의 데이터 타입을 정의하는 데 사용되는 구문이며, 상태 및 동작을 설명하는 데에 상요되는 데이터 멤버와 멤버 함수를 포함합니다.

개발자로써 Class와 Struct의 정확한 차이를 이해하고 두 가지 구문을 적절하게 활용하여 코드를 최적화 하는 것이 중요하기 때문에, 이에 대해 자세히 알아 볼 필요가 있습니다.

컴퓨터공학부를 전공하면서 이 두 구문의 차이를 생각했을 때, 단순하게 Class는 참조 타입, Struct는 값 타입이다. 라며 C++ 시간에 배웠던 것만 기억이 났습니다.

iOS를 공부하며 구글링을 통해 공부해 본 결과, Class는 ARC를 통해 메모리를 관리하고 메모리의 힙 영역에 저장된다 라는 것과 Struct는 메모리의 스택 영역에 저장된다 와 같은 새로운 사실들도 알게되었죠.

저는 보통 이런 것을 보면 어떤 식으로 이렇게 이루어지는 거지? 하며 원리와 활용 예시들을 보며 이해하는 편이기 때문에, 조금 더 자세하게 찾아보았습니다만 아직도 정확하게 모든 것을 이해하진 못해서 아쉬움이 남습니다. 하지만, 지금의 레벨에서는 모두 완벽하게 아는 것은 어렵다고 생각하기 때문에, 천천히 이론을 이해해 나가고 공부하며 성장해 나가려고 합니다.

그럼 먼저 Class와 Struct의 특징부터 알아보겠습니다.

Class

참조 타입(Reference Type)

• 인스턴스는 메모리에서 하나의 객체를 참조하며, 여러 변수나 상수가 같은 객체를 참조할 수 있습니다.
• 인스턴스가 여러 참조에 의해 공유되므로, 한 참조에서 객체의 상태를 변경하면 다른 모든 참조에서도 그 변경이 반영됩니다.

상속(Inheritance)

• 상속을 통해 다른 클래스로부터 상속받아 기능을 확장할 수 있습니다.

타입 캐스팅(Type Casting)

• 인스턴스의 타입을 런타임에 캐스팅할 수 있습니다.
• 클래스 인스턴스의 타입을 확인하거나 부모 클래스의 인스턴스를 자식 클래스의 타입으로 캐스팅할 수 있습니다. (is, as)

소멸자(deinit)

• deinit을 통해 클래스 인스턴스가 할당한 리소스를 해제할 수 있습니다.
• 해당 작업을 통해 메모리 할당 해제 시점을 확인할 수 있습니다.

메모리 영역(Memory Area)

• 클래스 인스턴스는 일반적으로 힙 메모리에 저장됩니다.
• 인스턴스를 가리키는 참조는 스택 영역에 저장됩니다.
• 쉽게 보자면 다음과 같이 저장되는 것이죠.

class AClass { }
class BClass { }

var a1 = AClass()
var a2 = a1
var b1 = BClass()

메모리 관리(Memory Management)

• ARC(Automatic Reference Counting)를 통해 메모리를 관리합니다. (매우 중요)
• 참조 카운트가 0이 되면 메모리에서 객체가 해제됩니다.

Struct

값 타입(Value Type)

• 인스턴스는 값을 직접 저장합니다.
• 구조체를 다른 변수에 할당하거나 함수를 전달할 때, 값이 복사됩니다.
• 복사된 구조체의 변경은 원본 구조체에 영향을 미치지 않습니다.

메모리 영역(Memory Area)

• 구조체 인스턴스는 일반적으로 스택 메모리에 저장됩니다.
• 클래스의 메모리 영역에 있는 그림과 비교하자면, 힙 영역이 아닌 스택 영역에 있는 변수마다 각각 구조체가 들어있다고 생각하면 됩니다.

Class와 Struct의 대표적인 특징들에 대해 알아봤습니다. 딱 봐도 Class가 Struct에 비해 뭐가 많죠?? 그만큼 Class에 대해 설명할 것이 아주 많습니다. 그 것들을 여러 포스팅에 나눠서 설명할 예정이구요.

두 타입의 특징을 나열한 것이 곧 차이점과 같은데요, 그럼 공통점을 알아보겠습니다.

Class와 Struct의 공통점

속성(Properties)

• 속성을 가질 수 있습니다.
• 이 속성들을 통해 데이터를 저장하고 나타냅니다.

메서드(Methods)

• 메서드를 정의할 수 있습니다.
• 이 메서드들을 통해 데이터 수정 등을 위한 기능을 제공합니다.

생성자(Initializers)

• 생성자를 정의하여 초기 상태를 설정합니다.
• 생성자를 통해 인스턴스를 생성할 수 있습니다.

• 두 타입 모두 생성자를 정의하여 초기 설정을 할 수 있지만, 속성의 값이 옵셔널이 아니면서 특정한 값으로 정의되어있지 않은 경우, 클래스에선 생성자를 명시적으로 정의해주어야 합니다. 이유는 이렇습니다.

  구조체는 기본 생성자를 제공합니다. 값 타입이고 인스턴스가 메모리의 스택 영역에 저장됩니다. 간단한 데이터 컨테이너로 동작하기 때문에, 초기화 과정이 간단하게 설계되어 있습니다.
  클래스는 기본 생성자를 제공하지 않습니다. 참조 타입이고 인스턴스가 메모리의 힙 영역에 저장되고 상속을 지원합니다. 초기화 과정에서 상속받은 클래스의 초기화 과정도 고려해야 합니다. 따라서, 상속 관계에서 부모 클래스의 초기화를 보장해야 하므로 자동 생성자를 제공하기 어렵습니다.

프로토콜 준수(Protocol Conformance)

• 프로토콜을 채택하고 준수할 수 있습니다.
• 준수한 프로토콜을 통해 특정 기능을 설정할 수 있습니다.

확장(Extension)

• 확장을 통해 기능을 확장하여 정의할 수 있습니다.

서브스크립트(Subscripts)

• 서브스크립트를 정의하여 인스턴스의 특정 값에 접근할 수 있습니다.
• subscript(index: Int) -> Any 이런 식으로 클래스나 구조체 안에 있는 배열에 접근하거나 특정 값을 반환하는 등의 작업을 할 수 있습니다. 하지만, Class와 Struct에 대한 공부와는 조금 거리가 있다고 판단하여 자세히 설명하지는 않겠습니다. 링크만 여기 걸어놓겠습니다.

Class와 Sturct의 사용

두 가지 타입의 특정을 비교하며 느낀 점은 이렇습니다. 그래서 언제 무엇을 사용해야 하는가? 실제로 네이버 부캠 베이직 과정 중, 같은 기능을 구현하는 데에도 불구하고 팀원 한 분은 구조체를 사용하고 저는 클래스를 사용하여 구현하자는 얘기가 나왔었습니다. 저의 경우는 작은 수의 속성을 가진 데이터 모델은 보통 구조체로 구현하고 그 모델을 활용한 특정 기능을 구현하는 객체는 클래스로 구현해왔었고, 팀원 분은 모두 구조체로 구현해왔던 것 같았습니다. 둘 다 현재 상황에선 뭐가 이렇기 때문에 더 좋다 라는 명확한 설명을 할 수 없었던 터라 저는 구조체로 구현하는 것이 궁금하여 구조체로 구현하자고 했던 경험이 있네요.

공식 문서에서는 다음과 같이 설명하고 있습니다.

기본적으로 구조체를 선택하세요.

• Swift에서는 구조체를 사용하여 일반적인 종류의 데이터를 표현하는 것이 좋습니다.
• 구조체는 저장 및 연산 프로퍼티, 메서드를 포함할 수 있으며, 프로토콜을 채택할 수 있습니다.
• 표준 라이브러리와 Foundation에서도 숫자, 문자열, 배열, 딕셔너리 등의 타입은 구조체를 사용합니다.
• 구조체는 값 타입이므로, 앱의 전체 상태를 고려하지 않아도 됩니다.

Objective-C와 상호 운용성이 필요한 경우 클래스를 사용하세요.

• Objective-C API를 사용해 데이터를 처리하거나, Objective-C 프레임워크에서 정의된 기존 클래스 계층에 데이터 모델을 맞춰야 한다면 클래스와 상속을 통해 데이터 모델링을 해야 할 수도 있습니다.

식별 제어가 필요한 경우 클래스를 사용하세요.

뭐가 길게 써있지만, 제대로 이해를 하기 어려워 GPT 교수님을 이용해 쉽게 이해할 수 있도록 계속 질문하며 이해하고 정리하였습니다.

• 클래스 인스턴스는 여러 변수에서 참조할 수 있기 때문에, 객체의 상태가 변경되면 해당 객체를 참조하는 모든 코드에서 변경된 상태를 확인할 수 있습니다.
• 식별 연산자를 통해 현재 접근하려는 객체가 완전히 동일한지 판단할 수 있고, 이를 통해 여러 군데에서 공유되는 인스턴스의 변경 사항이 예상치 못한 결과를 초래하는 것을 방지할 수 있습니다.

구조체와 프로토콜을 사용하여 상속과 동작 공유를 모델링하세요.

• 구조체는 클래스와 달리 상속 기능을 제공하지 않지만, 구조체와 프로토콜 상속을 이용하여 상속을 기능을 구현할 수 있습니다.
• 클래스 상속을 통해 구축할 수 있는 상속 계층을 프로토콜 상속과 구조체를 사용해 모델링할 수 있습니다.
• 상속 관계를 처음부터 구축하는 경우, 프로토콜 상속을 우선적으로 사용하세요. 클래스 상속은 클래스 간에만 호환되지만, 프로토콜은 클래스, 구조체, 열거형 모두 상속이 가능하기 때문입니다.

마치며

포스팅과 공부를 병행하며 여러 가지 자료를 찾아보고 있는데, 아직까지 실제 개발에서 언제 구조체를 사용하고 언제 클래스를 사용해야 하는 지에 대한 명확한 답을 내기가 어려운 것 같습니다. 현업에 종사하고 계시는 iOS 개발자 분들도 이 상황에 대한 의견이 많이 갈리는 것 같더라구요. 코드에 따라 구조체 안에 클래스가 들어가는 경우, 클래스 안에 구조체가 들어가는 경우 등 많은 복잡한 상황들이 존재하고 이를 memory leak을 최소화 하기 위해 어떻게 변경해야 하는 지 등등.. 언젠간 저도 더 많은 것을 깨닫고 이를 실제 현업 종사자분들과 토론하며 새로운 지식을 쌓아가는 날이 있길 희망합니다.

Class와 Struct에 관한 내용 2편은 코드를 포함한 더 자세한 내용들을 다루려고 합니다. Class에서 ARC가 참조 카운트를 어떻게 하는지, 두 타입이 어떤 상황에서 더 빠른지 등등이요.

참조

공식 문서 1 공식 문서 2 핑구님 블로그