[파이썬 기초] 딕셔너리, 셋, 불리언

딕셔너리 (dict)

딕셔너리는 키(key)와 값(value)의 쌍으로 데이터를 저장하는 자료형입니다.

키를 통해 값에 빠르게 접근할 수 있으며, 순서가 있는 가변 자료형입니다.

sample_info = {
    "id": "sample_01",
    "species": "Homo sapiens",
    "read_count": 15000000,
    "paired": True
}
empty = {}    # 빈 딕셔너리

키는 문자열, 숫자, 튜플처럼 불변 자료형만 사용할 수 있습니다. 리스트는 키로 사용할 수 없습니다.

값 접근 및 수정

# 값 접근
print(sample_info["id"])                       # sample_01
print(sample_info.get("tissue"))               # None (키 없을 때)
print(sample_info.get("tissue", "unknown"))    # unknown (기본값 지정)

# 값 수정 및 추가
sample_info["read_count"] = 20000000    # 기존 키 값 수정
sample_info["coverage"] = 30.5         # 새 키 추가

 

[]로 존재하지 않는 키에 접근하면 KeyError가 발생합니다. 키 존재 여부가 불확실할 때는 .get()을 사용하는 것이 안전합니다.

키와 값 확인

sample_info = {"id": "sample_01", "species": "Homo sapiens", "coverage": 30.5}

print("id" in sample_info)             # True (키 존재 여부 확인)
print(sample_info.keys())              # dict_keys(['id', 'species', 'coverage'])
print(sample_info.values())            # dict_values(['sample_01', 'Homo sapiens', 30.5])
print(sample_info.items())             # dict_items([('id', 'sample_01'), ...])

삭제

del sample_info["coverage"]            # 특정 키 삭제
popped = sample_info.pop("species")    # 특정 키 삭제 후 값 반환
sample_info.clear()                    # 전체 비우기

자주 쓰이는 패턴

딕셔너리 순회

gene_expression = {"BRCA1": 12.5, "TP53": 8.3, "EGFR": 21.0}

for gene, expr in gene_expression.items():
    print(f"{gene}: {expr}")

# 키만 순회
for gene in gene_expression:
    print(gene)

딕셔너리 컴프리헨션

# 발현량이 10 이상인 유전자만 추출
high_expr = {gene: val for gene, val in gene_expression.items() if val >= 10}
# {'BRCA1': 12.5, 'EGFR': 21.0}

# 리스트로 딕셔너리 생성
samples = ["sample_01", "sample_02", "sample_03"]
sample_dict = {s: i for i, s in enumerate(samples)}
# {'sample_01': 0, 'sample_02': 1, 'sample_03': 2}

setdefault와 defaultdict

딕셔너리에 키가 없을 때 기본값을 설정하면서 값을 추가하는 패턴입니다.

# setdefault: 키가 없을 때만 기본값 설정
gene_count = {}
gene_count.setdefault("TP53", 0)
gene_count["TP53"] += 1

# defaultdict: 키가 없을 때 자동으로 기본값 생성
from collections import defaultdict

gene_samples = defaultdict(list)
gene_samples["BRCA1"].append("sample_01")
gene_samples["BRCA1"].append("sample_02")
gene_samples["TP53"].append("sample_01")
# {'BRCA1': ['sample_01', 'sample_02'], 'TP53': ['sample_01']}

딕셔너리 병합

info_a = {"id": "sample_01", "species": "Homo sapiens"}
info_b = {"coverage": 30.5, "paired": True}

# 파이썬 3.9 이상
merged = info_a | info_b

# 파이썬 3.8 이하
merged = {**info_a, **info_b}

---

셋 (set)

셋은 중복 없는 값의 집합입니다.
순서가 없으며 가변 자료형입니다. 중괄호({})로 생성하지만, 빈 셋은 set()으로 생성해야 합니다({}는 빈 딕셔너리).

genes_a = {"BRCA1", "TP53", "EGFR", "TP53"}    # 중복 자동 제거
print(genes_a)    # {'BRCA1', 'TP53', 'EGFR'}

empty_set = set()    # 빈 셋

요소 추가 및 삭제

genes = {"BRCA1", "TP53"}

genes.add("EGFR")              # 요소 추가
genes.discard("BRCA1")        # 요소 삭제 (없어도 오류 없음)
genes.remove("TP53")          # 요소 삭제 (없으면 KeyError)

.remove()는 존재하지 않는 값을 삭제하려 할 때 KeyError가 발생합니다. 존재 여부가 불확실하면 .discard()를 사용하는 것이 안전합니다.

집합 연산

genes_a = {"BRCA1", "TP53", "EGFR"}
genes_b = {"TP53", "KRAS", "EGFR"}

print(genes_a & genes_b)     # 교집합: {'TP53', 'EGFR'}
print(genes_a | genes_b)     # 합집합: {'BRCA1', 'TP53', 'EGFR', 'KRAS'}
print(genes_a - genes_b)     # 차집합: {'BRCA1'} (a에만 있는 것)
print(genes_a ^ genes_b)     # 대칭 차집합: {'BRCA1', 'KRAS'} (둘 중 하나에만 있는 것)

# 부분집합 확인
print({"TP53"} <= genes_a)   # True (부분집합)
print(genes_a >= {"TP53"})   # True (상위집합)

메서드로도 같은 연산이 가능합니다.

genes_a.intersection(genes_b)    # 교집합 (&)
genes_a.union(genes_b)           # 합집합 (|)
genes_a.difference(genes_b)      # 차집합 (-)
genes_a.issubset(genes_b)        # 부분집합 여부

중복 제거에 활용

셋의 가장 실용적인 용도 중 하나는 리스트의 중복 제거입니다.

gene_list = ["TP53", "EGFR", "TP53", "BRCA1", "EGFR", "KRAS"]
unique_genes = list(set(gene_list))
print(len(unique_genes))    # 4

단, 셋은 순서를 보장하지 않으므로 원래 순서를 유지해야 한다면 다음 방법을 사용합니다.

seen = set()
unique_ordered = []
for gene in gene_list:
    if gene not in seen:
        seen.add(gene)
        unique_ordered.append(gene)

---

불리언 (bool)

불리언은 True와 False 두 가지 값만 가집니다. 조건문, 비교 연산의 결과로 자주 등장합니다.

비교 연산자

print(10 > 5)       # True
print(10 == 10)     # True
print(10 != 5)      # True
print(10 >= 10)     # True
print(3 < 1)        # False

논리 연산자

x = 15

print(x > 10 and x < 20)    # True (둘 다 참)
print(x < 10 or x > 20)     # False (둘 다 거짓)
print(not x > 10)            # False (반전)

and는 두 조건이 모두 참일 때, or는 하나라도 참일 때 True를 반환합니다. 파이썬의 and와 or는 단락 평가(short-circuit evaluation)를 합니다. and는 앞의 조건이 False면 뒤를 평가하지 않고, or는 앞의 조건이 True면 뒤를 평가하지 않습니다.

참/거짓으로 평가되는 값

파이썬에서 False로 평가되는 값들입니다.

bool(0)         # False
bool(0.0)       # False
bool("")        # False
bool([])        # False
bool({})        # False
bool(set())     # False
bool(None)      # False

위를 제외한 대부분의 값은 True로 평가됩니다. 이를 활용하면 조건문을 간결하게 작성할 수 있습니다.

gene_list = []

# 장황한 방식
if len(gene_list) == 0:
    print("비어 있음")

# 간결한 방식
if not gene_list:
    print("비어 있음")

bool은 int의 서브클래스

파이썬에서 bool은 int의 서브클래스입니다. True는 1, False는 0으로 처리됩니다.

print(True + True)      # 2
print(True * 5)         # 5
print(False + 10)       # 10

# 조건에 맞는 항목 수 세기
values = [3, 7, 1, 9, 4, 6]
count = sum(v > 5 for v in values)    # 5보다 큰 값의 개수
print(count)    # 3

sum(v > 5 for v in values) 패턴은 조건에 맞는 항목의 수를 셀 때 자주 사용합니다. 각 비교 결과가 True(1) 또는 False(0)로 처리되어 합산됩니다.

---

정리표

자료형	특징	주요 용도
dict	키-값 쌍, 가변, 순서 유지 (3.7+)	구조화된 데이터 저장, 빠른 키 조회
set	중복 없음, 가변, 순서 없음	중복 제거, 집합 연산
bool	True/False, int 서브클래스	조건 판단, 항목 수 세기