어제 오늘 내일

[Python 실전] 텍스트 파일을 읽어 딕셔너리로 변환하는 3가지 방법

hi.anna — Sat, 13 Jun 2026 12:38:50 +0900

1. JSON 형식으로 저장된 텍스트 읽기 (가장 추천)

파일 내용이 { "key": "value" } 형태라면 json 모듈을 사용하는 것이 가장 빠르고 안전합니다. 한 줄씩 읽을 필요 없이 파일 전체를 한 번에 딕셔너리로 복구합니다.

예제 코드

import json

# 파일 읽기
with open("user.txt", "r", encoding="utf-8") as f:
    # 파일 전체 내용을 딕셔너리로 바로 변환
    data_dict = json.load(f)

print(data_dict)
print(type(data_dict)) # <class 'dict'>

2. "Key: Value" 형태로 한 줄씩 기록된 경우

메모장 등에 과목: 점수처럼 사람이 읽기 좋게 기록된 텍스트는 한 줄씩 읽어서 직접 쪼개야 합니다.

예제 코드: 활용

# scores.txt 내용 예시:
# 수학: 90
# 영어: 85

result_dict = {}

with open("scores.txt", "r", encoding="utf-8") as f:
    for line in f:
        # 1. 줄바꿈 문자 제거 및 ' : ' 기준으로 쪼개기
        line = line.strip()
        if ":" in line:
            key, value = line.split(":")
            # 2. 앞뒤 공백 제거 후 딕셔너리에 추가
            result_dict[key.strip()] = value.strip()

print(result_dict)
# 출력: {'수학': '90', '영어': '85'}

3. 여러 개의 데이터가 줄바꿈으로 구분된 경우

예를 들어 ID, 이름, 지역이 한 줄씩 길게 나열된 텍스트 파일을 딕셔너리 리스트로 만드는 방법입니다.

예제 코드: 실무형 데이터 파싱

# data.txt 내용 예시:
# 1,철수,서울
# 2,영희,부산

user_list = []
keys = ["id", "name", "city"]

with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        values = line.strip().split(",")
        # zip을 사용해 key와 value를 매칭한 뒤 딕셔너리 생성
        user_dict = dict(zip(keys, values))
        user_list.append(user_dict)

print(user_list)
# 출력: [{'id': '1', 'name': '철수', 'city': '서울'}, ...]

핵심 요약 및 주의사항

.strip() 사용: 파일을 읽으면 줄 끝에 눈에 보이지 않는 줄바꿈 문자(\n)가 포함되므로 반드시 제거해야 합니다.
구분자 확인: 데이터가 :로 나뉘어 있는지, ,로 나뉘어 있는지 확인하고 split() 안에 넣어주세요.
데이터 타입: 파일에서 읽어온 모든 값은 기본적으로 문자열(str)입니다. 숫자가 필요하다면 int(value)로 직접 바꿔주어야 합니다.

[Python 실전] 파이썬 딕셔너리를 TXT 파일로 저장하는 법

hi.anna — Wed, 10 Jun 2026 11:53:38 +0900

1. 나중에 다시 읽을 수 있게 저장하기 (추천)

가장 좋은 방법은 json 모듈이나 str() 함수를 사용하는 것입니다. 텍스트 파일이지만 딕셔너리의 구조({ })를 그대로 유지하여 저장합니다.

방법 1: 모듈 활용 (가장 표준적인 방식)

.txt 확장자로 저장하더라도 내부 형식을 JSON으로 유지하면 나중에 데이터를 다시 불러와서 딕셔너리로 복구하기가 매우 쉽습니다.

import json

user_data = {"name": "철수", "age": 25, "city": "서울"}

# txt 파일로 저장
with open("user.txt", "w", encoding="utf-8") as f:
    # indent를 주면 보기 좋게 저장됩니다.
    json.dump(user_data, f, ensure_ascii=False, indent=4)

print("txt 파일에 딕셔너리 구조로 저장 완료!")

2. 사람이 보기 편한 '리스트' 형태로 저장하기

키와 값을 한 줄씩 예쁘게 나열하여 메모장처럼 저장하고 싶을 때 사용합니다.

방법 2: 반복문을 활용한 커스텀 저장

scores = {"수학": 90, "영어": 85, "과학": 95}

with open("scores.txt", "w", encoding="utf-8") as f:
    f.write("--- 성적표 ---\n")
    for subject, score in scores.items():
        # "과목: 점수" 형태로 한 줄씩 기록
        f.write(f"{subject}: {score}점\n")
    f.write("--------------")

print("사람이 읽기 편한 메모 형태로 저장 완료!")

3. 복잡한 객체 그대로 저장하기: 모듈

딕셔너리 안에 튜플이나 커스텀 클래스 객체처럼 JSON으로 담기 힘든 파이썬 전용 데이터가 섞여 있다면 pickle을 사용합니다. 단, 사람이 읽을 수는 없는 바이너리 형태로 저장됩니다.

import pickle

complex_data = {"id": 1, "coord": (10, 20), "tags": {"python", "coding"}}

# 'wb'는 Write Binary의 약자입니다.
with open("data.txt", "wb") as f:
    pickle.dump(complex_data, f)

# 다시 불러올 때
with open("data.txt", "rb") as f:
    loaded_data = pickle.load(f)
    print(loaded_data)

어떤 방법을 선택할까요?

저장 방식	확장자	특징	추천 용도
JSON 방식	`.txt` / `.json`	구조 유지, 범용성 높음	가장 권장 (데이터 보관용)
반복문 방식	`.txt`	사람이 읽기 가장 편함	로그 기록, 간단한 리포트
Pickle 방식	`.txt` / `.pkl`	파이썬 전용 데이터 완벽 보존	복잡한 파이썬 객체 저장

실무 팁: 한글 깨짐 방지

텍스트 파일로 저장할 때 encoding="utf-8"을 빼먹으면 한글이 깨져서 저장될 수 있습니다. 윈도우와 맥/리눅스 어디서든 잘 보이게 하려면 항상 이 옵션을 넣어주는 습관을 가지세요!

이제 딕셔너리를 JSON, CSV, TXT 모든 형식으로 저장하실 수 있게 되었습니다!

[Python 실전] 파이썬 딕셔너리를 CSV 파일로 저장하는 법

hi.anna — Mon, 8 Jun 2026 23:33:45 +0900

1. 여러 개의 딕셔너리(리스트 형태) 저장하기

가장 흔한 경우입니다. 리스트 안에 여러 개의 딕셔너리가 들어 있는 형태(JSON 배열 형태)를 CSV로 저장할 때는 파이썬 내장 csv 모듈의 DictWriter를 사용합니다.

실전 예제: 활용

import csv

# 저장할 데이터 (리스트 안의 딕셔너리 형태)
data = [
    {"이름": "철수", "나이": 25, "직업": "개발자"},
    {"이름": "영희", "나이": 30, "직업": "디자이너"},
    {"이름": "민수", "나이": 28, "직업": "데이터 분석가"}
]

# 1. 파일 열기 (newline=''은 윈도우에서 줄바꿈 중복 방지)
with open("members.csv", "w", encoding="utf-8-sig", newline="") as f:
    # 2. 필드 이름(컬럼명) 설정
    fieldnames = ["이름", "나이", "직업"]

    # 3. DictWriter 객체 생성
    writer = csv.DictWriter(f, fieldnames=fieldnames)

    # 4. 헤더(컬럼명) 쓰기
    writer.writeheader()

    # 5. 데이터 쓰기 (리스트 전체를 한 번에 저장)
    writer.writerows(data)

print("CSV 파일 저장이 완료되었습니다.")

utf-8-sig: 엑셀에서 한글이 깨지지 않도록 인코딩하는 팁입니다.
writeheader(): 딕셔너리의 키를 CSV의 첫 번째 줄(제목)로 만듭니다.

2. 단일 딕셔너리(Key-Value 쌍) 저장하기

하나의 딕셔너리에 담긴 정보를 '항목명-값'의 형태로 저장하고 싶을 때 사용합니다.

실전 예제: Key와 Value를 두 컬럼으로 저장

import csv

user_info = {
    "ID": "python_user",
    "Level": 99,
    "Status": "Active",
    "Point": 1500
}

with open("user_info.csv", "w", encoding="utf-8-sig", newline="") as f:
    writer = csv.writer(f)
    # 제목 줄 추가
    writer.writerow(["항목", "값"])

    # 딕셔너리의 데이터를 한 줄씩 쓰기
    for key, value in user_info.items():
        writer.writerow([key, value])

3. 실무 끝판왕: Pandas 활용하기

데이터 양이 많고 복잡하다면 Pandas 라이브러리를 쓰는 것이 가장 빠르고 강력합니다.

실전 예제: 활용

import pandas as pd

data = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 30}
]

# 1. 딕셔너리 리스트를 데이터프레임으로 변환
df = pd.DataFrame(data)

# 2. 바로 CSV로 저장 (index=False는 왼쪽 번호 생략)
df.to_csv("data.csv", index=False, encoding="utf-8-sig")

핵심 요약

표 형태의 데이터: csv.DictWriter를 사용하여 Key를 헤더로, Value를 데이터로 저장한다.
한글 깨짐 방지: encoding="utf-8-sig"를 사용하면 엑셀에서 바로 열어도 한글이 깨지지 않는다.
편의성: 복잡한 가공이 필요하다면 Pandas를 사용하는 것이 훨씬 효율적이다.

[Python 실전] 파이썬 딕셔너리를 파일로 저장하는 법: JSON 활용 가이드

hi.anna — Mon, 8 Jun 2026 06:46:43 +0900

1. JSON이란 무엇인가요?

JSON은 데이터를 저장하거나 전송할 때 사용하는 경량의 데이터 형식입니다. 파이썬의 딕셔너리({}) 및 리스트([]) 구조와 거의 1:1로 매칭되기 때문에 변환이 매우 쉽습니다.

2. 딕셔너리를 JSON 파일로 저장하기 ()

파이썬 내장 모듈인 json을 임포트하여 사용합니다. dump() 함수는 딕셔너리를 파일 객체로 직접 써넣어 줍니다.

실전 예제: 설정값 저장하기

import json

# 저장할 딕셔너리 데이터
config = {
    "user_id": "gemini_dev",
    "theme": "dark_mode",
    "notifications": True,
    "recent_projects": ["AI_bot", "Web_scraper"]
}

# 1. 파일 열기 (w: 쓰기 모드)
with open("user_config.json", "w", encoding="utf-8") as f:
    # 2. 딕셔너리를 JSON 파일로 저장
    # indent: 들여쓰기 칸수 (가독성 향상)
    # ensure_ascii=False: 한글 깨짐 방지
    json.dump(config, f, indent=4, ensure_ascii=False)

print("설정 파일이 저장되었습니다.")

3. JSON 파일을 딕셔너리로 불러오기 ()

반대로 저장된 파일을 읽어와 파이썬 딕셔너리 객체로 다시 변환하는 방법입니다.

실전 예제: 설정값 불러오기

import json

# 1. 파일 열기 (r: 읽기 모드)
with open("user_config.json", "r", encoding="utf-8") as f:
    # 2. JSON 파일을 딕셔너리로 변환
    loaded_config = json.load(f)

print(f"사용자 ID: {loaded_config['user_id']}")
print(f"최근 프로젝트: {loaded_config['recent_projects'][0]}")

4. 꿀팁: vs , vs 차이점

초보자들이 가장 헷갈려 하는 부분입니다. 뒤에 's'가 붙느냐 안 붙느냐에 따라 대상이 달라집니다.

dump() / `load()`: 파일(File)을 직접 다룰 때 사용 (f 같은 파일 객체 필요)
dumps() / `loads()`: 문자열(String)로 변환하거나 읽을 때 사용 (네트워크 전송 시 유용)

예제: 딕셔너리를 문자열로 바꾸기

# 딕셔너리를 한 줄짜리 JSON 문자열로 변환
json_string = json.dumps(config)
print(type(json_string)) # <class 'str'>

핵심 요약

모듈 임포트: import json은 필수입니다.
한글 설정: 한글이 들어있다면 ensure_ascii=False 옵션을 꼭 넣어주세요.
가독성: indent=4 옵션을 사용하면 텍스트 편집기에서 파일을 볼 때 구조가 명확하게 보입니다.
파일 닫기: with open(...) 구문을 사용하면 작업이 끝난 후 파일이 자동으로 안전하게 닫힙니다.

[Python 실전] 딕셔너리로 코드 속도 10배 올리기: 메모이제이션(Memoization)

hi.anna — Sun, 7 Jun 2026 22:44:47 +0900

1. 메모이제이션(Memoization)이란?

컴퓨터 프로그래밍에서 메모이제이션은 동일한 계산을 반복해야 할 때, 이전에 계산한 값을 딕셔너리 같은 저장 공간에 '메모'해 두었다가 다시 사용하는 기술입니다.
복잡한 연산을 매번 처음부터 다시 하지 않고, "아! 이거 아까 계산해둔 건데?" 하고 딕셔너리에서 바로 꺼내 쓰기 때문에 속도가 획기적으로 빨라집니다.

2. 왜 딕셔너리를 사용하나요?

메모이제이션의 핵심은 검색 속도입니다. 파이썬의 딕셔너리(Dictionary)는 내부적으로 해시 테이블(Hash Table) 구조를 사용하기 때문에, 데이터가 아무리 많아도 내가 원하는 값을 찾는 속도가 거의 일정하고 매우 빠릅니다. (시간 복잡도 $O(1)$)

3. 실전 예제: 피보나치 수열 (Fibonacci)

피보나치 수열은 재귀 함수로 구현할 때 중복 계산이 가장 많이 발생하는 대표적인 알고리즘입니다.

❌ 일반 재귀 방식 (매우 느림)

n=40만 되어도 연산 횟수가 수억 번에 달해 컴퓨터가 버벅이기 시작합니다.

def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

✅ 딕셔너리 메모이제이션 방식 (매우 빠름)

한 번 구한 값은 memo 딕셔너리에 저장하므로, 동일한 계산은 단 한 번만 수행됩니다.

# 결과를 저장할 캐시 딕셔너리
memo = {}

def fib_memo(n):
    # 1. 이미 메모에 적혀있다면 바로 반환
    if n in memo:
        return memo[n]

    # 2. 기본 조건 처리
    if n <= 1:
        return n

    # 3. 계산 후 결과를 메모에 저장
    memo[n] = fib_memo(n-1) + fib_memo(n-2)
    return memo[n]

print(fib_memo(100)) # 354224848179261915075 (0.001초 만에 결과 출력)

4. 고수들의 한 줄 팁:

사실 파이썬에서는 딕셔너리를 직접 만들지 않아도 이 기능을 사용할 수 있습니다. functools 라이브러리의 @lru_cache 데코레이터를 함수 위에 붙여주기만 하면 됩니다.

from functools import lru_cache

@lru_cache(maxsize=None)
def fib_smart(n):
    if n <= 1:
        return n
    return fib_smart(n-1) + fib_smart(n-2)

핵심 요약

중복 연산 제거: 똑같은 입력값에 대해 반복 계산이 일어난다면 메모이제이션을 고려하세요.
딕셔너리 활용: Key는 입력값, Value는 결과값으로 저장하여 캐시로 활용합니다.
효과: 연산량이 기하급수적으로 줄어들어 프로그램의 성능이 극대화됩니다.

[Python 실전] "복잡한 JSON도 척척!" 중첩 딕셔너리 데이터 추출 기술

hi.anna — Sun, 7 Jun 2026 08:48:16 +0900

1. 중첩 구조 접근의 정석 (계단식 접근)

JSON 데이터는 보통 딕셔너리와 리스트가 층층이 쌓인 구조입니다. 대괄호[]를 연달아 써서 안쪽으로 들어갈 수 있습니다.

예제 코드: 기상청 API 데이터 가공하기 (가상)

weather_json = {
    "status": "OK",
    "result": {
        "location": "Seoul",
        "forecast": [
            {"date": "2026-02-25", "temp": 12, "desc": "Sunny"},
            {"date": "2026-02-26", "temp": 8, "desc": "Rainy"}
        ]
    }
}

# '내일(26일)의 기온'을 가져오고 싶다면?
# 딕셔너리(result) -> 딕셔너리(forecast) -> 리스트의 두 번째[1] -> 딕셔너리(temp)
tomorrow_temp = weather_json["result"]["forecast"][1]["temp"]

print(f"내일 기온: {tomorrow_temp}도") # 8도

2. 에러 방지용 필수 기술: 체이닝

중첩 구조에서 가장 큰 문제는 중간에 키가 하나라도 없으면 코드가 멈춘다는 것입니다. 이를 방지하기 위해 get()을 연속으로 사용하거나 기본값을 빈 딕셔너리로 주는 팁이 있습니다.

팁 1: 안전하게 파고들기

# 'description' 키가 없을 수도 있는 상황이라면?
# 중간에 None이 반환되면 다음 get에서 에러가 날 수 있으므로 빈 딕셔너리{}를 기본값으로 줍니다.
desc = weather_json.get("result", {}).get("forecast", [{}])[0].get("desc", "정보 없음")

3. 고수의 도구: 라이브러리 (강력 추천)

만약 구조가 너무 깊고 복잡하다면, 파이썬 기본 기능만으로는 코드가 매우 지저분해집니다. 이때 glom이라는 라이브러리를 사용하면 마치 파일 경로를 적듯 데이터를 추출할 수 있습니다.

예제 코드: glom으로 한 줄에 추출하기

# pip install glom
from glom import glom

target_path = 'result.forecast.1.temp'
temp = glom(weather_json, target_path)

print(temp) # 8

4. 실전 활용: 데이터 전처리 (리스트 컴프리헨션 콜라보)

중첩 구조 안에 있는 특정 값들만 모아서 새로운 리스트를 만들 때 가장 많이 사용됩니다.

예제 코드: 모든 날짜의 기온만 리스트로 뽑기

# forecast 리스트 안의 모든 딕셔너리에서 'temp'만 추출
all_temps = [f["temp"] for f in weather_json["result"]["forecast"]]

print(all_temps) # [12, 8]

중첩 데이터 파싱 핵심 요약

구조 파악: 먼저 데이터의 어디가 딕셔너리{}이고 어디가 리스트[]인지 구분하세요.
안전 우선: 실무에서는 json["key"]보다는 json.get("key", {})처럼 기본값을 설정하는 습관이 프로그램을 튼튼하게 만듭니다.
반복문 활용: 리스트 형태의 중첩 데이터는 리스트 컴프리헨션으로 가공하는 것이 가장 빠르고 깔끔합니다.

[Python 실전] "KeyError는 이제 안녕!" 딕셔너리 안전 삭제 및 병합 가이드

hi.anna — Thu, 4 Jun 2026 11:30:03 +0900

1. 안전하게 삭제하기: 보다는

대부분 del dic["key"]를 먼저 배우지만, 이 방식은 키가 없으면 즉시 에러를 발생시킵니다. 실무에서는 .pop()을 사용하여 기본값을 설정하는 방식을 훨씬 선호합니다.

팁 1: 의 기본값(Default) 활용

키가 없어도 에러를 내지 않고 None이나 지정한 메시지를 반환하게 할 수 있습니다.

user = {"name": "제미니", "level": 10}

# 키가 없어도 에러 없이 안전하게 삭제 시도
# pop(키, 키가 없을 때 반환할 값)
removed_value = user.pop("email", "해당 키가 없습니다")

print(removed_value)  # 해당 키가 없습니다.
print(user)           # 원본은 그대로 유지됨

팁 2: 조건문을 활용한 삭제

여러 개의 키를 삭제해야 한다면 딕셔너리 컴프리헨션으로 '삭제할 것만 빼고' 새로 만드는 것이 더 안전하고 깔끔합니다.

data = {"a": 1, "b": 2, "c": 3, "d": 4}
remove_keys = {"b", "d"}

# b와 d를 제외한 나머지만 모아서 새 딕셔너리 생성
clean_data = {k: v for k, v in data.items() if k not in remove_keys}

2. 스마트하게 병합하기: 와 연산자

여러 곳에서 수집된 데이터를 하나로 합칠 때, 단순히 덮어쓰는 것이 아니라 효율적으로 병합하는 방법입니다.

팁 3: 파이썬 3.9+ '병합 연산자' 사용하기

최신 파이썬 버전에서는 | 기호 하나로 딕셔너리를 합칠 수 있습니다. 가독성이 매우 좋아집니다.

dict_a = {"apple": 1, "banana": 2}
dict_b = {"banana": 3, "cherry": 4}

# 병합 (뒤에 오는 dict_b의 값이 우선순위를 가집니다)
merged = dict_a | dict_b

print(merged) 
# {'apple': 1, 'banana': 3, 'cherry': 4}

팁 4: 원본을 유지하며 합치기 vs 수정하기

.update(): dict_a 자체를 수정하여 합칩니다.
`{dict_a, dict_b}`: 두 딕셔너리를 해체해서 새로운 딕셔너리를 만듭니다. (구버전 파이썬에서도 작동하는 팁)

3. 중복 키가 걱정될 때:

병합할 때 같은 키가 있으면 값이 덮어씌워지는 게 일반적입니다. 하지만 "기존 값을 유지하면서 새로운 값을 추가"하고 싶다면(예: 한 사람의 여러 취미를 모으는 경우), defaultdict가 정답입니다.

from collections import defaultdict

# 리스트를 기본값으로 가지는 딕셔너리 생성
hobby_map = defaultdict(list)

# 데이터 합치기 시도 (Key 존재 여부를 확인할 필요가 없음!)
data = [("철수", "축구"), ("영희", "독서"), ("철수", "농구")]

for name, hobby in data:
    hobby_map[name].append(hobby)

print(dict(hobby_map))
# {'철수': ['축구', '농구'], '영희': ['독서']}

핵심 요약

삭제할 때: 키 존재 여부가 불확실하다면 dic.pop("key", None)을 써라.
병합할 때: 최신 파이썬이라면 dict_a | dict_b가 가장 깔끔하다.
데이터를 누적할 때: defaultdict(list)를 쓰면 KeyError 없이 데이터를 쌓을 수 있다.

[Python 실전] "딕셔너리 고수되는 법" 정렬과 컴프리헨션 완벽 마스터

hi.anna — Wed, 3 Jun 2026 06:03:30 +0900

1. 딕셔너리 정렬 (Sorting)

딕셔너리는 기본적으로 순서가 중요하지 않은 자료형이지만, 출력하거나 분석할 때는 Key(이름표)나 Value(값)를 기준으로 정렬해야 할 때가 많습니다.

Key(이름표) 기준 정렬

sorted() 함수를 사용하면 기본적으로 Key를 기준으로 정렬된 Key 리스트를 반환합니다.

scores = {"철수": 85, "영희": 90, "민수": 75}

# 1. Key 기준 오름차순 (가나다순)
sorted_keys = sorted(scores)
print(sorted_keys) # ['민수', '영희', '철수']

# 2. Key 기준 정렬된 새로운 딕셔너리 만들기
sorted_dict = {k: scores[k] for k in sorted(scores)}

Value(값) 기준 정렬 (★실무 필수)

"점수가 높은 순서대로 정렬해 줘!"라고 할 때 쓰는 방식입니다. lambda 함수를 활용합니다.

# 점수가 높은 순(내림차순)으로 정렬
# x[1]은 딕셔너리의 (Key, Value) 튜플에서 1번 인덱스인 Value를 의미합니다.
sorted_by_score = sorted(scores.items(), key=lambda x: x[1], reverse=True)

print(sorted_by_score)
# 출력: [('영희', 90), ('철수', 85), ('민수', 75)]

2. 딕셔너리 컴프리헨션 (Dictionary Comprehension)

리스트 컴프리헨션처럼, 딕셔너리도 한 줄로 새롭게 생성하거나 필터링할 수 있습니다.

예제 1: 기존 데이터를 가공해서 만들기

모든 학생의 점수에 가산점 5점을 더한 새로운 딕셔너리를 만든다면?

# { Key: Value for 반복문 }
plus_scores = {name: score + 5 for name, score in scores.items()}
print(plus_scores) 
# {'철수': 90, '영희': 95, '민수': 80}

예제 2: 특정 조건으로 필터링하기

80점 이상인 '우수 학생'만 따로 골라내고 싶다면?

# 뒤에 if 조건을 붙여줍니다.
top_students = {name: score for name, score in scores.items() if score >= 80}
print(top_students) 
# {'철수': 85, '영희': 90}

3. 실전 팁: Key와 Value 뒤집기

데이터를 찾다 보면 가끔 "점수를 넣으면 이름이 나오게" 구조를 바꿔야 할 때가 있습니다.

# { Value: Key for Key, Value in 딕셔너리.items() }
reverse_scores = {v: k for k, v in scores.items()}

print(reverse_scores)
# {85: '철수', 90: '영희', 75: '민수'}

요약

정렬: sorted(scores.items(), key=lambda x: x[1]) 공식을 외워두면 점수/가격순 정렬이 아주 쉬워집니다.
컴프리헨션: 대량의 딕셔너리 데이터를 정제할 때 if문과 함께 사용하면 코드가 획기적으로 줄어듭니다.
순서 유지: 파이썬 3.7부터는 딕셔너리에 데이터를 넣은 순서가 기본적으로 유지되므로 안심하고 사용하세요!

[Python 기초] 딕셔너리(Dictionary) 완벽 가이드

hi.anna — Tue, 26 May 2026 11:00:45 +0900

1. 딕셔너리 만들기 (생성과 추가)

중괄호 {}를 사용하며, Key: Value 형태로 짝을 지어줍니다.

# 1. 딕셔너리 생성
user = {
    "name": "제미니",
    "level": 10,
    "job": "AI 메이트"
}

# 2. 새로운 데이터 추가
user["location"] = "Seoul"

# 3. 값 수정 (기존에 있는 Key에 새 값을 넣으면 덮어쓰기 됩니다)
user["level"] = 11

print(user)
# 출력: {'name': '제미니', 'level': 11, 'job': 'AI 메이트', 'location': 'Seoul'}

2. 데이터 꺼내기 (get vs 대괄호)

데이터를 가져올 때 대괄호([])를 쓰면 존재하지 않는 키를 넣었을 때 에러가 나지만, .get()을 쓰면 안전하게 처리할 수 있습니다.

# 방법 1: 대괄호 (키가 없으면 에러 발생 후 프로그램 종료)
print(user["name"]) 

# 방법 2: .get() 함수 (권장! 키가 없으면 None을 반환함)
email = user.get("email") 
print(email) # None

# 키가 없을 때 기본값 지정하기
email = user.get("email", "이메일 없음")
print(email) # 이메일 없음

3. 반복문에서 활용하기 (items, keys, values)

딕셔너리의 내용물을 싹 훑어야 할 때 사용하는 삼총사입니다.

# 1. 이름표(Key)와 내용(Value) 둘 다 한 번에 꺼내기
for key, value in user.items():
    print(f"[{key}] : {value}")

# 2. 이름표(Key)만 꺼내기
for key in user.keys():
    print(key)

# 3. 내용(Value)만 꺼내기
for value in user.values():
    print(value)

4. 데이터 삭제 및 합치기 (pop, update)

데이터를 지우거나 두 딕셔너리를 하나로 합칠 때 유용합니다.

# 1. 특정 키 삭제하기 (.pop은 지운 값을 반환해 줍니다)
job = user.pop("job")
print(f"삭제된 직업: {job}")

# 2. 두 딕셔너리 합치기 (파이썬 3.9+ 에서는 | 연산자 사용 가능)
extra_info = {"skill": "Python", "hobby": "Coding"}
user.update(extra_info)

# 최신 파이썬 한 줄 합치기 팁
# user = user | extra_info 

print(user)

딕셔너리 사용 꿀팁 (Q&A)

Q: 딕셔너리 키로 리스트를 쓸 수 있나요?
A: 아니요! 딕셔너리 키는 '변하지 않는 값'이어야 합니다. 리스트는 내용이 변할 수 있으므로 키로 쓸 수 없고, 대신 튜플(tuple)은 가능합니다.

Q: 키가 중복되면 어떻게 되나요?
A: 딕셔너리 안에는 똑같은 이름의 키가 두 개 존재할 수 없습니다. 나중에 입력된 값이 기존 값을 덮어씁니다.

[Python 기초] "리스트를 하나의 글로!" 파이썬 리스트 문자열 변환

hi.anna — Mon, 25 May 2026 23:02:57 +0900

['Hello', 'World']라는 리스트를 "Hello World"라는 문자열로 바꾸고 싶을 때, 초보자들은 흔히 for문을 돌리며 글자를 더하곤 합니다. 하지만 파이썬에는 이를 위한 전용 마법인 join()이 있습니다.

1. 가장 정석적인 방법:

join() 함수는 앞에 붙는 '구분자'를 기준으로 리스트의 요소들을 찰떡처럼 이어 붙여줍니다.

예제 코드: 공백이나 쉼표로 합치기

words = ["Apple", "Banana", "Orange"]

# 1. 공백(" ")으로 합치기
result1 = " ".join(words)
print(result1)  # 출력: Apple Banana Orange

# 2. 쉼표(",")로 합치기
result2 = ",".join(words)
print(result2)  # 출력: Apple,Banana,Orange

# 3. 아무 구분 없이 붙이기
result3 = "".join(words)
print(result3)  # 출력: AppleBananaOrange

2. 리스트에 숫자가 섞여 있을 때 (TypeError 해결법)

join() 함수는 리스트 안의 모든 데이터가 '문자열'일 때만 작동합니다. 숫자가 하나라도 섞여 있으면 에러가 발생하죠. 이때는 우리가 배웠던 리스트 컴프리헨션이나 map()을 섞어 쓰면 해결됩니다.

예제 코드: 숫자 리스트를 문자열로 합치기

nums = [1, 2, 3, 4, 5]

# 오류 발생: "".join(nums) -> TypeError

# 해결법: 모든 요소를 str()로 먼저 변환한 뒤 합칩니다.
# 1) 리스트 컴프리헨션 방식
result = "-".join([str(n) for n in nums])

# 2) map 함수 방식 (더 세련된 방식!)
result_map = "-".join(map(str, nums))

print(result) # 출력: 1-2-3-4-5

3. 실전 응용: 2차원 리스트를 문자열로 변환하기

여러 줄로 된 데이터(2차원 리스트)를 줄바꿈(\n)을 넣어 하나의 텍스트로 만들 때 유용합니다.

예제 코드: 2차원 리스트 ➔ 텍스트 파일 형식

data = [
    ["이름", "나이"],
    ["철수", "20"],
    ["영희", "22"]
]

# 각 행을 탭("\t")으로 합치고, 행끼리는 줄바꿈("\n")으로 합칩니다.
lines = ["\t".join(row) for row in data]
final_text = "\n".join(lines)

print(final_text)
# 출력:
# 이름    나이
# 철수    20
# 영희    22

핵심 요약

"".join(list): 리스트의 문자열들을 하나로 매끄럽게 잇는다.
" ".join(list): 단어 사이에 공백을 넣어 문장을 만든다.
숫자가 있다면: 반드시 map(str, list)를 사용해 문자로 먼저 바꾼다.

리스트를 문자열로 변환하는 법을 익히셨으니 이제 데이터를 출력하거나 파일로 저장하는 작업이 훨씬 쉬워질 거예요!

[Python 실전] "가로 세로 싹 다 더해라!" 2차원 리스트 합계와 평균 구하기

hi.anna — Mon, 25 May 2026 15:59:50 +0900

엑셀에서 행 전체를 드래그해서 합계를 구하거나, 열 하단에 평균을 내는 작업을 파이썬 코드로 구현해 보겠습니다.

1. 각 행(Row)의 합계와 평균 구하기

행의 합계는 매우 쉽습니다. 2차원 리스트에서 한 줄씩 꺼내면 그 자체가 1차원 리스트이므로, 파이썬 내장 함수인 sum()을 바로 적용하면 됩니다.

예제 코드: 리스트 컴프리헨션 활용

scores = [
    [80, 90, 100], # 1행
    [70, 60, 50],  # 2행
    [100, 100, 90] # 3행
]

# 각 행의 합계 구하기
row_sums = [sum(row) for row in scores]

# 각 행의 평균 구하기 (합계 / 개수)
row_averages = [sum(row) / len(row) for row in scores]

print("각 행의 합계:", row_sums)      # [270, 180, 290]
print("각 행의 평균:", row_averages)  # [90.0, 60.0, 96.66...]

2. 각 열(Column)의 합계와 평균 구하기

열의 합계는 행보다 조금 까다롭습니다. 같은 인덱스에 있는 세로 데이터들을 모아야 하기 때문이죠. 이때 우리가 이전에 배웠던 전치(Transpose) 기술인 zip(*matrix)를 쓰면 아주 우아하게 해결됩니다.

예제 코드: zip()을 활용한 열 합산

scores = [
    [80, 90, 100],
    [70, 60, 50],
    [100, 100, 90]
]

# 1. zip(*scores)로 행과 열을 뒤바꿉니다. 
# (80, 70, 100), (90, 60, 100)... 이런 식으로 묶입니다.

# 2. 묶인 데이터들의 합계를 구합니다.
col_sums = [sum(col) for col in zip(*scores)]

# 3. 열의 평균 구하기
col_averages = [sum(col) / len(col) for col in zip(*scores)]

print("각 열의 합계:", col_sums)      # [250, 250, 240]
print("각 열의 평균:", col_averages)  # [83.33, 83.33, 80.0]

3. 실무형 끝판왕: Pandas 사용하기

데이터의 양이 많아지면 위와 같은 리스트 방식은 코드가 복잡해집니다. Pandas를 쓰면 axis라는 옵션 하나로 가로/세로 계산을 끝낼 수 있습니다.

axis=1: 행(가로) 방향으로 계산
axis=0: 열(세로) 방향으로 계산

예제 코드: Pandas의 강력한 한 줄

import pandas as pd

df = pd.DataFrame([
    [80, 90, 100],
    [70, 60, 50],
    [100, 100, 90]
])

# 열(세로) 합계
col_sum = df.sum(axis=0)

# 행(가로) 평균
row_avg = df.mean(axis=1)

print("열 합계:\n", col_sum.tolist())
print("행 평균:\n", row_avg.tolist())

핵심 요약

행(가로) 계산: [sum(row) for row in matrix] 처럼 리스트에서 한 줄씩 꺼내서 바로 계산한다.
열(세로) 계산: zip(*matrix)를 사용해 세로 줄을 가로 줄로 변신시킨 뒤 계산한다.
데이터가 크다면: 무조건 Pandas나 NumPy를 사용하는 것이 정신 건강과 성능 면에서 이롭다.

이제 2차원 데이터를 합치고, 뒤집고, 계산하는 모든 핵심 기술을 섭렵하셨습니다!

[Python 실전] "좌표를 찍어라!" 2차원 리스트 데이터 위치 찾기

hi.anna — Mon, 25 May 2026 07:01:21 +0900

데이터가 바둑판처럼 나열된 2차원 리스트에서 우리가 원하는 값을 찾으려면 "몇 번째 줄(행), 몇 번째 칸(열)"인지 알아내야 합니다. 상황에 맞는 세 가지 해결책을 소개합니다.

1. 가장 정석적인 방법: 중첩 문과

가장 직관적이고 가독성이 좋은 방법입니다. enumerate()를 두 번 중첩해서 사용하면 행 번호와 열 번호를 동시에 얻을 수 있습니다.

예제 코드: 특정 값의 모든 좌표 찾기

grid = [
    ["A", "B", "C"],
    ["D", "Target", "F"],
    ["G", "H", "Target"]
]

target = "Target"
locations = []

# r: 행 번호, row: 해당 행의 리스트
for r, row in enumerate(grid):
    # c: 열 번호, val: 실제 값
    for c, val in enumerate(row):
        if val == target:
            locations.append((r, c)) # 좌표를 튜플 형태로 저장

print(f"'{target}'의 위치 목록 (행, 열):", locations)
# 출력: 'Target'의 위치 목록 (행, 열): [(1, 1), (2, 2)]

2. 고수의 한 줄 컷: 리스트 컴프리헨션 활용

위의 복잡한 5줄 코드를 단 한 줄로 줄일 수 있습니다. 코드가 간결해져서 실무에서 위치를 빠르게 뽑아낼 때 자주 쓰입니다.

예제 코드: 리스트 컴프리헨션으로 좌표 추출

grid = [
    [10, 20, 30],
    [40, 50, 60],
    [70, 20, 90]
]

target_value = 20

# (r, c) 좌표를 담는데, r행의 c열 값이 target_value와 같을 때만 담아라!
coords = [(r, c) for r, row in enumerate(grid) for c, val in enumerate(row) if val == target_value]

print(f"값 {target_value}의 위치:", coords)
# 출력: 값 20의 위치: [(0, 1), (2, 1)]

3. 조건에 맞는 첫 번째 위치만 빠르게 찾기

데이터가 아주 방대할 때, 모든 위치를 다 찾을 필요 없이 처음 발견된 곳에서 바로 검색을 중단하고 싶을 때 쓰는 효율적인 방식입니다.

예제 코드: 함수와 제너레이터 활용

grid = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 5라는 숫자의 위치를 찾자마자 종료
target = 5

# next()는 조건에 맞는 첫 번째 결과가 나오면 즉시 반환하고 멈춥니다.
# 만약 없다면 "찾을 수 없음"을 반환합니다.
found = next(((r, c) for r, row in enumerate(grid) for c, val in enumerate(row) if val == target), "찾을 수 없음")

print(f"숫자 {target}의 첫 번째 위치:", found)
# 출력: 숫자 5의 첫 번째 위치: (1, 1)

요약 및 실무 팁

모든 위치가 필요할 때: 중첩 enumerate()를 쓴 리스트 컴프리헨션이 가장 깔끔합니다.
가장 먼저 나오는 하나만 필요할 때: next() 함수를 써서 속도를 높이세요.
성능 팁: 리스트가 수만 행 이상으로 크다면, 리스트 대신 NumPy 라이브러리의 np.where() 함수를 사용하는 것이 훨씬 빠릅니다.

2차원 리스트에서 위치를 찾는 법까지 익히셨으니, 이제 격자 형태의 데이터를 자유자재로 다루실 수 있겠네요!

[Python 기초] "가로를 세로로!" 2차원 리스트 전치(Transpose) 완벽 가이드

hi.anna — Sun, 24 May 2026 23:26:47 +0900

전치 행렬이란 말 그대로 '행과 열의 인덱스를 서로 맞바꾼 행렬'을 의미합니다. 엑셀에서 표를 복사해서 [행/열 바꿈]으로 붙여넣는 것과 똑같은 작업이라고 생각하시면 됩니다.

1. 가장 파이썬다운 방법:

파이썬 고수들이 가장 즐겨 쓰는 방식입니다. 우리가 앞서 배운 언패킹(*)과 zip() 함수를 결합하면 단 한 줄로 전치가 가능합니다.

예제 코드: zip을 활용한 전치

matrix = [
    [1, 2, 3],
    [4, 5, 6]
]

# 1. *matrix로 행들을 해체한 뒤
# 2. zip으로 같은 인덱스끼리(열끼리) 묶어줍니다.
transposed = [list(row) for row in zip(*matrix)]

print(transposed)
# 출력: [[1, 4], [2, 5], [3, 6]]

원리 파헤치기:
zip(*matrix)는 zip([1, 2, 3], [4, 5, 6])과 같습니다. zip은 각 리스트의 첫 번째 요소인 (1, 4)를 묶고, 그다음 (2, 5), (3, 6)을 차례로 묶어주기 때문에 자연스럽게 행과 열이 바뀝니다.

2. 리스트 컴프리헨션만 사용하기

패키지나 복잡한 함수 없이 순수하게 인덱스 접근 방식으로 전치를 구현하는 방법입니다. 로직을 이해하는 데 아주 좋습니다.

예제 코드: 인덱스 기반 전치

matrix = [
    [1, 2, 3],
    [4, 5, 6]
]

# 바깥쪽 루프는 '열(column)'을 돌고, 안쪽 루프는 '행(row)'을 돕니다.
# "i번째 열의 값들을 모아서 새로운 행을 만들어라!"
transposed = [[matrix[row][col] for row in range(len(matrix))] for col in range(len(matrix[0]))]

print(transposed)
# 출력: [[1, 4], [2, 5], [3, 6]]

[col] vs matrix[col][row] to demonstrate the logic of matrix transposition]

3. 실무 끝판왕: 넘파이(NumPy) 활용

만약 여러분이 데이터 과학이나 머신러닝을 공부하고 있다면, 사실 위의 방법들을 직접 짜기보다 전용 라이브러리인 NumPy를 사용하는 것이 훨씬 빠르고 강력합니다.

예제 코드: NumPy의 .T 속성

import numpy as np

matrix = np.array([[1, 2, 3], [4, 5, 6]])

# .T 속성 하나면 전치 행렬이 완성됩니다.
transposed = matrix.T

print(transposed)
# 출력:
# [[1 4]
#  [2 5]
#  [3 6]]

핵심 요약

zip(*matrix): 가장 깔끔하고 대중적인 파이썬 표준 방식입니다.
리스트 컴프리헨션: 라이브러리 없이 인덱스 제어가 필요할 때 유용합니다.
NumPy: 대규모 행렬 연산이 필요한 실무 환경에서 가장 빠릅니다.

행과 열을 뒤바꾸는 법까지 익히셨으니 이제 2차원 데이터를 다루는 데 있어 두려울 게 없으실 것 같네요!

[Python 기초] "표 형태의 데이터도 한 줄로!" 2차원 리스트 컴프리헨션

hi.anna — Sun, 24 May 2026 18:36:05 +0900

2차원 리스트를 만들 때 가장 흔하게 저지르는 실수가 바로 리스트 곱하기(*)를 사용하는 것입니다. 하지만 앞서 배웠듯이 이는 참조 복사 버그를 일으키죠. 리스트 컴프리헨션을 사용하면 각 행이 독립적으로 존재하는 완벽한 2차원 배열을 단 한 줄로 안전하게 만들 수 있습니다.

1. 기본 구조: 중첩 리스트 생성하기

2차원 리스트는 '리스트 안에 리스트가 들어있는 구조'입니다. 따라서 컴프리헨션 안에 또 다른 컴프리헨션을 넣어주면 됩니다.

예제 코드: 3x4 크기의 0으로 채워진 행렬 만들기

rows = 3
cols = 4

# [ [안쪽 리스트] for 바깥쪽 반복문 ]
# "0을 4번 채운 리스트를 3번 만들어라!"
matrix = [[0 for _ in range(cols)] for _ in range(rows)]

print(matrix)
# 출력: [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

2. 값에 규칙 부여하기

인덱스 번호를 활용하여 2차원 배열 안에 특정한 값을 채울 수도 있습니다.

예제 코드: 구구단 2단부터 3단까지 리스트로 만들기

# [[결과값 for i 인덱스] for j 인덱스]
gugudan = [[j * i for i in range(1, 10)] for j in range(2, 4)]

print("2단:", gugudan[0])
print("3단:", gugudan[1])

3. 고수들의 기술: 2차원 리스트 '평탄화' (Flatten)

반대로 2차원 리스트를 다시 1차원 리스트로 쭉 펴야 할 때가 있습니다. 이때도 리스트 컴프리헨션을 쓰면 for문을 두 번 겹쳐 쓰는 것보다 훨씬 간결합니다.

예제 코드: 2차원 -> 1차원 변환

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# "행(row)에서 값(val)을 꺼내는데, 그 행은 matrix에서 하나씩 가져와라"
# 주의: 바깥쪽 for문이 앞에 옵니다!
flatten = [val for row in matrix for val in row]

print(flatten)
# 출력: [1, 2, 3, 4, 5, 6, 7, 8, 9]

4. 조건문이 포함된 2차원 컴프리헨션

특정 조건에 맞는 데이터만 골라내어 2차원 리스트를 정제할 수도 있습니다.

예제 코드: 2차원 리스트에서 짝수만 남기기

data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 각 행에서 짝수만 골라내어 새로운 2차원 리스트 생성
evens_only = [[x for x in row if x % 2 == 0] for row in data]

print(evens_only)
# 출력: [[2], [4, 6], [8]]

핵심 요약

독립성: 리스트 컴프리헨션으로 만든 2차원 리스트는 각 행이 독립적이라서 한 곳을 수정해도 다른 곳에 영향을 주지 않습니다.
순서: 평탄화(Flatten) 시에는 바깥쪽 반복문을 먼저 쓰고 안쪽 반복문을 뒤에 씁니다. ([val for row in matrix for val in row])
가독성: 2차원 이상의 깊이(3차원 등)로 들어가면 코드가 너무 복잡해질 수 있으니, 그때는 일반적인 for문을 쓰는 것이 나을 수도 있습니다.

2차원 리스트 컴프리헨션까지 정복하셨군요! 이제 데이터를 구조적으로 생성하고 가공하는 데 거침이 없으실 겁니다.

[Python 기초] "세 줄 코드를 한 줄로!" 리스트 컴프리헨션 완벽 이해

hi.anna — Sun, 24 May 2026 09:28:38 +0900

리스트 컴프리헨션은 리스트 안에 for문과 if문을 직접 집어넣어 새로운 리스트를 생성하는 기법입니다. 처음엔 생소할 수 있지만, 익숙해지면 가독성과 처리 속도라는 두 마리 토끼를 모두 잡을 수 있는 강력한 무기가 됩니다.

1. 기본 구조: 문 압축하기

기존의 방식은 빈 리스트를 만들고, for문을 돌리면서 하나씩 append를 해줘야 했습니다. 리스트 컴프리헨션은 이를 한 줄로 해결합니다.

예제 코드: 1부터 5까지의 제곱 구하기

# 1. 기존 방식 (3줄)
squares = []
for x in range(1, 6):
    squares.append(x**2)

# 2. 리스트 컴프리헨션 (1줄)
# [ 표현식 for 항목 in 반복가능객체 ]
squares_comp = [x**2 for x in range(1, 6)]

print(squares_comp) 
# 출력: [1, 4, 9, 16, 25]

2. 조건문() 추가하기: 데이터 필터링

특정 조건에 맞는 데이터만 골라내고 싶을 때, for문 뒤에 if문을 붙여주면 됩니다.

]

예제 코드: 1부터 10 사이의 짝수만 담기

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# "n을 담을 건데, numbers에서 꺼낸 n이 2로 나누어 떨어질 때만 담아라!"
evens = [n for n in numbers if n % 2 == 0]

print(evens)
# 출력: [2, 4, 6, 8, 10]

3. 조건부 표현식() 활용하기

조건에 따라 값을 다르게 저장하고 싶을 때는 if-else 문을 for문 앞에 배치합니다.

예제 코드: 홀수/짝수 판별 리스트

data = [1, 2, 3, 4, 5]

# "짝수면 'Even', 홀수면 'Odd'라고 적어서 리스트를 만들어라!"
labels = ["Even" if x % 2 == 0 else "Odd" for x in data]

print(labels)
# 출력: ['Odd', 'Even', 'Odd', 'Even', 'Odd']

4. 실전 활용: 데이터 전처리 (문자열)

크롤링 등으로 수집한 지저분한 문자열 데이터를 한 방에 깔끔하게 정리할 때 최고입니다.

raw_names = ["  김철수  ", "이영희 ", "  박민수"]

# 양쪽 공백을 제거(.strip())한 이름들의 리스트 만들기
clean_names = [name.strip() for name in raw_names]

print(clean_names)
# 출력: ['김철수', '이영희', '박민수']

핵심 요약

가독성: 코드가 간결해져서 로직을 한눈에 파악하기 좋습니다.
성능: 파이썬 내부적으로 최적화되어 있어 일반 for문보다 실행 속도가 약간 더 빠릅니다.
주의: 너무 복잡한 중첩 반복문이나 긴 조건문을 한 줄에 넣으면 오히려 가독성을 해칠 수 있습니다. (적당한 길이가 생명!)

리스트 컴프리헨션을 마스터하셨으니, 이제 여러분의 코드는 한층 더 세련되게 변할 거예요.

[Python 기초] "따로 노는 리스트를 하나로 묶자!" zip() 함수 활용법

hi.anna — Sun, 24 May 2026 06:34:23 +0900

zip()은 이름처럼 여러 개의 지퍼를 하나로 잠그듯, 서로 다른 리스트들의 요소를 같은 인덱스끼리 쏙쏙 뽑아 짝을 지어주는 함수입니다.

1. 기본 사용법: 리스트 짝꿍 만들기

두 개의 리스트에서 같은 번호에 있는 데이터끼리 묶어서 튜플(()) 형태로 보여줍니다.

예제 코드: 이름과 점수 매칭

names = ["철수", "영희", "민수"]
scores = [85, 90, 100]

# zip으로 묶은 뒤 리스트로 변환해서 확인
zipped = list(zip(names, scores))

print(zipped)
# 출력: [('철수', 85), ('영희', 90), ('민수', 100)]

2. 실무 1등 문법: 딕셔너리로 즉시 변환

zip()의 가장 강력한 용도는 두 리스트를 Key와 Value의 관계로 만드는 것입니다. dict() 함수와 결합하면 1초 만에 데이터베이스 형태가 완성됩니다.

예제 코드: 리스트 ➔ 딕셔너리

keys = ["id", "name", "email"]
values = [101, "Kim", "kim@test.com"]

# zip을 dict로 감싸면 앞의 리스트는 Key, 뒤는 Value가 됩니다.
user_dict = dict(zip(keys, values))

print(user_dict)
# 출력: {'id': 101, 'name': 'Kim', 'email': 'kim@test.com'}

3. 반복문()에서 동시에 꺼내 쓰기

리스트 두 개를 동시에 돌리면서 값을 활용하고 싶을 때 range(len(list))를 쓰는 것보다 훨씬 읽기 좋은 코드를 만들어줍니다.

예제 코드: 동시 순회

fruits = ["Apple", "Banana", "Orange"]
prices = [1000, 500, 700]

for fruit, price in zip(fruits, prices):
    print(f"{fruit}의 가격은 {price}원입니다.")

# 출력:
# Apple의 가격은 1000원입니다.
# Banana의 가격은 500원입니다.
# Orange의 가격은 700원입니다.

⚠️ 주의사항: 길이가 다르면 어떻게 되나요?

zip()은 아주 냉정합니다. 리스트들의 길이가 서로 다르면 가장 짧은 리스트의 길이에 맞춰서 남는 데이터는 그냥 버려버립니다.

a = [1, 2, 3]
b = ["A", "B"]

print(list(zip(a, b)))
# 출력: [(1, 'A'), (2, 'B')]  <-- 3은 짝이 없어서 사라집니다!

( 꿀팁: 만약 남는 데이터도 다 챙기고 싶다면 itertools.zip_longest라는 함수를 사용하면 됩니다.)

요약

zip(list1, list2): 같은 순서의 데이터를 튜플로 묶어준다.
dict(zip(keys, values)): 두 리스트를 딕셔너리로 변환할 때 최고다.
순회: 여러 리스트를 동시에 for문으로 돌릴 때 가독성이 좋다.

이제 리스트를 합치고, 자르고, 뒤집고, 대조하고, 짝짓는 모든 기초 기술을 습득하셨습니다!

[Python 기초] "누가 빠졌지?" 리스트 차집합 찾기 및 데이터 대조

hi.anna — Fri, 22 May 2026 19:16:38 +0900

두 명단을 비교해서 "한쪽에는 있지만 다른 쪽에는 없는" 데이터를 찾아내는 방법들을 정리해 드릴게요.

1. 가장 쉽고 빠른 방법: 빼기() 연산자

집합(set) 자료형은 우리가 숫자를 빼는 것과 똑같은 - 기호를 지원합니다. 앞의 집합에서 뒤의 집합과 겹치는 부분(교집합)을 덜어내고 남은 것만 보여줍니다.

예제 코드: '-' 기호로 누락 데이터 찾기

all_students = ["철수", "영희", "민수", "지훈", "수진"]
submitted = ["영희", "수진"]

# 1. 집합으로 변환
set_all = set(all_students)
set_sub = set(submitted)

# 2. 전체 명단에서 제출자 명단을 뺍니다.
not_submitted = set_all - set_sub

print("미제출자:", list(not_submitted))
# 출력: ['철수', '민수', '지훈'] (순서는 바뀔 수 있음)

2. 가독성을 높이는 방법: 함수

기호 대신 이름을 사용하는 방식입니다. 역시나 협업 환경에서 "차집합을 구한다"는 의도를 명확히 전달할 때 좋습니다.

예제 코드: difference 함수 활용

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]

# list1에는 있지만 list2에는 없는 요소들
diff = list(set(list1).difference(list2))

print("차집합 결과:", diff)
# 출력: [1, 2, 3]

3. 순서를 유지해야 할 때: 리스트 컴프리헨션

차집합 역시 set을 쓰면 순서가 뒤섞입니다. 만약 "전체 명단에 적힌 순서 그대로" 빠진 사람을 보고 싶다면 리스트 컴프리헨션을 사용하세요.

예제 코드: 순서 유지 차집합

total_list = ["A", "B", "C", "D", "E"]
remove_list = ["B", "D"]

# remove_list를 set으로 미리 바꿔두면 검색 속도가 훨씬 빨라집니다 (필수 꿀팁!)
set_remove = set(remove_list)

# total_list에서 하나씩 꺼내는데, 그게 remove_list에 '없는(not in)' 경우만 모으기
result = [item for item in total_list if item not in set_remove]

print("순서 유지 결과:", result)
# 출력: ['A', 'C', 'E']

요약 및 실무 팁

빠른 비교가 필요할 때: set_a - set_b
원본 순서가 중요할 때: [x for x in list_a if x not in set_b]

실무 꿀팁:
데이터 대조를 할 때 대소문자가 섞여 있으면 파이썬은 서로 다른 데이터로 인식합니다 ("Apple"과 "apple"은 다름). 이럴 땐 리스트를 집합으로 만들기 전에 모든 요소를 소문자로 바꾸는 과정이 필요합니다.

# 모든 요소를 소문자로 통일한 뒤 차집합 구하기
list_a = [x.lower() for x in list_a]
list_b = [x.lower() for x in list_b]
diff = set(list_a) - set(list_b)

[Python 기초] "겹치는 데이터만 골라내자!" 리스트 교집합 찾기 3가지 비법

hi.anna — Fri, 22 May 2026 10:00:39 +0900

예를 들어 '어제 방문한 고객 명단'과 '오늘 방문한 고객 명단'이 있을 때, "이틀 연속 방문한 단골손님"을 찾으려면 두 리스트의 교집합을 구해야 합니다. 파이썬에서는 어떻게 할까요?

1. 가장 정석적인 방법: 집합()과 연산자

파이썬의 집합(set) 자료형은 수학의 집합 연산을 완벽하게 지원합니다. 리스트를 집합으로 바꾼 뒤 & (앰퍼샌드) 기호 하나만 쓰면 끝납니다.

예제 코드: & 연산자 활용

list_a = ["사과", "바나나", "포도", "딸기"]
list_b = ["포도", "딸기", "수박", "참외"]

# 1. 리스트를 집합으로 변환
set_a = set(list_a)
set_b = set(list_b)

# 2. '&' 기호로 교집합 구하기
common = set_a & set_b

# 3. 다시 리스트로 변환 (필요한 경우)
result = list(common)

print("공통 요소:", result)
# 출력: ['포도', '딸기'] (순서는 바뀔 수 있습니다)

2. 가독성이 좋은 방법: 함수

기호(&) 대신 이름을 직접 부르는 함수를 사용하는 방법입니다. 코드가 더 명시적이어서 다른 사람이 읽을 때 "아, 교집합을 구하고 있구나!"라고 바로 이해하기 좋습니다.

예제 코드: intersection 함수 활용

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]

# 한 줄로 요약해서 쓰기
common = list(set(list1).intersection(list2))

print("겹치는 숫자:", common)
# 출력: [4, 5]

3. 순서를 유지해야 할 때: 리스트 컴프리헨션

집합(set)을 쓰면 중복 제거와 속도 면에서 유리하지만, 데이터의 순서가 뒤죽박죽 섞인다는 단점이 있습니다. 만약 "list_a에 들어있는 순서대로" 겹치는 값을 찾고 싶다면 리스트 컴프리헨션을 사용해야 합니다.

예제 코드: 순서 유지 교집합

list_a = ["A", "B", "C", "D"]
list_b = ["C", "E", "A", "F"]

# list_a에서 하나씩 꺼내는데, 그게 list_b에도 들어있는 경우만 모으기
# (이때 list_b를 set으로 미리 바꿔두면 속도가 훨씬 빨라집니다!)
set_b = set(list_b)
common = [item for item in list_a if item in set_b]

print("순서 유지 교집합:", common)
# 출력: ['A', 'C'] (list_a에 나타난 순서대로 'A'가 'C'보다 먼저 나옵니다)

한눈에 비교하는 요약

방법	특징	추천 상황
`set_a & set_b`	가장 짧고 빠름	순서가 상관없을 때 (가장 권장)
`.intersection()`	의미가 명확함	가독성이 중요한 협업 프로젝트
리스트 컴프리헨션	순서 유지 가능	원본의 순서가 중요할 때

보너스 팁: 3개 이상의 리스트라면?

세 개 이상의 리스트에서 공통 요소를 찾을 때도 set은 강력합니다.
set(list1) & set(list2) & set(list3) 처럼 계속 이어 붙여주기만 하면 됩니다.

[Python 기초] "흩어진 데이터를 하나로!" 파이썬 리스트 합치기 4가지 방법

hi.anna — Thu, 21 May 2026 07:04:27 +0900

데이터 수집(크롤링)을 하거나 여러 명단을 취합하다 보면 분산된 리스트들을 하나의 큰 리스트로 합쳐야 하는 일이 정말 많습니다. 상황에 따라 가장 효율적인 방법을 선택해 보세요.

1. 가장 직관적인 방법: 더하기() 연산자

두 리스트를 마치 숫자를 더하듯 + 기호로 연결하는 방법입니다. 코드가 가장 읽기 쉽고, 합쳐진 새로운 리스트를 만들어냅니다.

예제 코드: 리스트 연결

list_a = [1, 2, 3]
list_b = [4, 5, 6]

# 두 리스트를 합쳐 새로운 리스트 생성
combined = list_a + list_b

print(combined) 
# 출력: [1, 2, 3, 4, 5, 6]

2. 원본에 그대로 덧붙이기: 메소드

기존에 있던 리스트 뒤에 다른 리스트의 내용물만 쏙 뽑아서 추가하고 싶을 때 사용합니다. 새로운 리스트를 만들지 않고 원본 리스트를 수정하기 때문에 메모리 관면에서 더 효율적일 수 있습니다.

예제 코드: 원본 확장

fruits = ["사과", "바나나"]
new_fruits = ["포도", "딸기"]

# fruits 리스트 뒤에 그대로 이어 붙입니다.
fruits.extend(new_fruits)

print(fruits)
# 출력: ['사과', '바나나', '포도', '딸기']

3. 고수들의 세련된 방식: 언패킹() 연산자

파이썬 3.5 버전부터 도입된 강력한 기능입니다. 리스트 앞에 별표(*)를 붙여 내용물을 '해체'한 뒤 새로운 리스트 안에 담는 방식입니다. 여러 개의 리스트를 한꺼번에 합칠 때 가장 깔끔합니다.

예제 코드: 리스트 언패킹

a = [1, 2]
b = [3, 4]
c = [5, 6]

# 여러 리스트를 자유롭게 배치하여 합칠 수 있습니다.
all_in_one = [*a, *b, *c, 7, 8]

print(all_in_one)
# 출력: [1, 2, 3, 4, 5, 6, 7, 8]

4. 대용량 데이터 처리에 유리한:

만약 합쳐야 할 리스트가 수만 개이고, 데이터 양이 엄청나게 많다면 실제로 리스트를 합치는 대신 "하나의 리스트처럼 보이게 연결"해주는 방식이 좋습니다. 메모리를 절약할 수 있는 고급 기술입니다.

예제 코드: 체인 연결

import itertools

list1 = [1, 2]
list2 = [3, 4]
list3 = [5, 6]

# 실제로 합치지 않고 연결된 '상태'만 만듭니다 (메모리 절약)
combined_iter = itertools.chain(list1, list2, list3)

# 사용할 때 리스트로 변환하거나 반복문에서 씁니다.
print(list(combined_iter))
# 출력: [1, 2, 3, 4, 5, 6]

상황별 추천 요약

단순히 두 리스트를 합칠 때: list_a + list_b
기존 리스트를 확장하고 싶을 때: list_a.extend(list_b)
3개 이상의 리스트를 우아하게 합칠 때: [*a, *b, *c]
엄청난 대용량 데이터를 다룰 때: itertools.chain()

[Python 기초] "원하는 곳만 골라서 반전!" 리스트 부분 슬라이싱 및 뒤집기

hi.anna — Tue, 19 May 2026 22:08:54 +0900

리스트의 전체가 아니라, 예를 들어 "3번 인덱스부터 7번 인덱스까지만 거꾸로 뒤집고 싶다"면 어떻게 해야 할까요? 파이썬의 슬라이싱 규칙을 정확히 이해하면 아주 간단하게 해결됩니다.

1. 기본 원리: 부분 추출 후 뒤집기

가장 먼저 특정 구간을 슬라이싱으로 뽑아낸 뒤, 그 결과에 다시 뒤집기([::-1])를 적용하는 방식입니다.

예제 코드: 인덱스 2번부터 5번 직전까지 뒤집기

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 1. 2번 인덱스부터 5번 직전(4번)까지 추출: [2, 3, 4]
sub_list = numbers[2:5]

# 2. 추출한 부분만 뒤집기: [4, 3, 2]
reversed_sub = sub_list[::-1]

print(reversed_sub) 
# 출력: [4, 3, 2]

2. 고급 기술: 원본의 특정 구간만 '교체'하기

단순히 잘라서 출력하는 게 아니라, 원본 리스트 내의 특정 구간만 순서를 뒤집어서 다시 끼워 넣고 싶을 때 사용하는 실전 기술입니다. 리스트 슬라이싱의 '치환' 기능을 활용합니다.

예제 코드: 원본 리스트의 일부만 반전시키기

alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

# 인덱스 1번('b')부터 4번 직전('d')까지의 구간을 
# 해당 구간을 뒤집은 값으로 치환합니다.
alphabet[1:4] = alphabet[1:4][::-1]

print(alphabet)
# 출력: ['a', 'd', 'c', 'b', 'e', 'f', 'g']
# 설명: 'b', 'c', 'd' 구간이 'd', 'c', 'b'로 바뀌었습니다.

3. 더 정교한 조절: Step(보폭) 활용하기

슬라이싱의 세 번째 인자인 step을 활용하면 훨씬 정교한 작업이 가능합니다.

예제 코드: 전체 리스트에서 2칸씩 건너뛰며 뒤집기

data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 처음부터 끝까지 가되, 역순(-1)으로 2칸씩(-2) 건너뜁니다.
stepped_rev = data[::-2]

print(stepped_rev)
# 출력: [9, 7, 5, 3, 1]

실전 팁: 슬라이싱 뒤집기 공식 정리

이 공식만 기억하면 어떤 구간이든 자유자재로 요리할 수 있습니다.

list[start:stop]: start부터 stop-1까지 자르기
list[start:stop][::-1]: 해당 구간을 잘라서 뒤집기
list[start:stop] = list[start:stop][::-1]: 해당 구간만 뒤집어서 원본에 덮어쓰기
list[stop-1 : start-1 : -1]: 슬라이싱 한 번으로 특정 구간을 역순으로 가져오기 (비어있는 start 값이 있을 때 주의가 필요하여 위 방법을 더 추천합니다.)

마치며

특정 구간 슬라이싱은 데이터를 필요한 만큼만 떼어내어 가공할 때 매우 유용합니다. 특히 이미지 데이터의 픽셀을 반전시키거나, 문자열의 특정 부분만 암호화할 때 자주 사용되는 기술이죠.

[Python 기초] "거꾸로 줄을 서시오!" 파이썬 리스트 뒤집기 3가지 방법

hi.anna — Mon, 18 May 2026 23:56:02 +0900

데이터를 다루다 보면 시간순으로 쌓인 데이터를 역순으로 보여주거나, 리스트의 앞뒤를 반전시켜야 할 때가 있습니다. 파이썬에서 가장 많이 쓰이는 방식들을 정리해 드릴게요.

1. 원본을 직접 뒤집기:

리스트가 자체적으로 가지고 있는 기능입니다. 이 함수를 쓰면 원본 리스트의 순서가 영구적으로 뒤집힙니다. 별도의 결과값을 반환하지 않으므로 주의해야 합니다.

예제 코드: 리스트 자체를 반전

numbers = [1, 2, 3, 4, 5]

# 원본 리스트를 뒤집습니다.
numbers.reverse()

print(numbers)  
# 출력: [5, 4, 3, 2, 1]

2. 뒤집힌 복사본 만들기:

원본은 그대로 유지하고 싶을 때 사용합니다. reversed() 함수는 뒤집힌 상태의 '반복 가능한 객체'를 만들어주기 때문에, 다시 list()로 감싸주어야 우리가 아는 리스트 형태가 됩니다.

예제 코드: 원본 보존하며 뒤집기

origin = ["A", "B", "C"]

# 원본은 놔두고 뒤집힌 새 리스트 생성
rev_list = list(reversed(origin))

print("원본:", origin)    # 출력: ['A', 'B', 'C']
print("뒤집힘:", rev_list) # 출력: ['C', 'B', 'A']

3. 가장 파이썬스러운 방법: 슬라이싱

파이썬의 꽃이라 불리는 슬라이싱(Slicing)을 이용하는 방법입니다. 코드가 가장 짧고 직관적이어서 실무에서 가장 많이 사용됩니다. 이 방식 역시 원본은 그대로 유지됩니다.

예제 코드: 슬라이싱 활용

colors = ["red", "green", "blue"]

# [시작:끝:증감폭]인데 증감폭을 -1로 주면 거꾸로 갑니다.
reversed_colors = colors[::-1]

print(reversed_colors)
# 출력: ['blue', 'green', 'red']

마치며: 어떤 것을 쓸까요?

원본 리스트의 순서를 완전히 바꿔도 된다면? ➔ .reverse()
원본은 소중하니까 놔두고 뒤집힌 리스트만 따로 필요하다면? ➔ [::-1] (슬라이싱)
리스트가 너무 커서 메모리를 아끼며 하나씩 꺼내 쓰고 싶다면? ➔ reversed() (반복문과 함께 사용)

[Python 기초] "미리 빈 칸을 만들어두자!" 파이썬 리스트 크기 지정과 초기화

hi.anna — Mon, 18 May 2026 07:29:31 +0900

리스트의 크기를 미리 지정한다는 것은, 마치 아파트 입주 전에 미리 몇 호실까지 있을지 정해두고 빈 방을 만들어두는 것과 같습니다. 데이터가 들어올 자리를 미리 확보해두면 나중에 특정 위치(index)에 값을 바로 집어넣을 수 있어 편리합니다.

1. 가장 많이 쓰는 방법: 곱하기() 연산자

가장 직관적이고 빠른 방법입니다. [초기값] * 크기 형태로 작성합니다.

예제 코드: 0으로 채워진 리스트 만들기

# 10칸짜리 리스트를 만들고 모두 0으로 초기화
list_size = 10
zeros = [0] * list_size

print(zeros)
# 출력: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

# 이제 원하는 위치에 바로 값을 넣을 수 있습니다.
zeros[5] = 100
print(zeros)

2. 연속된 숫자로 크기 지정: 활용

단순히 빈 칸이 아니라 1, 2, 3... 처럼 순서대로 숫자가 채워진 리스트가 필요할 때 사용합니다.

예제 코드: 1부터 10까지 채워진 리스트

# 1부터 10까지 숫자가 들어있는 크기 10의 리스트
numbers = list(range(1, 11))

print(numbers)
# 출력: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

3. [중요] 2차원 리스트 크기 지정하기 (주의사항!)

가장 실수가 많은 부분입니다. 2차원 리스트(행렬)를 만들 때 곱하기(*) 연산자를 잘못 쓰면 모든 행이 같은 주소를 가리키는 대참사가 발생합니다.

❌ 잘못된 방법 (복사 버그 발생)

# 3행 3열을 만들고 싶어서 이렇게 하면...
bad_matrix = [[0] * 3] * 3
bad_matrix[0][0] = 99

print(bad_matrix)
# 출력: [[99, 0, 0], [99, 0, 0], [99, 0, 0]] 
# (첫 번째 칸만 바꿨는데 모든 행의 첫 번째 칸이 다 바뀌어 버립니다!)

✅ 올바른 방법 (리스트 컴프리헨션)

각 행을 독립적인 객체로 새로 생성해주어야 합니다.

# 3행 3열 2차원 리스트 만들기
rows, cols = 3, 3
matrix = [[0 for _ in range(cols)] for _ in range(rows)]

matrix[0][0] = 99
print(matrix)
# 출력: [[99, 0, 0], [0, 0, 0], [0, 0, 0]] (정상적으로 하나만 바뀜!)

4. 값이 없는 상태로 칸만 만들기: 사용

숫자 0도 넣기 싫고, "아직 값이 없음"을 명시적으로 표현하고 싶을 때 None을 사용합니다.

# 데이터 5개가 들어올 자리를 미리 비워둠
data_slots = [None] * 5

print(data_slots)
# 출력: [None, None, None, None, None]

마치며

핵심 요약입니다.

1차원 리스트: [초기값] * 크기 로 빠르게 만든다.
2차원 리스트: 반드시 리스트 컴프리헨션([[0] * 열 for _ in range(행)])을 사용한다.
숫자 채우기: list(range(시작, 끝)) 을 활용한다.

리스트의 크기를 정해두고 나면, 이제 그 안에 든 숫자들을 정렬하거나 특정 조건의 값만 필터링하는 작업이 훨씬 수월해집니다.

[Python 기초] "이 바구니에 데이터가 몇 개 들어있지?" 파이썬 리스트 길이 구하기 (len)

hi.anna — Sun, 17 May 2026 12:11:33 +0900

파이썬에서 리스트의 길이를 구하는 마법의 단어는 바로 len()입니다.

'길이'를 뜻하는 영어 단어 Length의 앞 글자를 딴 함수입니다.

1. 가장 기본: 리스트의 전체 개수 구하기

리스트 안에 들어있는 요소가 몇 개인지 궁금할 때 len() 안에 리스트 변수명을 넣어주면 끝납니다.

예제 코드: 기본 사용법

# 5명의 학생 명단
students = ["철수", "영희", "민수", "지훈", "수진"]

# len() 함수로 길이를 잽니다.
count = len(students)

print(f"현재 학생 수는 {count}명입니다.")
# 출력: 현재 학생 수는 5명입니다.

2. 2차원 리스트의 길이는 어떻게 될까?

리스트 안에 리스트가 들어있는 경우(2차원 리스트), len()을 쓰면 "큰 바구니 안에 들어있는 작은 바구니의 개수"를 알려줍니다.

예제 코드: 중첩 리스트의 길이

# 3개의 팀, 각 팀당 2명씩 있는 2차원 리스트
teams = [
    ["철수", "영희"], 
    ["민수", "지훈"], 
    ["수진", "동석"]
]

print(len(teams))  
# 출력: 3 (작은 리스트가 3개 들어있기 때문입니다.)

# 특정 팀 내부의 인원수가 궁금하다면?
print(len(teams[0])) 
# 출력: 2 (0번 인덱스인 ["철수", "영희"]의 길이를 잽니다.)

3. 실무 응용: 리스트가 비어있는지 확인하기

실무에서는 리스트의 개수 자체보다 "데이터가 하나라도 들어있는지" 확인하는 용도로 len()을 자주 씁니다.

예제 코드: 데이터 유무 확인

cart = []  # 빈 장바구니

if len(cart) == 0:
    print("장바구니가 비어 있습니다. 물건을 담아주세요!")

#   더 파이썬스러운 방법 (len을 안 써도 됩니다!)
if not cart:
    print("장바구니가 비어 있습니다.")

4. 문자열의 길이도 잴 수 있나요?

네! len() 함수는 리스트뿐만 아니라 문자열의 길이를 잴 때도 똑같이 사용됩니다. 공백(띄어쓰기)까지 포함해서 개수를 세어줍니다.

text = "Python is Fun!"
print(len(text)) 
# 출력: 14 (글자 12개 + 공백 2개)

마치며

핵심 요약입니다.

len(리스트): 리스트의 전체 요소 개수를 반환한다.
2차원 리스트에서는 바깥쪽 리스트의 개수를 먼저 센다.
문자열, 딕셔너리, 집합 등 거의 모든 자료형의 길이를 잴 때 공통으로 사용된다.

리스트의 길이를 재는 법을 익혔으니, 이제 이 데이터를 가지고 평균값을 구하거나 반복문(for)의 범위를 지정하는 일을 훨씬 수월하게 하실 수 있을 거예요!

[Python 실전 팁] "누가 겹치고 누가 빠졌지?" 파이썬 리스트 교집합, 차집합 비교하기

hi.anna — Thu, 14 May 2026 21:39:11 +0900

두 개의 리스트를 비교할 때, 파이썬 고수들은 리스트를 일단 집합(set)으로 변환하고 시작합니다. 집합 자료형은 더하기, 빼기 같은 기호를 써서 데이터를 직관적으로 비교하는 엄청난 능력을 갖추고 있기 때문입니다.

비교할 두 개의 리스트를 먼저 준비해 보겠습니다.

# A팀 명단과 B팀 명단
team_a = ["철수", "영희", "민수", "지훈"]
team_b = ["영희", "지훈", "수진", "동석"]

# 1. 비교를 위해 리스트를 집합(Set)으로 변환합니다.
set_a = set(team_a)
set_b = set(team_b)

1. 교집합 (Intersection): 양쪽 리스트에 모두 있는 데이터 찾기

"A팀과 B팀에 공통으로 속해 있는 사람은 누구일까?"
키보드의 앰퍼샌드(&) 기호를 사용하면 두 집합이 겹치는 부분만 쏙 뽑아냅니다.

예제 코드: 공통 데이터 찾기

# '&' 기호를 사용해 교집합을 구합니다.
common_members = set_a & set_b

# 다루기 편하게 다시 리스트로 묶어주고 정렬까지 해볼까요?
result_list = sorted(list(common_members))

print("양쪽에 다 있는 사람 (교집합):", result_list)
# 출력: ['영희', '지훈']

( 참고: 기호 대신 set_a.intersection(set_b) 라는 함수를 써도 결과는 완전히 똑같습니다!)

2. 차집합 (Difference): 한쪽 리스트에만 있는 데이터 찾기

"A팀에는 있는데, B팀에는 없는 사람은 누구일까?"
우리가 흔히 아는 빼기(-) 기호를 사용하면 됩니다. 앞의 집합에서 뒤의 집합과 겹치는 부분을 쿨하게 빼버립니다.

예제 코드: 누락된 데이터 찾기

# A팀에는 있지만 B팀에는 없는 사람 (A - B)
only_in_a = set_a - set_b
print("A팀에만 있는 사람:", list(only_in_a))
# 출력: ['민수', '철수']

# B팀에는 있지만 A팀에는 없는 사람 (B - A)
only_in_b = set_b - set_a
print("B팀에만 있는 사람:", list(only_in_b))
# 출력: ['동석', '수진']

이 차집합 기술은 실무에서 "전체 회원 명단(set_a)" - "이메일 수신 거부자 명단(set_b)" = "이메일 발송 가능 명단"을 뽑아낼 때 아주 기가 막히게 쓰입니다.

3. 합집합 (Union)과 대칭차집합 (Symmetric Difference)

자주 쓰이진 않지만, 알아두면 요긴한 나머지 두 가지 벤 다이어그램입니다.

① 합집합 ( 기호)

두 리스트의 데이터를 하나로 합치되, 중복은 알아서 하나로 처리해 줍니다. 키보드 엔터(Enter) 키 위에 있는 파이프(|) 기호를 씁니다.

# A팀과 B팀의 모든 사람을 중복 없이 모아보기
all_members = set_a | set_b
print("전체 명단 (합집합):", list(all_members))
# 출력: ['지훈', '민수', '수진', '철수', '동석', '영희']

② 대칭차집합 ( 기호)

"양쪽에 다 속한 박쥐(공통 데이터)는 빼고, 오직 한 팀에만 순수하게 속한 사람들만 모아줘!"
교집합의 정확히 반대되는 개념입니다.

# 겹치는 '영희', '지훈'을 제외한 나머지 사람들만 모입니다.
pure_members = set_a ^ set_b
print("한 팀에만 속한 사람 (대칭차집합):", list(pure_members))
# 출력: ['민수', '수진', '철수', '동석']

마치며

비교할 데이터가 10만 개든 100만 개든, 집합(Set) 연산을 사용하면 파이썬이 내부적으로 엄청나게 빠른 속도로 데이터를 대조해 냅니다.

공통점 찾기 (교집합): set_a & set_b
차이점 찾기 (차집합): set_a - set_b
중복 없이 합치기 (합집합): set_a | set_b

이 기호들만 기억해 두시면 엑셀 VLOOKUP으로 끙끙대며 데이터를 대조하던 시간을 1초로 단축하실 수 있습니다!
지금까지 리스트와 텍스트 데이터를 자유자재로 해체하고 조립하는 법을 마스터하셨습니다!

[Python] "중복 데이터, 대체 어디 숨어있어?" 파이썬 리스트 중복 인덱스(위치) 찾기 완벽 가이드

hi.anna — Tue, 12 May 2026 22:55:53 +0900

파이썬 리스트에서 특정 데이터의 위치를 찾을 때, 초보자분들이 가장 많이 하는 실수가 바로 .index() 함수를 사용하는 것입니다.

my_list.index("사과")를 쓰면 위치를 알려주긴 하지만, 치명적인 단점이 있습니다. 바로 "가장 먼저 발견된 '사과'의 위치 딱 하나만 알려주고 검색을 멈춰버린다"는 것입니다.

뒤에 숨어있는 두 번째, 세 번째 '사과'의 위치까지 싹 다 찾아내려면 어떻게 해야 할까요? 상황에 맞는 2가지 확실한 해결책을 소개합니다.

1. 특정 타겟 데이터의 모든 위치 찾기 ( 활용)

"이 리스트에서 '사과'가 도대체 몇 번, 몇 번 방에 들어있어?"
이렇게 내가 찾고 싶은 특정 타겟이 정해져 있을 때 가장 직관적이고 '파이썬스러운' 방법입니다.

이전에 반복문 단원에서 배웠던 enumerate() (인덱스 번호와 데이터를 같이 뽑아주는 마법의 함수)와 리스트 컴프리헨션을 결합합니다.

예제 코드: 특정 값의 모든 인덱스 찾기

fruits = ["사과", "바나나", "사과", "포도", "사과", "귤"]
target = "사과"

# 1. 일반 for문으로 찾기 (이해하기 쉬운 버전)
target_indices = []
for i, fruit in enumerate(fruits):
    if fruit == target:
        target_indices.append(i)

print(f"일반 for문 결과 - '{target}'의 위치: {target_indices}")


# 2. 리스트 컴프리헨션으로 찾기 (실무용 한 줄 컷!)
# "fruits에서 인덱스(i)와 과일(x)을 꺼내는데, 과일이 '사과'일 때만 그 인덱스(i)를 리스트에 담아라!"
target_indices_short = [i for i, x in enumerate(fruits) if x == target]

print(f"한 줄 컷 결과 - '{target}'의 위치: {target_indices_short}")
# 출력: [0, 2, 4] (사과는 0번, 2번, 4번 방에 있습니다!)

이 한 줄짜리 코드는 실무에서 특정 조건에 맞는 데이터의 위치를 뽑아낼 때 숨 쉬듯이 사용됩니다.

2. 리스트 전체 데이터의 중복 위치 그룹화하기 (딕셔너리 활용)

이번엔 상황이 다릅니다. "사과만 찾는 게 아니라, 이 리스트에 있는 모든 데이터가 각각 몇 번 방에 있는지 싹 다 정리해 줘!" 라는 요구사항이 들어왔습니다.
이때는 데이터의 이름을 이름표(Key)로, 위치(Index)들을 바구니(Value 리스트)에 담아주는 딕셔너리(Dictionary)를 활용하는 것이 정석입니다.

예제 코드: 모든 데이터의 인덱스 맵(Map) 만들기

# 출석체크 명단 (중복 발생)
attendance = ["철수", "영희", "민수", "철수", "지훈", "영희", "철수"]

# 데이터를 정리할 빈 딕셔너리를 만듭니다.
index_map = {}

for i, name in enumerate(attendance):
    # 만약 딕셔너리에 처음 등장하는 이름이라면, 빈 리스트를 먼저 만들어줍니다.
    if name not in index_map:
        index_map[name] = []

    # 해당 이름표(Key)의 리스트(Value)에 현재 인덱스(i)를 추가합니다.
    index_map[name].append(i)

print("▼ 전체 데이터 인덱스 정리 결과 ▼")
for name, indices in index_map.items():
    print(f"{name}: {indices}")

실행 결과:

▼ 전체 데이터 인덱스 정리 결과 ▼
철수: [0, 3, 6]
영희: [1, 5]
민수: [2]
지훈: [4]

어떤가요? 철수가 0, 3, 6번째 줄에 있고, 민수는 2번째 줄에 딱 한 번 있다는 것이 완벽하게 정리되었습니다!

3. 심화: 중복이 발생한(2번 이상 등장한) 데이터만 뽑아내기

위에서 만든 index_map 딕셔너리를 조금만 응용하면, "1번만 나온 정상 데이터는 빼고, 2번 이상 중복해서 나온 문제의 데이터들만 인덱스를 보여줘!"라는 것도 아주 쉽게 구현할 수 있습니다.

예제 코드: 중복된 항목만 필터링하기

# (위의 index_map 딕셔너리가 만들어져 있다고 가정합니다)

print("▼ 중복 발생 데이터 및 위치 ▼")

# 딕셔너리에서 이름과 위치리스트를 하나씩 꺼내봅니다.
for name, indices in index_map.items():
    # 리스트의 길이(len)가 1보다 크다 = 2번 이상 등장했다 = 중복이다!
    if len(indices) > 1:
        print(f"경고! '{name}' 데이터가 다음 위치에서 중복 발견됨: {indices}")

실행 결과:

▼ 중복 발생 데이터 및 위치 ▼
경고! '철수' 데이터가 다음 위치에서 중복 발견됨: [0, 3, 6]
경고! '영희' 데이터가 다음 위치에서 중복 발견됨: [1, 5]

보너스: 로 코드 더 줄이기

2번 예제에서 "딕셔너리에 Key가 없으면 빈 리스트를 만든다(if name not in index_map:)"는 코드를 적었죠?
파이썬의 내장 모듈인 collections.defaultdict를 쓰면 이 귀찮은 확인 과정을 파이썬이 알아서 대신해 줍니다. (실무 고수들이 정말 좋아하는 모듈입니다.)

from collections import defaultdict

attendance = ["철수", "영희", "민수", "철수"]

# "Key가 없으면 알아서 빈 리스트(list)를 기본값으로 세팅해 주는 딕셔너리를 만들게!"
index_map = defaultdict(list)

for i, name in enumerate(attendance):
    # Key가 있는지 없는지 검사할 필요 없이, 무지성으로 append만 하면 됩니다!
    index_map[name].append(i)

print(dict(index_map))
# 출력: {'철수': [0, 3], '영희': [1], '민수': [2]}

마치며

핵심만 다시 정리해 볼까요?

.index()의 배신: 가장 먼저 찾은 위치 1개만 반환하므로 중복 찾기에는 쓸 수 없다.
특정 값 1개만 찾을 때: [i for i, x in enumerate(리스트) if x == 타겟] (원샷원킬 리스트 컴프리헨션)
전체 데이터의 위치를 정리할 때: 딕셔너리(또는 defaultdict)에 이름: [인덱스들] 형태로 모아준다.

이 방법들을 숙지하고 계시면, 수만 줄짜리 엑셀이나 CSV 파일을 파이썬으로 불러왔을 때 불량(중복) 데이터가 몇 번째 줄에 숨어있는지 1초 만에 색출해 내실 수 있습니다!

[Python] "리스트 안의 리스트?" 2차원 리스트 중복 제거

hi.anna — Fri, 17 Apr 2026 08:44:36 +0900

1차원 리스트의 중복을 제거할 때는 마법의 주머니 set()을 쓰면 아주 쉽게 해결되었습니다.
하지만 실무에서 엑셀 데이터나 표 형태의 데이터를 다루다 보면 리스트 안에 또 리스트가 들어있는 '2차원 리스트'를 만나게 됩니다.

여기에 평소 하던 대로 set()을 씌우면 파이썬은 TypeError: unhashable type: 'list'라는 무시무시한 에러를 뿜어냅니다. 오늘은 이 에러가 왜 발생하는지 알아보고, 2차원 리스트의 중복을 3가지 방법으로 완벽하게 날려버리는 비법을 전수해 드립니다.

1. 왜 그냥 `set()`을 쓰면 에러가 날까요?

파이썬의 집합(set)이나 딕셔너리의 이름표(Key)에는 아주 엄격한 규칙이 하나 있습니다. 바로 "내용물이 중간에 바뀔 위험이 있는 데이터(Mutable)는 절대 들어올 수 없다"는 것입니다.

우리가 아는 리스트([])는 .append()로 값을 추가하거나 수정할 수 있는 자유로운 영혼입니다. 반면, 이전에 배웠던 튜플(())은 한 번 만들어지면 절대 수정할 수 없는 자물쇠 채운 상자(Immutable)죠.

파이썬은 내용물이 변할 수 있는 리스트를 집합에 넣는 것을 불안해해서 거부합니다. 따라서 해결책은 아주 간단합니다. 잠깐 자물쇠(튜플)를 채워서 중복을 제거하고, 다시 리스트로 풀어주면 됩니다.

2. 방법 1: 튜플(Tuple)로 변신시켜서 중복 날리기 (순서 무시)

가장 기본적이고 파이썬다운 방법입니다. 지난 시간에 배운 '리스트 컴프리헨션'을 활용하면 코드가 아주 깔끔해집니다.

예제 코드: `set`과 `tuple`의 콜라보

# 이름, 나이, 부서가 담긴 2차원 리스트 (홍길동 데이터가 중복됨)
data = [
    ["홍길동", 30, "영업팀"],
    ["김철수", 25, "개발팀"],
    ["홍길동", 30, "영업팀"],  # 완벽히 똑같은 중복 데이터!
    ["이영희", 28, "디자인팀"]
]

# 1. 안쪽 리스트들을 모두 튜플()로 바꾼 뒤, set()에 넣어 중복을 날립니다.
# (이때 데이터의 원래 순서는 뒤죽박죽 섞이게 됩니다.)
unique_tuples = set(tuple(row) for row in data)

# 2. 튜플로 묶여있던 데이터를 다시 리스트[]로 풀어줍니다.
clean_data = [list(row) for row in unique_tuples]

print(clean_data)
# 출력 예시 (순서는 다를 수 있음): 
# [['이영희', 28, '디자인팀'], ['홍길동', 30, '영업팀'], ['김철수', 25, '개발팀']]

3. 방법 2: 원래 순서까지 완벽하게 지키기 (`dict.fromkeys`)

크롤링을 했거나 시간순으로 쌓인 데이터라서 "처음 들어온 순서를 무조건 유지"해야 한다면, 1차원 리스트 때 썼던 딕셔너리 꼼수를 똑같이 적용하면 됩니다.

예제 코드: 순서 유지하며 중복 제거하기

data = [
    ["홍길동", 30, "영업팀"],
    ["김철수", 25, "개발팀"],
    ["홍길동", 30, "영업팀"],  # 중복
    ["이영희", 28, "디자인팀"]
]

# 1. 안쪽 리스트를 튜플로 바꿔서 딕셔너리의 Key로 만듭니다. (중복 제거 + 순서 기억)
dict_data = dict.fromkeys(tuple(row) for row in data)

# 2. 딕셔너리의 Key들만 쏙쏙 뽑아서 다시 리스트로 감싸줍니다.
ordered_clean_data = [list(key) for key in dict_data]

print("순서 유지 결과:")
for row in ordered_clean_data:
    print(row)

실행 결과:

순서 유지 결과:
['홍길동', 30, '영업팀']
['김철수', 25, '개발팀']
['이영희', 28, '디자인팀']

홍길동이 맨 처음에 등장했던 그 순서 그대로 예쁘게 살아남았습니다!

4. 방법 3: 보너스 트랙! 판다스(Pandas)로 1초 컷

만약 여러분이 엑셀처럼 방대한 데이터를 다루고 있고 이미 pandas 패키지를 알고 계신다면, 저렇게 복잡하게 튜플로 변환할 필요가 전혀 없습니다. 판다스는 2차원 리스트(표 형태)를 다루는 끝판왕이기 때문입니다.

예제 코드: 판다스의 `drop_duplicates()`

import pandas as pd

data = [
    ["홍길동", 30, "영업팀"],
    ["김철수", 25, "개발팀"],
    ["홍길동", 30, "영업팀"],
    ["이영희", 28, "디자인팀"]
]

# 1. 2차원 리스트를 판다스 데이터프레임으로 만듭니다.
df = pd.DataFrame(data)

# 2. 중복을 날리고(.drop_duplicates()), 다시 리스트로 되돌립니다(.values.tolist())
pandas_clean_data = df.drop_duplicates().values.tolist()

print(pandas_clean_data)
# 출력: [['홍길동', 30, '영업팀'], ['김철수', 25, '개발팀'], ['이영희', 28, '디자인팀']]

단 한 줄(df.drop_duplicates().values.tolist())로 순서까지 갓벽하게 유지하면서 중복을 없앴습니다. 실무에서 데이터 분석가들이 가장 사랑하는 방식입니다.

마치며

핵심 요약입니다.
2차원 리스트는 그냥 set()에 넣으면 에러가 납니다! 따라서 안쪽 데이터들을 자물쇠 채운 튜플(tuple)로 변환하는 과정을 거쳐야 합니다.

순서 상관없을 때: [list(x) for x in set(tuple(x) for x in data)]
순서 지켜야 할 때: [list(x) for x in dict.fromkeys(tuple(x) for x in data)]
판다스를 쓸 줄 안다면: pd.DataFrame(data).drop_duplicates().values.tolist()

이제 아무리 복잡하게 얽힌 다차원 리스트를 만나도 가뿐하게 중복을 날려버리실 수 있습니다.

[Python] "원하는 데이터만 쏙쏙!" 파이썬 정규표현식(Regex) 기초 완벽 가이드

hi.anna — Fri, 17 Apr 2026 01:43:58 +0900

정규표현식(Regex)은 특정한 규칙을 가진 문자열의 집합을 표현하는 '형식 언어'입니다. 처음 보면 마치 외계어처럼 생겼지만, 원리만 알면 수백 줄의 코드를 단 한 줄로 줄여주는 기적을 경험할 수 있습니다.

파이썬에서는 기본으로 제공하는 re 모듈을 가져와서 사용합니다.

1. 정규표현식의 핵심 기호 (마법의 주문)

정규표현식은 '패턴'을 만드는 것입니다. "숫자 3개, 하이픈(-), 숫자 4개" 같은 규칙을 기호로 표현합니다. 실무에서 가장 많이 쓰는 핵심 기호만 빠르게 훑어보겠습니다.

\d : 숫자 (Digit, 0~9)
\w : 문자+숫자 (Word, 알파벳, 한글, 숫자 등)
\s : 공백 (Space, 띄어쓰기, 탭 등)
+ : 앞의 문자가 1번 이상 반복됨 (예: \d+ = 숫자가 1개 이상 있음)
* : 앞의 문자가 0번 이상 반복됨 (없을 수도 있음)
{n} : 정확히 n번 반복됨 (예: \d{3} = 숫자가 정확히 3개)
[ ] : 괄호 안의 문자 중 하나 (예: [a-z] = 소문자 a부터 z까지 중 하나)

이 기호들을 레고 블록처럼 조립해서 우리가 원하는 패턴을 만듭니다.

2. 숨은 데이터 싹 다 찾기: `re.findall()`

수백 장의 텍스트 문서 안에서 전화번호(010-XXXX-XXXX) 패턴만 전부 찾아내서 리스트로 만들어주는 기능입니다.

예제 코드: 텍스트에서 전화번호만 추출하기

import re  # 정규표현식 모듈을 불러옵니다.

text = """
안녕하세요, 홍길동입니다. 제 번호는 010-1234-5678입니다.
급한 일은 010-9876-5432로 연락 주세요.
사무실 번호 02-111-2222는 당분간 안 받습니다.
"""

# 패턴 만들기: 숫자 3개 + 하이픈(-) + 숫자 3~4개 + 하이픈(-) + 숫자 4개
# \d{3} : 숫자 3개
# \d{3,4} : 숫자 3개 또는 4개
phone_pattern = r"\d{3}-\d{3,4}-\d{4}"

# re.findall(패턴, 텍스트) : 텍스트 안에서 패턴과 일치하는 모든 것을 '리스트'로 찾아줍니다.
results = re.findall(phone_pattern, text)

print("찾아낸 전화번호 목록:", results)

실행 결과:

찾아낸 전화번호 목록: ['010-1234-5678', '010-9876-5432', '02-111-2222']

꿀팁: r의 의미
패턴 문자열 앞에 r을 붙이는 것(r"...")은 Raw String이라는 뜻으로, 파이썬에게 "이 안의 역슬래시(\)를 특수기호로 처리하지 말고 있는 그대로(정규식 기호로) 봐줘!"라고 알려주는 필수 관행입니다.

3. 원하는 형태로 싹 바꾸기: `re.sub()`

데이터를 수집했는데, 개인정보 보호를 위해 전화번호 뒷자리를 별표(*)로 마스킹 처리하거나, 특수문자를 다 지워버리고 싶을 때 사용합니다. 엑셀의 '찾아 바꾸기'의 초강력 업그레이드 버전입니다.

예제 코드: 주민등록번호 뒷자리 마스킹하기

import re

info = "저의 주민번호는 901225-1234567 입니다. 친구는 911111-2345678 이에요."

# 패턴: 숫자 6개 + 하이픈(-) + 숫자 7개
# 괄호 ( )를 쳐주면 그 부분을 '그룹'으로 묶어서 기억할 수 있습니다.
# 앞부분(생년월일과 -)을 그룹 1번으로 묶어줍니다.
jumin_pattern = r"(\d{6}-)\d{7}"

# re.sub(패턴, 바꿀형태, 텍스트)
# \g<1> 은 "방금 패턴에서 괄호로 묶었던 1번 그룹(앞부분)은 그대로 두고!" 라는 뜻입니다.
masked_info = re.sub(jumin_pattern, r"\g<1>*******", info)

print("원본:", info)
print("마스킹 결과:", masked_info)

실행 결과:

원본: 저의 주민번호는 901225-1234567 입니다. 친구는 911111-2345678 이에요.
마스킹 결과: 저의 주민번호는 901225-******* 입니다. 친구는 911111-******* 이에요.

예제 코드: 지저분한 특수문자 한 방에 날리기

크롤링한 텍스트에서 한글, 알파벳, 숫자, 띄어쓰기만 남기고 이상한 기호들을 다 지우고 싶을 때 아주 유용합니다.

import re

dirty_text = "안녕!@#$ 파이썬(Python) 100점^^ 완성!!!"

# 패턴: [^가-힣a-zA-Z0-9\s] 
# 대괄호 안의 ^ 는 "NOT(이것들 빼고 전부)" 이라는 뜻입니다.
# 즉, "한글, 영문 대소문자, 숫자, 공백(\s) 빼고 나머지 전부 다 찾아라!"
clean_pattern = r"[^가-힣a-zA-Z0-9\s]"

# 특수문자들을 "" (빈 문자열)로 교체하여 아예 지워버립니다.
clean_text = re.sub(clean_pattern, "", dirty_text)

print("정제된 텍스트:", clean_text)
# 출력: 안녕 파이썬Python 100점 완성

4. 실전 응용: 이메일 주소만 추출하기

가장 대표적인 정규표현식 예제인 이메일 추출입니다. 이메일은 아이디@도메인.주소 형태를 띠고 있습니다.

import re

text = """
제 개인 이메일은 python_king123@gmail.com 이고요,
회사 이메일은 admin@company.co.kr 입니다.
연락 주세요!
"""

# 이메일 패턴 분석:
# 1. [a-zA-Z0-9_-]+ : 영문자, 숫자, 언더바, 하이픈으로 이루어진 아이디 (1개 이상)
# 2. @ : 골뱅이 기호
# 3. [a-zA-Z0-9.-]+ : 도메인 이름 (영문자, 숫자, 마침표, 하이픈)
# 4. \. : 진짜 마침표(.) 기호 (정규식에서 그냥 .을 쓰면 '모든 문자'를 뜻하므로 역슬래시를 붙여야 함)
# 5. [a-zA-Z]{2,} : com, net, kr 같은 최상위 도메인 (영문자 2개 이상)

email_pattern = r"[a-zA-Z0-9_-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"

emails = re.findall(email_pattern, text)
print("추출된 이메일:", emails)

실행 결과:

추출된 이메일: ['python_king123@gmail.com', 'admin@company.co.kr']

마치며

오늘 배운 정규표현식 요약입니다.

import re: 파이썬에서 정규식을 쓰기 위한 마법의 모듈.
re.findall(패턴, 텍스트): 패턴에 맞는 모든 글자를 찾아서 리스트로 뽑아준다.
re.sub(패턴, 교체할_글자, 텍스트): 패턴에 맞는 글자를 찾아 다른 글자로 싹 바꿔준다. (데이터 정제 필수품!)
패턴 앞에는 항상 r을 붙이는 습관을 들이자! (r"\d+")

정규표현식은 처음엔 외계어 같지만, 파이썬뿐만 아니라 엑셀, 자바스크립트 등 거의 모든 IT 환경에서 똑같이 쓰이는 만국 공통어입니다.
복잡한 패턴을 직접 다 외울 필요는 없습니다. 구글에 "이메일 정규표현식", "전화번호 정규식" 이라고 검색하면 전 세계 개발자들이 만들어둔 훌륭한 패턴들이 넘쳐나니 복사해서 re 모듈에 적용하기만 하면 됩니다!

이제 여러분은 파이썬으로 데이터를 자유자재로 요리할 수 있는 완벽한 셰프가 되셨습니다!

[Python 기초] "중복 제거와 정렬을 단 한 줄로!" 파이썬 리스트 완벽 정리 비법

hi.anna — Thu, 16 Apr 2026 08:43:31 +0900

데이터를 다루다 보면 "중복된 데이터를 없애고, 가나다순이나 크기순으로 깔끔하게 정렬해 줘!"라는 요구사항을 정말 많이 받게 됩니다.
이 두 가지 작업을 따로따로 하려면 코드가 길어지겠지만, 파이썬에서는 단 한 줄로 아주 우아하게 해결할 수 있습니다.

상황별로 골라 쓸 수 있는 완벽한 콤보 기술을 알아보겠습니다.

1. 실무 정석: `sorted()`와 `set()`의 환상적인 콜라보

가장 기본적이고 파이썬다운(Pythonic) 방법입니다.
중복을 없애는 set()과, 정렬된 새 리스트를 뱉어내는 sorted()를 양파 껍질처럼 겹쳐서 사용합니다.

예제 코드: 기본 오름차순 (작은 것부터 / 가나다순)

raw_data = [5, 2, 9, 1, 5, 2, 3, 9]

# 1. 안쪽의 set(raw_data)가 먼저 실행되어 중복을 날립니다. -> {1, 2, 3, 5, 9}
# 2. 바깥쪽의 sorted()가 그 결과를 받아 정렬된 '리스트'로 만듭니다.
clean_sorted_data = sorted(set(raw_data))

print("원본:", raw_data)
print("중복 제거 + 정렬:", clean_sorted_data)
# 출력: [1, 2, 3, 5, 9]

2. 반대로 정렬하기: 내림차순 (큰 것부터)

만약 1등부터 꼴등 순서로, 혹은 알파벳 Z부터 A 순서로 정렬하고 싶다면 sorted() 함수의 마법의 옵션인 reverse=True를 덧붙여주면 됩니다.

예제 코드: 내림차순 콤보

fruits = ["banana", "apple", "cherry", "apple", "banana"]

# set으로 중복을 없애고, sorted의 reverse=True로 역순 정렬을 지시합니다.
desc_fruits = sorted(set(fruits), reverse=True)

print("내림차순 정렬:", desc_fruits)
# 출력: ['cherry', 'banana', 'apple']

3. 응용편: 내 마음대로 정렬 기준 세우기 (`key` 옵션)

단순한 크기순이나 알파벳순이 아니라, "중복은 지우되, 글자 길이가 짧은 순서대로 정렬해 줘!"라는 복잡한 조건이 붙는다면 어떻게 할까요?
이때는 sorted()의 또 다른 옵션인 key를 활용합니다.

예제 코드: 글자 길이(len) 순으로 정렬하기

words = ["apple", "kiwi", "banana", "fig", "kiwi", "apple"]

# 1. set(words)로 중복 제거 -> {'fig', 'banana', 'apple', 'kiwi'}
# 2. key=len 옵션을 주어 글자 수가 적은 단어부터 앞으로 오게 정렬
length_sorted_words = sorted(set(words), key=len)

print("글자 길이순 정렬:", length_sorted_words)
# 출력: ['fig', 'kiwi', 'apple', 'banana']

4. ⚠️ 잠깐! `.sort()`를 쓰면 안 되나요?

파이썬에는 리스트 원본 자체를 섞어버리는 .sort() 메서드도 있습니다. 이걸로 중복 제거와 정렬을 같이 하려면 코드를 두 줄로 나누어 써야 합니다.

data = [3, 1, 2, 3]

# 1. 먼저 중복을 지우고 다시 리스트로 바꿉니다.
data = list(set(data))

# 2. 그 리스트 자체의 정렬 기능을 호출합니다.
data.sort()

이 방식도 틀린 것은 아니지만, 앞서 배운 sorted(set()) 방식이 코드 한 줄로 끝나고 원본 데이터(raw data)도 훼손하지 않고 안전하게 보존할 수 있어서 실무에서는 압도적으로 선호됩니다.

마치며

오늘의 핵심, 이 공식 딱 하나만 기억하시면 됩니다.

⭐ 새_리스트 = sorted(set(원본_리스트)) ⭐

어떤 지저분한 데이터를 만나더라도, 이 한 줄이면 중복 하나 없이 깔끔하게 각 잡힌 리스트를 얻어내실 수 있을 것입니다.

[Python 기초] "똑같은 데이터 다 나와!" 파이썬 리스트 중복 제거 완벽 가이드 (순서 유지 vs 순서 무시)

hi.anna — Thu, 16 Apr 2026 01:43:08 +0900

수만 건의 크롤링 데이터나 설문조사 결과를 취합하다 보면, 필연적으로 중복된 데이터가 섞여 들어옵니다. 파이썬에서는 이 중복 데이터를 아주 쉽게 날려버릴 수 있습니다.

오늘은 데이터의 '순서'를 중요하게 생각하느냐 마느냐에 따라 골라 쓸 수 있는 리스트 중복 제거의 3가지 비법을 소개해 드립니다.

1. 가장 쉽고 빠른 방법: `set()` 활용하기 (순서 섞임 주의)

파이썬에서 중복을 제거할 때 가장 먼저 떠올려야 할 마법의 단어는 바로 집합(set)입니다. 집합 자료형은 태생적으로 "같은 값을 두 번 허용하지 않는다"는 강력한 규칙을 가지고 있습니다.

예제 코드: set()으로 중복 날리기

# 중복이 섞여 있는 원본 리스트
raw_data = ["사과", "바나나", "사과", "딸기", "바나나", "포도"]

# 1. 리스트를 집합(set)으로 변환하면 알아서 중복이 날아갑니다.
unique_set = set(raw_data)

# 2. 다루기 편하게 다시 리스트(list)로 되돌려줍니다.
clean_list = list(unique_set)

print("원본:", raw_data)
print("중복 제거 후:", clean_list)
# 출력 예시: ['딸기', '포도', '바나나', '사과']

이 방법의 특징:

장점: 코드가 가장 짧고, 실행 속도도 압도적으로 빠릅니다. list(set(데이터)) 한 줄이면 끝납니다.
단점: 집합은 '순서'라는 개념이 없습니다. 따라서 위 출력 예시처럼 데이터가 원래 리스트에 있던 순서와 완전히 다르게 뒤죽박죽 섞여버립니다. (순서가 상관없을 때만 쓰세요!)

2. 전통적이고 직관적인 방법: `for` 반복문 사용하기 (순서 유지)

"데이터가 들어온 순서를 무조건 지켜야 해요!"
이럴 때 초보자분들이 가장 이해하기 쉬운 직관적인 방법은 바로 빈 바구니를 하나 만들고, 원래 바구니에서 하나씩 꺼내보며 "새 바구니에 이 값이 이미 있나?" 확인하는 것입니다.

예제 코드: for문과 in 연산자로 중복 걸러내기

raw_data = ["사과", "바나나", "사과", "딸기", "바나나", "포도"]

# 중복을 제거한 데이터를 담을 '새로운 빈 바구니'를 만듭니다.
clean_list = []

for item in raw_data:
    # 만약 새 바구니(clean_list) 안에 이 과일(item)이 '없다면(not in)'
    if item not in clean_list:
        clean_list.append(item)  # 새 바구니에 추가합니다.

print("중복 제거 후 (순서 유지):", clean_list)
# 출력: ['사과', '바나나', '딸기', '포도'] 
# (원본에서 처음 등장했던 순서가 그대로 유지됨!)

이 방법의 특징:

장점: 논리가 아주 명확해서 누구나 코드를 읽고 이해하기 쉽습니다. 원래 데이터의 순서도 완벽하게 지켜줍니다.
단점: 데이터가 100만 개쯤 되면, 매번 새 바구니를 뒤져봐야 하므로 컴퓨터가 처리하는 속도가 꽤 느려집니다.

3. 파이썬 고수들의 실무 방식: `dict.fromkeys()` (순서 유지 + 빠른 속도)

순서도 유지하고 싶고, 속도도 빠르게 처리하고 싶다면 어떻게 해야 할까요?
파이썬 개발자들이 실무에서 가장 사랑하는 우아한 방법은 바로 딕셔너리(Dictionary)의 성질을 이용하는 것입니다.

딕셔너리의 이름표(Key)는 절대 중복될 수 없다는 특징을 활용합니다. 파이썬 3.7 버전부터는 딕셔너리가 데이터가 입력된 순서를 기억하도록 업그레이드되었기 때문에 가능한 꼼수이자 정석입니다.

예제 코드: 딕셔너리를 활용한 스마트한 중복 제거

raw_data = ["사과", "바나나", "사과", "딸기", "바나나", "포도"]

# 1. dict.fromkeys()를 쓰면 리스트의 값들이 딕셔너리의 'Key'로 들어갑니다.
# (이 과정에서 중복된 Key는 무시되고, 처음 들어온 순서는 기억됩니다.)
dict_data = dict.fromkeys(raw_data)

# 2. 만들어진 딕셔너리를 다시 리스트로 감싸줍니다.
clean_list = list(dict_data)

# 실무에서는 보통 위 과정을 한 줄로 씁니다: 
# clean_list = list(dict.fromkeys(raw_data))

print("중복 제거 후 (고수 방식):", clean_list)
# 출력: ['사과', '바나나', '딸기', '포도']

이 방법의 특징:

장점: 코드가 단 한 줄로 깔끔하며, 원래 순서를 완벽하게 유지하면서도 for문을 쓰는 것보다 실행 속도가 훨씬 빠릅니다. (현재 파이썬에서 가장 권장되는 방식입니다.)

마치며

리스트 중복 제거의 3가지 방법 요약입니다.

순서가 섞여도 상관없을 때 (가장 빠름): list(set(데이터))
순서를 지켜야 하고, 직관적인 코드가 좋을 때: for문과 not in 사용
순서를 지키면서, 실무에서 가장 세련되게 쓸 때: list(dict.fromkeys(데이터))

이제 중복 데이터가 산더미처럼 쌓여있어도 당황하지 않고 상황에 맞는 칼을 꺼내 드실 수 있겠죠?

[Python 기초] "뒤죽박죽 데이터 깔끔하게 줄 세우기!" 파이썬 리스트 정렬 (sort vs sorted)

hi.anna — Wed, 15 Apr 2026 08:42:44 +0900

쇼핑몰에서 '가격 낮은 순', '평점 높은 순'으로 상품을 보거나, 학교에서 학생들의 시험 점수를 '1등부터 꼴등까지' 나열할 때 우리는 정렬(Sorting)을 사용합니다.

파이썬은 아주 강력하고 직관적인 정렬 기능을 제공합니다. 오늘은 가장 많이 쓰이는 두 가지 마법의 단어, sort()와 sorted(), 그리고 내가 원하는 기준대로 정렬하는 key 옵션에 대해 알아보겠습니다.

1. 원본을 직접 줄 세우기: `.sort()`

첫 번째 방법은 리스트가 가지고 있는 자체 기능인 .sort() 메서드를 사용하는 것입니다.
이 방법을 사용하면 원본 리스트 자체가 정렬된 상태로 영구적으로 바뀌게 됩니다.

예제 코드: 오름차순과 내림차순 정렬

# 1. 숫자 오름차순 정렬 (작은 수 -> 큰 수)
scores = [85, 100, 70, 95, 60]
scores.sort()
print("오름차순:", scores)  
# 출력: 오름차순: [60, 70, 85, 95, 100]

# 2. 숫자 내림차순 정렬 (큰 수 -> 작은 수)
# 괄호 안에 reverse=True (반대로 할게: 참) 옵션을 넣어줍니다!
scores.sort(reverse=True)
print("내림차순:", scores)  
# 출력: 내림차순: [100, 95, 85, 70, 60]

# 3. 문자열 정렬 (알파벳순, 가나다순)
fruits = ["banana", "apple", "cherry", "사과", "바나나"]
fruits.sort()
print("문자열 정렬:", fruits)
# 출력: 문자열 정렬: ['apple', 'banana', 'cherry', '바나나', '사과']
# (참고: 영어 대문자 -> 영어 소문자 -> 한글 순서로 정렬됩니다.)

⚠️ 주의할 점: scores.sort()는 원본을 바꿀 뿐, 결과값을 밖으로 뱉어내지(return) 않습니다. 따라서 new_list = scores.sort()라고 쓰면 new_list에는 아무것도 없는 None이 들어가 버리니 주의하세요!

2. 원본은 놔두고, 새로운 리스트 만들기: `sorted()`

데이터 분석을 하다 보면 원본 데이터(예: 수집한 시간순 데이터)는 그대로 보존해야 할 때가 많습니다. 이때는 원본을 건드리지 않고, 정렬된 '새로운 리스트'를 복사해서 만들어주는 sorted() 파이썬 내장 함수를 사용합니다.

예제 코드: 안전하게 정렬하기

original_numbers = [3, 1, 4, 2, 5]

# 원본은 그대로 두고, 정렬된 새 리스트를 변수에 담습니다.
sorted_numbers = sorted(original_numbers)

print("원본 리스트:", original_numbers)
print("새로운 리스트:", sorted_numbers)

실행 결과:

원본 리스트: [3, 1, 4, 2, 5]
새로운 리스트: [1, 2, 3, 4, 5]

sorted() 함수 역시 내림차순을 원한다면 괄호 안에 reverse=True를 추가해주면 됩니다. (예: sorted(numbers, reverse=True))

3. "내 맘대로 줄 세울래!" 마법의 `key` 옵션 (실전용)

단순히 가나다순, 크기순이 아니라 "글자 길이가 짧은 순서대로 정렬해 줘!" 라거나, "이름과 점수가 같이 있는데, 점수를 기준으로 정렬해 줘!"라고 디테일한 명령을 내리고 싶을 때가 있습니다.

이때 사용하는 것이 바로 key 옵션입니다. 정렬의 기준(Key)이 될 함수를 지정해 주는 아주 강력한 기능입니다.

예제 코드: 글자 길이로 정렬하기

파이썬의 길이를 재는 내장 함수인 len을 기준으로 삼아보겠습니다.

words = ["apple", "kiwi", "banana", "fig", "strawberry"]

# 기준(key)을 글자 길이(len)로 설정합니다.
# 알파벳 순서가 아니라 짧은 단어부터 긴 단어 순으로 정렬됩니다.
words.sort(key=len)

print("글자 길이순 정렬:", words)
# 출력: 글자 길이순 정렬: ['fig', 'kiwi', 'apple', 'banana', 'strawberry']

예제 코드: 복잡한 데이터 정렬하기 (람다 함수 활용)

이전에 배운 람다(lambda) 함수와 결합하면 그 위력이 배가 됩니다. 학생의 이름과 점수가 묶여있는 리스트를 '점수' 기준으로 정렬해 보겠습니다.

# [이름, 점수] 로 이루어진 리스트
students = [
    ["홍길동", 85],
    ["김철수", 100],
    ["이영희", 92]
]

# 그냥 sort()를 하면 첫 번째 데이터인 '이름(가나다순)'으로 정렬되어 버립니다.
# "x가 들어오면, x의 1번 인덱스(즉, 점수)를 기준으로 정렬해라!"
students.sort(key=lambda x: x[1], reverse=True)

print("점수 높은 순 정렬:")
for student in students:
    print(student)

실행 결과:

점수 높은 순 정렬:
['김철수', 100]
['이영희', 92]
['홍길동', 85]

마치며

리스트 정렬의 핵심 요약입니다.

.sort(): 원본 리스트를 직접 정렬해 버린다. (메모리 절약)
sorted(): 원본은 안전하게 보존하고 정렬된 새 리스트를 만든다. (안전함)
reverse=True: 내림차순(큰 것부터)으로 정렬할 때 쓰는 마법의 옵션.
key=함수: 정렬 기준을 내 마음대로 커스텀할 때 사용한다. (lambda와 찰떡궁합!)

이 4가지만 알고 계시면 파이썬에서 만나는 어떤 데이터든 예쁘게 줄 세우실 수 있습니다.

[Python 실전 보너스] 18. "100만 줄 엑셀도 1초 컷!" 데이터 분석의 끝판왕, 판다스(Pandas) 찍어 먹기

hi.anna — Wed, 15 Apr 2026 00:54:16 +0900

엑셀에서 VLOOKUP을 쓰거나 피벗 테이블을 돌려본 적 있으신가요?
판다스(Pandas)는 이런 복잡한 표 계산과 데이터 조작을 단 몇 줄의 파이썬 코드로 순식간에 처리해 주는 마법의 도구입니다. 데이터 과학자나 AI 개발자들에게는 숨 쉬는 것과도 같은 필수 패키지입니다.

1. 준비 운동: 판다스 설치와 핵심 개념 (DataFrame)

먼저 터미널을 열고 판다스를 설치해 줍니다.

pip install pandas

판다스를 이해하려면 딱 하나의 단어만 기억하면 됩니다. 바로 데이터프레임(DataFrame)입니다.
데이터프레임은 쉽게 말해 '파이썬 안에 띄워놓은 가상의 엑셀 시트'입니다. 행(Row)과 열(Column)로 이루어진 완벽한 표 형태를 띠고 있죠.

2. 엑셀/CSV 파일 한 번에 빨아들이기

openpyxl에서는 빈 워크북을 만들고 시트를 찾아서 한 줄씩 읽어야 했지만, 판다스는 그런 자잘한 과정을 모두 생략합니다.

예제 코드: 단 한 줄로 데이터 불러오기

import pandas as pd  # pandas는 관행적으로 pd라는 별명으로 줄여 씁니다.

# 1. CSV 파일이나 엑셀 파일을 통째로 읽어서 '데이터프레임'으로 만듭니다.
# (미리 "sales_data.csv" 파일이 있다고 가정합니다)
df = pd.read_csv("sales_data.csv")

# 엑셀 파일이라면? df = pd.read_excel("sales_data.xlsx") 라고 쓰면 끝입니다!

# 2. 데이터가 어떻게 생겼는지 위에서부터 5줄만 살짝 엿보기
print(df.head())

실행 결과 (터미널에 표가 예쁘게 출력됩니다!):

         날짜     부서   직급      매출액
0  2026-02-01  영업1팀   대리  3500000
1  2026-02-01  영업2팀   사원  2100000
2  2026-02-02  마케팅팀   과장  5000000
3  2026-02-02  영업1팀   부장  8000000
4  2026-02-03  영업2팀   대리  4200000

맨 왼쪽에 0, 1, 2... 하고 붙은 숫자는 판다스가 알아서 매겨준 데이터의 주민등록번호(인덱스)입니다.

3. 판다스의 진가: 데이터 필터링과 계산

판다스가 진짜 무서운 이유는 조건 검색과 계산입니다. 엑셀에서 마우스로 필터를 걸고 클릭하던 작업을 코드로 아주 직관적으로 할 수 있습니다.

예제 코드: 조건에 맞는 데이터만 뽑아내기

import pandas as pd

# 데이터 불러오기
df = pd.read_csv("sales_data.csv")

# --- 1. 특정 열(Column)만 뽑아보기 ---
# 딕셔너리에서 Key로 값을 찾듯, 대괄호 안에 열 이름을 넣습니다.
print(df["매출액"]) 

print("-" * 30)

# --- 2. 조건 필터링 (영업1팀 데이터만 찾기) ---
# "df의 부서가 '영업1팀'인 것만 다시 df에서 골라내라!"
team1_data = df[df["부서"] == "영업1팀"]
print("▼ 영업1팀 데이터 ▼")
print(team1_data)

print("-" * 30)

# --- 3. 복합 조건 (매출액 400만 원 이상인 대리 찾기) ---
# 괄호()로 조건을 묶고, & (그리고) 기호로 연결합니다.
vip_sales = df[(df["매출액"] >= 4000000) & (df["직급"] == "대리")]
print("▼ 400만 원 이상 매출을 낸 대리 ▼")
print(vip_sales)

print("-" * 30)

# --- 4. 통계 계산 1초 컷 ---
total_sales = df["매출액"].sum()    # 총합
avg_sales = df["매출액"].mean()     # 평균
max_sales = df["매출액"].max()      # 최댓값

print(f"전체 총 매출액: {total_sales}원")
print(f"평균 매출액: {avg_sales}원")

만약 이 작업을 순수 파이썬의 for문과 if문으로 짰다면 코드가 10줄은 훌쩍 넘어갔겠지만, 판다스를 쓰면 단 한 줄로 끝납니다. 심지어 데이터가 100만 개여도 눈 깜짝할 사이에 계산을 끝냅니다.

4. 분석한 결과를 다시 새로운 엑셀로 저장하기

요리가 끝났으니 다시 그릇에 담아내야겠죠? 판다스는 저장하는 것도 예술적으로 간단합니다.

예제 코드: 데이터프레임을 엑셀로 내보내기

import pandas as pd

df = pd.read_csv("sales_data.csv")

# 영업1팀 데이터만 필터링
team1_data = df[df["부서"] == "영업1팀"]

# 결과를 새로운 엑셀 파일로 저장합니다.
# index=False 옵션을 주면, 맨 왼쪽에 있던 0, 1, 2... 번호표는 빼고 깔끔하게 저장됩니다.
team1_data.to_excel("영업1팀_실적보고서.xlsx", index=False)

print("엑셀 파일 저장이 완료되었습니다!")

read_csv()로 빨아들이고, to_excel()로 뱉어낸다. 정말 직관적이지 않나요?

마치며

보너스 트랙의 핵심 요약입니다.

판다스(Pandas): 파이썬에서 표 형태의 데이터를 엑셀처럼, 아니 엑셀보다 훨씬 빠르고 강력하게 다루게 해주는 패키지.
pd.read_csv() / `pd.read_excel()`: 파일을 한 번에 읽어와 데이터프레임으로 만든다.
df[ 조건 ]: 직관적인 코드로 원하는 데이터만 쏙쏙 필터링할 수 있다.
df.to_excel(): 분석이 끝난 데이터를 깔끔하게 다시 파일로 저장한다.

웹 크롤링(requests, BeautifulSoup)으로 긁어온 수만 건의 데이터를 판다스(pandas) 데이터프레임에 넣고, 중복을 제거하고 통계를 낸 뒤 엑셀 파일로 저장한다!
이것이 바로 현업에서 매일같이 쓰이는 데이터 수집 및 분석의 정석 파이프라인입니다.

정말, 정말로 파이썬 기초 여행이 모두 끝났습니다!

[Python 실전] 17. "크롤링보다 100배 쉽고 정확하다!" 공공데이터 API 연동과 JSON 다루기

hi.anna — Tue, 14 Apr 2026 08:53:36 +0900

크롤링이 남의 집 담벼락을 몰래 훔쳐보는 것이라면, API는 정문으로 당당하게 들어가서 "여기 날씨 정보 1인분 포장해 주세요!"라고 주문하는 것과 같습니다.

합법적이고, 데이터가 아주 깔끔하게 정리되어 오기 때문에 실무에서는 무조건 크롤링보다 API를 우선적으로 사용합니다. 오늘은 별도의 회원가입이나 인증키 없이 무료로 사용할 수 있는 날씨 API를 통해 그 원리를 파헤쳐 보겠습니다.

1. API란 무엇인가요? (식당 점원 비유)

API를 가장 쉽게 이해하는 방법은 식당의 '점원(웨이터)'으로 생각하는 것입니다.

손님 (파이썬 코드): 메뉴판을 보고 "서울 날씨 주세요!"라고 주문(요청, Request)합니다.
점원 (API): 손님의 주문을 주방에 전달하고, 완성된 요리를 가져다줍니다.
주방 (서버/데이터베이스): 실제 날씨 데이터를 가지고 요리하는 곳입니다.

우리는 주방장이 요리를 어떻게 하는지(서버가 어떻게 동작하는지) 알 필요가 없습니다. 그저 점원(API)이 알아들을 수 있는 규칙(메뉴판)에 맞춰서 파이썬 코드로 주문만 하면 됩니다.

2. JSON: 전 세계 컴퓨터들의 공용어

웹 크롤링을 할 때는 지저분한 HTML 태그들(<div class="...">) 사이에서 텍스트를 발라내야 했습니다. 하지만 API는 컴퓨터가 읽기 가장 편한 형태인 JSON(JavaScript Object Notation)이라는 형식으로 요리를 내어줍니다.

JSON의 가장 큰 특징은 우리가 배운 파이썬의 '딕셔너리(Dictionary)'와 99.9% 똑같이 생겼다는 것입니다. 중괄호 {} 안에 Key: Value 쌍으로 이루어져 있어서, 데이터를 꺼내 쓰기가 예술적으로 편합니다.

3. 실전! 무료 날씨 API로 서울 기온 가져오기

인증키 발급 없이 바로 사용할 수 있는 유명한 무료 날씨 API인 Open-Meteo를 사용해 보겠습니다.
우리의 목표는 현재 서울의 온도를 파이썬으로 가져오는 것입니다.

예제 코드: API 요청하고 JSON 데이터 받아오기

지난 시간에 크롤링할 때 썼던 requests 패키지를 그대로 사용합니다!

import requests

# 1. API 메뉴판에 맞게 요청 주소(URL) 만들기
# 서울의 위도(latitude=37.56)와 경도(longitude=126.97)를 입력하고, 현재 날씨(current_weather=true)를 요청합니다.
api_url = "https://api.open-meteo.com/v1/forecast?latitude=37.56&longitude=126.97&current_weather=true"

# 2. requests 패키지로 API 점원에게 주문서 넣기 (GET 방식)
response = requests.get(api_url)

# 3. 응답 확인하기 (200이면 성공)
if response.status_code == 200:
    # 4. 받아온 데이터를 파이썬 딕셔너리로 완벽하게 변환하기! (이게 핵심입니다)
    weather_data = response.json()

    # 데이터가 어떻게 생겼는지 한번 볼까요?
    print("▼ API가 보내준 원본 JSON 데이터 ▼")
    print(weather_data)
else:
    print("API 요청에 실패했습니다.")

실행 결과 (원본 JSON):

▼ API가 보내준 원본 JSON 데이터 ▼
{'latitude': 37.56, 'longitude': 126.97, 'generationtime_ms': 0.123, 'utc_offset_seconds': 0, 'timezone': 'GMT', 'timezone_abbreviation': 'GMT', 'elevation': 38.0, 'current_weather': {'temperature': 15.2, 'windspeed': 5.4, 'winddirection': 210.0, 'weathercode': 1, 'is_day': 1, 'time': '2026-02-24T14:00'}}

보기엔 복잡해 보이지만, 자세히 보면 중괄호 {}와 쉼표 ,로 이루어진 전형적인 파이썬 딕셔너리입니다!

4. 딕셔너리에서 원하는 데이터만 쏙쏙 뽑아내기

이제 저 복잡한 딕셔너리에서 우리가 진짜 원하는 '온도(temperature)' 값만 꺼내보겠습니다.
이전에 딕셔너리 단원에서 배운 변수["Key이름"] 문법을 그대로 쓰면 됩니다.

예제 코드: 중첩 딕셔너리 데이터 추출하기

# (위 코드에 이어서 작성합니다)

# 1. 전체 데이터에서 'current_weather'라는 Key의 데이터를 꺼냅니다.
# 꺼내고 나면 그 안에도 또 딕셔너리가 들어있습니다! (중첩 딕셔너리)
current = weather_data["current_weather"]

# 2. 꺼낸 데이터 안에서 다시 'temperature'라는 Key의 데이터를 꺼냅니다.
temperature = current["temperature"]

# 3. 시간 정보도 꺼내볼까요?
time = current["time"]

print("\n▼ 깔끔하게 추출한 데이터 ▼")
print(f"기준 시간: {time}")
print(f"현재 서울 기온: {temperature}도")

실행 결과:

▼ 깔끔하게 추출한 데이터 ▼
기준 시간: 2026-02-24T14:00
현재 서울 기온: 15.2도

한 줄로 줄여서 쓰기:
딕셔너리 안의 딕셔너리를 접근할 때는 대괄호를 연달아 붙여서 weather_data["current_weather"]["temperature"] 처럼 한 번에 접근할 수도 있습니다. 아주 파이썬다운 깔끔한 문법이죠!

5. 이제 무엇을 할 수 있을까요?

이 원리 하나만 깨우치면, 파이썬으로 할 수 있는 일은 무궁무진해집니다.

공공데이터포털(data.go.kr): 미세먼지 수치, 아파트 실거래가, 전국 약국 위치 정보 등을 API로 받아와서 엑셀로 자동 정리할 수 있습니다.
카카오톡/텔레그램 API: 오늘 추출한 이 날씨 데이터를 매일 아침 7시마다 내 카카오톡 메시지로 쏴주는 나만의 비서를 만들 수 있습니다.
금융/주식 API: 비트코인 시세나 주식 가격을 1초마다 API로 받아와서, 특정 가격이 되면 자동으로 문자를 보내게 할 수도 있죠.

대단원의 막을 내리며 (시리즈 총정리)

여러분, 정말 고생 많으셨습니다! 첫 번째 포스팅에서 파이썬을 설치하던 것이 엊그제 같은데, 어느덧 데이터를 수집하고 엑셀을 다루며 API까지 호출하는 수준에 도달하셨습니다.

우리가 함께 걸어온 길을 돌아볼까요?

Phase 1~3: 변수, 리스트, 딕셔너리, if문, for문 등 파이썬의 기본 근육을 키웠습니다.
Phase 4~5: 함수, 모듈(import), 파일 다루기, 예외 처리 등 남의 코드를 읽고 내 컴퓨터를 다루는 실전 뼈대를 세웠습니다.
Phase 6: 크롤링, openpyxl(엑셀), API 연동을 통해 여러분의 업무 시간을 획기적으로 줄여줄 무기를 장착했습니다.

프로그래밍은 암기가 아닙니다. 문법을 완벽히 외울 필요는 전혀 없습니다. "아, 리스트 안에 딕셔너리가 있었지!", "반복문으로 엑셀 한 줄씩 넣으면 되겠네!"라는 아이디어와 흐름만 떠올릴 수 있다면, 구체적인 코드는 검색과 AI의 도움을 받아 얼마든지 짜맞출 수 있습니다.

이제 배운 것들을 활용해 여러분의 일상과 업무에서 작고 귀찮은 일들을 하나씩 자동화해 보세요. 직접 코드를 짜서 돌아갈 때의 그 짜릿함이 여러분을 더 멋진 개발의 세계로 이끌어 줄 것입니다.

정말 수고하셨습니다!

[Python 실전] 16. "엑셀 노가다 완벽 해방!" openpyxl로 파이썬에서 엑셀 다루기

hi.anna — Tue, 14 Apr 2026 00:53:10 +0900

매달 말일마다 부서별로 흩어진 수십 개의 엑셀 파일을 열어서 하나의 시트로 합치거나, 특정 서식을 복사 붙여넣기 하는 작업을 해보신 적 있나요? 사람이 직접 하면 눈도 아프고 실수하기도 쉽습니다.

하지만 파이썬의 openpyxl 패키지를 사용하면 엑셀을 켜지 않고도 백그라운드에서 순식간에 데이터를 쓰고, 읽고, 서식까지 지정할 수 있습니다.

1. 준비 운동: 패키지 설치와 엑셀의 3단 구조 이해하기

먼저 터미널(명령 프롬프트)을 열고 외부 패키지를 설치해 줍니다.

pip install openpyxl

파이썬으로 엑셀을 다루기 전에 반드시 알아야 할 엑셀의 3단 구조가 있습니다.

워크북 (Workbook): 엑셀 파일 그 자체 (.xlsx)
워크시트 (Worksheet): 파일 안 하단에 있는 탭 (Sheet1, Sheet2...)
셀 (Cell): 데이터를 입력하는 각각의 네모 칸 (A1, B2...)

코드를 짤 때도 항상 "파일을 열고 ➔ 시트를 고르고 ➔ 셀에 값을 넣는다" 순서로 진행됩니다.

2. 무에서 유를 창조하기: 새 엑셀 파일 만들고 데이터 쓰기

아무것도 없는 백지상태에서 새로운 엑셀 파일을 만들고, 특정 칸에 데이터를 집어넣어 보겠습니다.

예제 코드: 새 엑셀 파일 생성하기

import openpyxl

# 1. 워크북(엑셀 파일) 생성하기
wb = openpyxl.Workbook()

# 2. 현재 활성화된 시트(기본 시트) 가져오기
ws = wb.active

# 시트 이름도 내 마음대로 바꿀 수 있습니다.
ws.title = "크롤링_결과"

# 3. 셀에 데이터 입력하기 (A1 셀, B1 셀 지정)
ws["A1"] = "순번"
ws["B1"] = "뉴스 제목"

ws["A2"] = 1
ws["B2"] = "파이썬으로 업무 자동화 성공!"

# 4. 워크북 저장하기 (반드시 마지막에 저장해야 실제 파일이 생깁니다!)
wb.save("news_data.xlsx")
# 작업이 끝났으면 닫아주는 것이 좋습니다.
wb.close()

print("엑셀 파일이 성공적으로 만들어졌습니다.")

코드를 실행하고 폴더를 확인해 보면 news_data.xlsx 파일이 예쁘게 생성된 것을 확인할 수 있습니다.

3. 실무 필수 스킬: 리스트 데이터를 한 줄씩 추가하기 (`append`)

실무에서는 위처럼 ws["A1"], ws["A2"] 하나하나 주소를 지정해서 데이터를 넣지 않습니다. 지난 시간에 크롤링한 데이터처럼, 수십 개의 데이터가 담긴 리스트(List)를 한 번에 한 줄씩 밀어 넣는 방식을 압도적으로 많이 사용합니다.

이때 사용하는 마법의 함수가 바로 append()입니다.

예제 코드: 여러 줄의 데이터를 엑셀에 한 번에 쓰기

import openpyxl

# 저장할 데이터가 담긴 리스트 (크롤링 결과라고 가정해 봅시다)
crawling_data = [
    ["날짜", "부서", "매출액"],  # 첫 번째 줄 (헤더)
    ["2026-02-24", "영업1팀", 5000000],
    ["2026-02-24", "영업2팀", 4500000],
    ["2026-02-25", "마케팅팀", 3000000]
]

wb = openpyxl.Workbook()
ws = wb.active
ws.title = "매출보고서"

# for문을 돌면서 리스트를 한 줄씩 엑셀의 맨 아랫줄에 추가합니다.
for row in crawling_data:
    # 엑셀 시트의 맨 아래 빈 줄에 row(리스트)를 통째로 끼워 넣습니다.
    ws.append(row)

wb.save("sales_report.xlsx")
wb.close()

단 4줄의 for문만으로 복잡한 표가 엑셀 파일에 완벽하게 들어갔습니다!

4. 이미 있는 엑셀 파일 불러와서 읽기 (`load_workbook`)

이번엔 반대로, 컴퓨터에 이미 저장되어 있는 엑셀 파일을 파이썬으로 불러와서 안에 있는 데이터를 읽어보겠습니다.
이 기능은 "특정 단어가 포함된 행만 지우기", "오타 한 번에 수정하기" 같은 매크로 작업을 할 때 필수적입니다.

예제 코드: 엑셀 파일 불러오기

import openpyxl

# 1. 이미 존재하는 엑셀 파일 불러오기
# data_only=True 옵션을 주면 엑셀의 '수식' 대신 계산된 '결과값'만 가져옵니다.
wb = openpyxl.load_workbook("sales_report.xlsx", data_only=True)

# 2. 작업할 시트 이름으로 정확히 찝어서 가져오기
ws = wb["매출보고서"]

# 3. 특정 셀의 값 읽기 (A2 셀)
print("A2 셀의 값:", ws["A2"].value) # 주의: 그냥 ws["A2"]를 출력하면 셀 객체 자체가 나옵니다. 반드시 .value를 붙이세요!

print("-" * 20)

# 4. 시트에 있는 모든 데이터 한 줄씩 꺼내서 보기 (iter_rows 활용)
# min_row=2 를 주면 1번째 줄(헤더)을 건너뛰고 2번째 줄부터 가져옵니다.
for row in ws.iter_rows(min_row=2):
    date = row[0].value
    team = row[1].value
    sales = row[2].value

    print(f"{date} | {team} | {sales}원")

wb.close()

.value를 잊지 마세요!
ws["A1"]은 "A1이라는 네모 칸(상자)" 자체를 의미합니다. 그 상자 안에 든 내용물을 꺼내려면 반드시 뒤에 .value를 붙여주어야 합니다. 초보자들이 가장 많이 하는 실수입니다!

마치며

오늘의 핵심 요약입니다.

openpyxl.Workbook(): 완전히 새로운 빈 엑셀 파일을 하나 만든다.
openpyxl.load_workbook("파일명.xlsx"): 이미 있는 엑셀 파일을 파이썬으로 불러온다.
ws.append(리스트): 엑셀 시트의 맨 아랫줄에 데이터를 한 줄(행) 전체로 깔끔하게 밀어 넣는다.
셀.value: 셀 상자 안에 들어있는 진짜 데이터 값을 꺼낸다.

이제 여러분은 파이썬으로 크롤링을 하고(requests, BeautifulSoup), 그 결과를 엑셀 파일(.xlsx)로 저장해 팀원들에게 자동으로 공유할 수 있는 엄청난 능력을 갖추게 되었습니다.

길고 길었던 파이썬 정복 시리즈도 어느덧 마지막을 향해 달려가고 있습니다.
다음 포스팅에서는 대망의 마지막 프로젝트, "날씨 정보를 내 카톡으로? 공공데이터 API 연동 기초"를 다루어 보겠습니다. 남이 정성껏 만들어둔 데이터를 가장 안전하고 확실하게 가져오는 API의 세계로 초대합니다.

도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 실전] 15. "뉴스 제목 1초 만에 긁어오기" 웹 크롤링 기초 (requests, BeautifulSoup)

hi.anna — Mon, 13 Apr 2026 08:52:35 +0900

매일 아침 출근해서 관심 있는 분야의 뉴스 기사 제목을 엑셀로 정리하는 업무가 있다고 가정해 봅시다. 마우스로 드래그하고, 복사하고, 붙여넣기... 100개의 기사를 정리하려면 한참이 걸립니다.

하지만 파이썬을 사용하면 이 모든 과정을 단 1초 만에 끝낼 수 있습니다. 인터넷 웹페이지에 있는 데이터를 파이썬이 대신 읽어서 필요한 부분만 쏙쏙 뽑아오는 기술, 바로 웹 크롤링(Web Scraping/Crawling)입니다.

오늘은 크롤링의 양대 산맥인 requests 패키지와 BeautifulSoup 패키지를 사용해 보겠습니다.

1. 크롤링 준비물 챙기기 (패키지 설치)

크롤링을 하려면 남이 만든 훌륭한 도구(외부 패키지) 두 개가 필요합니다. 터미널(명령 프롬프트)을 열고 아래 명령어를 입력해 설치해 주세요.

# 1. 웹페이지 접속을 도와주는 패키지
pip install requests

# 2. 복잡한 웹페이지 문서(HTML)에서 원하는 데이터만 예쁘게 발라내는 패키지
pip install beautifulsoup4

2. 웹 크롤링의 3단계 작동 원리

크롤링은 우리가 웹 브라우저(크롬, 사파리 등)로 인터넷을 하는 과정과 완전히 똑같습니다. 단지 사람이 눈으로 보는 대신, 파이썬 코드가 대신 읽어주는 것뿐입니다.

요청(Request): 파이썬이 대상 웹사이트에 "이 페이지 좀 보여줘!"라고 접속을 요청합니다. (requests 사용)
응답(Response): 웹사이트가 파이썬에게 해당 페이지의 설계도인 HTML 문서를 던져줍니다.
추출(Parsing): 받은 HTML 문서에서 제목, 날짜, 본문 등 "내가 원하는 글자"만 예쁘게 핀셋으로 뽑아냅니다. (BeautifulSoup 사용)

3. F12 (개발자 도구)로 웹페이지 구조 훔쳐보기

크롤링을 하려면 내가 가져오고 싶은 데이터가 HTML 설계도 안에서 '어떤 이름표(클래스)'를 달고 있는지 알아야 합니다.

크롬(Chrome) 브라우저에서 네이버 뉴스(또는 아무 웹페이지)를 띄우고 키보드의 F12를 눌러보세요. 오른쪽에 복잡한 외계어 같은 코드가 나타납니다. 이것이 바로 웹페이지의 민낯인 HTML입니다.

돋보기(또는 화살표) 아이콘을 누르고 뉴스 제목을 클릭해 보세요.
뉴스 제목이 <a href="..." class="news_tit"> 같은 태그(Tag)로 감싸져 있는 것을 볼 수 있습니다.
여기서 class="news_tit" 이 부분이 바로 우리가 핀셋으로 집어낼 고유한 이름표입니다.

4. 실전! 파이썬으로 뉴스 제목 긁어오기

자, 이제 코드를 작성해 볼 차례입니다. (참고: 네이버 검색 결과의 뉴스 탭을 기준으로 한 예시입니다. 웹사이트의 구조는 수시로 바뀌므로, 클래스 이름은 F12를 눌러 직접 확인한 값으로 변경해야 할 수도 있습니다.)

예제 코드: 파이썬 크롤러 만들기

import requests
from bs4 import BeautifulSoup

# 1. 접속할 웹페이지 주소 (네이버에 '파이썬'을 검색한 뉴스 탭 결과)
url = "https://search.naver.com/search.naver?where=news&query=파이썬"

# ⚠️ 꿀팁: 로봇(크롤러)이 아닌 척하기 위한 신분증(User-Agent) 생성
# 네이버 같은 대형 사이트는 기계가 접속하는 것을 차단하기도 합니다. "나 진짜 사람 브라우저야!"라고 속이는 코드입니다.
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/100.0.4896.75"}

# 2. 웹사이트에 접속해서 HTML 문서 받아오기 (requests)
response = requests.get(url, headers=headers)

# 접속이 잘 되었는지 확인 (200이 나오면 정상)
if response.status_code == 200:

    # 3. 받아온 HTML 문서를 BeautifulSoup이 분석할 수 있게 끓이기(Parsing)
    # response.text: 받아온 문서 전체 내용
    # "html.parser": HTML 번역기 사용
    soup = BeautifulSoup(response.text, "html.parser")

    # 4. 원하는 데이터만 핀셋으로 쏙쏙 뽑아내기
    # select() 함수는 조건에 맞는 모든 데이터를 '리스트' 형태로 찾아줍니다.
    # HTML에서 class 이름으로 찾을 때는 이름 앞에 점(.)을 찍습니다!
    titles = soup.select(".news_tit")

    # 5. 찾은 데이터들(리스트)을 for문으로 하나씩 꺼내서 출력하기
    # enumerate를 써서 1번부터 번호표를 붙여줍니다. (기억나시죠?)
    for i, title in enumerate(titles, start=1):
        # title.text: HTML 태그(<a...>)는 다 떼어버리고 진짜 '글자'만 가져옵니다.
        # title["href"]: 기사를 클릭했을 때 이동하는 진짜 '링크 주소'를 가져옵니다.
        print(f"{i}번째 기사: {title.text}")
        print(f"링크: {title['href']}")
        print("-" * 50)

else:
    print(f"웹페이지 접속 실패! 에러 코드: {response.status_code}")

실행 결과:

1번째 기사: "파이썬으로 코딩해요"… 00구, 초등생 대상 디지털 교육
링크: https://n.news.naver.com/mnews/article/...
--------------------------------------------------
2번째 기사: 파이썬 등 IT 전문 인력 모십니다.
링크: https://www.어쩌구저쩌구.com/...
--------------------------------------------------
... (쭉 이어짐)

코드 핵심 설명:

requests.get(): 지정한 주소로 접속해 데이터를 가져옵니다.
soup.select(".클래스이름"): HTML 문서에서 해당 클래스 이름표를 단 모든 요소를 찾아 리스트로 반환합니다.
.text: 복잡한 기호들을 싹 지우고 우리 눈에 보이는 순수 텍스트만 추출합니다. 정말 편리하죠!

5. 크롤링할 때 반드시 지켜야 할 매너 (주의사항)

파이썬 크롤링은 너무나 강력해서, 자칫하면 상대방 웹사이트 서버를 다운시킬 수도 있습니다(이것이 바로 디도스 공격의 원리입니다). 따라서 지켜야 할 윤리가 있습니다.

너무 빠르게 반복하지 마세요: for문을 돌려 수천 페이지를 긁어올 때는, 지난 시간에 배운 표준 라이브러리인 time.sleep(1) (1초 쉬기) 등을 사용해 서버에 숨통을 트여주어야 합니다.
저작권과 개인정보를 주의하세요: 남의 사이트에서 긁어온 데이터를 상업적으로 함부로 팔거나 배포하면 법적 처벌을 받을 수 있습니다. 가급적 '개인 학습 및 업무 자동화' 용도로만 사용하세요.

마치며

오늘의 핵심 요약입니다.

requests.get(url): 해당 웹페이지의 전체 소스 코드(HTML)를 다운로드해온다.
BeautifulSoup(html, "html.parser"): 다운로드한 코드를 탐색하기 쉽게 정돈해 준다.
soup.select(".클래스명"): 정돈된 코드 중에서 내가 원하는 데이터(태그)만 쏙 뽑아 리스트로 만든다.
.text: 뽑아낸 데이터에서 군더더기를 버리고 순수 텍스트만 추출한다.

이제 여러분은 인터넷에 널려 있는 수많은 정보(주식 시세, 영화 평점, 부동산 가격 등)를 내 컴퓨터로 자동으로 가져올 수 있는 마법사가 되었습니다.

하지만 이렇게 터미널(까만 창)에 출력만 해두면 나중에 다시 보기가 힘들죠?
다음 포스팅에서는 "파이썬으로 엑셀 파일 만들고 서식까지 꾸미기" - openpyxl 라이브러리를 활용한 엑셀 노가다 해방 일지에 대해 알아보겠습니다. 방금 크롤링한 뉴스 제목들을 엑셀 파일로 예쁘게 저장해 볼게요!

도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 14. "에러가 나도 멈추지 않아!" 프로그램 생명 연장, try-except 예외 처리

hi.anna — Mon, 13 Apr 2026 00:52:11 +0900

파이썬이 열심히 코드를 한 줄 한 줄 실행하다가, 도저히 계산할 수 없거나 처리할 수 없는 상황을 마주치면 어떻게 할까요? 파이썬은 즉시 두 손을 들고 파업을 선언합니다. 이것을 우리는 예외(Exception)가 발생했다고 부릅니다.

하지만 실무에서 돌아가는 프로그램이 에러 하나 났다고 픽픽 꺼져버리면 안 되겠죠? 이럴 때 파이썬에게 "에러가 나면 멈추지 말고, 이렇게 대처해!"라고 지시하는 문법이 바로 try-except입니다.

1. 예외(Exception)란 무엇인가요?

문법을 틀려서 발생하는 오타(Syntax Error)와 달리, 문법은 완벽하지만 실행 도중에 발생하는 문제를 예외라고 합니다.

가장 대표적인 예외 상황들을 볼까요?

ZeroDivisionError: 숫자를 0으로 나누려고 할 때
ValueError: 숫자로 바꿀 수 없는 문자를 int()로 바꾸려고 할 때
FileNotFoundError: 없는 파일을 open()으로 열려고 할 때

이런 상황을 대비해 안전망을 깔아보겠습니다.

2. 기본 안전망: `try-except`

사용법은 아주 직관적입니다. 에러가 날 것 같은 불안한 코드를 try 블록(구역) 안에 넣고, 에러가 났을 때 실행할 대안 코드를 except 블록 안에 넣습니다.

예제 코드: 0으로 나누기 방어하기

print("계산기를 켭니다.")

# 1. 에러가 날 수도 있는 코드를 try 안에 넣습니다.
try:
    result = 10 / 0  # 숫자를 0으로 나누면 에러가 발생합니다!
    print(f"결과는 {result}입니다.")  # 위에서 에러가 났으므로 이 줄은 무시됩니다.

# 2. 에러가 발생하면 파이썬이 즉시 except 구역으로 도망쳐 옵니다.
except:
    print("앗! 숫자를 0으로 나눌 수는 없습니다.")

# 에러를 안전하게 처리했으므로 프로그램이 죽지 않고 끝까지 실행됩니다!
print("계산기를 끕니다.")

실행 결과:

계산기를 켭니다.
앗! 숫자를 0으로 나눌 수는 없습니다.
계산기를 끕니다.

만약 try-except가 없었다면 프로그램은 10 / 0 부분에서 시뻘건 에러를 뿜어내며 멈췄을 것이고, "계산기를 끕니다"라는 마지막 문장은 영영 출력되지 못했을 것입니다.

3. 에러 종류별로 다르게 대처하기

병원에서도 배가 아픈 환자와 뼈가 부러진 환자의 처방이 다르듯, 에러의 종류에 따라 다른 메시지를 보여줄 수 있습니다. except 뒤에 구체적인 에러 이름을 적어주면 됩니다.

예제 코드: 여러 가지 에러 대처하기

data_list = ["10", "20", "파이썬", "40"]

for item in data_list:
    try:
        # 문자를 숫자로 바꾸고, 100을 그 숫자로 나눠봅니다.
        number = int(item)
        print(100 / number)

    except ValueError:
        # int("파이썬") 처럼 숫자로 바꿀 수 없을 때
        print(f"[{item}]은(는) 숫자로 바꿀 수 없는 데이터입니다!")

    except ZeroDivisionError:
        # 100 / 0 처럼 0으로 나누려 할 때 (위 데이터엔 0이 없지만 예시로 넣음)
        print("0으로는 나눌 수 없어요!")

코드 설명:

"파이썬"이라는 문자를 만났을 때 ValueError가 발생합니다.
파이썬은 여러 개의 except 문을 훑어보다가, ValueError에 해당하는 처방전을 찾아 실행하고 다음 반복으로 부드럽게 넘어갑니다.

4. 에러의 진짜 원인 파악하기 (`as e`)

에러가 나긴 났는데, 정확히 무슨 에러인지 컴퓨터가 알려주는 메시지를 그대로 보고 싶을 때가 있습니다. (주로 개발자가 디버깅을 할 때 씁니다.)
이때는 except Exception as e라는 마법의 주문을 사용합니다.

예제 코드: 에러 메시지 캡처하기

try:
    # 존재하지 않는 파일을 열려고 시도해 봅니다.
    with open("ghost_file.txt", "r") as f:
        content = f.read()

# 모든 에러(Exception)를 잡아서 그 내용을 변수 'e'에 담습니다.
except Exception as e:
    print("오류가 발생했습니다!")
    print(f"상세 원인: {e}")

실행 결과:

오류가 발생했습니다!
상세 원인: [Errno 2] No such file or directory: 'ghost_file.txt'

5. 무조건 실행되는 마무리 투수: `finally`

try 블록에서 에러가 나든 안 나든, 마지막에 무조건 100% 실행되어야 하는 코드가 있을 때 finally를 사용합니다.
주로 데이터베이스(DB) 접속을 끊거나 외부 자원(네트워크 등)을 해제할 때 아주 요긴합니다. (물론 with문을 쓰면 파일은 알아서 닫히지만, 다른 자원에는 여전히 유용합니다.)

예제 코드: 에러 여부와 상관없는 실행 보장

try:
    print("은행 시스템에 접속했습니다.")
    print("계좌이체를 시작합니다...")
    # 강제로 에러를 발생시킵니다!
    raise Exception("잔액 부족")

except Exception as e:
    print(f"이체 실패: {e}")

finally:
    # 이체가 성공하든 실패하든, 시스템 접속은 무조건 끊어야 합니다!
    print("은행 시스템 접속을 종료합니다.")

실행 결과:

은행 시스템에 접속했습니다.
계좌이체를 시작합니다...
이체 실패: 잔액 부족
은행 시스템 접속을 종료합니다.

6. 조용히 무시하기: `pass`

가끔은 크롤링을 하거나 데이터를 분석할 때, 사소한 에러는 그냥 무시하고 넘어가고 싶을 때가 있습니다. 이때는 except 문 안에 파이썬의 pass 키워드 하나만 딸랑 적어두면 됩니다.

try:
    # 에러가 날 만한 복잡한 크롤링 작업
    print(1 / 0)
except:
    # "에러 나도 괜찮아, 아무 일도 없었던 것처럼 그냥 넘어가!"
    pass

print("프로그램이 계속 실행됩니다.")

⚠️ 주의: pass를 남용하면 진짜 치명적인 버그가 생겼을 때조차 에러 메시지가 뜨지 않아서, 밤을 새워도 원인을 못 찾는 대참사가 일어날 수 있습니다. 정말 확신할 때만 쓰세요!

마치며

오늘의 핵심 요약입니다.

try: 일단 여기서 에러가 날 수도 있는 코드를 조심스럽게 실행해 본다.
except: 만약 위에서 에러가 터지면, 프로그램이 멈추지 않게 이곳의 코드를 실행하며 대처한다.
Exception as e: 파이썬이 알려주는 구체적인 에러 원인을 e라는 변수에 담아서 출력할 수 있다.
finally: 에러가 나든 안 나든 마지막에 무조건 한 번 실행되는 정리 정돈 코드다.
pass: 에러를 완전히 무시하고 다음 코드로 부드럽게 넘어가는 키워드다.

이제 여러분의 프로그램은 돌발 상황에서도 꿋꿋하게 살아남을 수 있는 강인한 생명력을 갖게 되었습니다.

지금까지 길고 길었던 파이썬 기초 문법(Phase 1 ~ Phase 5) 과정을 모두 수료하셨습니다. 정말 고생 많으셨습니다!
하지만 진짜 재미있는 건 지금부터입니다. 우리가 배운 문법들을 조합해서 실생활에 써먹을 수 있는 도구를 만들어봐야죠.

다음 포스팅부터는 Phase 6. 미니 프로젝트의 첫 번째 시간!
"네이버 뉴스 제목 1초 만에 긁어오기" - requests와 BeautifulSoup을 이용한 웹 크롤링 기초에 대해 알아보겠습니다. 드디어 마법 지팡이를 휘두를 시간입니다!

도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 13. "데이터를 내 컴퓨터에 영구 저장하자!" 텍스트 파일과 CSV 읽고 쓰기 (open, with)

hi.anna — Sun, 12 Apr 2026 07:02:26 +0900

크롤링으로 수집한 10,000건의 뉴스 기사, 혹은 반복문으로 열심히 계산한 결과물들. 이것들을 파이썬 프로그램이 종료된 후에도 남겨두려면 '파일' 형태로 저장해야 합니다.

오늘은 파이썬으로 가장 기본이 되는 텍스트 파일(.txt)을 다루는 법과, 엑셀에서 바로 열어볼 수 있는 .csv 파일을 직접 만들어보겠습니다.

1. 파일 다루기의 3단계: 열기(open) ➔ 작업하기 ➔ 닫기(close)

파이썬에서 파일을 다룰 때는 마치 냉장고를 쓰는 것과 같습니다. 냉장고 문을 열고, 내용물을 넣거나 빼고, 반드시 문을 닫아야 하죠. 문을 안 닫으면 냉장고가 고장 나듯, 파이썬에서도 파일을 닫지 않으면 에러가 발생할 수 있습니다.

예제 코드: 메모장 파일 만들고 글씨 쓰기

# 1. 파일 열기 (open)
# "memo.txt"라는 파일을 "w"(쓰기 모드)로 엽니다.
# 한글이 깨지지 않게 encoding="utf-8"을 꼭 적어주세요!
f = open("memo.txt", "w", encoding="utf-8")

# 2. 작업하기 (글씨 쓰기)
f.write("안녕하세요! 파이썬으로 만든 첫 번째 파일입니다.\n")
f.write("두 번째 줄입니다.")

# 3. 파일 닫기 (close) - 매우 중요!
f.close()

위 코드를 실행하고 VS Code의 왼쪽 탐색기를 보면, 방금 전까지 없었던 memo.txt 파일이 마법처럼 생성된 것을 볼 수 있습니다!

파일 모드 3가지

"w" (Write): 쓰기 모드. 파일이 없으면 새로 만들고, 파일이 이미 있으면 기존 내용을 다 지우고 새로 씁니다. (덮어쓰기)
"a" (Append): 추가 모드. 기존 파일 내용 맨 끝에 이어서 새로운 내용을 추가합니다. (일기장이나 로그 남길 때 유용)
"r" (Read): 읽기 모드. 이미 있는 파일의 내용을 파이썬으로 읽어옵니다.

2. 파이썬의 마법: `with` 문으로 자동 닫기

위에서 냉장고 문(close())을 닫는 게 아주 중요하다고 했습니다. 하지만 코드가 길어지다 보면 문 닫는 걸 깜빡하기 쉽습니다.

그래서 파이썬 개발자들은 작업이 끝나면 알아서 파일을 닫아주는 아주 우아한 문법을 만들었습니다. 바로 with 문입니다. 실무에서는 100% 이 방식을 사용합니다.

예제 코드: `with` 문을 활용한 안전한 파일 쓰기/읽기

# --- 파일 쓰기 (with 문 사용) ---
# "f = open(...)" 대신 "with open(...) as f:" 형태를 씁니다.
with open("diary.txt", "w", encoding="utf-8") as f:
    f.write("오늘은 파이썬 파일 입출력을 배웠다.\n")
    f.write("with 문을 쓰니까 close()를 안 해도 돼서 정말 편하다!")

# 들여쓰기가 끝나는 순간, 파이썬이 알아서 f.close()를 실행해 줍니다.


# --- 파일 읽기 ---
# 읽어올 때는 모드를 "r"로 설정합니다.
with open("diary.txt", "r", encoding="utf-8") as f:
    # f.read()는 파일 내용 전체를 하나의 거대한 문자열로 가져옵니다.
    content = f.read()

print("--- 불러온 내용 ---")
print(content)

어떤가요? 들여쓰기 구역 안에서만 파일이 열려있고, 구역을 빠져나오면 자동으로 파일이 닫히니 훨씬 안전하고 코드가 깔끔해집니다.

3. 실전 응용: 엑셀에서 열리는 CSV 파일 만들기

텍스트 파일만 만들면 아쉽죠? 데이터 분석의 기본이 되는 엑셀 파일을 파이썬으로 만들어 보겠습니다.

가장 쉬운 방법은 CSV(Comma Separated Values) 형태의 텍스트 파일을 만드는 것입니다. 이름 그대로 "데이터를 쉼표(,)로 구분해 놓은 파일"인데, 엑셀에서 열면 쉼표를 기준으로 알아서 예쁘게 표를 만들어줍니다.

예제 코드: 학생 점수표를 CSV 파일로 저장하기

# 파이썬 리스트에 담긴 데이터
students = [
    ["이름", "국어", "수학"],  # 엑셀의 첫 번째 줄(헤더)
    ["홍길동", 90, 85],
    ["김철수", 80, 100],
    ["이영희", 100, 95]
]

# 확장자를 .csv로 지정하고, 쓰기("w") 모드로 엽니다.
with open("scores.csv", "w", encoding="utf-8-sig") as f:

    for row in students:
        # 각 리스트의 요소를 문자로 바꾸고 쉼표(,)로 이어붙입니다.
        # 예: ["홍길동", 90, 85] -> "홍길동,90,85"
        line = f"{row[0]},{row[1]},{row[2]}\n"
        f.write(line)

print("scores.csv 파일이 성공적으로 생성되었습니다!")

( 꿀팁: 엑셀에서 한글 CSV를 열 때 글자가 깨진다면, 인코딩을 "utf-8" 대신 "utf-8-sig"로 적어주면 완벽하게 해결됩니다!)

코드를 실행하고 폴더에 생긴 scores.csv 파일을 더블클릭해서 엑셀로 열어보세요. 파이썬 데이터가 엑셀 표에 깔끔하게 들어간 것을 보고 엄청난 희열을 느끼실 수 있을 겁니다.

4. 파일을 통째로 읽어 리스트로 만들기: `readlines()`

이번엔 반대로, 컴퓨터에 저장된 여러 줄의 데이터를 파이썬의 '리스트'로 한 줄씩 예쁘게 가져와 보겠습니다.

with open("memo.txt", "r", encoding="utf-8") as f:
    # readlines()는 파일의 모든 줄을 읽어서 '리스트' 형태로 만들어줍니다.
    lines = f.readlines()

print(lines)
# 출력 예시: ['안녕하세요! 파이썬으로 만든 첫 번째 파일입니다.\n', '두 번째 줄입니다.']

# 리스트니까 for문으로 하나씩 꺼내 쓰기 좋겠죠?
for line in lines:
    # 파일에 적힌 줄바꿈(\n)과 print()의 줄바꿈이 중복되지 않게 strip()으로 청소해줍니다.
    print(line.strip())

마치며

오늘의 핵심 요약입니다.

open("파일명", "모드"): 파일을 다루는 기본 함수. 모드에는 쓰기(w), 추가(a), 읽기(r)가 있다.
encoding="utf-8": 한글을 다룰 때 글자가 깨지지 않게 해주는 필수 방패.
with open(...) as f:: 파일을 열고 작업한 뒤, 안전하게 자동으로 닫아주는(close) 파이썬만의 우아한 문법.
데이터를 쉼표(,)로 구분해서 .csv 파일로 저장하면 엑셀에서 쉽게 열어볼 수 있다.

이제 파이썬과 여러분의 하드디스크가 연결되었습니다. 크롤링한 데이터를 저장하거나, 매일 쌓이는 로그 데이터를 기록하는 등 진짜 쓸모 있는 프로그램에 한 발짝 더 다가섰네요!

하지만 프로그램을 돌리다 보면 "파일이 존재하지 않습니다!" 라거나 "숫자를 0으로 나눌 수 없습니다!" 같은 돌발 상황(에러)이 무조건 발생합니다. 에러가 나면 프로그램은 그 자리에서 빨간 글씨를 뿜으며 처참하게 죽어버리죠.

다음 포스팅에서는 "에러가 나도 프로그램이 죽지 않게 보호하는 방어막! 예외 처리(try-except)"에 대해 알아보겠습니다.

도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 12. "객체지향이긴 한데..." 파이썬 클래스(Class)와 self의 정체 완벽 이해

hi.anna — Sun, 12 Apr 2026 01:01:09 +0900

여러분이 RPG 게임을 만든다고 상상해 보세요. 슬라임, 오크, 드래곤 같은 몬스터들을 만들어야 합니다. 몬스터는 '이름', '체력'이라는 데이터(변수)를 가지고 있고, '공격하기'라는 행동(함수)을 할 수 있습니다.

몬스터가 100마리라면 변수와 함수를 100개씩 따로 만들어야 할까요?
이럴 때 필요한 것이 바로 "몬스터를 찍어내는 붕어빵 틀", 즉 클래스(Class)입니다.

1. 붕어빵 틀(Class)과 붕어빵(Object/Instance)

가장 유명하고 찰떡같은 비유를 들어보겠습니다.

클래스(Class): 똑같은 모양의 붕어빵을 무한대로 찍어낼 수 있는 '틀(설계도)'입니다.
객체(Object) 또는 인스턴스(Instance): 그 틀에서 구워져 나온 '실제 붕어빵'입니다. 팥을 넣으면 팥붕어빵, 슈크림을 넣으면 슈크림붕어빵이 되듯, 틀은 하나지만 결과물은 여러 개를 만들 수 있습니다.

예제 코드: 가장 단순한 붕어빵 틀 만들기

# 1. 클래스(틀) 정의하기
# 클래스 이름은 대문자로 시작하는 것이 파이썬의 암묵적인 규칙입니다.
class Monster:
    pass  # pass는 "일단 아무 기능 없이 빈 껍데기만 둘게"라는 뜻입니다.

# 2. 객체(붕어빵) 찍어내기
slime = Monster()  # 몬스터 틀로 'slime'이라는 객체를 하나 만듦
orc = Monster()    # 똑같은 틀로 'orc'라는 객체를 하나 더 만듦

# 출력해보면 서로 다른 메모리에 존재하는 별개의 객체임을 알 수 있습니다.
print(type(slime))
print(type(orc))

2. 초기화의 마법사: `init` 생성자

빈 껍데기 몬스터는 재미가 없죠. 몬스터가 세상에 처음 태어날 때(객체가 생성될 때) "너의 이름은 뭐고, 체력은 몇이야!"라고 초기 설정을 해주려면 어떻게 해야 할까요?

파이썬에서는 이름 앞뒤로 언더바가 두 개씩 붙은 __init__ (initialize의 약자)라는 특별한 함수를 사용합니다. 붕어빵이 구워질 때 앙금을 넣는 작업이라고 생각하시면 됩니다.

3. 미스터리 풀기: `self`는 도대체 누구인가?

클래스를 배우면 무조건 마주치는 단어가 바로 self입니다.
self를 한마디로 정의하자면 "수많은 붕어빵 중에서, 지금 당장 일을 하고 있는 바로 '나 자신(현재 객체)'"을 의미합니다.

클래스 안에서 만들어지는 모든 함수(이를 메서드라고 부릅니다)는 무조건 첫 번째 재료(매개변수)로 self를 적어주어야 합니다. 그래야 파이썬이 "아, 지금 슬라임이 공격하는 거구나", "오크가 공격하는 거구나"를 구분할 수 있습니다.

예제 코드: 체력과 이름을 가진 몬스터 클래스 완성하기

class Monster:
    # 1. 생성자 함수 (__init__)
    # 몬스터가 만들어질 때 자동으로 딱 한 번 실행됩니다.
    def __init__(self, name, hp):
        # self.name: "나 자신의 이름(변수)에 방금 입력받은 name을 저장해라!"
        self.name = name  
        self.hp = hp      
        print(f"야생의 {self.name}이(가) 나타났다! (체력: {self.hp})")

    # 2. 일반 메서드 (몬스터의 행동)
    # 반드시 첫 번째 매개변수로 self를 넣어야 합니다.
    def attack(self):
        # self.name을 쓰면, 알아서 '자신의 이름'을 찾아옵니다.
        print(f"[{self.name}]의 맹공격! 상대에게 피해를 입혔습니다.")

# --- 클래스 사용해보기 ---

# 슬라임 객체 생성 (이때 __init__이 자동 실행되며 이름과 체력이 세팅됨)
# 주의: 괄호 안에 self는 우리가 직접 넣지 않습니다! 파이썬이 알아서 '나 자신'을 몰래 넣어줍니다.
slime = Monster("초록 슬라임", 100)

# 오크 객체 생성
orc = Monster("성난 오크", 300)

print("-" * 20)

# 몬스터 행동 개시!
slime.attack() # 슬라임이 공격합니다. (이때 내부적으로 self는 slime이 됩니다.)
orc.attack()   # 오크가 공격합니다. (이때 내부적으로 self는 orc가 됩니다.)

실행 결과:

야생의 초록 슬라임이(가) 나타났다! (체력: 100)
야생의 성난 오크이(가) 나타났다! (체력: 300)
--------------------
[초록 슬라임]의 맹공격! 상대에게 피해를 입혔습니다.
[성난 오크]의 맹공격! 상대에게 피해를 입혔습니다.

코드 핵심 설명:

Monster("초록 슬라임", 100)을 호출하면 파이썬은 내부적으로 __init__(slime, "초록 슬라임", 100)처럼 동작합니다.
클래스 내부에서 self.name이라고 적어두면, 슬라임이 부를 땐 '슬라임의 이름'이 되고, 오크가 부를 땐 '오크의 이름'이 됩니다. 즉, 객체들끼리 데이터가 섞이지 않도록 지켜주는 역할을 합니다.

4. 언제 클래스를 써야 할까요?

단순한 데이터 전처리나 파일 이름 바꾸기 같은 1회성 스크립트를 짤 때는 굳이 클래스를 만들 필요가 없습니다. (함수 몇 개로 충분합니다.)

하지만 다음과 같은 상황에서는 클래스가 압도적으로 유리합니다.

데이터와 행동이 밀접하게 연관되어 있을 때 (예: 유저 정보 데이터 + 로그인/로그아웃 행동)
똑같은 구조를 가진 무언가를 여러 개 만들어야 할 때 (예: 웹 크롤러를 사이트별로 여러 개 띄울 때)
규모가 큰 프로그램을 짤 때 (코드를 부품화해서 관리하기 편함)

마치며

오늘의 핵심 요약입니다.

클래스(Class): 변수와 함수를 하나로 묶어놓은 붕어빵 틀(설계도)이다.
객체/인스턴스: 클래스라는 틀을 통해 실제로 메모리에 만들어진 붕어빵이다.
__init__: 객체가 생성될 때 가장 먼저 실행되어 초기 상태를 세팅해 주는 특별한 함수다.
self: 수많은 객체 중에서 현재 일하고 있는 '나 자신'을 가리키는 파이썬의 필수 키워드다.

이해하기 조금 까다로울 수 있지만, 파이썬으로 작성된 오픈소스나 라이브러리를 열어보면 99%가 이 클래스 형태로 짜여 있습니다. self의 개념만 잡아두셔도 남의 코드를 읽는 눈이 확 트이실 겁니다!

자, 이제 문법적인 기초 훈련(Phase 4)이 모두 끝났습니다!
다음 포스팅부터는 Phase 5. 실전 기술로 들어갑니다. 파이썬 세상 안에서만 놀던 데이터를 드디어 내 컴퓨터로 끄집어낼 차례입니다.

다음 주제는 "엑셀, 텍스트 파일 읽고 쓰기 (open, with문)"입니다. 파이썬으로 메모장을 열고 글씨를 써보는 신기한 경험을 해보겠습니다.

도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 11. "남이 만든 바퀴를 가져다 쓰자!" 파이썬 모듈(import)과 pip 패키지 가이드

hi.anna — Sat, 11 Apr 2026 08:00:38 +0900

파이썬이 데이터 분석, 인공지능, 웹 개발 등 모든 분야를 휩쓸고 있는 가장 큰 이유는 바로 압도적인 생태계 때문입니다. 내가 상상하는 거의 모든 기능이 이미 누군가에 의해 만들어져서 무료로 배포되고 있습니다. 우리는 그저 '다운로드'하고 '가져다 쓰기'만 하면 됩니다.

오늘은 그 마법의 주문인 import와, 파이썬의 앱스토어 역할을 하는 pip에 대해 알아보겠습니다.

1. 모듈(Module)과 기본 주문: `import`

모듈이란 쉽게 말해 '잘 만들어진 파이썬 파일(.py)'입니다. 파일 하나에 유용한 함수와 변수들을 잔뜩 모아놓은 공구 상자라고 생각하시면 됩니다.

파이썬을 설치하면 기본적으로 제공되는 훌륭한 공구 상자들이 있습니다. 이를 표준 라이브러리(Standard Library)라고 부릅니다. 이 공구 상자를 열기 위해 사용하는 키워드가 바로 import입니다.

예제 코드: 표준 라이브러리 활용하기 (math, datetime)

# 1. math 모듈 전체를 가져오기
import math

# math 상자 안에 있는 원주율(pi)과 올림(ceil) 함수 사용
print(math.pi)        # 출력: 3.141592653589793
print(math.ceil(3.2)) # 출력: 4

print("-" * 20)

# 2. 모듈에서 특정 기능만 콕 집어서 가져오기 (from ~ import ~)
# "datetime 모듈 안에서 datetime이라는 기능만 가져올게!"
from datetime import datetime

# 지금 현재 시간 출력하기
now = datetime.now()
print(f"현재 시간: {now}") 

print("-" * 20)

# 3. 모듈 이름이 너무 길면 별명(alias) 붙여주기 (import ~ as ~)
import random as rd

# random 대신 rd라는 짧은 이름으로 사용 가능
lucky_number = rd.randint(1, 45) # 1부터 45 사이의 무작위 정수 뽑기
print(f"행운의 번호: {lucky_number}")

코드 설명:

import 모듈명: 모듈 전체를 가져옵니다. 사용할 때마다 모듈명.함수이름() 형태로 써야 합니다.
from 모듈명 import 기능: 상자 전체를 가져오지 않고, 필요한 도구만 쏙 빼옵니다. 쓸 때 모듈 이름을 생략할 수 있어 편리합니다.
import 모듈명 as 별명: 이름이 길 때 줄임말을 지정해 줍니다. 데이터 분석에서 import pandas as pd 형태로 아주 많이 쓰입니다.

2. 외부 패키지 다운로드: `pip`의 등장

파이썬이 기본으로 제공하는 도구 상자(표준 라이브러리)도 훌륭하지만, 인터넷 데이터를 수집하거나 엑셀 파일을 다루는 등 더 전문적인 작업을 하려면 전 세계 개발자들이 만든 외부 패키지를 다운로드해야 합니다.

이때 사용하는 것이 파이썬의 앱스토어인 PyPI (Python Package Index)와, 여기서 패키지를 다운받아 설치해 주는 매니저 프로그램인 pip입니다.

터미널(명령 프롬프트)에서 패키지 설치하기

VS Code 하단의 터미널(Terminal) 창을 열고 아래와 같이 입력합니다. (파이썬 코드를 적는 곳이 아닙니다!)

# 인터넷 웹페이지의 데이터를 쉽게 가져오게 해주는 'requests' 패키지 설치
pip install requests

# 설치된 패키지 목록 확인하기
pip list

# 패키지 삭제하기 (필요 없어졌을 때)
pip uninstall requests

단 한 줄의 명령어로 복잡한 인터넷 통신 기능을 내 컴퓨터에 설치했습니다!

3. 다운받은 외부 패키지 사용해 보기

방금 설치한 requests 패키지를 이용해서, 실제로 인터넷에 있는 데이터를 내 파이썬 코드로 가져와 보겠습니다.

예제 코드: requests 패키지로 웹 데이터 가져오기

# 방금 pip로 설치한 외부 패키지를 가져옵니다.
import requests

# 구글 메인 페이지에 접속(GET 요청)해서 응답을 받아옵니다.
response = requests.get("https://www.google.com")

# 접속이 성공적으로 되었는지 상태 코드(200이면 정상)를 확인합니다.
print(f"응답 코드: {response.status_code}")

if response.status_code == 200:
    print("구글에 성공적으로 접속했습니다!")
else:
    print("접속에 실패했습니다.")

만약 터미널에서 pip install requests를 하지 않고 위 코드를 실행했다면, 파이썬은 ModuleNotFoundError(그런 모듈 없는데요?)라는 에러를 뱉어냅니다. 외부 패키지는 반드시 먼저 설치해야 한다는 점을 잊지 마세요!

4. 실무 꿀팁: 내 컴퓨터의 환경을 팀원과 공유하기 (`requirements.txt`)

내가 만든 파이썬 프로그램을 다른 팀원에게 주거나, 서버에 올릴 때 문제가 하나 생깁니다.
"내가 내 컴퓨터에 어떤 패키지들을 pip install 했는지 어떻게 다 기억하지?"

이때 사용하는 것이 requirements.txt 파일입니다. 내 컴퓨터에 설치된 패키지 목록과 버전을 텍스트 파일로 쫙 뽑아주는 기능입니다.

터미널에 입력:

# 현재 설치된 패키지 목록을 requirements.txt 파일로 내보내기
pip freeze > requirements.txt

이제 이 텍스트 파일을 넘겨받은 다른 팀원은, 일일이 패키지를 설치할 필요 없이 아래 명령어 한 줄이면 나와 똑같은 개발 환경을 1분 만에 세팅할 수 있습니다.

터미널에 입력:

# 파일에 적힌 패키지들을 한 번에 싹 다 설치하기
pip install -r requirements.txt

마치며

오늘의 핵심 요약입니다.

모듈과 `import`: 이미 만들어진 파이썬 코드를 내 코드로 불러와서 부품처럼 사용하는 방법.
표준 라이브러리: 파이썬을 깔면 기본적으로 제공되는 도구들 (math, datetime, random 등).
pip: 파이썬의 앱스토어에서 외부 개발자가 만든 강력한 패키지(requests 등)를 다운로드하는 마법의 명령어.

import와 pip를 알게 된 순간, 여러분의 파이썬 실력은 한계가 없어졌습니다. 이제 인터넷에 있는 수만 개의 도구들을 자유롭게 가져다 쓸 수 있게 되었으니까요.

하지만 남이 만든 도구를 잘 가져다 쓰려면, 그 도구가 어떻게 설계되었는지 이해하는 것도 중요합니다. 다음 포스팅에서는 초보자들이 가장 헷갈려 하지만 반드시 넘어야 할 산, "객체지향과 클래스(Class), 그리고 self의 정체"에 대해 아주 쉽게 풀어드리겠습니다.

도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 10. "똑같은 코드 또 쓰지 마세요!" 파이썬 함수(def)와 람다(Lambda)

hi.anna — Sat, 11 Apr 2026 01:00:07 +0900

프로그래밍에서 함수(Function)란 자판기나 믹서기 같은 '마법의 상자'입니다.
딸기와 우유(입력값)를 넣고 버튼을 누르면, 딸기 우유(결과값)가 짠 하고 나오는 기계와 같습니다. 한 번 튼튼한 믹서기를 만들어두면, 나중에 바나나나 키위를 넣어도 알아서 주스를 만들어주니 아주 편하겠죠?

오늘은 파이썬에서 나만의 믹서기를 직접 조립하는 방법을 배워보겠습니다.

1. 나만의 마법 상자 만들기: `def`

파이썬에서 함수를 정의할 때는 def (define의 약자)라는 키워드를 사용합니다.

기본 공식:

def 함수이름(재료1, 재료2):
    실행할 코드
    return 결과물

예제 코드: 커피 머신 함수 만들기

# 1. 함수 정의하기 (믹서기 만들기)
def make_coffee(bean, water_ml):
    print("커피를 내리는 중입니다 삐빅...")
    result = f"{bean} 원두로 내린 커피 {water_ml}ml"
    return result  # 완성된 결과물을 밖으로 반환(배출)합니다.

# 2. 함수 사용하기 (버튼 누르기)
# 브라질 원두와 물 250ml를 넣습니다.
my_coffee = make_coffee("브라질", 250) 
print("주문하신 음료:", my_coffee)

print("-" * 20)

# 다른 재료를 넣으면 다른 결과가 나옵니다!
your_coffee = make_coffee("에티오피아", 300)
print("주문하신 음료:", your_coffee)

실행 결과:

커피를 내리는 중입니다 삐빅...
주문하신 음료: 브라질 원두로 내린 커피 250ml
--------------------
커피를 내리는 중입니다 삐빅...
주문하신 음료: 에티오피아 원두로 내린 커피 300ml

코드 설명:

bean과 water_ml은 함수 안으로 들어가는 매개변수(Parameter)입니다.
return은 함수가 작업을 끝내고 최종적으로 뱉어내는 반환값입니다. return을 만나는 순간 함수는 즉시 종료됩니다.

2. 센스 있는 기본값 설정 (Default Parameter)

만약 매번 "물은 250ml로 해주세요"라고 말하기 귀찮다면, 함수를 만들 때 아예 기본값을 세팅해 둘 수 있습니다.

예제 코드: 기본값이 있는 인사 함수

# msg 매개변수에 미리 "안녕하세요!"라는 기본값을 넣어둡니다.
def greet(name, msg="안녕하세요!"):
    print(f"{name}님, {msg}")

# 1. 두 가지 재료를 다 넣었을 때
greet("김파이", "반갑습니다~")  # 출력: 김파이님, 반갑습니다~

# 2. 하나의 재료만 넣었을 때 (알아서 기본값이 들어감!)
greet("박코드")                 # 출력: 박코드님, 안녕하세요!

3. 이름조차 필요 없는 한 줄짜리 함수: `lambda` (람다)

어떤 함수는 코드가 단 한 줄이면 충분할 정도로 너무 단순합니다. 게다가 딱 한 번 쓰고 버릴 거라서 굳이 def를 써서 거창하게 이름을 붙여주기도 귀찮을 때가 있죠.
이때 사용하는 것이 바로 람다(Lambda) 함수입니다.

기본 공식:
lambda 입력값 : 출력할 표현식

예제 코드: def와 lambda의 비교

# 일반적인 함수 (def 사용)
def add_ten(x):
    return x + 10

print(add_ten(5))  # 출력: 15

# 람다 함수 (lambda 사용)
# "x가 들어오면, x + 10을 뱉어라"라는 뜻입니다.
lambda_add_ten = lambda x: x + 10

print(lambda_add_ten(5))  # 출력: 15

4. 람다의 진짜 진가: `map()`과 `filter()`

사실 람다는 단독으로 쓰일 때보다, 다른 함수의 재료(매개변수)로 쏙 들어갈 때 진짜 빛을 발합니다. 특히 리스트의 데이터를 한 방에 조작하는 map()과 filter()의 단짝 친구입니다.

① `map()` : 리스트의 모든 값에 함수를 똑같이 적용하기

"리스트에 있는 모든 숫자에 3을 곱해줘!"

numbers = [1, 2, 3, 4, 5]

# map(적용할 함수, 데이터 꾸러미)
# lambda x: x * 3 이라는 이름 없는 함수를 numbers 전체에 적용합니다.
result = map(lambda x: x * 3, numbers)

# map의 결과물은 눈에 보이지 않는 상태이므로, list()로 감싸서 꺼내줍니다.
print(list(result))  # 출력: [3, 6, 9, 12, 15]

② `filter()` : 조건에 맞는 값만 걸러내기

"리스트에 있는 숫자 중에서 짝수만 뽑아줘!"

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# filter(조건 함수, 데이터 꾸러미)
# lambda x: x % 2 == 0 (짝수인지 묻는 조건)이 True인 녀석들만 통과시킵니다.
even_numbers = filter(lambda x: x % 2 == 0, numbers)

print(list(even_numbers))  # 출력: [2, 4, 6, 8, 10]

( 참고: 지난 시간에 배운 '리스트 컴프리헨션'으로도 똑같은 작업을 할 수 있습니다. 실무에서는 리스트 컴프리헨션을 더 선호하는 경향이 있지만, 이 map/filter 문법도 다른 사람의 코드를 읽기 위해 반드시 알아두어야 합니다!)

마치며

오늘의 핵심 요약입니다.

def: 반복되는 코드는 묶어서 이름을 붙이고 재사용하자. 입력(매개변수)과 출력(return)이 있다.
기본값: 변수=값 형태로 함수 매개변수의 기본 옵션을 설정할 수 있다.
lambda: def를 쓰기엔 너무 단순한 1회용 한 줄 함수.
map/filter: 리스트의 데이터를 일괄적으로 변환하거나 필터링할 때 람다와 함께 쓰면 찰떡궁합이다.

내가 만든 함수들을 모아두면 아주 강력한 무기가 됩니다. 그런데 만약 전 세계의 천재 개발자들이 이미 만들어둔 엄청난 함수들이 있다면 어떨까요? 그걸 내 코드로 쏙 가져와서 쓸 수 있다면?

다음 포스팅에서는 "남이 만든 바퀴를 다시 발명하지 마라! 모듈(Module)과 pip 패키지 관리"에 대해 알아보겠습니다. 드디어 진짜 파이썬 생태계에 발을 들이는 순간입니다.

도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 9. "세 줄을 한 줄로 끝낸다!" 파이썬의 꽃, 리스트 컴프리헨션

hi.anna — Fri, 10 Apr 2026 08:59:31 +0900

파이썬 개발자들은 코드가 길어지는 것을 별로 좋아하지 않습니다. "어떻게 하면 더 직관적이고 짧게 쓸 수 있을까?"를 늘 고민하죠. (이런 스타일을 '파이썬스럽다', 즉 Pythonic하다고 부릅니다.)

그 Pythonic의 결정체가 바로 오늘 배울 리스트 컴프리헨션입니다. 우리말로는 '리스트 내포'라고도 부르는데, 쉽게 말해 "리스트 안에 for문을 쏙 집어넣어서, 새로운 리스트를 뚝딱 만들어내는 마법의 문법"입니다.

1. 기존 방식 vs 파이썬 방식 (비교 체험)

숫자가 담긴 리스트에서 모든 숫자에 2를 곱한 새로운 리스트를 만든다고 가정해 봅시다.

❌ 기존 방식 (일반적인 `for`문)

빈 바구니를 만들고, 하나씩 꺼내서, 계산하고, 다시 빈 바구니에 넣는 3단계 과정이 필요합니다.

numbers = [1, 2, 3, 4, 5]
double_numbers = []  # 1. 빈 리스트 생성

for n in numbers:    # 2. 반복문 돌리기
    double_numbers.append(n * 2)  # 3. 계산해서 집어넣기

print(double_numbers)  # 출력: [2, 4, 6, 8, 10]

✅ 파이썬 방식 (리스트 컴프리헨션)

위의 3줄짜리 코드를 단 한 줄로 압축해 버립니다.

numbers = [1, 2, 3, 4, 5]

# "n * 2를 리스트에 담을 건데, 그 n은 numbers에서 하나씩 꺼내온 거야."
double_numbers = [n * 2 for n in numbers]

print(double_numbers)  # 출력: [2, 4, 6, 8, 10]

어떤가요? 처음엔 어색할 수 있지만, 영어 문장을 읽듯 뒤에서부터 앞으로 읽어보면 아주 직관적입니다.

with arrows explaining the flow]

2. 조건문(`if`) 필터링 섞어 쓰기

이 문법이 진짜 무서운 이유는 for문 뒤에 if문까지 딱 붙여서 원하는 데이터만 골라낼 수 있다는 점입니다.

기본 공식:
[ 넣을_데이터 for 임시변수 in 리스트 if 조건식 ]

예제 코드: 짝수만 골라서 제곱하기

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# "numbers에서 n을 하나씩 꺼내는데, 만약 n이 짝수(n % 2 == 0)라면, n의 제곱(n**2)을 리스트에 담아라!"
even_squares = [n ** 2 for n in numbers if n % 2 == 0]

print(even_squares)  
# 출력: [4, 16, 36, 64, 100]

이걸 일반 for문으로 짰다면 for문 안에 if문이 들어가고 append를 하는 등 코드가 4~5줄로 훌쩍 길어졌을 겁니다.

3. 실무에서는 어떻게 쓰일까? (데이터 전처리)

데이터 분석이나 업무 자동화를 하다 보면 엑셀이나 텍스트 파일에서 데이터를 긁어올 때가 많습니다. 이때 데이터 주변에 지저분한 띄어쓰기(공백)나 불필요한 문자가 묻어있는 경우가 태반이죠.

리스트 컴프리헨션을 쓰면 이런 '데이터 청소'를 1초 만에 끝낼 수 있습니다.

예제 코드: 지저분한 텍스트 데이터 깔끔하게 다듬기

# 웹 크롤링으로 긁어왔는데 공백이 잔뜩 묻어있는 데이터
raw_names = ["  김파이  ", "이썬 ", "  박코드", "최자동  "]

# 지난 시간에 배운 문자열 함수 .strip()을 활용합니다!
# "raw_names에서 이름을 하나씩 꺼내서, 양쪽 공백을 다 지운(strip) 다음 새 리스트로 만들어!"
clean_names = [name.strip() for name in raw_names]

print(clean_names)
# 출력: ['김파이', '이썬', '박코드', '최자동']

어떤가요? 실무에서 정말 숨 쉬듯이 쓰이는 패턴입니다. 데이터가 10만 개여도 코드는 저 한 줄이면 충분합니다.

4. ⚠️ 주의사항: 무조건 짧다고 좋은 건 아니다!

리스트 컴프리헨션이 아무리 좋아도 남용하면 독이 됩니다.
조건이 너무 복잡해서 if, else, 그리고 이중 for문까지 한 줄에 다 구겨 넣으려고 하면, 코드를 짠 본인조차 다음 날 읽지 못하는 참사가 벌어집니다.

# ❌ 너무 복잡한 리스트 컴프리헨션 (나쁜 예)
result = [x * y for x in range(10) if x % 2 == 0 for y in range(10) if y % 3 == 0]

가독성이 생명입니다. 코드가 너무 길어지고 복잡해진다면, 억지로 한 줄로 만들지 말고 원래 하던 대로 정직하게 for문과 if문을 여러 줄로 나누어 쓰는 것이 훨씬 좋은 프로그래밍 습관입니다.

마치며

오늘의 핵심 요약입니다.

리스트 컴프리헨션은 새로운 리스트를 만들 때 for문과 append를 한 줄로 압축하는 파이썬만의 문법이다.
[표현식 for 변수 in 데이터] 형태로 작성한다.
맨 뒤에 if 조건을 붙여서 원하는 데이터만 쏙쏙 골라낼 수 있다. (데이터 전처리에 최고!)

지금까지 여러분은 변수, 자료형, 조건문, 반복문 등 파이썬의 '기초 체력'을 모두 다졌습니다.
이제는 내가 만든 이 훌륭한 로직들을 "이름을 붙여서 언제든 꺼내 쓸 수 있는 나만의 도구"로 만들 차례입니다.

다음 포스팅에서는 Phase 4의 첫 번째 시간, "코드의 재사용성을 극대화하는 함수(Function) 만들기"에 대해 완벽하게 파헤쳐 보겠습니다.

도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 8. "100번의 단순 노동을 단 세 줄로!" 파이썬의 for-in 반복문 완벽 가이드

hi.anna — Fri, 10 Apr 2026 01:19:40 +0900

만약 엑셀 파일 100개를 열어서 각각의 파일명을 바꿔야 한다고 상상해 보세요. 사람이 직접 하면 마우스 클릭을 수천 번 해야 하고 실수하기도 쉽습니다. 하지만 프로그래밍의 반복문을 사용하면 단 몇 줄의 코드로 1초 만에 끝낼 수 있습니다.

오늘은 파이썬에서 가장 많이 쓰이고, 가장 직관적인 형태를 가진 for-in 반복문과 그 단짝 친구들(range, enumerate, zip)을 완벽하게 마스터해 보겠습니다.

1. 파이썬 반복문의 핵심: 구조

파이썬의 for문은 아주 직관적입니다. "저 바구니(리스트)에 있는 물건들을 하나씩 꺼내서, 다 떨어질 때까지 이 작업을 반복해!"라는 뜻입니다.

기본 공식:

for 임시변수 in 데이터꾸러미:
    반복할 코드

예제 코드: 장바구니 물건 하나씩 꺼내기

cart = ["사과", "바나나", "포도"]

for fruit in cart:
    print(f"장바구니에서 {fruit}를 꺼냈습니다.")

print("장바구니가 비었습니다!")

실행 결과:

장바구니에서 사과를 꺼냈습니다.
장바구니에서 바나나를 꺼냈습니다.
장바구니에서 포도를 꺼냈습니다.
장바구니가 비었습니다!

코드 설명:

cart라는 리스트 안에 있는 데이터를 맨 앞에서부터 하나씩 꺼냅니다.
꺼낸 데이터는 fruit라는 임시 상자(변수)에 잠시 담깁니다.
들여쓰기 된 print 문장이 실행됩니다.
리스트의 끝까지 도달하면 들여쓰기 블록을 빠져나와 마지막 문장을 출력합니다.

2. 원하는 횟수만큼 반복하기: 함수

만약 데이터 꾸러미(리스트)가 없고, 그냥 "이 문장을 5번 반복해 줘!"라고 시키고 싶을 때는 어떻게 할까요? 이때 숫자를 자동으로 만들어주는 마법의 기계, range() 함수를 사용합니다.

예제 코드: range()의 3가지 변신

# 1. 종료 숫자만 지정하기: 0부터 '종료 숫자 직전'까지
for i in range(3):
    print(f"{i}번째 인사: 안녕하세요!")
# 출력: 0, 1, 2 (총 3번)

print("-" * 20)

# 2. 시작과 종료 숫자 지정하기: 1부터 5 앞(4)까지
for i in range(1, 5):
    print(f"번호표 {i}번 고객님~")
# 출력: 1, 2, 3, 4

print("-" * 20)

# 3. 건너뛰기 (step) 추가: 1부터 10 앞까지 2칸씩 뛰어서
for i in range(1, 10, 2):
    print(f"홀수만 출력: {i}")
# 출력: 1, 3, 5, 7, 9

⚠️ 주의사항: 슬라이싱 때와 마찬가지로 range(A, B)에서 끝 번호 B는 절대 포함되지 않습니다! B의 바로 앞 숫자까지만 만들어냅니다.

3. 순서(번호표)와 데이터를 동시에:

실무에서 반복문을 돌리다 보면 데이터뿐만 아니라 "이 데이터가 몇 번째 데이터인지(인덱스)" 알아야 할 때가 정말 많습니다. 파이썬에서는 아주 우아한 해결책인 enumerate()를 제공합니다.

예제 코드: 달리기 대회 순위 발표

runners = ["철수", "영희", "민수", "지훈"]

# 데이터만 꺼내는 방식
# for name in runners:
#     print(name)

# 순서(인덱스)와 데이터를 함께 꺼내는 방식 (start=1 옵션으로 1등부터 시작!)
for rank, name in enumerate(runners, start=1):
    print(f"{rank}등: {name} 선수")

실행 결과:

1등: 철수 선수
2등: 영희 선수
3등: 민수 선수
4등: 지훈 선수

enumerate()를 쓰면 rank에는 번호표가, name에는 실제 데이터가 동시에 쏙쏙 들어갑니다. 코드가 훨씬 깔끔해지죠.

4. 여러 개의 주머니를 한 번에 털기:

이름이 들어있는 리스트 하나, 점수가 들어있는 리스트 하나. 이 두 리스트를 동시에 짝지어서 돌리고 싶다면 어떻게 해야 할까요?
이름처럼 두 리스트의 지퍼를 쫙 채워주는 zip() 함수를 씁니다.

예제 코드: 학생 이름과 점수 짝지어 출력하기

names = ["Alice", "Bob", "Charlie"]
scores = [95, 80, 100]

# 두 리스트를 zip으로 묶으면, 같은 위치(인덱스)에 있는 것끼리 짝꿍이 됩니다.
for name, score in zip(names, scores):
    print(f"이름: {name}, 점수: {score}점")

실행 결과:

이름: Alice, 점수: 95점
이름: Bob, 점수: 80점
이름: Charlie, 점수: 100점

5. 무한루프와 제어기: 문, ,

횟수가 정해져 있지 않고, "특정 조건이 만족될 때까지 계속해!"라고 할 때는 while 문을 사용합니다.
이때 반복문을 강제로 멈추거나 건너뛰는 버튼도 있습니다.

예제 코드: 비밀번호 맞추기 게임

while True:  # True이므로 영원히 반복되는 무한루프입니다.
    pwd = input("비밀번호를 입력하세요: ")  # 사용자에게 입력을 받습니다.

    if pwd == "1234":
        print("로그인 성공!")
        break  # 반복문을 즉시 박살 내고(종료하고) 빠져나옵니다.

    if pwd == "0000":
        print("0000은 너무 쉬운 비밀번호입니다. 다시 시도하세요.")
        continue  # 아래 코드를 무시하고, 다시 반복문의 맨 처음으로 올라갑니다.

    print("비밀번호가 틀렸습니다. 다시 시도하세요.")

break: 브레이크를 밟아서 반복문을 아예 끝내버립니다.
continue: 이번 턴(차례)만 건너뛰고 다음 반복으로 넘어갑니다.

마치며

오늘 배운 핵심 요약입니다.

for 변수 in 리스트: - 리스트의 데이터를 하나씩 순서대로 꺼내며 반복한다.
range() - 원하는 횟수만큼 숫자를 자동으로 만들어준다. (끝 숫자는 포함 X)
enumerate() - 데이터의 순서(인덱스)와 값을 동시에 뽑아준다.
zip() - 여러 개의 리스트를 같은 순서끼리 짝지어서 뽑아준다.

이 4가지만 자유자재로 다뤄도 여러분은 엑셀 수천 줄의 데이터를 파이썬으로 가볍게 요리할 수 있습니다.
그런데 파이썬 개발자들은 이 반복문조차도 여러 줄 쓰는 것을 귀찮아해서, 아예 한 줄로 압축해 버리는 마법을 만들어냈습니다.
다음 포스팅에서는 "리스트를 만드는 가장 파이썬스러운 방법, 코드의 길이를 반으로 줄여주는 리스트 컴프리헨션(List Comprehension)"에 대해 알아보겠습니다.
도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 7. "괄호가 없어서 어색해요..." 파이썬의 생명, 들여쓰기(Indentation)와 if문

hi.anna — Thu, 9 Apr 2026 09:36:57 +0900

프로그램이 똑똑해 보이려면 상황에 맞게 다른 행동을 해야 합니다. 로그인할 때 비밀번호가 맞으면 환영해주고, 틀리면 다시 입력하라고 경고창을 띄우는 것처럼요.
이런 논리적인 흐름을 제어하는 제1원칙이 바로 조건문(if문)입니다. 그리고 파이썬에서 조건문을 쓸 때 절대 모르면 안 되는 아주 독특하고 아름다운 규칙이 하나 있습니다.

1. 파이썬의 생명줄: 들여쓰기 (Indentation)

다른 프로그래밍 언어들을 보면 복잡한 중괄호 { }를 사용해서 "여기서부터 여기까지가 한 묶음이야!"라고 표시합니다.
하지만 파이썬 창시자는 코드가 지저분해지는 것을 싫어했습니다. 그래서 괄호를 과감히 없애고, '들여쓰기(여백)'로 코드의 구역을 나누도록 만들었습니다.

규칙 1: 조건문 끝에는 반드시 콜론(:)을 붙여야 합니다. ("내 밑으로 주목!" 이라는 뜻입니다.)
규칙 2: 콜론 다음 줄부터는 무조건 들여쓰기(Space 4번 또는 Tab 1번)를 해야 합니다.
규칙 3: 들여쓰기가 끝나는 시점이 조건문이 끝나는 시점입니다.

예제 코드: 들여쓰기의 중요성

weather = "비"

if weather == "비":
    print("우산을 챙기세요!")  # 들여쓰기 됨 (if문에 포함)
    print("장화도 신으세요!")  # 들여쓰기 됨 (if문에 포함)

print("외출을 합니다.")       # 들여쓰기 없음 (if문과 상관없이 무조건 실행)

만약 print("우산을 챙기세요!") 앞에 띄어쓰기를 깜빡한다면 파이썬은 IndentationError(들여쓰기 에러)를 내뿜으며 파업해버립니다. 처음엔 낯설지만, 이 규칙 덕분에 세상 모든 파이썬 코드는 누가 짜든 아주 깔끔하고 읽기 쉽습니다.

2. 기본 조건문: if, else, elif

조건이 하나만 있는 게 아니죠? "비가 오면 우산, 눈이 오면 패딩, 둘 다 아니면 겉옷"처럼 여러 갈래로 나눌 때 사용하는 삼총사입니다.

if: 만약 ~라면 (가장 처음에 등장)
elif: 그게 아니고, 만약 ~라면 (여러 번 사용 가능, else if의 줄임말)
else: 위의 조건들이 모두 아니라면 (가장 마지막에 등장, 조건식 불필요)

예제 코드: 점수에 따른 학점 매기기

score = 85

if score >= 90:
    print("A학점입니다.")
elif score >= 80:
    print("B학점입니다.")  # score가 85이므로 여기가 실행됩니다!
elif score >= 70:
    print("C학점입니다.")
else:
    print("재수강을 권장합니다.")

코드 설명:

위에서부터 차례대로 조건을 검사합니다.
score >= 90이 거짓(False)이므로 다음 elif로 넘어갑니다.
score >= 80이 참(True)이므로 "B학점입니다."를 출력하고, 그 아래의 조건들은 거들떠보지도 않고 빠져나옵니다.

3. 파이썬만의 아름다운 논리 연산자 (and, or, not)

조건을 여러 개 섞어야 할 때도 파이썬은 기호를 쓰지 않고 영어 단어를 그대로 씁니다.

and (그리고): 양쪽 조건이 모두 참이어야 실행
or (또는): 둘 중 하나만 참이어도 실행
not (반대): 참이면 거짓으로, 거짓이면 참으로 뒤집음

예제 코드: 놀이기구 탑승 조건

age = 15
height = 160

# 나이가 14세 이상 '그리고' 키가 150 이상이어야 탑승 가능
if age >= 14 and height >= 150:
    print("롤러코스터 탑승 가능!")
else:
    print("탑승 불가!")

파이썬만의 사기 스킬: in 연산자
리스트나 문자열 안에 내가 찾는 값이 들어있는지 확인할 때, 다른 언어들은 복잡한 코드를 짜야 하지만 파이썬은 단어 하나면 끝납니다.

cart = ["사과", "바나나", "포도"]

if "사과" in cart:
    print("장바구니에 사과가 이미 있습니다!")

if "수박" not in cart:
    print("수박을 추가로 사야겠네요.")

4. [보너스] 인터넷에서 자주 보이는 은 뭘까요?

파이썬 코드를 보다 보면 파일 맨 밑에 이런 요상한 코드가 있는 걸 보게 됩니다.

if __name__ == "__main__":
    print("프로그램을 시작합니다.")

이건 파이썬만의 독특한 관용구입니다. 쉽게 번역하자면 "이 파일을 다른 곳에서 부품(모듈)으로 몰래 가져다 쓴 게 아니라, 내가 직접 더블클릭해서(메인으로) 실행한 게 맞나요?"라고 묻는 조건문입니다.

내가 직접 실행함 -> 저 안의 코드가 작동함
다른 파일에서 import로 가져감 -> 저 안의 코드는 작동하지 않고 조용히 기능만 빌려줌

지금 완벽히 이해하지 않아도 괜찮습니다. "아, 프로그램의 진짜 시작점을 알려주는 표지판이구나!" 정도로만 기억해 두세요.

마치며

오늘의 핵심 요약입니다.

파이썬에서 코드를 하나로 묶으려면 괄호 대신 들여쓰기(Space 4번)를 쓴다.
조건문(if, elif, else) 끝에는 항상 콜론(:)을 잊지 말자.
여러 조건을 묶을 땐 직관적인 and, or, in을 활용하자.

조건문을 배우셨으니 이제 여러분의 프로그램은 스스로 판단을 내릴 수 있게 되었습니다.

하지만 만약 "이 동작을 100번 반복해!"라고 시키고 싶다면 어떻게 할까요? print()를 100줄 복사 붙여넣기 할 수는 없겠죠.
다음 포스팅에서는 "수백 번의 단순 노동을 한 방에 끝내는 마법! 파이썬의 for-in 반복문"에 대해 완벽하게 알아보겠습니다.

도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 6. "데이터에 이름표를 달아주자!" 파이썬 딕셔너리(Dictionary)와 집합(Set)

hi.anna — Thu, 9 Apr 2026 00:36:13 +0900

만약 한 사람의 정보를 리스트로 저장한다면 이렇게 될 것입니다. user = ["홍길동", 30, "010-1234-5678"].
나이를 꺼내려면 user[1]을 찾아야 하죠. 1번 방이 나이였다는 사실을 개발자가 매번 외우고 있어야 합니다. 너무 불편하지 않나요?

이럴 때 사용하는 것이 바로 파이썬의 꽃, 딕셔너리(Dictionary)입니다.

1. 딕셔너리(Dictionary): Key와 Value의 환상 짝꿍

딕셔너리는 말 그대로 '사전'입니다. 사전에서 단어(Key)를 찾으면 뜻(Value)이 나오는 것처럼, 파이썬 딕셔너리도 이름표(Key)와 실제 데이터(Value)가 한 쌍으로 묶여 있습니다.

만드는 방법은 중괄호 { }를 사용하며, 내부는 이름표 : 데이터 형태로 적어줍니다. 웹 개발에서 자주 쓰이는 JSON 포맷과 완전히 똑같이 생겼습니다.

예제 코드: 딕셔너리 만들고 데이터 꺼내기

# 딕셔너리 생성 (중괄호 사용, Key: Value 형태)
user_info = {
    "name": "홍길동",
    "age": 30,
    "phone": "010-1234-5678"
}

# 1. 데이터 꺼내기 (대괄호 안에 인덱스 번호 대신 'Key 이름'을 넣습니다!)
print(user_info["name"])  # 출력: 홍길동
print(user_info["age"])   # 출력: 30

# 2. 안전하게 꺼내기 (.get() 함수 사용)
print(user_info.get("email")) # Key가 없으면 에러 대신 'None(없음)'을 반환합니다.
# print(user_info["email"])   # 이렇게 하면 KeyError가 발생하며 프로그램이 멈춥니다.

코드 설명:

user_info[1]처럼 숫자로 찾는 것이 아니라, user_info["name"]처럼 직관적인 이름표로 데이터를 찾습니다. 코드를 읽기만 해도 무슨 데이터인지 바로 알 수 있죠!

2. 딕셔너리 요리하기: 추가, 수정, 삭제

딕셔너리도 리스트처럼 내용물을 자유롭게 바꿀 수 있습니다. 방법은 아주 직관적입니다.

예제 코드: 딕셔너리 데이터 조작하기

my_dict = {"apple": "사과", "banana": "바나나"}

# 1. 새로운 데이터 추가하기 (없는 Key에 값을 넣으면 새로 생김)
my_dict["grape"] = "포도"
print(my_dict)  # 출력: {'apple': '사과', 'banana': '바나나', 'grape': '포도'}

# 2. 기존 데이터 수정하기 (있는 Key에 값을 넣으면 덮어쓰기 됨)
my_dict["apple"] = "꿀사과"
print(my_dict)  # 출력: {'apple': '꿀사과', 'banana': '바나나', 'grape': '포도'}

# 3. 데이터 삭제하기 (del 키워드 사용)
del my_dict["banana"]
print(my_dict)  # 출력: {'apple': '꿀사과', 'grape': '포도'}

3. 딕셔너리의 유용한 도구들 (keys, values, items)

딕셔너리 안에 어떤 이름표(Key)들이 있는지, 혹은 어떤 값(Value)들만 있는지 모아서 보고 싶을 때가 있습니다. 이때 아래 세 가지 함수를 사용합니다.

score_dict = {"국어": 90, "영어": 85, "수학": 100}

# 1. Key(과목명)만 다 모아줘!
print(score_dict.keys())    # 출력: dict_keys(['국어', '영어', '수학'])

# 2. Value(점수)만 다 모아줘!
print(score_dict.values())  # 출력: dict_values([90, 85, 100])

# 3. Key와 Value를 쌍으로 묶어서 다 모아줘!
print(score_dict.items())   
# 출력: dict_items([('국어', 90), ('영어', 85), ('수학', 100)])

( 참고: 이 함수들은 나중에 배울 for 반복문과 결합하면 엄청난 시너지를 발휘합니다.)

4. 집합(Set): 중복을 허락하지 않는 주머니

마지막으로 알아볼 자료형은 집합(Set)입니다. 딕셔너리와 똑같이 중괄호 { }를 쓰지만, Key: Value 쌍이 아니라 리스트처럼 값만 덩그러니 들어있습니다.

집합의 가장 강력한 특징 두 가지는 다음과 같습니다.

중복을 허용하지 않는다.
순서가 없다. (인덱싱 불가능)

예제 코드: 리스트의 중복 데이터 1초 만에 날리기

집합은 언제 쓸까요? 바로 "수많은 데이터 중에서 중복을 제거할 때" 가장 많이 쓰입니다.

# 1. 중복이 잔뜩 있는 리스트
attendance_list = ["철수", "영희", "민수", "철수", "철수", "영희"]

# 2. 리스트를 집합(Set)으로 변환해 버립니다! (이때 중복이 마법처럼 사라짐)
unique_set = set(attendance_list)
print(unique_set)  # 출력: {'영희', '민수', '철수'} (순서는 뒤죽박죽일 수 있음)

# 3. 다시 다루기 편하게 리스트로 되돌려줍니다.
final_list = list(unique_set)
print(final_list)  # 출력: ['영희', '민수', '철수']

수학 시간에 배운 교집합, 합집합도 가능합니다.

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(set1 & set2)  # 교집합 (공통으로 있는 것) -> {3, 4}
print(set1 | set2)  # 합집합 (전체 다 합친 것, 중복은 하나만) -> {1, 2, 3, 4, 5, 6}

마치며

지금까지 배운 파이썬의 4대 데이터 바구니를 총정리해 보겠습니다.

리스트 `[ ]`: 순서가 있고, 중복도 허용하고, 내용물 수정도 가능. (가장 만만함)
튜플 `( )`: 리스트와 같지만, 내용물 수정이 절대 불가능. (안전함)
딕셔너리 `{Key: Value}`: 순서 대신 이름표(Key)로 값을 찾음. (직관적임)
집합 `{ }`: 순서가 없고, 중복을 제거해 줌. (필터 역할)

상황에 맞게 적절한 바구니를 고르는 것이 좋은 코드를 작성하는 첫걸음입니다!
재료 준비는 모두 끝났습니다. 이제 이 데이터들을 가지고 "비가 오면 우산을 쓰고, 안 오면 그냥 간다" 같은 조건을 만들어 컴퓨터에게 생각하는 법을 가르칠 차례입니다.
다음 포스팅에서는 "들여쓰기의 마법! 프로그램의 흐름을 통제하는 if문(조건문)"에 대해 알아보겠습니다.
도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 5. "수십 개의 데이터를 상자 하나에!" 파이썬 리스트(List)와 튜플(Tuple) 완벽 가이드

hi.anna — Wed, 8 Apr 2026 09:35:51 +0900

데이터를 다루다 보면 "여러 개의 데이터"를 한 묶음으로 처리해야 할 일이 무조건 생깁니다. 로또 번호 6개, 우리 팀원 5명의 이름, 한 달 치 온도 기록처럼 말이죠.
파이썬은 이런 여러 개의 데이터를 하나의 변수 이름표로 묶어서 관리할 수 있는 아주 강력하고 유연한 바구니를 제공합니다. 그중 가장 대표적인 것이 바로 리스트(List)입니다.

1. 리스트(List): 무엇이든 담을 수 있는 마법의 바구니

리스트를 만드는 방법은 아주 간단합니다. 대괄호 [와 ]로 데이터를 감싸고, 각 데이터는 쉼표 ,로 구분해주면 됩니다.

가장 놀라운 점은 파이썬의 리스트에는 종류가 다른 데이터도 한 바구니에 마구잡이로 담을 수 있다는 것입니다.

예제 코드: 리스트 만들고 꺼내보기

# 1. 숫자만 담은 리스트
lotto_numbers = [3, 15, 22, 38, 41, 45]

# 2. 문자만 담은 리스트
team_members = ["철수", "영희", "민수"]

# 3. 짬뽕 리스트 (숫자, 문자, 불린형 심지어 다른 리스트까지 가능!)
mixed_list = [100, "파이썬", True, [1, 2, 3]]

# 리스트 출력하기
print(team_members)

실행 결과:

['철수', '영희', '민수']

2. 리스트 다루기: 인덱싱과 슬라이싱

지난 시간에 문자열에서 배웠던 '인덱싱(방 번호)'과 '슬라이싱(자르기)' 기억하시나요? 리스트에서도 똑같이 0번부터 시작하는 방 번호가 적용됩니다!

예제 코드: 리스트에서 원하는 데이터 뽑기

subway = ["사당", "방배", "서초", "교대", "강남"]

# 1. 인덱싱 (특정 위치 데이터 가져오기)
print(subway[0])   # 0번 방 (첫 번째): 사당
print(subway[-1])  # -1번 방 (마지막): 강남

# 2. 슬라이싱 (구간 잘라오기)
print(subway[1:4]) # 1번 방부터 4번 앞(3번)까지 가져오기

실행 결과:

사당
강남
['방배', '서초', '교대']

주의: 슬라이싱으로 잘라낸 결과물 역시 '리스트' 형태로 나옵니다.

3. 리스트 수정하기: 추가, 삭제, 변경

리스트의 가장 큰 장점은 바구니 안에 든 내용물을 마음대로 바꾸고, 더하고, 뺄 수 있다(Mutable)는 점입니다.

예제 코드: 리스트 요리조리 주무르기

cart = ["사과", "바나나"]

# 1. 추가하기 (append: 맨 뒤에 쏙 넣기)
cart.append("포도")
print(cart)  # 출력: ['사과', '바나나', '포도']

# 2. 특정 위치에 끼워 넣기 (insert)
cart.insert(1, "딸기") # 1번 방에 '딸기'를 새치기시킴
print(cart)  # 출력: ['사과', '딸기', '바나나', '포도']

# 3. 삭제하기 (remove: 이름으로 지우기)
cart.remove("바나나")
print(cart)  # 출력: ['사과', '딸기', '포도']

# 4. 내용물 바꾸기 (인덱스로 접근해서 값 덮어쓰기)
cart[0] = "수박"  # 0번 방에 있던 '사과'를 빼고 '수박'을 넣음
print(cart)  # 출력: ['수박', '딸기', '포도']

# 5. 리스트 크기(데이터 개수) 확인하기 (len 함수)
print(len(cart))  # 출력: 3

append와 len은 앞으로 코딩하시면서 숨 쉬듯이 쓰게 될 필수 기능이니 꼭 눈에 익혀두세요!

4. 튜플(Tuple): 수정할 수 없는 자물쇠 채운 바구니

리스트와 거의 똑같이 생겼지만, 성질이 완전히 다른 형제가 있습니다. 바로 튜플(Tuple)입니다.

튜플은 대괄호 [] 대신 소괄호 ()를 사용해서 만듭니다. 가장 큰 특징은 "한 번 만들면 내용물을 절대로 수정할 수 없다(Immutable)"는 것입니다.

예제 코드: 튜플 만들고 수정 시도해 보기

# 튜플 만들기 (소괄호 사용)
menu_tuple = ("돈까스", "치즈돈까스")

# 인덱싱은 리스트와 똑같이 가능합니다. (가져다 보는 건 문제없음)
print(menu_tuple[0])  # 출력: 돈까스

# ❌ 오류 발생: 내용물 바꾸기 시도
# menu_tuple[0] = "생선까스" 
# -> TypeError: 'tuple' object does not support item assignment (튜플은 값 변경을 지원하지 않습니다!)

# ❌ 오류 발생: 데이터 추가 시도
# menu_tuple.append("우동") 
# -> AttributeError: 'tuple' object has no attribute 'append' (튜플은 append 기능이 없습니다!)

튜플은 왜 쓸까요?

"수정도 못 하는 거 불편하게 왜 쓰나요?"라는 생각이 드실 수 있습니다.

안전성: 요금표, 주민등록번호, 프로그램 설정값 등 중간에 실수로라도 내용이 바뀌면 큰일 나는 중요한 데이터를 보호할 때 씁니다.
속도: 내용물 변경 기능이 빠져있기 때문에 컴퓨터가 처리하는 속도가 리스트보다 미세하게 더 빠르고, 메모리도 적게 차지합니다.

마치며

오늘의 핵심 요약입니다.

리스트([]): 여러 데이터를 한곳에 담는 바구니. 자유롭게 추가, 삭제, 변경이 가능하다.
튜플(()): 리스트와 비슷하지만, 한 번 담으면 내용을 바꿀 수 없는 읽기 전용 바구니.
리스트와 튜플 모두 0부터 시작하는 인덱싱과 슬라이싱을 사용할 수 있다.

이제 데이터를 효율적으로 묶어서 관리하는 방법을 알게 되었습니다.

하지만 만약 회원가입 정보를 담아야 하는데 ['홍길동', 30, '010-1234-5678'] 처럼 리스트로 담아두면, 0번이 이름인지 1번이 나이인지 헷갈리겠죠? 데이터에 이름표(Key)를 달아서 직관적으로 관리할 수 있다면 얼마나 좋을까요?

다음 포스팅에서는 "이름표와 데이터의 찰떡궁합, JSON이랑 똑같이 생긴 파이썬 딕셔너리(Dictionary)"에 대해 완벽하게 파헤쳐 보겠습니다.
도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 4. "문자열을 떡 주무르듯이" 인덱싱, 슬라이싱, 그리고 f-string

hi.anna — Wed, 8 Apr 2026 01:35:13 +0900

우리가 엑셀을 쓰다 보면 '주민등록번호 앞자리만 빼오기', '이메일 주소에서 아이디만 분리하기' 같은 작업을 자주 하죠? 파이썬에서는 이런 텍스트 가공 작업이 정말 눈 깜짝할 사이에 끝납니다.
오늘은 문자열의 특정 위치를 콕 집어내는 인덱싱(Indexing), 원하는 만큼 싹둑 잘라내는 슬라이싱(Slicing), 그리고 문장 사이에 변수를 예쁘게 끼워 넣는 f-string 기술을 완벽하게 마스터해 보겠습니다.

1. 인덱싱(Indexing): 글자의 '방 번호' 알아내기

파이썬에서 문자열은 글자들이 기차처럼 일렬로 쭉 늘어선 형태입니다. 그리고 각 글자에는 0번부터 시작하는 방 번호(인덱스)가 매겨져 있습니다.
가장 중요한 규칙 두 가지를 기억하세요.

파이썬은 숫자를 0부터 셉니다. (첫 번째 글자는 0번 방)
뒤에서부터 셀 때는 -1부터 셉니다. (마지막 글자는 -1번 방)

예제 코드: 글자 하나씩 뽑아오기

text = "PYTHON"

# 1. 앞에서부터 뽑기 (양수 인덱스)
print(text[0])  # 첫 번째 글자: P
print(text[2])  # 세 번째 글자: T

# 2. 뒤에서부터 뽑기 (음수 인덱스)
print(text[-1]) # 맨 마지막 글자: N
print(text[-2]) # 뒤에서 두 번째 글자: O

코드 설명:

변수 이름 뒤에 대괄호 []를 붙이고, 그 안에 방 번호를 적어주면 해당 위치의 글자 하나만 쏙 빼옵니다.
음수 인덱스는 "문장의 길이가 얼마나 되든 무조건 맨 끝 글자를 가져와!"라고 할 때 매우 유용합니다.

2. 슬라이싱(Slicing): 원하는 구간만큼 싹둑 자르기

글자 하나가 아니라 여러 글자를 통째로 잘라내고 싶다면 슬라이싱을 사용합니다. 대괄호 안에 콜론(:)을 넣어 시작과 끝을 정해줍니다.

기본 공식: `변수명[시작 번호 : 끝 번호]`
(단, '끝 번호'에 해당하는 글자는 포함되지 않고 그 직전까지만 잘라냅니다!)

예제 코드: 날짜 데이터 쪼개기

date_info = "20260224"

# 1. 연도 뽑기 (0번부터 4번 앞(3번)까지)
year = date_info[0:4]
print("연도:", year)  # 출력: 2026

# 2. 월 뽑기 (4번부터 6번 앞(5번)까지)
month = date_info[4:6]
print("월:", month)   # 출력: 02

# 3. 일 뽑기 (6번부터 끝까지)
day = date_info[6:]   
print("일:", day)     # 출력: 24

슬라이싱 생략의 미학:

[0:4]는 시작이 0이므로 [:4]라고 써도 똑같이 작동합니다. (처음부터 4번 앞까지)
[6:]처럼 끝 번호를 비워두면, 시작 번호부터 문장의 맨 끝까지 전부 가져옵니다.

3. f-string: 마법의 문자열 포맷팅

"제 이름은 OOO이고, 나이는 OO살입니다."
이런 문장을 만들 때, OOO 자리에 변수를 넣으려면 어떻게 해야 할까요? 파이썬 3.6 버전부터 도입된 f-string을 쓰면 너무나도 직관적이고 편하게 문장을 조립할 수 있습니다.

방법은 아주 간단합니다. 따옴표 앞에 소문자 f를 붙이고, 변수가 들어갈 자리에 중괄호 {}를 적어주면 끝입니다.

예제 코드: f-string으로 깔끔한 문장 만들기

name = "김파이"
age = 30
job = "개발자"

# 예전 방식 (더하기 기호 사용 - 띄어쓰기 챙기기 귀찮고, 숫자는 문자로 바꿔야 함)
old_way = "제 이름은 " + name + "이고, 나이는 " + str(age) + "살 " + job + "입니다."

# f-string 방식 (압도적으로 깔끔함!)
new_way = f"제 이름은 {name}이고, 나이는 {age}살 {job}입니다."

print(old_way)
print(new_way)

실행 결과:

제 이름은 김파이이고, 나이는 30살 개발자입니다.
제 이름은 김파이이고, 나이는 30살 개발자입니다.

코드 설명:

f-string 안에서는 {age}처럼 숫자가 담긴 변수도 억지로 문자로 바꿀(str()) 필요 없이 파이썬이 알아서 문장 속에 자연스럽게 녹여줍니다.

4. 알아두면 퇴근이 빨라지는 문자열 함수 Top 3

파이썬에는 문자열을 가공하는 아주 유용한 내장 기능(함수)들이 있습니다. 그중 실무에서 매일 쓰는 3가지만 소개합니다.

예제 코드: replace, split, strip

text = "   맛있는 사과, 달콤한 사과   "

# 1. replace: 단어 교체하기 (사과 -> 바나나)
changed_text = text.replace("사과", "바나나")
print(changed_text) 
# 출력: "   맛있는 바나나, 달콤한 바나나   "

# 2. strip: 양쪽 공백(띄어쓰기) 제거하기 (크롤링할 때 필수!)
clean_text = changed_text.strip()
print(clean_text)   
# 출력: "맛있는 바나나, 달콤한 바나나"

# 3. split: 특정 기준(여기선 쉼표)으로 문자열을 쪼개서 분리하기
items = clean_text.split(", ")
print(items)        
# 출력: ['맛있는 바나나', '달콤한 바나나'] (이건 다음 시간에 배울 '리스트' 형태입니다!)

마치며

오늘의 핵심 요약입니다.

인덱싱([번호]): 파이썬은 0부터 숫자를 센다. 맨 끝은 -1이다.
슬라이싱([시작:끝]): 끝 번호 글자는 포함되지 않으니 주의해서 자르자.
f-string (f"안녕 {변수}"): 변수를 문장에 끼워 넣을 때는 고민 없이 f-string을 쓰자.

문자열 다루기는 파이썬의 꽃입니다. 이것만 잘해도 엑셀의 LEFT, MID, RIGHT 함수보다 훨씬 복잡한 텍스트 전처리 작업을 쉽게 해낼 수 있습니다.

마지막 예제에서 .split()을 썼을 때 대괄호 [ ]로 묶인 데이터가 나온 것을 보셨나요? 이것이 바로 여러 개의 데이터를 한 번에 담는 파이썬의 핵심 자료구조입니다.

다음 포스팅에서는 "배열인 듯 배열 아닌" 수많은 데이터를 한 바구니에 담는 리스트(List)와 튜플(Tuple)에 대해 완벽하게 파헤쳐 보겠습니다.
도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 3. "Hello World"는 이제 그만! 변수와 자료형(Data Type) 제대로 알기

hi.anna — Tue, 7 Apr 2026 08:23:05 +0900

지난 시간에는 화면에 글자를 띄워보는 기초적인 작업을 해보았습니다. 하지만 진짜 쓸모 있는 프로그램을 만들려면 데이터를 기억하고, 계산하고, 조작할 줄 알아야 합니다.
오늘은 데이터를 담는 상자인 변수(Variable)와, 그 상자에 들어가는 데이터의 종류인 자력형(Data Type)에 대해 완벽하게 정리해 드리겠습니다.

1. 변수(Variable): 데이터를 담는 이름표 붙인 상자

컴퓨터에게 "이 숫자 좀 잠깐 기억해 줘!"라고 명령할 때 사용하는 것이 바로 변수입니다. 쉽게 말해, 데이터에 이름표를 붙여서 상자에 보관하는 것과 같습니다.

파이썬에서는 수학 기호인 = (등호)를 사용해서 변수에 값을 넣습니다. (프로그래밍에서 =는 '같다'가 아니라 '오른쪽의 값을 왼쪽 상자에 넣어라(대입해라)'라는 뜻입니다.)

예제 코드: 변수 만들기

# 이름, 나이, 키를 각각의 변수에 저장합니다.
name = "홍길동"
age = 25
height = 175.5

# 저장된 변수들을 출력해 봅니다.
print(name)
print(age)
print(height)

코드 설명:

name이라는 상자를 만들고 "홍길동"이라는 글자를 넣었습니다.
age라는 상자에는 25라는 숫자를 넣었습니다.
print() 괄호 안에 변수 이름을 넣으면, 상자 안에 들어있던 실제 값이 화면에 출력됩니다.

2. 파이썬의 핵심! 동적 타이핑 (Dynamic Typing)

파이썬의 가장 강력한 매력 중 하나는 프로그래머가 상자의 종류를 미리 정해주지 않아도 된다는 것입니다.
파이썬은 아주 똑똑한 통역사라서, 여러분이 상자에 숫자를 넣으면 '아, 이건 숫자 상자구나!', 글자를 넣으면 '아, 이건 글자 상자구나!' 하고 스스로 알아서 판단합니다. 이를 동적 타이핑이라고 부릅니다.
심지어 쓰던 상자의 내용물을 아예 다른 종류로 바꿔버려도 에러가 나지 않습니다.

예제 코드: 똑똑한 파이썬의 자료형 자동 인식

# 처음엔 숫자를 넣습니다.
my_box = 100
print(type(my_box))  # type()은 상자 안에 든 데이터의 종류를 알려줍니다.

# 같은 상자에 이번엔 글자를 넣어버립니다!
my_box = "안녕하세요"
print(type(my_box))

실행 결과:

<class 'int'>
<class 'str'>

코드 설명:

type() 함수는 변수가 현재 어떤 자료형을 담고 있는지 알려주는 아주 유용한 마법 도구입니다.
처음엔 int(정수)라고 대답하더니, 글자를 넣자 불평 없이 str(문자열)로 상자의 성질을 바꿔버립니다. 정말 유연하죠?

3. 가장 많이 쓰는 기본 자료형 3가지

그렇다면 파이썬에는 어떤 종류의 데이터들이 있을까요? 가장 기본이 되는 세 가지만 알면 충분합니다.

① 숫자형 (Numbers)

소수점이 없는 정수(int)와 소수점이 있는 실수(float)로 나뉩니다. 사칙연산이 아주 자유롭습니다.

a = 10      # 정수 (int)
b = 3.14    # 실수 (float)

print(a + 2)    # 덧셈: 12
print(a - 2)    # 뺄셈: 8
print(a * 2)    # 곱셈: 20
print(a / 3)    # 나눗셈: 3.3333...

# 파이썬만의 유용한 수학 기호들
print(a // 3)   # 몫만 구하기: 3
print(a % 3)    # 나머지만 구하기: 1
print(a ** 2)   # 거듭제곱 (10의 2승): 100

② 문자열 (String, str)

글자, 단어, 문장을 의미합니다. 반드시 큰따옴표(" ")나 작은따옴표(' ')로 감싸주어야 합니다. 따옴표로 감싸면 숫자라도 문자로 취급됩니다.

greeting = "Hello"
target = 'World'

# 문자열끼리 더하면 글자가 이어붙습니다!
message = greeting + " " + target 
print(message)  # 결과: Hello World

# 문자열을 곱하면 그 수만큼 반복됩니다!
print("하" * 3)  # 결과: 하하하

③ 불린형 (Boolean, bool)

참(True)과 거짓(False), 딱 두 가지 값만 가지는 자료형입니다. 주로 "이 조건이 맞는지 틀린 지" 검사할 때 씁니다. (첫 글자는 반드시 대문자로 적어야 합니다!)

is_adult = True
is_student = False

# 조건문을 만들 때 결과값으로 자주 등장합니다.
print(10 > 5)   # 10은 5보다 크다 -> 결과: True
print(10 == 5)  # 10과 5는 같다 (등호 2개 사용!) -> 결과: False

4. 자료형 변환 (Type Casting): 상자 내용물 억지로 바꾸기

가끔은 문자로 된 숫자를 진짜 숫자로 바꾸거나, 숫자를 문자로 바꿔야 할 때가 있습니다. 이때는 원하는 자료형의 이름을 함수처럼 써주면 됩니다.

예제 코드: 자료형 바꾸기

str_num = "100"  # 따옴표가 있으니 이것은 '문자'입니다.
# print(str_num + 50) -> 에러 발생! (문자와 숫자는 더할 수 없습니다)

# 문자 "100"을 진짜 숫자(정수)로 변환합니다.
real_num = int(str_num)
print(real_num + 50)  # 결과: 150

# 반대로 숫자를 문자로 바꿀 수도 있습니다.
age = 25
# print("제 나이는 " + age + "입니다.") -> 에러 발생!
print("제 나이는 " + str(age) + "입니다.") # 숫자를 문자로 변환하여 이어붙임

마치며

오늘의 결론입니다.

데이터를 저장할 때는 변수(이름표 붙인 상자)를 쓴다.
파이썬은 상자에 넣는 데이터의 종류(자료형)를 스스로 파악하는 아주 똑똑한 언어다.
기본 자료형에는 숫자(int, float), 문자(str), 참/거짓(bool)이 있다.

기초적인 재료 다듬기가 끝났습니다.
다음 포스팅에서는 이 재료 중에서도 가장 많이 다루게 될 "문자열(String)"을 도마 위에 올려놓고, 요리조리 자르고 붙이는 "문자열 슬라이싱(Slicing)과 포맷팅" 기술을 배워보겠습니다.
도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 2. 5분 컷! 파이썬 설치하고 VS Code와 연동하기 (윈도우/맥)

hi.anna — Tue, 7 Apr 2026 00:01:53 +0900

요리를 하려면 '식재료'와 '도마'가 필요하듯, 파이썬을 하려면 파이썬 인터프리터(명령어를 컴퓨터 언어로 번역해 주는 프로그램)와 코드 에디터(코드를 작성하는 도마)가 필요합니다.
시중에는 '아나콘다(Anaconda)'라는 데이터 분석용 통합 패키지도 있지만, 처음 배우기에는 용량이 크고 무거울 수 있습니다. 오늘은 가장 가볍고, 현업 개발자들이 가장 많이 사용하는 "순정 파이썬 + VS Code" 조합으로 세팅해 보겠습니다. 딱 5분이면 충분합니다!

1단계: 파이썬(Python) 설치하기

먼저 컴퓨터에게 파이썬 문법을 이해할 수 있는 능력을 심어줘야 합니다.

python.org 공식 홈페이지에 접속합니다.
메인 화면에 있는 "Download Python 3.x.x" 노란색 버튼을 클릭해 설치 파일을 다운로드합니다. (버전은 계속 업데이트되니 최신 버전으로 받으시면 됩니다.)

⚠️ [윈도우 사용자 필독] 가장 중요한 체크박스!

설치 파일을 실행하면 첫 화면 아래쪽에 체크박스가 두 개 나옵니다. 여기서 두 번째 체크박스를 잊지 마세요.

Add Python 3.x to PATH (또는 Add python.exe to PATH)를 꼭! 체크하세요.
이 옵션을 켜야 윈도우의 어느 폴더에서든 파이썬 명령어를 자유롭게 실행할 수 있습니다. (체크하지 않으면 나중에 파이썬을 찾을 수 없다는 에러가 뜹니다.)
체크 후 상단의 Install Now를 누르면 설치가 완료됩니다. 맥(Mac) 사용자는 기본 설정대로 쭉 넘겨서 설치하시면 됩니다.

2단계: VS Code (Visual Studio Code) 설치하기

기본 메모장으로도 코딩은 할 수 있지만, 오타도 안 잡아주고 색깔도 없어서 매우 힘듭니다. 전 세계에서 가장 사랑받는 무료 코드 에디터인 VS Code를 설치합니다.

code.visualstudio.com 에 접속합니다.
자신의 운영체제(Windows/Mac)에 맞는 파란색 다운로드 버튼을 눌러 설치합니다. 설치 과정은 '다음'만 누르시면 무사히 끝납니다.

3단계: VS Code와 파이썬 연결하기 (확장 프로그램)

VS Code 자체는 여러 언어를 다룰 수 있는 '빈 도화지' 같습니다. 여기에 "파이썬 맞춤형 도구"를 추가해 줘야 합니다.

VS Code를 실행합니다.
왼쪽 메뉴바에서 테트리스 블록 모양 아이콘 (Extensions, 확장)을 클릭합니다.
검색창에 Python이라고 입력합니다.
Microsoft가 직접 만든 Python 확장을 찾아 Install(설치) 버튼을 누릅니다.

이제 VS Code가 파이썬 코드를 인식하고, 오타를 찾아주며, 코드를 예쁘게 칠해주는(Syntax Highlighting) 모든 준비를 마쳤습니다.

4단계: 역사적인 첫 코드 실행해 보기 (Hello World)

모든 준비가 끝났습니다. 코드를 직접 치고 실행해 봅시다.

컴퓨터 바탕화면이나 원하는 곳에 python_study라는 새 폴더를 하나 만듭니다.
VS Code 상단 메뉴에서 File(파일) -> Open Folder(폴더 열기)를 눌러 방금 만든 폴더를 엽니다.
왼쪽 탐색기 빈 공간에 마우스 우클릭 -> New File(새 파일)을 클릭하고, 이름을 hello.py라고 입력합니다.

( 참고: .py는 이 파일이 파이썬 코드라는 것을 알려주는 확장자입니다.)

예제 코드:

방금 만든 파일에 아래 두 줄을 똑같이 입력해 보세요.

print("Hello, Python!")
print("파이썬 설치 성공!")

실행 방법:
코드를 다 적었다면, 우측 상단에 있는 ▷ (재생 버튼, Run Python File)을 누릅니다.
실행 결과 (하단 터미널 창):

Hello, Python!
파이썬 설치 성공!

하단에 텍스트가 잘 출력되었나요? 그렇다면 축하합니다!
이제 여러분의 컴퓨터는 파이썬 코드를 이해하고 실행할 준비가 완벽하게 되었습니다.

보너스: 가상환경(Virtual Environment)이란?

앞으로 파이썬을 다루다 보면 '가상환경'이라는 단어를 자주 듣게 됩니다.
파이썬은 다양한 외부 라이브러리(남들이 만들어둔 코드 뭉치)를 다운받아 씁니다. 만약 A 프로젝트는 '버전 1.0'이 필요하고, B 프로젝트는 '버전 2.0'이 필요하다면 어떻게 될까요? 둘이 충돌해서 에러가 날 수 있습니다.
이때 프로젝트마다 "서로 간섭하지 않는 독립된 방"을 만들어 주는 기술이 바로 가상환경입니다. 지금 당장 만들 필요는 없지만, "프로젝트마다 독립된 폴더 환경을 구축하는구나!" 정도로만 기억해 두시면 나중에 큰 도움이 됩니다.

마치며

이제 파이썬의 세계를 탐험할 튼튼한 배(VS Code)와 나침반(Python)이 준비되었습니다. 첫 코드를 실행했을 때의 짜릿함을 잊지 마세요!
다음 포스팅부터는 본격적으로 파이썬의 문법을 배워봅니다. 다음 주제는 "Hello World는 이제 그만! 변수와 자료형(Data Type) 제대로 알기"입니다. 숫자, 텍스트를 파이썬이 어떻게 다루는지 알아보겠습니다.
도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Python 기초] 1. "엑셀보다 쉽고 강력하다?" 왜 지금 파이썬을 배워야 할까요?

hi.anna — Mon, 6 Apr 2026 08:01:09 +0900

안녕하세요! 여러분의 업무 자동화와 칼퇴를 돕는 하이애나입니다.
"코딩, 전공자만 하는 거 아닌가요?"
"엑셀 함수도 어려운데 프로그래밍을 어떻게 해요?"
이런 걱정은 잠시 접어두셔도 좋습니다. 오늘 소개할 파이썬(Python)은 전 세계에서 "가장 배우기 쉬운 프로그래밍 언어" 1위로 꼽힙니다.
구글, 넷플릭스, NASA, 그리고 수많은 데이터 분석가들이 파이썬을 선택한 이유, 그리고 우리가 왜 지금 이것을 배워야 하는지 그 매력을 알아보겠습니다.

1. 사람이 읽기 쉬운 언어 (Readability)

파이썬의 가장 큰 특징은 "코드 자체가 영어 문장처럼 읽힌다"는 점입니다.
복잡한 기호나 괄호를 최대한 배제하고, 들여쓰기(Indentation)를 통해 문단을 구분합니다.
백문이 불여일견, 코드를 한번 볼까요?

예제 코드: 점수에 따른 합격 여부 판단

score = 85  # 점수 변수 설정

if score >= 60:
    print("축하합니다!")
    print("합격입니다.")
else:
    print("아쉽네요.")
    print("불합격입니다.")

코드 설명:

if score >= 60:: 만약(if) 점수가 60점 이상이면... (마치 영어 문장 같죠?)
들여쓰기: if문 아래에 안쪽으로 들여쓰기 된 부분(print...)이 조건이 맞을 때 실행되는 코드입니다. 별도의 괄호{} 없이도 구조가 한눈에 들어옵니다.
else:: 그게 아니라면(60점 미만이라면)...

프로그래밍을 전혀 모르는 사람도 위 코드를 보면 "아, 60점 넘으면 합격이라고 출력하는구나"라고 바로 이해할 수 있습니다. 이것이 파이썬의 힘입니다.

2. 인터프리터 언어: 쓰면 바로 실행된다!

어떤 언어들은 코드를 다 짜고 나서 컴퓨터가 이해할 수 있게 번역(컴파일)하는 복잡한 과정이 필요합니다. 하지만 파이썬은 통역사(Interpreter)가 있어서, 한 줄 입력하면 바로 한 줄을 실행해 줍니다.
이 덕분에 결과를 바로바로 확인하면서 코드를 수정할 수 있어 초보자가 배우기에 아주 좋습니다.

예제 코드: 즉석 계산기

width = 20
height = 5 * 9

area = width * height
print(area)

실행 결과:

코드 설명:

width와 height라는 상자에 값을 넣고, 둘을 곱해서 area에 넣습니다.
복잡한 설정 없이 그냥 수식만 적으면 계산기처럼 동작합니다.

3. "배터리 포함" (Batteries Included)

파이썬에는 "이미 다 준비되어 있으니 가져다 쓰세요"라는 철학이 있습니다.
날짜 계산, 랜덤 숫자 뽑기, 파일 다루기 등 자주 쓰는 기능들이 표준 라이브러리로 이미 내장되어 있습니다. 우리는 import만 하면 됩니다.

예제 코드: 오늘 점심 메뉴 고르기

import random  # 랜덤 기능을 가져온다

menus = ["김치찌개", "돈까스", "제육볶음", "샐러드", "초밥"]

# 메뉴 리스트 중에서 하나를 무작위로 선택
lunch = random.choice(menus)

print(f"오늘의 점심 메뉴는: {lunch}")

실행 결과 (매번 다름):

오늘의 점심 메뉴는: 제육볶음

코드 설명:

import random: "파이썬아, 나 무작위 기능 좀 쓸게."라고 선언합니다.
random.choice(menus): menus라는 목록에서 하나를 알아서 뽑아줍니다. 복잡한 확률 계산 코드를 짤 필요가 전혀 없습니다.

4. 무엇을 할 수 있나요? (활용 분야)

파이썬을 배우면 단순히 계산만 하는 게 아닙니다. 다음과 같은 엄청난 일들을 할 수 있습니다.

데이터 분석 & 시각화: 엑셀로 처리하기 힘든 100만 건의 데이터를 순식간에 분석하고 그래프를 그립니다.
웹 크롤링: 인터넷에 있는 뉴스 기사, 주식 정보, 최저가 정보를 자동으로 수집합니다.
업무 자동화: 매일 아침마다 보내야 하는 이메일, 엑셀 보고서 작성을 버튼 하나로 끝냅니다.
인공지능(AI): ChatGPT 같은 AI 모델도 파이썬을 기반으로 연구되고 개발됩니다.

마치며

파이썬은 "생각하는 대로 코드를 작성할 수 있는" 도구입니다.
문법이 어렵지 않아서, 여러분이 해결하고 싶은 문제(What)에만 집중할 수 있게 도와줍니다.
"나도 한번 해볼까?"라는 생각이 드셨나요?
그렇다면 이미 절반은 성공입니다.
다음 포스팅에서는 "5분 컷! 파이썬 설치하고 개발 환경(VS Code) 설정하기"를 통해 내 컴퓨터에 파이썬이라는 마법 지팡이를 쥐여드리겠습니다.
도움이 되셨다면 좋아요와 댓글 부탁드립니다!

[Chrome 브라우저] 크롬 캐시 완벽하게 지우는 2가지 방법 (일반 캐시 & DNS 캐시)

hi.anna — Mon, 6 Apr 2026 00:01:10 +0900

크롬 브라우저에서 캐시를 지우는 목적에 따라 두 가지 방법이 있습니다. 웹페이지의 이미지나 레이아웃이 제대로 새로고침되지 않을 때는 일반 캐시를, hosts 파일을 수정했는데도 접속할 IP가 바뀌지 않을 때는 내부 DNS 캐시를 지워야 합니다.

1. 일반 브라우저 캐시 지우기 (단축키 활용)

웹사이트의 업데이트된 내용이 보이지 않거나 화면이 깨질 때 가장 먼저 시도하는 표준적인 방법입니다.

크롬 브라우저를 열고 단축키 Ctrl + Shift + Delete를 누릅니다. (Mac은 Cmd + Shift + Delete)
화면에 '인터넷 사용 기록 삭제' 창이 나타납니다.
상단의 기간을 '전체 기간'으로 선택합니다.
아래 항목 중 '캐시된 이미지 및 파일'에 체크합니다. (로그인 상태를 유지하려면 '쿠키 및 기타 사이트 데이터'는 체크 해제해도 됩니다.)
'데이터 삭제' 버튼을 클릭합니다.

2. 강력한 숨겨진 기능: 크롬 내부 DNS 캐시 지우기

앞서 수정한 hosts 파일 내용이 크롬에서만 유독 적용되지 않는다면, 크롬이 브라우저 내부에 자체적으로 보관하고 있는 DNS(도메인-IP 연결 기록) 캐시를 강제로 비워야 합니다. 일반 설정 메뉴에서는 찾을 수 없는 숨겨진 기능입니다.

크롬 브라우저 주소창에 다음 주소를 복사하여 붙여넣고 Enter를 누릅니다.
chrome://net-internals/#dns
화면 왼쪽 메뉴에서 'DNS'가 선택되어 있는지 확인합니다.
우측 화면에서 'Clear host cache' 버튼을 클릭합니다. (버튼을 눌러도 별도의 팝업이나 완료 메시지가 뜨지 않지만, 즉시 삭제 처리됩니다.)
(선택 사항) 더 확실한 초기화를 위해 주소창에 chrome://net-internals/#sockets를 입력하고 이동한 뒤, 'Flush socket pools' 버튼도 한 번 클릭해 줍니다.
열려있는 모든 크롬 창을 닫고 다시 실행합니다.

[Windows 기초] DNS 캐시 초기화 방법 (hosts 파일 수정 후 적용이 안 될 때)

hi.anna — Sun, 5 Apr 2026 09:59:44 +0900

hosts 파일을 올바르게 수정하고 저장했는데도 웹 브라우저에서 바뀐 IP로 접속되지 않는 경우가 많습니다. 이는 윈도우 운영체제가 이전에 접속했던 기록을 임시로 기억하고 있기 때문입니다.

이때 기존의 기억을 강제로 지우고 수정한 hosts 파일을 즉각 반영하게 만드는 DNS 캐시 초기화 방법을 정리해 드립니다.

1. 왜 수정한 내용이 바로 적용되지 않을까요?

윈도우는 인터넷 접속 속도를 높이기 위해, 한 번 방문했던 웹사이트의 IP 주소를 매번 새로 찾지 않고 컴퓨터 내부에 임시로 저장해 둡니다. 이를 DNS 캐시(Cache)라고 부릅니다.

hosts 파일을 방금 수정했더라도, 윈도우가 "이 사이트 주소는 아까 저장해 둔 캐시에 있어!"라고 판단하여 과거의 IP 주소로 먼저 연결을 시도해 버리기 때문에 변경 사항이 무시되는 것입니다.

2. 해결 방법: 명령어 사용

명령 프롬프트를 이용해 윈도우에 쌓여 있는 기존 DNS 캐시를 깔끔하게 삭제할 수 있습니다.

윈도우 시작(검색) 메뉴를 엽니다.
cmd 또는 명령 프롬프트를 검색하여 클릭합니다. (일반 권한으로 실행해도 무방합니다.)
나타난 검은색 창에 아래 명령어를 입력하고 Enter를 누릅니다.

ipconfig /flushdns

정상적으로 처리되면 창에 다음과 같은 성공 메시지가 나타납니다.

이제 웹 브라우저를 새로고침(F5) 하거나 껐다가 다시 켜서 접속해 보면, 수정한 hosts 파일의 내용이 정상적으로 반영된 것을 확인할 수 있습니다.

3. 그래도 적용이 안 된다면? (브라우저 자체 캐시)

명령 프롬프트에서 초기화를 마쳤는데도 여전히 예전 화면이 나온다면, 크롬(Chrome)이나 엣지(Edge) 같은 웹 브라우저가 자체적으로 가지고 있는 내부 DNS 캐시가 원인일 확률이 매우 높습니다.