sehee 님의 블로그

[데이터 파이프라인 구축 프로젝트] 4. 기존 파이프라인 수정하기

sehee00 — Mon, 30 Dec 2024 14:50:07 +0900

현재 설계된 데이터 파이프라인은 특정 날짜의 데이터를 저장하는 구조이다. 하지만, 데이터 분석과 시각화를 진행하기 위해선, 현재 방식으로는 충분한 데이터를 확보하기 어렵다.

데이터 파이프라인 설계를 처음 시도하다 보니, "일단 해보자"는 마음으로 진행했지만, 이를 통해 설계상의 한계를 명확히 느낄 수 있었다.

특히, 초기 설계의 중요성을 크게 느꼈다. 데이터 파이프라인의 설계는 목적에 따라 매우 달라지며, 명확한 목표 설정 없이 진행하면 원하는 결과를 얻기 어려울 수 있다는 것을 배웠습니다.

따라서 이번에는 데이터 분석 목표를 명확히 설정한 후, 데이터 파이프라인을 재구축할 계획이다.

충분한 데이터를 수집하고 저장할 수 있는 구조를 설계함으로써, 이후의 분석과 시각화 까지 진행할 예정이다.

1. 데이터 분석 목표

특정 기간 동안의 누적 매출액 변화와 관객 수 추이 분석
영화 장르별 매출 비중, 국가별 영화 비중 등을 계산, 특정 국가에서 제작된 영화의 매출 증가 추세, 월별, 계절별 영화 흥행 트렌드 등과 같은 결과를 나타낼 수 있다.
데이터 분석 결과 대시보드 구성

2. 기존 데이터베이스 수정

1) 기존 데이터베이스 ERD

daily_box_office 테이블의 수정이 필요하다.

daily_box_office API의 응답 필드는 아래와 같다.

boxofficeType	문자열	박스오피스 종류를 출력합니다.
showRange	문자열	박스오피스 조회 일자를 출력합니다.
rnum	문자열	순번을 출력합니다.
rank	문자열	해당일자의 박스오피스 순위를 출력합니다.
rankInten	문자열	전일대비 순위의 증감분을 출력합니다.
rankOldAndNew	문자열	랭킹에 신규진입여부를 출력합니다. “OLD” : 기존 , “NEW” : 신규
movieCd	문자열	영화의 대표코드를 출력합니다.
movieNm	문자열	영화명(국문)을 출력합니다.
openDt	문자열	영화의 개봉일을 출력합니다.
salesAmt	문자열	해당일의 매출액을 출력합니다.
salesShare	문자열	해당일자 상영작의 매출총액 대비 해당 영화의 매출비율을 출력합니다.
salesInten	문자열	전일 대비 매출액 증감분을 출력합니다.
salesChange	문자열	전일 대비 매출액 증감 비율을 출력합니다.
salesAcc	문자열	누적매출액을 출력합니다.
audiCnt	문자열	해당일의 관객수를 출력합니다.
audiInten	문자열	전일 대비 관객수 증감분을 출력합니다.
audiChange	문자열	전일 대비 관객수 증감 비율을 출력합니다.
audiAcc	문자열	누적관객수를 출력합니다.
scrnCnt	문자열	해당일자에 상영한 스크린수를 출력합니다.
showCnt	문자열	해당일자에 상영된 횟수를 출력합니다.

데이터 분석 목표에 맞는 칼럼들만 저장하려고 하는데,

기존의 테이블은 칼럼을 잘못 가져오고 있 는 것 같아 다시 분석하며 수정하려고 한다.

2) 누적 매출액 변화 분석에 필요한 칼럼

salesAmt: 해당일의 매출액 - 매일의 매출 변화 추적하여 일별 매출 변동 파악
salesAcc(누적매출액), salesInten(전일 대비 매출액 증감분), salesChange(전일 대비 매출액 증감 비율)
- ⚠️ 고민: 이 칼럼들은 그냥 한 달치를 저장한 뒤 sql로 조작하여 값을 구할 수 있으므로 따로 저장X or 값이 주어지기 때문에 sql 조작 불필요
- 저장 공간을 절약하고 유연성을 높이려면 매일의 salesAmt만 저장하면 되며, 필요할 때마다 쿼리에서 계산하여 사용하면 된다.
- 성능을 우선시하고 빠른 조회를 원하는 경우 salesAcc, salesInten, salesChange 값을 저장해두면 된다.
- 따라서, 데이터 분석을 주로 하고 실시간으로 매일의 변화를 추적하는 데 중점을 둔다면, 실시간 계산을 추천하고, 만약 대규모 데이터에서 성능이 중요하고 자주 조회되는 값이라면, 미리 계산하여 저장하는 방법이 더 적합할 수 있다고 한다.
- ⚠️ 결론: 나는 현재 데이터베이스가 AWS RDS 클라우드 환경에서 사용되고 있고, 용량이 제한적인 무료 버전을 사용하기 때문에 저장공간을 절약할 수 있는 경우로 진행하려고 한다.

3) 관객 수 변화 분석에 필요한 칼럼

audiCnt: 해당일의 관객수 - 매일의 관객 수를 추적하여 관객 수의 변화 파악
audiAcc, audiInten, audiChange - 위와 동일한 고민으로 동일한 결론으로 진행할 예정이다.

4) 영화 정보 분석을 위한 칼럼

movieCd: 영화의 대표코드
movieNm: 영화명
rank: 해당일의 박스오피스 순위 - 순위에 따른 매출 추이 분석에 활용할 수 있다.
openDt: 개봉일 - 기간을 기준으로 매출 추이 분석에 활용할 수 있다.
scrnCnt: 상영 스크린수 - 스크린수와 매출의 상관관계 분석에 활용 가능하다.
showCnt: 상영 횟수 - 상영 횟수와 매출의 상관관계 분석에 활용 가능하다.

5) daily_box_office API 테이블

고정적인 값이라 바뀌지 않는 칼럼이 있고, 매일매일 값이 달라져서 새로운 값이 저장되어야 하는 칼럼이 있다.

그래서 고정값 저장과 가변값 저장 테이블을 분리하여 저장하려고 한다.

고정값: movieCd, movieNm, openDt
조회 날짜에 따라 매일 저장되어야하는 값: rank, sales_amt, audi_cnt, scrn_cnt, show_cnt

따라서, 아래와 같이 테이블을 구성할 수 있다.

daily_box_office(movieCd, movieNm, openDt)

dialy_box_ofiice_data(movieCd, target_date, rank, sales_amt, audi_cnt, scrn_cnt, show_cnt)

movie_id	movie_nm	open_dt
20200142	소방관	2024-12-04
20240737	모아나2	2024-11-27
20247693	위키드	2024-11-20

movie_id	target_date	movie_rank	sales_amt	audi_cnt	scrn_cnt	show_cnt
20200142	2024-12-09	1	880247950	833537	1183	4193
20200142	2024-12-10	2	880247953	833545	1190	4190
20200142	2024-12-11	1	880248000	833555	1180	4198
20200142	2024-12-12	3	880248098	833590	1188	4200
20240737	2024-12-09	4	355586230	2240410	1078	3421
20240737	2024-12-10	5	355586236	2240418	1070	3425
20240737	2024-12-11	3	355586238	2240420	1079	3441
20240737	2024-12-12	2	355586240	2240422	1073	3423

기본키와 복합키

테이블은 오직 하나의 기본키를 가질 수 있다.
daily_box_office 테이블은 movie_id를 키본키로 지정한다.
dialy_box_ofiice_data 테이블은 (target_date, movieCd) 복합키로 지정해야 한다.
여러 칼럼을 이용하여 복합키를 지정하는 경우 설계 시 중복이 적은 순서대로 적는 것이 필요하다.
- movieCd는 외래키로 dialy_box_ofiice 테이블의 movieCd를 참조한다.
- 한달치 데이터를 저장한다고 했을 때, target_date는 같은 값이 10개씩 고정적이고, movieCd는 10개가 넘을 수도 있다.
- 따라서, (target_date, movieCd) 로 복합키를 지정한다.

CREATE TABLE

-- 일별 박스오피스 테이블 생성 
CREATE TABLE daily_box_office (
    movie_id VARCHAR(20) PRIMARY KEY,  -- 영화 대표코드
    movie_nm VARCHAR(255) NOT NULL, -- 영화명
	open_date DATE NOT NULL-- 개봉일
);
    

-- 일별 박스오피스 데이터 테이블 생성 
CREATE TABLE daily_box_office_data (
	target_date DATE, -- 조회 날짜
    movie_id VARCHAR(20),  -- 영화 대표코드
    movie_rank INT, -- 해당일의 박스오피스 순위
    sales_amt BIGINT, -- 해당일의 매출액
    audi_cnt BIGINT, -- 해당일의 관객수
    scrn_cnt INT, -- 해당일의 상영 스크린 수
    show_cnt INT,  -- 해당일의 상영 횟수
    CONSTRAINT daily_box_office_data_PK PRIMARY KEY (target_date, movie_id), --복합키
    FOREIGN KEY (movie_id) REFERENCES daily_box_office(movie_id) -- 외래키 참조
);

수정된 테이블의 DDL문이다.

6) 수정된 데이터베이스 ERD

3. ETL 수정하기

1) Extract (데이터 추출):

데이터 추출에서는 기존과 동일하다.

일별 박스오피스, 영화 상세정보 API를 그대로 가져온다.

2) Transform (데이터 정제):

# 데이터 변환(Transform)
def transform_data(box_office_data, movie_info_data, target_date):

    """박스오피스 데이터와 영화 상세정보 데이터를 정제합니다."""
    clean_records_box_office = []
    clean_records_movie_details = []

    # target_date가 datetime 객체로 변환되지 않았다면 변환
    if isinstance(target_date, str):
        target_date = datetime.strptime(target_date, "%Y%m%d")

    # 필요한 경우 다시 문자열로 변환
    target_date_str = target_date.strftime("%Y%m%d")

    for movie in box_office_data:
        movieCd = movie.get("movieCd", "")
        rank = int(movie.get("rank", 0)) # 박스오피스 순위
        movieNm = movie.get("movieNm", "") # 영화명(국문)
        openDt = movie.get("openDt", None) # 개봉일 
        salesAmt = int(movie.get("salesAmt", 0)) # 해당일의 매출액 
        audiCnt = int(movie.get("audiCnt", 0)) # 해당일의 관객수 
        scrnCnt = int(movie.get("scrnCnt", 0)) # 해당일의 상영 스크린 수
        showCnt = int(movie.get("showCnt", 0)) # 해당일의 상영 횟수 

        # 정제된 박스오피스 데이터를 저장
        clean_records_box_office.append((
            movieCd, target_date_str, rank, movieNm, openDt, salesAmt, audiCnt, scrnCnt, showCnt
        ))

        # 영화 상세 정보
        info = movie_info_data.get(movieCd, {})
        nations = [n.get("nationNm", "") for n in info.get("nations", [])] # 국가: ["미국"], ["한국", "중국"]
        genres = [g.get("genreNm", "") for g in info.get("genres", [])] # 장르: ["액션"], ["드라마", "스릴러"]
        directors = [d.get("peopleNm", "") for d in info.get("directors", [])] # 감독: [{"peopleNm": "봉준호"}]
        actors = [a.get("peopleNm", "") for a in info.get("actors", [])[:5]] # 배우: [{"peopleNm": "송강호"}, {"peopleNm": "김혜수"}]
        showTypes = [s.get("showTypeNm", "") for s in info.get("showTypes", [])] # 상영형태: ["2D", "IMAX"]
        companies = [c.get("companyNm", "") for c in info.get("companys", [])] # 제작사: [{"companyNm": "CJ 엔터테인먼트"}]
        watchGradeNm = [w.get("watchGradeNm", "") for w in info.get("audits", [])] # 관람등급: "15세 관람가", "전체 관람가"

        nation_str = ",".join(nations)
        genre_str = ",".join(genres)
        director_str = ",".join(directors)
        actor_str = ",".join(actors)
        show_type_str = ",".join(showTypes)
        company_str = ",".join(companies)
        watch_grade_str = ",".join(watchGradeNm)

        # movie_details 데이터 수집
        clean_records_movie_details.append((
            movieCd, nation_str, genre_str, director_str, actor_str, show_type_str, company_str, watch_grade_str
        ))

    return clean_records_box_office, clean_records_movie_details

target_date 매개변수를 추가하여 조회 날짜에 따른 박스오피스 데이터를 저장한다.
salesAcc(누적 매출액), audiAcc(누적 관객수) 칼럼 삭제 및 audiCnt(해당일의 관객수) 칼럼 추가

3) Load (데이터 적재):

# 데이터 로드(Load)
def load_data_to_mysql(box_office_records, movie_details_records, target_date):
    # MySQL 연결
    connection = pymysql.connect(host=MYSQL_HOST, user=MYSQL_USER, password=MYSQL_PASSWORD, db=MYSQL_DB)
    cursor = connection.cursor()

    # 1. 박스오피스 데이터 가져오기
    box_office_data = fetch_daily_box_office(target_date)

    # 2. 영화 상세 정보 가져오기
    movie_info_data = {}
    for movie in box_office_data:
        movieCd = movie.get("movieCd")
        movie_info_data[movieCd] = fetch_movie_info(movieCd)

    # 3. 데이터 변환
    clean_records_box_office, clean_records_movie_details = transform_data(box_office_data, movie_info_data, target_date)

    # 4. 박스오피스 테이블 삽입 (기본 정보)
    insert_box_office_sql = """
    INSERT INTO daily_box_office (
        movie_id, movie_nm, open_date
    ) VALUES (%s, %s, %s)
    ON DUPLICATE KEY UPDATE
        movie_nm = VALUES(movie_nm),
        open_date = VALUES(open_date)
    """
    for record in clean_records_box_office:
        cursor.execute(insert_box_office_sql, (record[0], record[3], record[4]))
    connection.commit()

    # 4-1. 일별 박스오피스 데이터 테이블 삽입 (상세 정보)
    insert_box_office_data_sql = """
    INSERT INTO daily_box_office_data (
        target_date, movie_id, movie_rank, sales_amt, audi_cnt, scrn_cnt, show_cnt
    ) VALUES (%s, %s, %s, %s, %s, %s, %s)
    ON DUPLICATE KEY UPDATE
        sales_amt = VALUES(sales_amt),
        audi_cnt = VALUES(audi_cnt),
        scrn_cnt = VALUES(scrn_cnt),
        show_cnt = VALUES(show_cnt)
    """
    for record in clean_records_box_office:
        cursor.execute(insert_box_office_data_sql, (record[1], record[0], record[2], record[5], record[6], record[7], record[8]))
    connection.commit()
    

    # 5. 영화 상세 데이터 삽입
    for record in clean_records_movie_details:
        insert_sql = """
        INSERT INTO movie_details (
            movie_id, nation_nm, genre_nm, director_nm, actor_nm, show_type_nm, company_nm, watch_grade_nm) 
        VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
        ON DUPLICATE KEY UPDATE
            nation_nm = IFNULL(VALUES(nation_nm), nation_nm),
            genre_nm = IFNULL(VALUES(genre_nm), genre_nm),
            director_nm = IFNULL(VALUES(director_nm), director_nm),
            actor_nm = IFNULL(VALUES(actor_nm), actor_nm),
            show_type_nm = IFNULL(VALUES(show_type_nm), show_type_nm),
            company_nm = IFNULL(VALUES(company_nm), company_nm),
            watch_grade_nm = IFNULL(VALUES(watch_grade_nm), watch_grade_nm)
        """
        cursor.executemany(insert_sql, clean_records_movie_details)
        cursor.connection.commit()
    
    # 연결 종료
    connection.close()

def load_movie_relations_to_mysql(box_office_data, movie_info_data):
    connection = pymysql.connect(host=MYSQL_HOST, user=MYSQL_USER, password=MYSQL_PASSWORD, db=MYSQL_DB)
    cursor = connection.cursor()

    # 데이터 정제
    clean_records_box_office, clean_records_movie_details = transform_data(box_office_data, movie_info_data, target_date)

    # 영화 상세 정보 처리
    for movie in clean_records_movie_details:
        print(f"처리 중인 영화: {movie}\n")
        movie_id = movie[0]  # 영화ID
        nations = movie[1].split(",") if movie[1] else []  # 국가 목록
        genres = movie[2].split(",") if movie[2] else []  # 장르 목록
        directors = movie[3].split(",") if movie[3] else []  # 감독 목록
        actors = movie[4].split(",") if movie[4] else []  # 배우 목록
        showTypes = movie[5].split(",") if movie[5] else []  # 상영형태 목록
        companies = movie[6].split(",") if movie[6] else []  # 제작사 목록

        # 관계 테이블에 데이터 삽입
        process_movie_relations(connection, movie_id, nations, genres, directors, actors, showTypes, companies)

    # 한 번에 커밋
    connection.commit()
    # 연결 종료
    connection.close()

# 날짜 목록 생성
def get_dates(start_date):
    """시작 날짜부터 설정 기간의 날짜 목록 생성"""
    # start_date가 문자열이라면 datetime 객체로 변환
    if isinstance(start_date, str):
        start_date = datetime.strptime(start_date, "%Y%m%d")

    dates = []
    current_date = start_date  # datetime 객체로 초기화
    for i in range(38):  # 기간 설정 
        # 날짜를 "YYYYMMDD" 형식의 문자열로 저장
        dates.append(current_date.strftime("%Y%m%d"))
        # 다음 날짜로 이동
        current_date += timedelta(days=1)

    print("get_date: ", dates)
    return dates

target_date 매개변수 추가하여 함수 수정
daily_box_office와 daily_box_office_data 테이블에 각각 데이터 저장
특정 기간의 데이터를 지정할 수 있는 get_dates() 함수 추가
- start_date를 기준으로 지정하는 기간의 데이터를 저장할 수 있음

4) Main 함수

if __name__ == "__main__":
    start_date = "20241218"  # 데이터를 수집할 시작 날짜    
    
    try:
        # MySQL 연결 생성
        connection = pymysql.connect(host=MYSQL_HOST, user=MYSQL_USER, password=MYSQL_PASSWORD, db=MYSQL_DB)
        cursor = connection.cursor() 

        # 날짜 생성
        week_dates = get_dates(start_date)
        for target_date in week_dates:
            # print(type(target_date)) # str
            # print(f"날짜 처리 중: {target_date}")

            # 1. 일별 박스오피스 데이터 수집
            box_office_data = fetch_daily_box_office(target_date)
            # print("박스오피스 데이터 수집 성공 ! \n")
            
            # 2. 각 영화의 상세정보 수집
            movie_info_data = {}
            for movie in box_office_data:
                movieCd = movie["movieCd"]
                movie_info_data[movieCd] = fetch_movie_info(movieCd)
            # print("영화 상세 데이터 수집 성공 ! \n")
        
            # 3. 데이터 정제
            box_office_records, movie_details_records = transform_data(
                box_office_data, movie_info_data, target_date)
            # print("정제된 데이터 확인 - 박스오피스:\n", box_office_records)
            # print("정제된 데이터 확인 - 영화 상세정보:\n", movie_details_records)
        
            # 4. MySQL에 데이터 삽입
            load_data_to_mysql(box_office_records, movie_details_records, target_date)  
            # print("박스오피스, 상세정보 테이블 적재 성공 \n")
            load_movie_relations_to_mysql(box_office_data, movie_info_data)
            # print("관계 테이블 적재 성공\n")
 
        # 연결 종료
        cursor.close()
        connection.close()

    except Exception as e:
        print(f"오류 발생: {e}")

4. 실행 결과

1) daily_box_office 테이블

총 93개의 영화가 저장되었다.

2) daily_box_office_data 테이블

target_date에 따라 매일 10개의 영화가 저장된 것을 확인할 수 있다.

3) movie_details 테이블

영화 상세정보 테이블의 데이터도 모두 잘 저장된 것을 확인할 수 있다.

director_nm, actor_nm, company_nm 칼럼은 null인 데이터가 한 두개 존재해서 어떻게 처리할 지 고민이 필요하다.

3) 관계 테이블

nation 테이블을 예시로 가져왔다.

모두 매핑이 모두 잘 되어 저장된 것을 확인할 수 있다.

예시로, movie_id가 20149210인 영화 '인터스텔라'는 미국, 영국의 제작 국가를 가진다.

위와 같이 데이터 저장이 잘 된것을 확인할 수 있다.

이렇게 기존 파이프라인과 데이터베이스 수정을 모두 마쳤다.

다음에는 SQL 조작 및 분석, 데이터 분석 및 대시보드 제작을 진행할 예정이다.

[백준][파이썬] 1012 유기농배추

sehee00 — Mon, 16 Dec 2024 13:30:09 +0900

문제

차세대 영농인 한나는 강원도 고랭지에서 유기농 배추를 재배하기로 하였다. 농약을 쓰지 않고 배추를 재배하려면 배추를 해충으로부터 보호하는 것이 중요하기 때문에, 한나는 해충 방지에 효과적인 배추흰지렁이를 구입하기로 결심한다. 이 지렁이는 배추근처에 서식하며 해충을 잡아 먹음으로써 배추를 보호한다. 특히, 어떤 배추에 배추흰지렁이가 한 마리라도 살고 있으면 이 지렁이는 인접한 다른 배추로 이동할 수 있어, 그 배추들 역시 해충으로부터 보호받을 수 있다. 한 배추의 상하좌우 네 방향에 다른 배추가 위치한 경우에 서로 인접해있는 것이다.

한나가 배추를 재배하는 땅은 고르지 못해서 배추를 군데군데 심어 놓았다. 배추들이 모여있는 곳에는 배추흰지렁이가 한 마리만 있으면 되므로 서로 인접해있는 배추들이 몇 군데에 퍼져있는지 조사하면 총 몇 마리의 지렁이가 필요한지 알 수 있다. 예를 들어 배추밭이 아래와 같이 구성되어 있으면 최소 5마리의 배추흰지렁이가 필요하다. 0은 배추가 심어져 있지 않은 땅이고, 1은 배추가 심어져 있는 땅을 나타낸다.

1	1	0	0	0	0	0	0
0	1	0	0	0	0	0	0
0	0	0	0	1	0	0	0
0	0	0	0	1	0	0	0
0	0	1	1	0	1	1	1
0	0	0	0	1	1	1	1

입력

입력의 첫 줄에는 테스트 케이스의 개수 T가 주어진다. 그 다음 줄부터 각각의 테스트 케이스에 대해 첫째 줄에는 배추를 심은 배추밭의 가로길이 M(1 ≤ M ≤ 50)과 세로길이 N(1 ≤ N ≤ 50), 그리고 배추가 심어져 있는 위치의 개수 K(1 ≤ K ≤ 2500)이 주어진다. 그 다음 K줄에는 배추의 위치 X(0 ≤ X ≤ M-1), Y(0 ≤ Y ≤ N-1)가 주어진다. 두 배추의 위치가 같은 경우는 없다.

출력

각 테스트 케이스에 대해 필요한 최소의 배추흰지렁이 마리 수를 출력한다.

예제 입력 1 복사

예제 출력 1 복사

예제 입력 2 복사

예제 출력 2 복사

5 1

문제 풀이

#  재귀 limit 설정
import sys
sys.setrecursionlimit(10000)

# DFS 정의 
def dfs(x,y):
  # 상,하, 좌,우
  dx = [1, -1, 0, 0] 
  dy = [0, 0, 1, -1]
   
  for i in range(4): 
    nx = x + dx[i] 
    ny = y + dy[i]
    if (0 <= nx < m) and (0 <= ny < n): 
      if graph[ny][nx] == 1:
      	# 방문했다는 표시 -1
        graph[ny][nx] = -1
        dfs(nx, ny)

# 테스트 케이스      
t = int(input())

for i in range(t):
  # 배추밭의 가로길이, 세로길이, 배추가 심어져 있는 위치의 개수
  m,n,k = map(int, input().split())
  graph = [[0]*m for _ in range(n)]
  result = 0
  
  # 배추 위치에 1 표시
  for i in range(k):
    a,b = map(int,input().split())
    graph[b][a] = 1

  # DFS를 활용해서 배추 그룹 수 세기
  for i in range(m):
    for j in range(n):
      if graph[j][i] == 1:
        dfs(i, j)
        result += 1
  
  # 출력
  print(result)

⚠️ 주의

x, y 위치 지정 주의해야 함 !!!

1) 문제에서 주어진 좌표계 (x, y)

x: 열 (왼쪽에서 오른쪽으로 증가)
y: 행 (위에서 아래로 증가)

2) 배열의 표현방식

graph[a][b]
a: 행 (세로축)
b: 열 (가로축)

⚠️ 런타임 에러

sys.setrecursionlimit(10000) # 런타임에러 방지 - 재귀 깊이 설정

백준 채점 시스템에서 최대 재귀 깊이를 디폴트 값으로 1000으로 정해놓음
런타임 에러는 그 최대 깊이를 초과하여 재귀 호출을 하기 때문에 발생
최대 재귀 깊이를 늘려준다!

[데이터 파이프라인 구축 프로젝트] 3. RDS 구축하기

sehee00 — Thu, 12 Dec 2024 17:23:59 +0900

1. 개발 환경

현재 개발 환경은 다음과 같다.

1) 서버:

AWS EC2 인스턴스라는 클라우드 환경 위에서 운영하고 있다.

2) 데이터베이스:

Docker 컨테이너 내부에서 MySQL이 실행되고 있다.

하지만 Docker 컨테이너는 EC2 인스턴스 내부에서 실행되므로, EC2 기준으로 로컬 환경에 해당한다.

그래서 정리하자면,

서버는 클라우드 환경이고,
데이터베이스는 클라우드 서버(EC2)의 로컬환경에서 실행되고 있다.

⚠️ 문제점

데이터베이스가 EC2 인스턴스의 로컬 환경에서 실행 중이기 때문에,

EC2 서버가 종료되거나 Docker 컨테이너가 중지되면 자동화된 데이터 추출 및 적재 작업은 중단된다.

그래서 저번에 이유를 알 수 없이 Docker 컨테이너가 중지되어, 만들어둔 데이터베이스가 다 날아간 적이 있다.

아직 데이터를 많이 적재해두기 전이라 다시 만들긴 했지만 중요한 데이터가 있었다면 큰일날 뻔했다.

EC2 서버에 문제가 생기면 데이터베이스에도 접근하지 못한다.

또한, 자동화 시스템을 만들기 위해서는 데이터베이스와 서버가 항상 가동 상태를 유지해야 한다.

따라서 데이터베이스를 로컬 환경이 아닌 클라우드 환경인 AWS RDS와 같은 관리형 데이터베이스로 변경하려고 한다.

이렇게 데이터베이스를 분리하면 다음과 같은 이점이 있다.

자동 백업 및 복구
- 정기적인 스냅샷(백업)을 자동으로 생성해 복구를 쉽게 한다.
- EC2 서버 장애가 발생해도 데이터는 손실되지 않는다.
자동 확장성
- 트래픽이 증가하거나 데이터가 커질 경우, 필요에 따라 스토리지와 성능을 확장할 수 있다.
고가용성
- 장애 발생 시 RDS는 자동으로 다른 가용 영역(Availability Zone)에 있는 복제본으로 전환한다.
관리 부담 감소
- 데이터베이스 설치, 패치, 업그레이드, 유지보수 등의 작업을 AWS가 관리한다.

2. RDS 구축하기

RDS(Relational Databasse Service)

AWS에 데이터베이스를 직접 설치하게 되면 모니터링, 알람, 백업 HA 구성 등을 모두 직접하게 됨
이러한 작업들을 하지 않기 위해서 AWS에서 지원하는 클라우드 기반 관계형 데이터 베이스

1. AWS RDS 인스턴스 생성

MySQL로 버전은 8.4.3을 선택했다.

현재 내 컴퓨터에 설치된 MySQL 버전은 9.0.1 이지만, 해당 버전이 없어서 가장 최신 버전을 선택했다.

MySQL 9.1.0은 MySQL Server 버전 8.0 이상과 호환된다고 하니 일단 설치해본다.

인스턴스 식별자와 자격 증명 설정을 해준다.

<db.t2 – CPU 사용률을 최대로 버스트할 수 있는 기능으로 기준 성능 수준을 제공하는 인스턴스 클래스입니다.>

그래서 다들 db.t2를 사용하는데, db.t2는 종료된 것을 확인할 수 있었다.

"Amazon RDS는 db.t2를 사용하는 인스턴스를 최신 세대 db.t3 인스턴스 클래스로 자동 업그레이드하기 시작했습니다. db.t2 인스턴스 클래스를 사용하여 DB 인스턴스를 생성하는 것은 더 이상 지원되지 않습니다." << https://docs.aws.amazon.com/ko_kr/AmazonRDS/latest/UserGuide/Concepts.DBInstanceClass.Types.html

<db.t3 – CPU 사용률을 최대로 버스트할 수 있는 기능으로 기준 성능 수준을 제공하는 인스턴스 클래스입니다. db.t3 인스턴스는 무제한 모드로 구성됩니다. 이 인스턴스 클래스는 이전의 db.t2 인스턴스 클래스보다 더 많은 컴퓨팅 용량을 제공합니다. >

위와 같은 이유로 나는 db.t3를 사용할 예정이다.

추가 스토리지 구성을 클릭해, 스토리지 자동 조정 활성화를 꼭 해제해야 한다.

프리티어임에도 이 옵션이 선택되어 있으면 요금이 부과될 수 있다.

퍼블릭 액세스를 꼭 "예"로 선택해준다.

VPC 보안 그룹은 기존 항목을 선택하였다.

추가 구성의 데이터베이스 포트는 3306으로 그대로 둔다.

초기 데이터베이스 이름을 기존과 동일하게 "movie_analysis"로 설정해줬다.

자동 백업과 마이너 버전 자동 업그레이드 사용은 해제해뒀다. 나중에 요금이 부과될 수도 있기 때문이다.

모든 설정을 마치고 데이터베이스 생성하기를 클릭하면 아래와 같이 데이터베이스가 생성된다.

생성되는데 시간이 조금 걸린다.

아래와 같이 생성이 완료됐다.

2. RDS 운영환경에 맞는 파라미터 설정

파라미터 그룹 > 파라미터 그룹 생성

생성한 파라미터 그룹을 선택한 후 편집을 진행한다.

1) time_zone 설정

time_zone을 검색하여 Asia/Seoul로 설정해준다.

2) Characater set utf-8 설정

한글 데이터가 깨지지 않고 잘 출력시키게 하기 위해서 utf-8 인코더를 설정해줘야 합니다.

character_set를 검색하여 나오는 아래와 같은 항목을 모두 utf8mb4로 설정해줍니다.

character_set_client
character_set_connection
character_set_database
character_set_filesystem
character_set_results
character_set_server

https://minyoongi96.github.io/aws/aws08_RDS-파라미터-그룹/

3) collation 설정

collation을 검색하여 나오는 아래와 같은 항목을 모두 utf8mb4_unicode_ci로 설정해줍니다.

collation_connection
collation_server

4) 생성된 파라미터 그룹으로 변경하기

데이터베이스 > 수정 > 추가 구성 > DB 파라미터 그룹 설정 이름으로 변경

만들어둔 파라미터 그룹으로 변경해준다.

3. EC2와 연결

1) EC2 인스턴스 접속하여 보안 그룹 ID 확인

보안 그룹으로 접속하여 보안 그룹 ID를 복사해준다.

2) RDS에 접속하여 VPC 보안 그룹 선택하기

RDS의 보안그룹 > 보안 그룹 ID > 인바운드 규칙 편집

인바운드 규칙 편집에서 복사한 EC2 보안 그룹 ID 를 추가해준다.

4. Local에서 RDS 접근하기

1) RDS 엔드포인트 확인하기

RDS의 데이터베이스에 접속한 후 엔드포인트를 복사한다. 해 MySQL 워크벤치의 Hostname에 넣어준다.

2) MySQL Workbench - connect to database 실행하기

MySQL Workbench에 접속한 후, 새로운 연결을 시작한다.

복사해 둔 엔드포인트를 Hostname에 넣어준다.

⚠️ 에러

위의 모든 설정을 마쳤음에도 연결이 계속해서 안되는 문제가 있었다.

인바운드 규칙 편집에서 0.0.0.0/0(테스트용)을 추가해줬더니 바로 연결에 성공했다.

4. EC2에서 RDS 접속하기

터미널에서 아래와 같이 입력해준다.

mysql -u 사용자명 -p -h RDS엔드포인트주소

설정해둔 패스워드를 입력하면 위와 같이 접속이 된 것을 확인할 수 있다.

* RDS 한글테스트 진행하기

위와 같이 한글테스트를 진행해본 결과, 한글이 깨지지 않고 잘 나오는 것을 확인할 수 있었다.

이제 서버와 데이터베이스 모두 클라우드 환경에서 동작한다.

서버: AWS EC2 인스턴스
데이터베이스: AWS RDS에서 관리하는 MySQL

[백준][파이썬] 단계별로 풀어보기 - 스택, 큐, 덱(28278, 10773, 9012, 18258, 2164, 11866, 28279, 2346)

sehee00 — Thu, 12 Dec 2024 12:37:09 +0900

https://www.acmicpc.net/step/11

28278 스택2

import sys
input = sys.stdin.readline

N = int(input())

stack = []
result = []
for _ in range(N):
    command = input().split()

    # 1 X: 정수 X를 스택에 넣는다. 
    if command[0] == '1': 
        stack.append(int(command[1]))

    # 2: 스택에 정수가 있다면 맨 위의 정수를 빼고 출력한다. 없다면 -1을 대신 출력한다.
    elif command[0] == '2': 
        if stack:
            result.append(stack.pop())
        else:
            result.append(-1)

    # 3: 스택에 들어있는 정수의 개수를 출력한다.
    elif command[0] == '3': 
        result.append(len(stack))

    # 4: 스택이 비어있으면 1, 아니면 0을 출력한다.
    elif command[0] == '4': 
        if stack: 
            result.append(0)
        else:
            result.append(1)
            
    # 5: 스택에 정수가 있다면 맨 위의 정수를 출력한다. 없다면 -1을 대신 출력한다.
    elif command[0] == '5':
        if stack:
            result.append(stack[-1])
        else:
            result.append(-1)

print('\n'.join(map(str, result)))

10773 제로

import sys
input = sys.stdin.readline

k = int(input())
stack = []

for _ in range(k):
    command = int(input())

    if command == 0:
        stack.pop()
    else:
        stack.append(command)
        
print(sum(stack))

9012 괄호

import sys
input = sys.stdin.readline

n = int(input())

for _ in range(n):
    string = input().strip()
    stack = []
    is_vps = True

    for char in string:
        if char == '(':
            stack.append(char)
        elif char == ')':
            if stack: # 스택에 ( 있으면 pop
                stack.pop()
            else: # 스택 비어있으면 VPS 아님 
                is_vps = False
                break

    # 스택이 비어있지 않으면 VPS 아님 
    if stack:
        is_vps = False

    print("YES" if is_vps else "NO")

')' 일 때 스택이 비어있으면 VPS 아님
스택 연산 후, 스택 비어있지 않으면 VPS 아님

18258 큐2

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

N = int(input())
queue = deque()

for _ in range(N):
    command = input().split()

    # push X: 정수 X를 큐에 넣는 연산
    if command[0] == 'push':
        queue.append(int(command[1]))

    # 큐에서 가장 앞에 있는 정수를 빼고, 그 수를 출력 
    # 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력
    elif command[0] == 'pop':
        if queue:
            print(queue[0])
            queue.popleft()
        else:
            print(-1)

    # size: 큐에 들어있는 정수의 개수를 출력
    elif command[0] == 'size':
        print(len(queue))

    # empty: 큐가 비어있으면 1, 아니면 0을 출력
    elif command[0] == 'empty':
        if queue:
            print(0)
        else:
            print(1)

    # front: 큐의 가장 앞에 있는 정수를 출력
    # 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력
    elif command[0] == 'front':
        if queue:
            print(queue[0])
        else:
            print(-1)

    # back: 큐의 가장 뒤에 있는 정수를 출력
    # 만약 큐에 들어있는 정수가 없는 경우에는 -1을 출력
    elif command[0] == 'back':
        if queue:
            print(queue[-1])
        else:
            print(-1)

deque() 덱으로 구현하면 됨 !
나머지 연산들은 스택과 유사함

2164 카드2

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

N = int(input())
queue = deque()

for i in range(1, N+1):
    queue.append(i)

while len(queue) > 1:
    queue.popleft()
    queue.append(queue.popleft())

print(queue[0])

11866 요세푸스 문제0

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

N, K = map(int, input().split())
queue = deque(range(1, N+1))
result = []

while queue:
    for _ in range(K-1):
        queue.append(queue.popleft())
    result.append(queue.popleft())

print("<" + ", ".join(map(str, result)) + ">")

k번째 사람 제거:
- 큐의 첫 번째 요소를 뒤로 옮기는 작업을 K-1번 반복 // K = 3이면 1, 2 뽑아서 맨 뒤로 보내고
- 그 후, K번째 사람을 제거하여 결과 리스트에 추가 // 3 뽑아서 결과리스트에 저장

28279 덱2

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

N = int(input())
queue = deque()

for _ in range(N):
    command = input().strip().split()

    if command[0] == '1': # 앞에 추가 
        queue.appendleft(int(command[1]))
    elif command[0] == '2': # 뒤에 추가 
        queue.append(int(command[1]))
    elif command[0] == '3':
        if queue: 
            print(queue.popleft())
        else:
            print(-1)
    elif command[0] == '4':
        if queue:
            print(queue.pop())
        else:
            print(-1)
    elif command[0] == '5':
        print(len(queue))
    elif command[0] == '6':
        if queue:
            print(0)
        else:
            print(1)
    elif command[0] == '7':
        if queue:
            print(queue[0])
        else:
            print(-1)
    elif command[0] == '8':
        if queue:
            print(queue[-1])
        else:
            print(-1)

덱 앞에 추가 appendleft(), 뒤에 추가 append()
덱 앞에 삭제 popleft(),뒤에 삭제 pop()

deque.rotate(n)

from collections import deque

queue = deque([1, 2, 3, 4, 5])

queue.rotate(2)  # 오른쪽으로 2칸
print(queue)  # [4, 5, 1, 2, 3]

queue.rotate(-3)  # 왼쪽으로 3칸
print(queue)  # [2, 3, 4, 5, 1]

deque.rotate(n)은 큐를 오른쪽으로 n칸 회전시키는 함수입니다.
- : 오른쪽으로 번 회전.
- : 왼쪽으로 |n|번 회전.
rotate(+n)은 큐의 오른쪽 끝 요소를 앞으로 옮기는 것입니다.
rotate(-n)은 큐의 왼쪽 끝 요소를 뒤로 옮기는 것입니다.

2346 풍선 터뜨리기

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

N = int(input())
# 풍선 번호와 명령 저장 
queue = deque(enumerate(map(int, input().split()), start=1)) 
result = []

while queue: 
    index, step = queue.popleft() # 현재 풍선 번호와 명령어 가져오기 
    result.append(index) # 풍선 터뜨리기 

    if not queue:  # 남은 풍선이 없으면 종료 
        break
      
    # 큐를 step에 맞게 회전 
    if step > 0:
        queue.rotate(-(step-1)) # 오른쪽 이동 
    else:
        queue.rotate(-step)  # 왼쪽 이동 

print(" ".join(map(str, result)))

풍선과 명령이 짝을 이루므로 enmerate()로 함께 저장 !
queue.rotate(-(step-1))
- 이미 popleft()를 사용해 현재 위치를 칸 앞으로 이동했으므로 추가로 오른쪽으로 step−1칸 이동.
- rotate 함수는 양수를 오른쪽 회전으로 해석하므로, 칸 오른쪽 이동은 rotate(-(step - 1))로 표현 >> 이는 부호 반전 때문
  - rotate(+n) → 오른쪽 이동.
  - rotate(-n) → 왼쪽 이동이지만, 우리가 음수를 넣으면 이미 방향 반전이 된 회전을 실행하게 됩니다.

[데이터 파이프라인 구축 프로젝트] 02. ETL 수행하기

sehee00 — Wed, 11 Dec 2024 16:57:43 +0900

영화진흥회 API를 살펴보며 데이터 수집 계획을 세우고, 데이터 추출, 변환, 적재를 진행할 예정이다.

1. 영화진흥회 API

API(Application Programming Interface)란?

API는 특정 애플리케이션, 서비스, 또는 시스템이 다른 애플리케이션과 통신할 수 있도록 정의된 일련의 규칙
애플리케이션 간의 계약: API는 두 애플리케이션 간의 데이터 전달 및 명령어 실행 방식(어떤 데이터를 보내야 하고, 어떤 방식으로 받을지)에 대한 규칙을 정해놓은 것. 이를 통해 두 시스템은 서로 무엇을 기대하는지 알 수 있게 된다.
웹 API (RESTful API): 웹에서 가장 흔히 사용되는 형태로, HTTP를 통해 요청(request)과 응답(response)을 주고받는다. 예를 들어, 클라이언트가 API를 통해 데이터를 요청하면, 서버는 해당 데이터를 제공하는 방식이다.
API의 사용 예: 영화진흥회 API처럼, 특정 웹 서비스가 데이터를 제공하고 이를 다른 애플리케이션이 활용할 수 있도록 해주는 방식. 이를 통해 데이터를 추출하거나 특정 기능을 다른 애플리케이션에서 사용할 수 있다.

영화진흥위원회 오픈 API

https://www.kobis.or.kr/kobisopenapi/homepg/board/findServiceGuideList.do

오픈 API를 이용하려면 일단 키를 발급받아야 한다.

키는 신청만 하면 바로 발급된다.

일 3000회로 사용 제한이 있다.

발급키

제공 서비스

영화 진흥회 Open API

제공서비스에는 일별 박스오피스, 주간/주말 박스오피스, 공통코드 조회 등 다양한 서비스를 제공한다.

다음에는 API를 살펴보며 어떤 데이터를 사용할지 고민해보려고 한다.

2. 데이터 소스 선정하기

데이터 추출(Extract) 단계에서 필요한 데이터만 수집할지, 아니면 가능한 데이터를 모두 가져올지 고민이다.

필요한 데이터만 가져오는 경우:
- 데이터 크기가 작아 처리 시간이 단축되고, 파이프라인이 간결하며 유지보수가 용이하다.
- 데이터 요구사항이 변경되거나 추가적인 분석이 필요해지면, 다시 데이터를 추출해야 한다.
- 추출 단계에서 데이터 선정을 잘못하거나 오류가 있다면, 중요한 데이터를 놓칠 수 있다.
가능한 데이터를 모두 가져오는 경우:
- 변환 단계에서 다양한 데이터 전처리 및 조작이 가능한 유연성을 갖출 수 있다.
- 데이터 손실이나 누락을 최소화하며, 추후 확장성이 좋다. 데이터 재수집을 하지 않아도 된다.
- 저장소가 많이 필요하며 시간이 오래 걸린다.
현대적인 데이터 파이프라인 설계 트렌드:
- 데이터를 최대한 수집하여 ELT 방식으로 처리하는 경우가 많습니다.
- 이유는 저장 비용이 낮아졌고, 클라우드 서비스에서 컴퓨팅 자원을 유연하게 사용할 수 있기 때문이다.
결론
- 나는 "데이터 파이프라인 구축"에 초점을 맞추고 있기 때문에, 가능한 데이터를 모두 가져오는 방식이 맞을 것 같다.
- 최대한 데이터를 수집하고, 다양한 데이터 전처리 및 조작을 통해 활용할 수 있는 환경을 제공하는 쪽으로 해야겠다.
- 명확한 요구사항이 있는게 아니고 데이터를 다각도로 활용할 가능성이 있기 때문에, 가능한 모든 데이터를 수집하자!

1) 일별 박스오피스 API 살펴보기

2024년 11월 27일자 일별 박스오피스 API의 일부를 가져왔다.

일별 박스오피스 API에서는 영화 장르가 제공되지 않아서 'movieCd(영화의 대표코드)'를 외부키로 연결하여 영화 상세정보 API에서 영화 장르를 얻어야 한다.

일별 박스오피스 API의 응답필드에서 필요하지 않은 필드도 있다. 예를 들어, rnum(순번)은 필요하지 않다.

rank(해당일자의 박스오피스 순위), rankOldAndNew(랭킹에 신규진입여부, “OLD” : 기존 , “NEW” : 신규), movieCd(영화의 대표코드), movieNm(영화명(국문)), openDt(개봉일), salesAmt(해당일의 매출액), salesShare(해당일자 상영작의 매출총액 대비 해당 영화의 매출비율), salesInten(전일 대비 매출액 증감분), salesChange(전일 대비 매출액 증감 비율), salesAcc(누적매출액), audiAcc(해당일의 관객수), audiInten(전일 대비 관객수 증감분), audiChange(전일 대비 관객수 증감 비율), audiAcc(누적 관객수), scrnCnt(해당일자에 상영한 스크린수), showCnt(해당일자에 상영된 횟수) 데이터를 수집할 예정이다. 총 16개의 필드를 가진다.

2) 영화 상세정보 API 살펴보기

'외국영화 - 모아나 2'와 '한국영화 - 히든페이스' 상세정보를 불러와 비교해 봤다.

또, 다른 영화들의 상세정보를 확인하며 데이터 세부 정부를 파악해 봤다.

movieNmOg(영화명(원문)): 모두 None값이다.
nations(제작국가): 1개 이상일 수 있다. ex. (미국, 캐나다)
genres(장르): 1개 이상일 수 있다. ex. 애니메이션, 스릴러, (범죄, 스릴러)
directors(감독): 1명 이상일 수 있다.
actors(배우): 외국 영화는 2명인 거에 비해 한국 영화는 27명이었다.
showTypes(상영형태): 외국 영화는 4가지, 한국 영화는 1가지였다. 즉, 여러 개일 수 있다.
companys(참여영화사): 1개 이상일 수 있다.
audits(심의정보) - watchGradNm(관람등급 명칭) : 1개 이상일 수 있는데, 의미는 같을 수 있다.
staffs(스텝): 외국 영화는 스텝이 하나도 출력되지 않았고, 한국 영화는 약 100명 이상 출력된다.

영화 상세정보 API에서는 movieNmOg(영화명(원문)), nations(제작국가), genres(장르), directors(감독), showTypes(상영형태), companys(참여영화사), watchGradNm(관람등급 명칭) 데이터를 수집할 예정이다. 총 7개의 필드를 가진다.

3) 다른 API

일별 박스오피스, 주간/주말 박스오피스, 공통코드 조회, 영화목록, 영화 상세정보, 영화사목록, 영화사 상세정보, 영화인목록, 영화인 상세정보 API들이 있지만, 모든 API의 정보를 가져올 필요는 없을 것 같다.

- 영화사 상세정보 API

companyCd(영화사코드)로 영화사 상세정보 API를 조회해 봤다.

영화사 정보(영화사 목록/상세정보): 제작사, 배급사 관련 데이터 분석이 필요할 때 유용할 것 같다.

- 영화인 목록 API

"peopleNm(영화인명)으로 영화인 목록을 조회해봤다.

- 영화인 상세정보 API

모든 API를 추출하고 ERD를 구성하는 것은 너무 복잡하고 불필요해 보여서, 우선 핵심 API(일별 박스오피스, 영화 상세정보)의 데이터만 가져오기로 결정했다.
프로젝트를 진행하며 추가 API가 필요하다고 판단되면, 그때 데이터를 확장하고 ERD를 업데이트할 예정이다.

3. 데이터베이스 설계하기

1) AWS EC2에서 Doker로 MySQL 띄우기 (이전게시물 참조)

이전에 작성한 글과 같은 방법으로 새로운 인스턴스를 생성하여 MySQL 컨테이너를 새로 만들었다.

이제 데이터베이스를 만들고, 사용자 생성 및 권한 설정을 해줘야 한다.

# 데이터베이스 생성 
CREATE DATABASE movie_analysis;
# 데이터베이스 사용
USE movie_analysis;

클라우드에서 데이터를 처리하도록 하기 위해,

사용자 계정을 외부 접속 계정(%)으로 생성하고, 권한 부여도 해준다.

CREATE USER '유저명'@'%' IDENTIFIED BY '설정할 비밀번호';
GRANT ALL PRIVILEGES ON your_database_name.* TO '유저명'@'%';
FLUSH PRIVILEGES;

2) 테이블 설계 및 생성하기

테이블 설계를 먼저 진행하는 이유

데이터를 변환(Transform)하거나 적재(Load) 하기 전에 테이블 구조를 명확히 정의하면 데이터 처리 중 오류를 최소화하고 일관된 파이프라인을 유지할 수 있다.

데이터베이스 설계를 하려니 어떻게 이름을 명명해야 할지 고민이 되어 구글링을 해봤다. 블로그를 참조하여 필수적인 명명규칙을 정리해 봤다.

소문자로 작성한다.
단어와 단어 사이는 _ 로 구분한다.
약어를 사용하지 않는다. (ex. mid_nm 대신 middle_name 사용)
몇 긴 단어의 경우 약어가 단어 자체보다 더 통용되는 경우가 있다. 이런 경우에는 약어를 사용한다.
기본키 필드의 이름 id로 작성한다.
외래 키 필드는 참조된 테이블의 이름과 참조된 필드의 이름 조합이어야 한다. ex. team_id

일별 박스오피스(daily_box_office) 테이블

-- 일별 박스오피스 테이블 생성
CREATE TABLE daily_box_office (
    movie_id VARCHAR(20) PRIMARY KEY, -- 영화 대표코드
    movie_rank INT, -- 박스오피스 순위
    movie_nm VARCHAR(255), -- 영화명
    open_date DATE, -- 개봉일
    sales_amt BIGINT, -- 해당일의 매출액
    sales_acc BIGINT, -- 누적 매출액
    audi_acc BIGINT, -- 누적 관객수
    scrn_cnt INT, -- 상영 스크린 수
    show_cnt INT  -- 상영 횟수
);

총 16개의 칼럼을 모두 가져와 저장하려 했으나, 데이터를 분석할 때 반드시 필요한지 고려하고 비슷한 정보를 제공하는 필드는 통합하여 필드 수를 줄이려고 한다.

movie_id: 영화 대표코드 → 고유 식별자
movie_rank: 해당 일자의 박스오피스 순위 → 순위 분석에 필수
movie_nm: 영화명 → 분석 시 사람이 이해하기 쉬운 값 제공
open_date: 개봉일 → 영화의 신작 여부 및 상영 기간 분석
sales_amt: 해당일의 매출액 → 매출 분석의 기본 데이터
sales_acc: 누적 매출액 → 장기 흥행 정도 분석
audi_acc: 누적 관객수 → 관객수와 매출의 상관관계 분석
scrn_cnt: 상영 스크린 수 → 상영 규모와 매출의 상관 관계 분석
show_cnt: 상영 횟수 → 상영 횟수 대비 성과 측정/ 상영 횟수와 매출의 상관 관계 분석

이렇게 총 9개의 칼럼을 추출하기로 결정했다.

영화 상세정보(movie_details) 테이블

-- 영화 상세정보 테이블 생성
CREATE TABLE movie_details (
    movie_id VARCHAR(20) PRIMARY KEY, -- 영화 대표코드
    nation_nm VARCHAR(50), -- 제작국가
    genre_nm VARCHAR(50), -- 장르명 
    director_nm VARCHAR(255), -- 감독명 
    actor_nm VARCHAR(255), -- 배우명 
    show_type_nm VARCHAR(255), -- 상영 형태 
    company_nm VARCHAR(255), -- 참여 영회사
    watch_grade_nm VARCHAR(255), -- 관람등급 명칭
    FOREIGN KEY (movie_id) REFERENCES daily_box_office(movie_id)
);

movie_id: 영화 대표코드→ 다른 테이블과의 관계 설정 및 데이터 통합 관리에 필수 // 일별 박스오피스 테이블의 movie_id와 Foreign Key로 연결하여 통합 데이터 관리 필요
nation_nm: 제작국가 → 국가별 영화 매출 비중, 관객 수 분석, 영화 시장 트렌드 파악
genre_nm: 장르 → 장르별 흥행 비율 분석, 특정 장르 트렌드 및 인기 장르 파악
director_nm: 감독 → 감독별 영화 성과 분석, 흥행 성공률 조사, 특정 감독의 영화 스타일 트렌드 분석
actor_nm: 배우 → 배우별 영화 매출 기여도 분석, 주연 배우가 매출 및 관객 수에 미치는 영향 평가
show_type: 상영형태 → 상영 방식별 관객 선호도, 매출 비교 분석
company_nm: 참여 영화사 → 영화사별 프로젝트 규모 및 성과 분석, 특정 영화사의 흥행 성과 추적
watch_grade_nm: 관람등급 명칭 → 관람 등급별 관객층 분석 // 데이터 정제 과정으로 중복 제거 필요

이렇게 총 8개의 칼럼을 추출하기로 결정했다.

영화 상세정보 테이블은 다대다 관계를 고려해야 한다.

nation_nm: 한 영화는 여러 제작국가를 가질 수 있고, 하나의 국가는 여러 영화에 속할 수 있습니다.
genre_nm: 한 영화는 여러 장르를 가질 수 있고, 하나의 장르는 여러 영화에 속할 수 있습니다.
director_nm: 한 영화는 여러 감독을 가질 수 있고, 한 명의 감독은 여러 영화에 속할 수 있습니다.
actor_nm: 한 영화는 여러 배우를 가질 수 있고, 한 명의 배우는 여러 영화에 속할 수 있습니다.
show_type: 한 영화는 여러 상영형태를 가질 수 있고, 하나의 상영형태는 여러 영화에 속할 수 있습니다.
company_nm: 한 영화는 여러 영화사를 가질 수 있고, 하나의 영화사는 여러 영화에 속할 수 있습니다.

다대다 관계

다대다 관계는 일대다, 다대일로 풀어줄 수 있도록 연관 테이블을 추가했다.

-- 국가 테이블
CREATE TABLE nations (
    nation_id INT AUTO_INCREMENT PRIMARY KEY, -- 고유 ID
    nation_nm VARCHAR(255) NOT NULL -- 국가명
);

-- 영화와 국가의 관계 테이블
CREATE TABLE movie_and_nation (
    movie_id VARCHAR(20) NOT NULL, -- 영화 대표코드
    nation_id INT NOT NULL, -- 국가 ID
    PRIMARY KEY (movie_id, nation_id),
    FOREIGN KEY (movie_id) REFERENCES movie_details (movie_id) ON DELETE CASCADE,
    FOREIGN KEY (nation_id) REFERENCES nations (nation_id) ON DELETE CASCADE
);

-- 장르 테이블
CREATE TABLE genres (
    genre_id INT AUTO_INCREMENT PRIMARY KEY, -- 고유 ID
    genre_nm VARCHAR(255) NOT NULL -- 장르명
);

-- 영화와 장르의 관계 테이블
CREATE TABLE movie_and_genre (
    movie_id VARCHAR(20) NOT NULL, -- 영화 대표코드
    genre_id INT NOT NULL, -- 장르 ID
    PRIMARY KEY (movie_id, genre_id),
    FOREIGN KEY (movie_id) REFERENCES movie_details (movie_id) ON DELETE CASCADE,
    FOREIGN KEY (genre_id) REFERENCES genres (genre_id) ON DELETE CASCADE
);

-- 감독 테이블
CREATE TABLE directors (
    director_id INT AUTO_INCREMENT PRIMARY KEY, -- 고유 ID
    director_nm VARCHAR(255) NOT NULL -- 감독명
);

-- 영화와 감독의 관계 테이블
CREATE TABLE movie_and_director (
    movie_id VARCHAR(20) NOT NULL, -- 영화 대표코드
    director_id INT NOT NULL, -- 감독 ID
    PRIMARY KEY (movie_id, director_id),
    FOREIGN KEY (movie_id) REFERENCES movie_details (movie_id) ON DELETE CASCADE,
    FOREIGN KEY (director_id) REFERENCES directors (director_id) ON DELETE CASCADE
);

-- 배우 테이블
CREATE TABLE actors (
    actor_id INT AUTO_INCREMENT PRIMARY KEY, -- 고유 ID
    actor_nm VARCHAR(255) NOT NULL -- 배우명
);

-- 영화와 배우의 관계 테이블
CREATE TABLE movie_and_actor (
    movie_id VARCHAR(20) NOT NULL, -- 영화 대표코드
    actor_id INT NOT NULL, -- 배우 ID
    PRIMARY KEY (movie_id, actor_id),
    FOREIGN KEY (movie_id) REFERENCES movie_details (movie_id) ON DELETE CASCADE,
    FOREIGN KEY (actor_id) REFERENCES actors (actor_id) ON DELETE CASCADE
);

-- 상영형태 테이블
CREATE TABLE show_types (
    show_type_id INT AUTO_INCREMENT PRIMARY KEY, -- 고유 ID
    show_type VARCHAR(255) NOT NULL -- 상영형태
);

-- 영화와 상영형태의 관계 테이블
CREATE TABLE movie_and_show_type (
    movie_id VARCHAR(20) NOT NULL, -- 영화 대표코드
    show_type_id INT NOT NULL, -- 상영형태 ID
    PRIMARY KEY (movie_id, show_type_id),
    FOREIGN KEY (movie_id) REFERENCES movie_details (movie_id) ON DELETE CASCADE,
    FOREIGN KEY (show_type_id) REFERENCES show_types (show_type_id) ON DELETE CASCADE
);

-- 영화사 테이블
CREATE TABLE companies (
    company_id INT AUTO_INCREMENT PRIMARY KEY, -- 고유 ID
    company_nm VARCHAR(255) NOT NULL -- 영화사명
);

-- 영화와 영화사의 관계 테이블
CREATE TABLE movie_and_company (
    movie_id VARCHAR(20) NOT NULL, -- 영화 대표코드
    company_id INT NOT NULL, -- 영화사 ID
    PRIMARY KEY (movie_id, company_id),
    FOREIGN KEY (movie_id) REFERENCES movie_details (movie_id) ON DELETE CASCADE,
    FOREIGN KEY (company_id) REFERENCES companies (company_id) ON DELETE CASCADE
);

ERD(개체 관계 다이어그램)

4. ETL 수행하기

1) Extract (데이터 추출): API를 통해 데이터를 가져옵니다.

# 데이터 추출(Extract)
def fetch_daily_box_office(date):
    """일별 박스오피스 데이터를 API에서 가져옵니다."""
    params = {"key": API_KEY, "targetDt": date}
    response = requests.get(BOX_OFFICE_URL, params=params)
    if response.status_code == 200:
        data = response.json()
        return data["boxOfficeResult"]["dailyBoxOfficeList"]
    else:
        raise Exception(f"API 호출 실패: {response.status_code}")

def fetch_movie_info(movieCd):
    """영화 상세정보 데이터를 API에서 가져옵니다."""
    params = {"key": API_KEY, "movieCd": movieCd}
    response = requests.get(MOVIE_INFO_URL, params=params)
    if response.status_code == 200:
        data = response.json()
        return data["movieInfoResult"]["movieInfo"]
    else:
        raise Exception(f"API 호출 실패: {response.status_code}")

2) Transform (데이터 정제): 가져온 데이터를 정제합니다. 필요에 따라 데이터 형식 변환, 중복 제거, 필터링 등을 합니다.

# 데이터 변환(Transform)
def transform_data(box_office_data, movie_info_data):

    """박스오피스 데이터와 영화 상세정보 데이터를 정제합니다."""
    clean_records_box_office = []
    clean_records_movie_details = []

    for movie in box_office_data:
        movieCd = movie.get("movieCd", "")
        rank = int(movie.get("rank", 0)) # 박스오피스 순위
        movieNm = movie.get("movieNm", "") # 영화명(국문)
        openDt = movie.get("openDt", None) # 개봉일 
        salesAmt = int(movie.get("salesAmt", 0)) # 해당일의 매출액 
        salesAcc = int(movie.get("salesAcc", 0)) # 누적 매출액 
        audiAcc = int(movie.get("audiAcc", 0)) # 누적 관객수 
        scrnCnt = int(movie.get("scrnCnt", 0)) # 해당일의 상영 스크린 수
        showCnt = int(movie.get("showCnt", 0)) # 해당일의 상영 횟수 

        # 정제된 박스오피스 데이터를 저장
        clean_records_box_office.append((
            movieCd, rank, movieNm, openDt, salesAmt, salesAcc, audiAcc, scrnCnt, showCnt
        ))

        # 영화 상세 정보
        info = movie_info_data.get(movieCd, {})
        nations = [n.get("nationNm", "") for n in info.get("nations", [])] # 국가: ["미국"], ["한국", "중국"]
        genres = [g.get("genreNm", "") for g in info.get("genres", [])] # 장르: ["액션"], ["드라마", "스릴러"]
        directors = [d.get("peopleNm", "") for d in info.get("directors", [])] # 감독: [{"peopleNm": "봉준호"}]
        actors = [a.get("peopleNm", "") for a in info.get("actors", [])[:5]] # 배우: [{"peopleNm": "송강호"}, {"peopleNm": "김혜수"}]
        showTypes = [s.get("showTypeNm", "") for s in info.get("showTypes", [])] # 상영형태: ["2D", "IMAX"]
        companies = [c.get("companyNm", "") for c in info.get("companys", [])] # 제작사: [{"companyNm": "CJ 엔터테인먼트"}]
        watchGradeNm = [w.get("watchGradeNm", "") for w in info.get("audits", [])] # 관람등급: "15세 관람가", "전체 관람가"

        nation_str = ",".join(nations)
        genre_str = ",".join(genres)
        director_str = ",".join(directors)
        actor_str = ",".join(actors)
        show_type_str = ",".join(showTypes)
        company_str = ",".join(companies)
        watch_grade_str = ",".join(watchGradeNm)

        # movie_details 데이터 수집
        clean_records_movie_details.append((
            movieCd, nation_str, genre_str, director_str, actor_str, show_type_str, company_str, watch_grade_str
        ))

    return clean_records_box_office, clean_records_movie_details

일단, 일별 박스오피스 데이터와 영화 상세정보 데이터를 정제한다.
이후 관계 테이블에 데이터 적재를 위해 관계 테이블 데이터를 정제한다.

영화 데이터와 관련된 모든 관계 정보를 처리.
중복된 데이터는 삽입하지 않으며, 필요한 경우 새 데이터를 생성.
각 영화와 관계를 효율적으로 매핑하며, 데이터의 일관성과 중복 방지를 보장.

# 관계 테이블의 column_nm이 있는지 확인하고 column_id를 가져오는 함수
def get_relation_id(connection, table_nm, column_nm): 
    """관계 테이블에서 column_nm을 기준으로 column_id를 확인하고 없으면 추가"""
    cursor = connection.cursor()
    select_query = f"SELECT {table_nm}_id FROM {table_nm} WHERE {table_nm}_nm = %s"
    cursor.execute(select_query, (column_nm,))
    result = cursor.fetchone() 

    if result:
        # 이미 존재하는 경우 ID 반환
        return result[0]
    else:
        # 새로운 데이터를 추가하고 ID 반환
        insert_query = f"INSERT INTO {table_nm} ({table_nm}_nm) VALUES (%s)"
        cursor.execute(insert_query, (column_nm,))
        # connection.commit()
        return cursor.lastrowid
    
# 영화와 *의 관계를 movie_and_relation 테이블에 추가하는 함수 
def insert_relation(connection, movie_id, table_nm, column_id):
    """영화와 관계 테이블에 매핑"""
    cursor = connection.cursor()

    # 중복 확인 쿼리
    check_query = f"SELECT 1 FROM movie_and_{table_nm} WHERE movie_id = %s AND {table_nm}_id = %s"
    cursor.execute(check_query, (movie_id, column_id))
    if cursor.fetchone():
        print(f"영화 {movie_id}와 {table_nm} {column_id}은(는) 이미 존재합니다.")
        return  # 이미 존재하면 삽입하지 않음
    
    # 중복되지 않으면 삽입
    insert_query = f"INSERT INTO movie_and_{table_nm} (movie_id, {table_nm}_id) VALUES (%s, %s)"
    cursor.execute(insert_query, (movie_id, column_id))
    connection.commit()
    print(f"영화 {movie_id}와 {table_nm} {column_id} 처리 완료")
    # connection.commit()

def process_movie_relations(connection, movie_id, nations, genres, directors, actors, showTypes, companies):
    """각 영화에 대해 국가, 장르, 감독, 배우, 상영형태, 회사와 관계 테이블을 매핑"""
    
    # 국가 처리
    for nation in nations:
        nation_id = get_relation_id(connection, "nation", nation)
        insert_relation(connection, movie_id, "nation", nation_id)
        print(f"영화 {movie_id}와 국가 {nation} 처리 완료")
    
    # 장르 처리
    for genre in genres:
        genre_id = get_relation_id(connection, "genre", genre)
        insert_relation(connection, movie_id, "genre", genre_id)
        print(f"영화 {movie_id}와 장르 {genre} 처리 완료")
    
    # 감독 처리
    for director in directors:
        director_id = get_relation_id(connection, "director", director)
        insert_relation(connection, movie_id, "director", director_id)
        print(f"영화 {movie_id}와 감독 {director} 처리 완료")
    
    # 배우 처리
    for actor in actors:
        actor_id = get_relation_id(connection, "actor", actor)
        insert_relation(connection, movie_id, "actor", actor_id)
        print(f"영화 {movie_id}와 배우 {actor} 처리 완료")
    
    # 상영형태 처리
    for show_type in showTypes:
        show_type_id = get_relation_id(connection, "show_type", show_type)
        insert_relation(connection, movie_id, "show_type", show_type_id)
        print(f"영화 {movie_id}와 상영형태 {show_type} 처리 완료")
    
    # 제작사 처리
    for company in companies:
        company_id = get_relation_id(connection, "company", company)
        insert_relation(connection, movie_id, "company", company_id)
        print(f"영화 {movie_id}와 영화사 {company} 처리 완료")

get_relation_id 함수:
- 특정 관계 테이블(nation, genre, director, actor, show_type, company)에서 column_nm(예: 국가명, 장르명 등)을 검색
- 해당 값이 이미 존재하면 ID를 반환
- 존재하지 않으면 새 데이터를 삽입하고 삽입된 ID를 반환
insert_relation 함수:
- 영화(movie_id)와 특정 관계 테이블 항목(table_nm의 column_id)의 관계를 movie_and_relation 테이블에 추가
- 추가하기 전에 중복 여부를 확인
- 중복되지 않으면 데이터를 삽입하고 관계를 매핑
process_movie_relations 함수:
- 영화 ID(movie_id)를 중심으로 여러 관계(국가, 장르, 감독, 배우, 상영형태, 제작사)를 처리
- 각 관계 데이터(nations, genres, 등등)를 순회하면서 다음 작업 수행:
  1. get_relation_id를 호출해 관계 테이블에서 ID 확인 또는 추가
  2. insert_relation을 호출해 영화와 관계 데이터를 매핑
- 관계별로 처리 완료 메시지를 출력

3) Load (데이터 적재): 정제된 데이터를 MySQL에 삽입합니다.

# 데이터 로드(Load)
def load_data_to_mysql():
    # MySQL 연결
    connection = pymysql.connect(host=MYSQL_HOST, user=MYSQL_USER, password=MYSQL_PASSWORD, db=MYSQL_DB)
    cursor = connection.cursor()

    # 1. 박스오피스 데이터 가져오기
    date = "20241127"  # 날짜 입력
    box_office_data = fetch_daily_box_office(date)

    # 2. 영화 상세 정보 가져오기
    movie_info_data = {}
    for movie in box_office_data:
        movieCd = movie.get("movieCd")
        movie_info_data[movieCd] = fetch_movie_info(movieCd)

    # 3. 데이터 변환
    clean_records_box_office, clean_records_movie_details = transform_data(box_office_data, movie_info_data)

    # 4. 박스오피스 데이터 삽입
    for record in clean_records_box_office:
        insert_sql = """
        INSERT INTO daily_box_office (
            movie_id, movie_rank, movie_nm, open_date, sales_amt, sales_acc, audi_acc, scrn_cnt, show_cnt)
        VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
        ON DUPLICATE KEY UPDATE sales_amt = VALUES(sales_amt)
        """
        cursor.execute(insert_sql, record)
        connection.commit()

    # 5. 영화 상세 데이터 삽입
    for record in clean_records_movie_details:
        insert_sql = """
        INSERT INTO movie_details (
            movie_id, nation_nm, genre_nm, director_nm, actor_nm, show_type_nm, company_nm, watch_grade_nm) 
        VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
        ON DUPLICATE KEY UPDATE
            nation_nm = IFNULL(VALUES(nation_nm), nation_nm),
            genre_nm = IFNULL(VALUES(genre_nm), genre_nm),
            director_nm = IFNULL(VALUES(director_nm), director_nm),
            actor_nm = IFNULL(VALUES(actor_nm), actor_nm),
            show_type_nm = IFNULL(VALUES(show_type_nm), show_type_nm),
            company_nm = IFNULL(VALUES(company_nm), company_nm),
            watch_grade_nm = IFNULL(VALUES(watch_grade_nm), watch_grade_nm)
        """
        cursor.executemany(insert_sql, clean_records_movie_details)
        cursor.connection.commit()
    
    # 연결 종료
    connection.close()

def load_movie_relations_to_mysql(box_office_data, movie_info_data):
    connection = pymysql.connect(host=MYSQL_HOST, user=MYSQL_USER, password=MYSQL_PASSWORD, db=MYSQL_DB)
    cursor = connection.cursor()

    # 데이터 정제
    clean_records_box_office, clean_records_movie_details = transform_data(box_office_data, movie_info_data)

    # 영화 상세 정보 처리
    for movie in clean_records_movie_details:
        print(f"처리 중인 영화: {movie}\n")
        movie_id = movie[0]  # 영화ID
        nations = movie[1].split(",") if movie[1] else []  # 국가 목록
        genres = movie[2].split(",") if movie[2] else []  # 장르 목록
        directors = movie[3].split(",") if movie[3] else []  # 감독 목록
        actors = movie[4].split(",") if movie[4] else []  # 배우 목록
        showTypes = movie[5].split(",") if movie[5] else []  # 상영형태 목록
        companies = movie[6].split(",") if movie[6] else []  # 제작사 목록

        # 관계 테이블에 데이터 삽입
        process_movie_relations(connection, movie_id, nations, genres, directors, actors, showTypes, companies)

    # 한 번에 커밋
    connection.commit()
    # 연결 종료
    connection.close()

4) Main 함수

if __name__ == "__main__":
    target_date = "20241127"  # 데이터를 수집할 날짜
    try:
        # MySQL 연결 생성
        connection = pymysql.connect(host=MYSQL_HOST, user=MYSQL_USER, password=MYSQL_PASSWORD, db=MYSQL_DB)
        cursor = connection.cursor() 

        # 1. 일별 박스오피스 데이터 수집
        box_office_data = fetch_daily_box_office(target_date)
        
        # 2. 각 영화의 상세정보 수집
        movie_info_data = {}
        for movie in box_office_data:
            movieCd = movie["movieCd"]
            movie_info_data[movieCd] = fetch_movie_info(movieCd)
       
        # 3. 데이터 정제
        box_office_records, movie_details_records = transform_data(
            box_office_data, movie_info_data)
     
        # 4. MySQL에 데이터 삽입
        load_data_to_mysql()  
        load_movie_relations_to_mysql(box_office_data, movie_info_data)
 
        # 연결 종료
        cursor.close()
        connection.close()

    except Exception as e:
        print(f"오류 발생: {e}")

5. 실행 결과

20241127 일자의 데이터를 저장한 결과,

위와 같이 관계 테이블의 중복은 제외하고, 데이터가 잘 저장되는 것을 확인할 수 있다.

이제, MySQL에 데이터가 적재되어 있는지 확인해 보자.

1) daily_box_office(일별 박스오피스) 테이블

daily_box_office 테이블 조회 결과

2) movie_details(영화 상세정보) 테이블

movie_details 테이블 조회 결과

3) ex. movie_id = '20240737' 모아나 2 결과 확인(일부분)

SELECT * FROM nation;
-- 1 미국
-- 2 한국
-- 3 캐나다
-- 4 일본 
-- 5 대만 
-- 6 영국


SELECT * FROM movie_and_nation WHERE movie_id = '20240737';
-- movie_id  nation_id
-- 20240737  1
-- 20240737  3

SELECT * FROM genre;
-- genre_id  genre_nm 
-- 1		 판타지
-- 2 		 뮤지컬
-- 3 		 스릴러
-- 4 		 액션
-- 5 		 사극
-- 6 		 드라마
-- 7 		 멜로/로맨스 
-- 8 		 애니메이션
-- 9 		 코미디
-- 10 		 공연
-- 11 		 다큐멘터리

SELECT * FROM movie_and_genre where movie_id = '20240737';
-- movie_id  genre_id
-- 20240737  8

movie_and_nation, genre, director, actor, show_type, company 테이블 모두 데이터 중복 없이 데이터가 의도대로 삽입되는 것을 확인할 수 있다.
movie_id로 '모아나 2'의 nation, movie_and_nation, genre, movie_and_genre 테이블을 확인해 본 결과, 데이터 삽입이 잘 된 것을 확인할 수 있다.

다음에는, 하루치 데이터가 아닌 장기 데이터를 저장하고 간단한 데이터 분석과 데이터 시각화를 진행해 볼 예정이다.

일단은 일주일치 데이터를 저장해 보고, 다음에는 한 달 치, 일 년 치 데이터를 저장해서 다뤄봐야겠다.

이후에는 매일매일 데이터를 저장하도록 자동화 시스템을 구축해보려고 한다.

또, 데이터 검증과 데이터 품질도 확인해 보면 좋겠다.

[백준][파이썬] 단계별로 풀어보기 - 집합과 맵(10815, 14425, 7785, 1269, 11478)

sehee00 — Mon, 9 Dec 2024 17:32:15 +0900

정답률이 너무 낮은 문제는 풀지 않았다.

10815 숫자 카드

import sys
input = sys.stdin.readline

N = int(input())
my_arr = set(map(int, input().split()))  # 리스트를 집합으로 변환

M = int(input())
serch_arr = list(map(int, input().split()))

# 기존 정렬과 비교하면서 일치하면 1 아니면 0 
result = [1 if num in my_arr else 0 for num in serch_arr]
print(' '.join(map(str, result)))

리스트 컴프리헨션: 리스트를 순회하며 가지고 있으면 1을, 아니면 0을 출력

# 리스트 컴프리헨션 
result = [1 if num in my_arr else 0 for num in my_arr]

# 풀어서 쓰면 
result = []
for num in serch_arr:  # serch_arr의 각 요소를 순회
    if num in my_arr:  # my_arr에 num이 있으면
        result.append(1)  # 1을 추가
    else:  # 없으면
        result.append(0)  # 0을 추가

⚠️ 에러

제출 결과: 시간 초과

N = int(input())
my_arr = list(map(int, input().split()))

# 중복 제거 후 정렬 
sorted_arr = sorted(set(my_arr))

정렬한 집합이 어디에도 쓰이지 않고 불필요해서 아래와 같이 수정했다.

# 리스트를 집합으로 변환
my_arr = set(map(int, input().split()))

14425 문자열 집합

import sys
input = sys.stdin.readline

N, M = map(int, input().split())
my_arr = []
search_arr = []

for _ in range(N):
    my_arr.append(input())

for _ in range(M):
    search_arr.append(input())

cnt = 0 
for word in search_arr:
    if word in my_arr:
        cnt += 1 

# 리스트 컴프리헨션으로 하면 
cnt = sum(1 for word in search_arr if word in my_arr)
 
print(cnt)

Enter로 입력 : arr.append(input())으로 입력받아야함 !!!!

딕셔너리

# 딕셔너리 기본 모습 
{Key1: Value1, Key2: Value2, Key3: Value3, ...}

# 예제 
a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}

a.keys() # dict_keys(['name', 'phone', 'birth'])
a.values() # dict_values(['pey', '010-9999-1234', '1118'])
a.items() # dict_items([('name', 'pey'), ('phone', '010-9999-1234'), ('birth', '1118')])

a.get('name')  # 'pey'
a.get('phone')  #'010-9999-1234'

7785 회사에 있는 사람

import sys
input = sys.stdin.readline

N = int(input())
temp = dict() # 딕셔너리 형 

for _ in range(N):
    a, b = map(str, input().split())

    # 출입
    if b == 'enter':
        temp[a] = b
    # 퇴근시 삭제 
    else:
        del temp[a]

# 사전 순의 역순으로 정렬 
temp = sorted(temp.keys(), reverse=True)

print("\n".join(temp))

딕셔너리 형으로 입력받는게 포인트
역순으로 정렬 reverse=True

집합 자료형

# 집합 자료형 
# 특징: 중복 허용 X, 순서 X 
s = set() 

# 교집합, 합집합, 차집합 구하기 
s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6, 7, 8, 9])

s1 & s2  # {4, 5, 6}
s1.intersection(s2)  # {4, 5, 6}

s1 | s2  # {1, 2, 3, 4, 5, 6, 7, 8, 9}
s1.union(s2)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}

s1 - s2  # {1, 2, 3}
s1.difference(s2)  # {1, 2, 3}
s2 - s1  # {8, 9, 7}
s2.difference(s1)  # {8, 9, 7}


# 집합 자료형 관련 함수
s1 = set([1, 2, 3])

s1.add(4)  # {1, 2, 3, 4}
s1.update([4, 5, 6])  # {1, 2, 3, 4, 5, 6}
s1.remove(2). # {1, 3}

1269 대칭 차집합

import sys
input = sys.stdin.readline

N, M = map(int, input().split())
# 집합 연산은 set 자료형 사용 
A = set(map(int, input().split()))
B = set(map(int, input().split()))

print(len(A-B) + len(B-A))

집합 연산은 set() 자료형 사용

11478 서로 다른 부분 문자열의 개수

import sys
input = sys.stdin.readline

S = input().strip()
word = set()

for i in range(len(S)):
    for j in range(i, len(S)):
        word.add(S[i:j+1])

print(len(word))

[백준][파이썬] 단계별로 풀어보기 - 정렬 모음(2750, 2587, 25305, 2751, 10989, 1427, 11650, 11651, 1181, 10814, 18870)

sehee00 — Thu, 5 Dec 2024 16:19:17 +0900

https://www.acmicpc.net/step/9

2750 수 정렬하기

N = int(input())
arr = []

for i in range(N):
    arr.append(int(input()))

arr.sort()
print('\n'.join(map(str, arr)))

Enter 간격으로 들어오는 1차원 배열 입력받기
리스트를 특정 조건에 맞게 출력하기 - join 함수 이용 # join함수는 내부 요소들이 str이어야 함!

2587 대표값2

arr = []

for _ in range(5):
    arr.append(int(input()))

arr.sort()
print(int(sum(arr)/5))
print(arr[2])

25305 커트라인

N, k = map(int, input().split())
arr = list(map(int, input().split()))
 
arr.sort() 
print(arr[-k]) # 98
# print(arr[-k:-k+1]) # [98]

arr[-k:-k+1]로 출력하니 [] 대괄호 없이 출력이 안됨 -> 인덱싱 슬라이싱은 항상 리스트를 반환
인덱싱(arr[-k])은 리스트의 특정 값을 직접 반환

2751 수 정렬하기2

import sys
input = sys.stdin.readline

N = int(input())
arr = []

for _ in range(N):
    arr.append(int(input()))

arr.sort()
print('\n'.join(map(str, arr)))

카운팅 정렬

count = [0, 0, 0, 0, 0, 0]
숫자 2 → count[2] += 1 → count = [0, 0, 1, 0, 0, 0]
숫자 3 → count[3] += 1 → count = [0, 0, 1, 1, 0, 0]
숫자 2 → count[2] += 1 → count = [0, 0, 2, 1, 0, 0]
숫자 5 → count[5] += 1 → count = [0, 0, 2, 1, 0, 1]
숫자 3 → count[3] += 1 → count = [0, 0, 2, 2, 0, 1]

숫자의 개수를 세는 배열을 만들어 정렬하는 간단한 방법이다! 숫자 범위가 좁고 정수로만 이루어진 데이터에서 매우 효율적이다.
데이터의 등장 횟수를 센다: 각 숫자가 몇 번 등장했는지 기록하는 배열(카운트 배열)을 사용한다.
카운트 배열을 기반으로 데이터를 출력: 등장 횟수만큼 해당 숫자를 출력하면 정렬된 결과가 나온다.

10989 수 정렬하기3

수 정렬하기2와 동일하게 제출하면 '메모리 초과'
힌트 >> 수의 범위가 작다면 카운팅 정렬을 사용하여 더욱 빠르게 정렬할 수 있습니다.

import sys
input = sys.stdin.readline

N = int(input())
count = [0] * 10001 # 입력값이 10000개까지 주어지니 10000 + 1개의 리스트 선언

# 등장 횟수를 누적합으로 구하기 
for _ in range(N):
    input_num = int(input())
    count[input_num] += 1

# 인덱스 데이터만 출력 
for i in range(len(count)):
    for j in range(count[i]):
        print(i)

1427 소트인사이드

import sys
input = sys.stdin.readline

arr = list(map(int, input().strip()))
arr.sort()
print(''.join(map(str,arr[::-1])))

[ ] 대괄호 없이 출력: ''.join(map(str, list))

11650 좌표 정렬하기

import sys
input = sys.stdin.readline

N = int(input())
arr = []

for _ in range(N):
    arr.append(list(map(int, input().split())))

arr.sort()
for i in range(N):
    print(' '.join(map(str, arr[i])))

11651 좌표 정렬하기2

import sys
input = sys.stdin.readline

N = int(input())
arr = []

for _ in range(N):
    arr.append(list(map(int, input().split())))

# y좌표, x좌표 순서로 정렬
arr.sort(key=lambda x: (x[1], x[0]))

# arr.sort(key=lambda x: x[1])
for i in range(N):
    print(' '.join(map(str, arr[i])))

sort(key = lambda x: (x[1], x[0]): 다중 조건 정렬은 key를 이용

1181 단어 정렬

import sys
input = sys.stdin.readline

N = int(input())
arr = []
new_arr = []

for _ in range(N):
    arr.append(list(input()))

arr.sort()
arr.sort(key=lambda x: (len(x)))

for i in arr:
    if i not in new_arr:
        new_arr.append(i)

for i in range(len(new_arr)):
    print(''.join(map(str, new_arr[i])), end='')

리스트 중복 제거: 기존 리스트 반복하며 새로운 리스트에 없으면 넣어줌
개행문자 제거하여 출력: end = ''

10814 나이순 정렬

import sys
input = sys.stdin.readline

N = int(input())
arr = []

for _ in range(N):
    arr.append(list(input().split()))

for i in range(N):
    arr[i][0] = int(arr[i][0])

arr.sort(key=lambda x: x[0])
for i in range(N):
    print(' '.join(map(str, arr[i])))

좌표 압축

ex. 2, 4, -10, 4, -9

1. 중복을 제거하고, 값을 오름차순 정렬:
-10, -9, 2, 4

2. 각 값에 순위를 부여:
-10 -> 0
-9  -> 1
2   -> 2
4   -> 3

3. 원래 리스트에서 각 값의 순위를 찾아 변환:
2   -> 2
4   -> 3
-10 -> 0
4   -> 3
-9  -> 1

출력: 2 3 0 3 1

좌표 압축은 큰 범위의 숫자 값을 작은 범위의 숫자로 변환하는 방법
주어진 좌표를 크기순으로 정렬하여 상대적 순위를 계산
순위를 기준으로 좌표를 변환(압축)한 결과를 출력
즉, 작은 값부터 시작해 0부터 인덱스를 부여

enumerate 함수

enumerate(iterable, start=0)
# iterable: 반복 가능한(iterable) 객체, 예를 들면 리스트(list), 튜플(tuple), 문자열(str), 딕셔너리(dictionary) 등
# start: 인덱스의 시작값을 설정, 기본값은 0

fruits = ["apple", "banana", "cherry"]
for i in range(len(fruits)):
    print(f"과일 리스트에서 {i} 인덱스 요소는 {fruit} 이다")
    
#출력
#과일 리스트에서 1 인덱스 요소는 apple 이다
#과일 리스트에서 2 인덱스 요소는 banana 이다
#과일 리스트에서 3 인덱스 요소는 cherry 이다

"enumerate" 함수는 주로 for 루프와 함께 사용
for 루프는 반복 가능한(iterable) 객체를 순회하면서, 각 요소를 처리
반복 가능한(iterable) 객체를 인자로 받아서 해당 객체의 요소들을 순회하면서, 각 요소의 인덱스와 값을 순서쌍으로 반환

18870 좌표 압축

import sys
input = sys.stdin.readline

N = int(input())
arr = list(map(int, input().split()))

# 중복 제거 후 정렬 
sorted_unique = sorted(set(arr)) 

# 각 값을 순위(0부터 시작)로 매핑하는 딕셔너리를 생성
index_map = {value: idx for idx, value in enumerate(sorted_unique)}

# 원래 배열의 값을 순위로 변환하여 새로운 배열을 생성
result = [index_map[value] for value in arr]

print(' '.join(map(str, result)))

enumerate(): 각 요소의 인덱스와 값을 순서쌍으로 반환
값 -> 순위로 매핑: value: idx

[백준][파이썬] 단계별로 풀어보기 - 2차원 배열 모음(2783, 2566, 10798, 2563)

sehee00 — Tue, 3 Dec 2024 14:18:48 +0900

https://www.acmicpc.net/step/2

1차원 배열 입력받기

arr = list(map(int, input().split()))

띄어쓰기 간격으로 들어오는 경우
list(): map의 결과를 배열로 반환
map(int, 리스트): 리스트의 모든 요소를 int로 변환

arr = []

for i in range(N):
    arr.append(int(input()))

Enter 간격으로 들어오는 경우

2차원 배열 입력받기

arr = []

for i in range(N):    
	arr.append(list(map(int, input().split())))

배열의 세로길이, 즉 열의 길이를 아는 경우에만 사용 가능

2783 행렬 덧셈

A, B = [], [] 
N, M = map(int, input().split())

for i in range(N):
    A.append(list(map(int, input().split())))


for i in range(N):
    B.append(list(map(int, input().split())))

for i in range(N):
    for j in range(M):
        print(A[i][j] + B[i][j], end = ' ')
    print()

2차원 행렬의 최대값, 최소값, 합 구하기 - map 함수 이용

x = [[1,0,-30,6,5],
[3,4,7,8,1],
     [3,2,6,7,1],
     [-1,2,3,6,8],
     [99,1,2,3,6,8]]

print(max(map(max, x))) # 최대값 99
print(min(map(min, x))) # 최소값 -30
print(min(map(max, x))) # 내부 배열의 최대 값들 중에서 가장 작은 값 6
print(max(map(min, x))) # 내부 배열의 최소 값들 중에서 가장 큰 값 1
print(sum(map(sum, x))) # 2차원 배열의 모든 값의 합

리스트를 특정 조건에 맞게 출력 - join 함수 이용

# join 함수는 내부 요소들이 Str 타입일 경우만 가능!
y = [0,1,2,2,3]

print(''.join(map(str,y))) # 01223
print(','.join(map(str,y))) # 0,1,2,2,3
print('\n'.join(map(str,y)))
# 0
# 1
# 2
# 2
# 3

2566 최댓값

A = [] 

for i in range(9):
    A.append(list(map(int, input().split())))

num = max(list(map(max, A)))
print(num)

for i in range(9):
    for j in range(9):
        if num == A[i][j]:
            print(i+1, j+1, end= ' ')

10798 세로읽기

A = [] 
B = "" # 세로로 읽은 문자열 저장

for i in range(5):
    A.append(list(map(str, input().strip())))

# 가장 긴 문자열의 길이 
max_len = max(len(word) for word in A)

for i in range(max_len):
    for j in range(5):
        if i < len(A[j]):
            B += A[j][i]

print(B)

첫 번째 입출력에 맞춰 푸니 두 번째 입출력에서 바로 막혔다. 처음부터 조건에 맞춰 풀자
if i < len(A[j]): 현재 열(i)이 해당 행(A[j])의 길이보다 작은 경우에만 문자를 읽도록 제한 !!!
예를 들어, i = 4일 때, len(A[3]) = 3. 따라서 A[3][4]는 존재하지 않으므로 IndexError가 발생

2563 색종이

이걸 어떻게 풀지 ??? 싶었는데 쉬운 방법이 있었다.
1X1 픽셀로 생각하면 된다.

n = int(input())
arr = [[0] * 100 for _ in range(100)]

for _ in range(n):
    a, b = map(int, input().split())
    for i in range(a, a + 10):
        for j in range(b, b + 10):
            arr[i][j] = 1 

cnt = 0 
for i in range(100):
    cnt += arr[i].count(1)

print(cnt)

도화지 크기는 100 * 100으로 고정, 검은색 색종이는 10 * 10의 크기로 고정
열을 돌면서 행마다 1인 값을 찾아서 개수를 세주면 됨 !!!

[백준-2667] python3 단지 번호 붙이기

sehee00 — Mon, 2 Dec 2024 20:35:00 +0900

문제

<그림 1>과 같이 정사각형 모양의 지도가 있다. 1은 집이 있는 곳을, 0은 집이 없는 곳을 나타낸다. 철수는 이 지도를 가지고 연결된 집의 모임인 단지를 정의하고, 단지에 번호를 붙이려 한다. 여기서 연결되었다는 것은 어떤 집이 좌우, 혹은 아래위로 다른 집이 있는 경우를 말한다. 대각선상에 집이 있는 경우는 연결된 것이 아니다. <그림 2>는 <그림 1>을 단지별로 번호를 붙인 것이다. 지도를 입력하여 단지수를 출력하고, 각 단지에 속하는 집의 수를 오름차순으로 정렬하여 출력하는 프로그램을 작성하시오.

입력

첫 번째 줄에는 지도의 크기 N(정사각형이므로 가로와 세로의 크기는 같으며 5≤N≤25)이 입력되고, 그 다음 N줄에는 각각 N개의 자료(0혹은 1)가 입력된다.

출력

첫 번째 줄에는 총 단지수를 출력하시오. 그리고 각 단지내 집의 수를 오름차순으로 정렬하여 한 줄에 하나씩 출력하시오.

문제 풀이

N = int(input()) 
graph = [list(map(int, input())) for _ in range(N)] # 지도 정보 
num = [] # 단지별 집의 개수를 저장할 리스트 

dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

def DFS(x, y):
	if x < 0 or x >= N or y < 0 or y >= N:
    	return False
        
    if graph[x][y] == 1: # 아직 방문하지 않은 집의 위치 
    	global count 
        count += 1 # 단지의 집 개수 +1 
        graph[x][y] = 0 # 방문 처리 
        
       	for i in range(4): 
        	nx = x + dx[i]
            ny = y + dy[i]
            DFS(nx, ny)
            
        return True  # 단지를 찾았음을 반환
    return False  # 방문하지 않았거나 집이 없는 경우

count = 0 # 현재 단지의 집 개수 
result = 0 # 총 단지 수 

for i in range(N):
	for j in range(N):
    	if DFS(i, j) == True: # 새로운 단지를 발견한 경우 
        	num.append(count) # 현재 단지의 집 개수 저장 
            result += 1 # 단지 개수 증가 
            count = 0 # 다음 단지를 위해 초기화 
            
num.sort() # 단지 크기 정렬 
print(result) # 총 단지 수 출력 

for i in range(len(num)): # 각 단지 크기 출력 
	print(num[i])

참고사이트:

[백준][Python] 2667번 단지번호붙이기

https://www.acmicpc.net/problem/2667<그림 1>과 같이 정사각형 모양의 지도가 있다. 1은 집이 있는 곳을, 0은 집이 없는 곳을 나타낸다. 철수는 이 지도를 가지고 연결된 집의 모임인 단지를 정의하고, 단지

velog.io

[오블완] 작심삼주 오블완 챌린지 결산 ✨

sehee00 — Wed, 27 Nov 2024 23:04:46 +0900

어쩌다 보니 챌린지 100% 달성 !

의도하진 않았지만, 진로에 대한 방향을 결정하고 기술 블로그를 해야겠다 마음먹은 즈음과 챌린지가 겹쳐서

11월 6일부터 27일, 오늘까지 22일간 매일 블로글 글을 작성했다.

칭찬해 !!!!!!!!!!! 나 자신, 너무 칭찬한다.

잘했다. 뿌듯하다. 하면 된다. 할 수 있다.

올 해도 얼마 안남았다.

이번 년도는 나에게 큰 변화가 많았던 한 해다.

좋은 일도, 안 좋은 일도 있었지만 어쨌든 좋은 한 해였던 건 분명하다.

내년을 기대하며 남은 올 해도 잘 보내고 싶다.

1	1	0	0	0	0	0	0
0	1	0	0	0	0	0	0
0	0	0	0	1	0	0	0
0	0	0	0	1	0	0	0
0	0	1	1	0	1	1	1
0	0	0	0	1	1	1	1

1	1	0	0	0	0	0	0
0	1	0	0	0	0	0	0
0	0	0	0	1	0	0	0
0	0	0	0	1	0	0	0
0	0	1	1	0	1	1	1
0	0	0	0	1	1	1	1

1	1	0	0	0	0	0	0
0	1	0	0	0	0	0	0
0	0	0	0	1	0	0	0
0	0	0	0	1	0	0	0
0	0	1	1	0	1	1	1
0	0	0	0	1	1	1	1