🗄️ Ⅱ. 데이터

1) 왜 압축이 필요할까?

데이터를 저장·전송하는 데는 공간과 시간, 그리고 전기가 든다. 전 세계 데이터 센터가 배출하는 이산화탄소량은 2002년 약 7,600만 톤에서 2020년 약 2억 5,900만 톤으로 급증했다 — 우리가 무심코 쓰는 데이터가 실제로 기후 변화에 영향을 준다는 뜻이다. 압축은 이 문제를 줄이는 가장 직접적인 방법이다.

• 저장 공간을 줄인다 — 같은 서버에 더 많은 정보를 담을 수 있다.
• 전송 시간을 줄인다 — 스트리밍·업로드가 빨라진다.
• 보안에도 도움이 된다 — 압축된 데이터는 그대로 봐서는 해독하기 어렵다.
• 비용과 전력을 줄여 환경적으로도 이득이다.

💡 잠깐, 그 전에 — 데이터는 결국 2진수다

압축이든 암호화든, 컴퓨터가 다루는 모든 데이터는 결국 0과 1(2진수)로 저장돼 있다. 다만 2진수는 자릿수가 너무 길어서 사람이 읽기 불편하니, 같은 비트를 3개씩 묶어 8진수로, 4개씩 묶어 16진수로 줄여 쓰기도 한다. 묶는 방법만 다를 뿐 같은 데이터이므로, 10진수로 환산한 값은 셋 다 똑같다 — 아래에서 버튼을 눌러 직접 확인해 보자.

2) 무손실 압축 — 원본을 그대로 복원

0과 1의 나열을 손실 없이 더 짧게 표현했다가, 필요할 때 원본과 똑같이 되돌리는 방식이다. 텍스트 파일, 은행 기록처럼 한 글자도 틀리면 안 되는 데이터에 적합하다.

① 런 길이 부호화 (Run Length Encoding)

같은 문자가 몇 번 반복되는지를 기록해 데이터를 짧게 만드는 방식. 단색이 많은 아이콘·로고(BMP 파일 등)에는 효율적이지만, 색이 다양한 사진에는 잘 맞지 않는다.

② 사전 압축과 허프만 부호화

압축할 데이터: 문자열 AAADDBOOOO(총 10글자). 컴퓨터에서 한 글자를 8비트(1바이트)로 저장한다고 하면, 압축하기 전 원본 크기는 10글자 × 8비트 = 80비트(10바이트)다. 이 80비트를 어디까지 줄일 수 있는지, 쉬운 방법부터 차근차근 따라가 보자.

1️⃣ 가장 단순한 방법 — 사전 압축(등장 순서대로 번호 붙이기)

문자열에 등장하는 문자를 나온 순서대로 A→D→B→O로 정리하고, 모두 똑같은 길이(3비트)의 번호를 매긴다. (3비트면 000~111, 즉 최대 8종류의 문자를 구분할 수 있다.)

문자 10개를 전부 3비트로 바꾸면 10 × 3 = 30비트. 압축비는 80 ÷ 30 ≒ 2.67 (37.5%)이다.

2️⃣ 더 똑똑한 방법 — 허프만 부호화(자주 나올수록 짧게)

허프만 부호화(Huffman coding)의 핵심 아이디어는 단 하나다 — 자주 등장하는 문자에는 짧은 부호를, 드물게 등장하는 문자에는 긴 부호를 준다. 5단계를 하나씩 직접 따라가며 트리를 완성해 보자.

[1단계] 문자별 등장 빈도 세기

빈도가 높은 순서(내림차순)로 미리 정렬해 두었다.

[2단계] 가장 작은 두 값을 하나로 묶는다

지금 가장 작은 두 값은 D(2)와 B(1)이다. 둘을 묶어 합계 3짜리 새 노드를 만들고, 먼저 나열된 쪽(D)에 0, 나중 쪽(B)에 1을 붙인다.

[3단계] 다시 가장 작은 두 값을 찾아 묶는다

이제 후보는 O(4), A(3), 방금 만든 노드(3) — 세 개다. 가장 작은 두 값은 A(3)와 노드(3)인데, 값이 같으면 정렬 순서가 앞선 쪽을 먼저 처리하므로 A와 [D,B]노드를 묶는다. 합계는 6이고, A에 0, [D,B]노드에 1을 붙인다.

[4단계] 마지막 두 값을 묶어 트리를 완성한다

이제 남은 건 O(4)와 방금 만든 노드(6)뿐이다. 이 둘을 묶으면 전체 합계 10인 맨 위(뿌리, root)가 완성된다. 노드(6)에 0, O에 1을 붙인다.

[5단계] 뿌리부터 각 문자까지 경로를 이어붙여 부호 완성

뿌리에서 출발해 그 문자에 도착할 때까지 지나온 0과 1을 순서대로 이어붙이면, 그것이 그 문자의 부호가 된다.

데이터 변환하기 — 최종 압축 결과

문자열 AAADDBOOOO를 완성된 부호표(O=1, A=00, D=010, B=011)에 따라 한 글자씩 바꿔서 이어붙이면 다음과 같다.

원본 80비트가 19비트로 줄었다. 압축비는 80 ÷ 19 ≒ 4.21 (23.8%)이다.

3️⃣ 두 방법 비교 — 왜 허프만이 더 효율적일까?

📌 참고 — 허프만 부호화 뒤에는 클로드 섀넌이 있다
방금 "자주 나오는 문자에는 짧은 부호를, 드물게 나오는 문자에는 긴 부호를 주면 유리하다"는 걸 직접 확인했다. 이 아이디어를 수학적으로 처음 증명한 사람이 클로드 섀넌(Claude Shannon, 1916~2001)이다. '정보이론(Information Theory)의 아버지'로 불리는 미국의 공학자·수학자로, 비트(bit)라는 단위 자체를 세상에 알린 사람이기도 하다.

• 1948년 논문에서 정보량(엔트로피)을 확률로 정의했다 — 예측하기 쉬운(자주 등장하는) 것일수록 정보량이 작다. 허프만 부호화가 자주 나오는 문자에 짧은 부호를 주는 것은 바로 이 원리를 그대로 따른 것이다.
• 1937년 석사 논문에서는 불 대수(참/거짓 논리)를 전기 스위치 회로로 구현할 수 있음을 증명했다 — 오늘날 모든 디지털 회로·컴퓨터가 0과 1로 동작하는 이론적 뿌리다.
• 1949년에는 OTP(일회용 암호)가 이론적으로 절대 뚫리지 않는 "완전 비밀성(perfect secrecy)"을 만족함을 증명했다 — 뒤에 나올 대칭 암호화 단원의 OTP와 연결된다.
• 요즘 많이 쓰는 AI 챗봇 Claude(클로드)도 바로 이 섀넌에게 헌정하는 의미로 붙인 이름이다 — AI 역시 결국 '정보'를 다루는 기술이기 때문이다.

사진: Tekniska museet(스웨덴 국립기술박물관), Wikimedia Commons · CC BY 2.0

3) 손실 압축 — 사람이 눈치채기 힘든 부분만 버린다

이미지·영상·소리처럼 사람의 눈과 귀가 완벽히 구분하지 못하는 영역의 정보는 과감히 버려서 용량을 획기적으로 줄이는 방식이다. 압축 해제한 데이터는 원본과 정확히 같지 않지만, 체감 품질 차이는 크지 않다.

① JPEG — 이미지 압축

사람 눈은 색보다 밝기 차이를 더 잘 인식한다는 성질을 이용해, R·G·B 값을 그대로 저장하지 않고 휘도(밝기)와 색 차이 정보 위주로 압축한다. 이미지를 8×8 픽셀 블록으로 나눠 처리한다.

② MPEG — 영상 압축

영상은 JPEG로 압축한 이미지(프레임)가 여러 장 이어진 것이다. MPEG는 연속된 프레임의 유사성을 이용해, 이전 프레임과 달라진 부분만 저장한다 — 배경이 그대로인 장면일수록 압축 효율이 크게 오른다.

③ 소리의 표본화 · 양자화 · 부호화

아날로그 소리를 표본화 → 양자화 → 부호화 순서로 바꿔 디지털 데이터로 만드는 이 과정 전체를 PCM 변환(Pulse Code Modulation)이라 부른다.

• 표본화: 아날로그 신호를 일정한 시간 간격으로 측정한다.
• 양자화: 측정값을 정해진 단계 중 가장 가까운 값으로 반올림한다 — 이때 실젯값과 차이(양자화 오차)가 생긴다.
• 부호화: 변환된 값을 0과 1의 비트로 표현한다.

예시 — 사람 목소리를 PCM으로 바꾸면?

전화 통화를 예로, 실제 숫자를 따라가며 목소리가 디지털 데이터가 되는 과정을 확인해 보자.

1. 목소리의 주파수 범위 확인 — 사람 음성이 알아듣기에 충분한 핵심 대역은 약 300Hz~3,400Hz(전화 음성 대역)다. 최고 주파수를 대략 4kHz로 본다.
2. 표본화 — 나이퀴스트율 적용 — 4kHz까지 왜곡(앨리어싱) 없이 담으려면 나이퀴스트율(2 × 4kHz = 8kHz) 이상으로 표본화해야 한다. 그래서 유선전화·인터넷전화(VoIP)는 실제로 초당 8,000번(8kHz) 목소리를 측정한다.
3. 양자화 — 측정한 값을 256단계(8비트)로 반올림한다. (국제표준 통화 코덱 G.711의 방식)
4. 부호화 — 표본 하나하나를 8비트 이진수로 표현한다.

④ MP3 — 사람이 못 듣는 소리는 지운다

MP3(MPEG-1 Audio Layer III)는 표본화·양자화·부호화를 거쳐 만들어진 디지털 음원(PCM)을 한 번 더 압축하는 손실 압축 방식이다. 핵심 아이디어는 "사람 귀가 애초에 듣지 못하는 소리는 저장할 필요가 없다"는 심리음향(psychoacoustic) 모델이다.

• 가청 주파수 한계: 사람은 대략 20Hz~20,000Hz의 소리만 들을 수 있다 — 이 범위 밖 정보는 처음부터 버린다.
• 주파수 마스킹(동시 마스킹): 큰 소리 옆에 있는 작은 소리는 묻혀서 안 들린다. 예를 들어 시끄러운 콘서트장에서 옆 사람의 속삭임이 안 들리는 것과 같은 원리다.
• 시간 마스킹: 아주 큰 소리가 난 직후 아주 짧은 순간에는, 원래 들렸을 작은 소리도 잠깐 안 들린다.

MP3는 이렇게 ① 소리를 여러 주파수 대역으로 나누고 ② 심리음향 모델로 어느 대역이 들리는지/안 들리는지 분석해 ③ 잘 들리는 대역엔 비트를 많이, 안 들리는 대역엔 비트를 적게(또는 아예 0을) 할당한 뒤 ④ 남은 값을 양자화·부호화한다. 이 과정을 거치면 원본 CD 음원(약 1,411kbps)을 1/10 수준(128kbps)까지 줄이면서도 사람 귀에는 거의 같은 소리로 들린다.

🐍 실습 — 이미지 압축 비교 (BMP · PNG · GIF · JPG)

구글 코랩(Colab)에서 바로 돌려볼 수 있다. 같은 사진을 네 가지 형식으로 저장해 보고, 해상도는 그대로인데 파일 크기만 달라지는 것을 확인해 보자. 마지막에는 무손실과 손실을 눈이 아니라 코드로 판별해 본다.

내려받은 BMP 이미지(.bmp)를 코랩에 업로드한 뒤, 이미지 변환에 필요한 라이브러리를 불러온다.

# os: 파일 크기 확인용 / PIL(Pillow): 이미지 열기·저장용
import os
from PIL import Image

im = Image.open('flower_BMP.bmp')
print('이미지 확장자', im.format)
print('이미지 해상도', im.size)
print('파일 크기', os.path.getsize('flower_BMP.bmp'), 'Bytes')

# PNG로 저장 후 다시 열어 확인
im.save('flower_PNG.png', 'png')
im2 = Image.open('flower_PNG.png')
print('이미지 확장자', im2.format)
print('이미지 해상도', im2.size)
print('파일 크기', os.path.getsize('flower_PNG.png'), 'Bytes')

# GIF로 저장 후 다시 열어 확인
im.save('flower_GIF.gif', 'gif')
im3 = Image.open('flower_GIF.gif')
print('이미지 확장자', im3.format)
print('이미지 해상도', im3.size)
print('파일 크기', os.path.getsize('flower_GIF.gif'), 'Bytes')

# JPG로 저장 후 다시 열어 확인
im.save('flower_JPG.jpg', 'jpeg')
im4 = Image.open('flower_JPG.jpg')
print('이미지 확장자', im4.format)
print('이미지 해상도', im4.size)
print('파일 크기', os.path.getsize('flower_JPG.jpg'), 'Bytes')

# 코랩에서는 변수 이름만 적어도 이미지가 출력된다
im
im2
im3
im4

"똑같아 보인다"와 "똑같다"는 다르다. 두 이미지의 픽셀을 하나하나 빼서 차이가 0인지 확인하면, 정보를 잃었는지 정확히 알 수 있다.

# ImageChops: 두 이미지를 픽셀 단위로 계산해 주는 도구
from PIL import ImageChops

origin = im.convert('RGB')

for name, file in [('PNG', 'flower_PNG.png'),
                   ('GIF', 'flower_GIF.gif'),
                   ('JPG', 'flower_JPG.jpg')]:
    other = Image.open(file).convert('RGB')
    diff = ImageChops.difference(origin, other)   # 픽셀끼리 뺀 결과
    if diff.getbbox() is None:               # 차이가 전부 0이면 None
        print(name, ': 원본과 완전히 동일 → 무손실')
    else:
        print(name, ': 원본과 다름 → 정보가 사라짐')

말로만 넘어가지 말고 직접 확인해 보자. 색을 미리 256개로 줄여 둔 이미지를 GIF로 저장하면, ①단계에서 버릴 색이 이미 없다. 남는 것은 ②압축뿐이다. 이때도 원본과 달라질까?

# 색을 미리 256개로 줄인 이미지를 만든다 (여기서 색을 버림)
small = im.convert('RGB').quantize(colors=256).convert('RGB')
small.save('small.bmp')          # 이것을 '원본'으로 삼는다

# 이미 256색이므로, GIF로 저장해도 더 버릴 색이 없다
small.save('small.gif', 'gif')

print('BMP', os.path.getsize('small.bmp'), '->  GIF', os.path.getsize('small.gif'), 'Bytes')

diff = ImageChops.difference(small, Image.open('small.gif').convert('RGB'))
print('원본과 동일한가:', diff.getbbox() is None)

사진을 고치고 저장하기를 반복하는 일은 흔하다. 형식마다 결과가 다른데, 이 차이가 실제로는 가장 중요하다.

# GIF로 두 번 더 저장해 본다
g1 = Image.open('flower_GIF.gif').convert('RGB')
g1.save('g2.gif', 'gif')
g2 = Image.open('g2.gif').convert('RGB')
g2.save('g3.gif', 'gif')
g3 = Image.open('g3.gif').convert('RGB')
print('GIF 2번 더 저장 후 그대로인가:', ImageChops.difference(g1, g3).getbbox() is None)

# JPG로 두 번 더 저장해 본다
j1 = Image.open('flower_JPG.jpg').convert('RGB')
j1.save('j2.jpg', 'jpeg')
j2 = Image.open('j2.jpg').convert('RGB')
j2.save('j3.jpg', 'jpeg')
j3 = Image.open('j3.jpg').convert('RGB')
print('JPG 2번 더 저장 후 그대로인가:', ImageChops.difference(j1, j3).getbbox() is None)

🐍 실습 — 허프만 부호화 직접 만들기

앞에서 손으로 만든 허프만 트리를 이번엔 파이썬으로 만들어 본다. 구글 코랩(Colab)에서 그대로 붙여 넣어 실행하면 된다. 설치할 라이브러리는 없다.

압축할 문자열은 앞에서 쓴 AAADDBOOOO 그대로다.

# heapq: 가장 작은 값을 빠르게 꺼내는 도구 (트리를 아래에서부터 쌓을 때 사용)
import heapq
from collections import Counter

data = 'AAADDBOOOO'

# 문자별 등장 횟수
freq = Counter(data)
print('빈도:', dict(freq))

가장 드문 문자 두 개를 꺼내 하나로 묶는 일을, 노드가 하나만 남을 때까지 반복한다. 손으로 D와 B를 먼저 묶었던 것과 같은 과정이다.

# [빈도, 순번, 문자, 왼쪽자식, 오른쪽자식]  — 순번은 빈도가 같을 때 순서를 정해 준다
heap = [[w, i, ch, None, None] for i, (ch, w) in enumerate(sorted(freq.items()))]
heapq.heapify(heap)

counter = len(heap)
while len(heap) > 1:
    left = heapq.heappop(heap)      # 가장 드문 것
    right = heapq.heappop(heap)     # 그 다음으로 드문 것
    # 둘을 묶어 부모 노드를 만든다 (빈도는 두 개의 합)
    heapq.heappush(heap, [left[0] + right[0], counter, None, left, right])
    counter += 1

root = heap[0]   # 마지막에 남은 하나가 뿌리(root)

뿌리에서 각 문자까지 내려가며 지나온 가지의 0·1을 이어 붙이면 그 문자의 부호가 된다.

def walk(node, prefix=''):
    if node[2] is not None:      # 문자가 들어 있으면 = 가지 끝(리프)
        codes[node[2]] = prefix or '0'
        return
    walk(node[3], prefix + '0')   # 왼쪽으로 가면 0
    walk(node[4], prefix + '1')   # 오른쪽으로 가면 1

codes = {}
walk(root)

for ch in sorted(codes, key=lambda c: (len(codes[c]), c)):
    print(f'{ch} ({freq[ch]}회) -> {codes[ch]} ({len(codes[ch])}비트)')

encoded = ''.join(codes[c] for c in data)

print('인코딩:', encoded)
print('원본 :', len(data) * 8, '비트')   # 한 글자 8비트로 저장했다면
print('압축 :', len(encoded), '비트')
print('압축비: %.2f' % (len(data) * 8 / len(encoded)))

압축한 비트열을 다시 원래 문자열로 되돌려, 한 글자도 잃지 않았는지 확인한다.

out = []
node = root
for b in encoded:
    node = node[3] if b == '0' else node[4]   # 0이면 왼쪽, 1이면 오른쪽
    if node[2] is not None:                    # 가지 끝에 닿으면 한 글자 완성
        out.append(node[2])
        node = root                              # 다시 뿌리로 돌아가 다음 글자

print('복호화:', ''.join(out))
print('원본과 일치:', ''.join(out) == data)

1) 암호화의 기본 개념

• 암호화(encryption): 원본 데이터(평문)를 읽기 어려운 형태(암호문)로 바꾸는 과정.
• 복호화(decryption): 암호문을 다시 평문으로 되돌리는 과정.
• 암호키(encryption key): 암호화·복호화에 필요한 규칙.

2) 치환형 암호화 — 카이사르 암호

평문의 각 문자를 약속된 다른 문자로 치환하는 방법이다. 로마 황제 율리우스 카이사르가 전쟁 중 군사 정보를 전달하기 위해 고안했다고 전해져 카이사르 암호라 불린다. 알파벳을 정해진 칸수(키)만큼 밀어서 치환하고, 복호화할 때는 반대 방향으로 밀어 되돌린다.

고대에는 문자의 순서를 재배치하는 전치형 암호화도 쓰였다. 그리스 군사들이 사용한 스키테일(scytale)이 대표적인 예로, 정해진 지름의 막대에 종이를 감아 글을 쓰면 풀었을 때 문자가 뒤섞여 보인다 — 같은 지름의 막대를 가진 사람만 다시 감아 해독할 수 있다.

실제 스키테일 복제품 — 막대에 가죽 끈을 나선으로 감고 글자를 새겨 넣었다. 풀면 글자 순서가 뒤섞이고, 같은 굵기의 막대에 다시 감아야만 원래 순서로 읽힌다.

스키테일 암호 — 문자를 바꾸지 않고 순서만 재배치하는 전치형 암호화

3) 지금 우리가 쓰는 암호화 — 단방향 / 대칭 / 비대칭

① 단방향 암호화

암호화는 되지만 복호화는 불가능한 방식. 같은 평문은 항상 같은 암호문(해시값)을 만들고, 한 글자만 달라져도 완전히 다른 결과가 나온다. 그래서 원문을 노출하지 않고도 일치 여부만 비교할 수 있어 비밀번호 저장, 파일 위·변조 확인, QR코드 신원 인증 등에 쓰인다. 대표 알고리즘은 SHA-256.

② 대칭 암호화 (비밀키)

송신자와 수신자가 같은 키로 암호화·복호화하는 양방향 방식. 속도가 빠르지만, 사용자마다 키를 개별적으로 안전하게 전달해야 하는 키 배송 문제가 있다 — 사용자가 10만 명이면 키도 10만 개를 관리해야 한다. 인터넷·모바일 뱅킹의 OTP와 보안카드가 대표 사례다.

③ 비대칭 암호화 (공개키 · 개인키)

대칭 암호화의 키 배송 문제를 해결하기 위해 등장했다. 송수신자가 서로 다른 키 쌍(공개키·개인키)을 가지며, 한쪽 키로 암호화한 것은 반드시 짝을 이루는 다른 키로만 풀 수 있다. 처리 속도는 느리지만 키를 안전하게 교환할 필요가 없다. 전자 서명, 공동(공인) 인증서가 대표 사례다.

그럼 이 두 개의 키를 실제로 누가, 어떻게 나눠 갖는 걸까? 우리가 매일 쓰는 은행 거래로 살펴보자.

Ⓐ 이체 내용을 비밀로 보내기 — 기밀성

누가 중간에 가로채도 내용을 못 읽게 하는 것이 목적. 받는 쪽(은행)의 키 쌍을 쓴다.

1. 고객이 은행이 공개해 둔 은행 공개키를 받아온다. (공개된 것이라 누구나 가질 수 있다)
2. 그 은행 공개키로 이체 내용을 암호화한다 → 알아볼 수 없는 암호문이 된다.
3. 암호문을 은행에 전송한다. 중간에 누가 훔쳐봐도 읽지 못한다.
4. 은행은 자기만 가진 은행 개인키로 복호화해 내용을 읽는다.

Ⓑ 내가 보낸 게 맞음을 증명하기 — 인증·전자 서명

"진짜 본인이 보냈는지"를 증명하는 것이 목적. 보내는 쪽(고객)의 키 쌍을 쓴다.

1. 고객이 인증서 비밀번호를 입력해, 내 기기에 잠겨 있던 고객 개인키를 꺼낸다.
2. 그 고객 개인키로 이체 내용에 전자 서명을 만든다. 개인키 자체는 기기 밖으로 나가지 않는다.
3. 이체 내용과 전자 서명을 함께 은행에 전송한다.
4. 은행은 인증서에 담긴 고객 공개키로 서명을 검증한다.
5. 정상적으로 검증되면 인증(개인키를 가진 본인이 맞다)과 무결성(금액·계좌가 바뀌지 않았다)이 동시에 증명된다 → 이체 실행.

공동(공인) 인증서는 어떻게 발급될까?

"은행에서 인증서를 받는다"고 흔히 말하지만, 실제로는 은행이 내 키를 만들어 주는 것이 아니다. 키 쌍은 내 기기 안에서 만들어지고, 인증기관은 그중 공개키에만 도장을 찍어 준다.

공개키와 개인키 사이에 수학적 관계가 있을까?

있다. 두 키는 남남이 아니라 한 쌍으로 태어난 짝꿍이다. 그런데 이상하다 — 관계가 있다면 공개키를 보고 개인키를 알아낼 수 있어야 하지 않을까? 바로 그 지점을 막아 둔 것이 비대칭 암호의 핵심이다. 세 단계로 나눠 보자.

1단계 · 한쪽으로만 쉬운 계산이 있다

다음 두 문제를 직접 풀어 보자. 계산기 없이 걸리는 시간이 완전히 다르다.

문제 A.  61 × 53 = ?            → 몇 초면 된다 (3233)
문제 B.  3233 = ? × ?           → 2, 3, 5, 7, 11 … 하나씩 나눠 봐야 한다

둘은 같은 사실을 묻는데 난이도가 다르다. 곱하는 방향은 쉽고, 되돌리는 방향은 어렵다. 이렇게 한쪽으로만 쉬운 계산을 일방향 함수라고 부른다. 공개키는 이미 곱해 놓은 결과(3233)를, 개인키는 그 재료(61과 53)를 아는 사람만 만들 수 있다.

2단계 · 암호는 '시계 산수'를 쓴다

시계를 떠올려 보자. 지금이 10시인데 5시간이 지나면 15시가 아니라 3시다. 12를 넘으면 다시 처음으로 돌아오기 때문이다. 이런 계산을 나머지 연산이라 하고 mod(모드)라고 쓴다.

10 + 5 = 15  →  15 mod 12 = 3        (12시간짜리 시계)

암호에서는 3233짜리 시계를 쓴다고 생각하면 된다. 숫자를 아무리 크게 곱해도 결과는 항상 0~3232 사이 어딘가로 돌아온다. 밖에서 보면 값이 마구 튀어서 원래 숫자를 짐작할 수 없다.

3단계 · 두 키는 서로를 되돌리는 짝이다

이제 키를 실제로 만들어 보자. 순서대로 따라가면 숫자가 어디서 나오는지 보인다.

① 소수 두 개를 고른다        p = 61,  q = 53     ← 나만 아는 재료
② 시계 크기를 만든다          n = 61 × 53 = 3233   ← 공개해도 되는 값
③ 시계의 '한 바퀴'를 구한다    (61-1) × (53-1) = 60 × 52 = 3120
④ 잠금 횟수를 고른다          e = 17               ← 내가 정하는 값
⑤ 풀림 횟수를 계산한다        17 × d 를 3120으로 나눠 나머지가 1이 되는 d
                             d = 2753             (17 × 2753 = 46801 = 3120 × 15 + 1)

17은 우리가 고른 숫자고, 2753은 계산해서 나온 숫자다. ④에서 e를 19나 23으로 골랐다면 d도 다른 값이 됐을 것이다. 그러니 공개키 e는 "17번 곱해서 잠그기", 개인키 d는 "2753번 곱해서 풀기"인 셈이고, 17번 잠그고 2753번 풀면 정확히 제자리로 돌아온다. ⑤를 그렇게 되도록 맞춰 놓았기 때문이다.

여기가 핵심이다. ⑤에서 d를 구하려면 ③의 3120이 필요하고, 3120을 구하려면 ①의 61과 53을 알아야 한다. 그런데 밖으로 공개되는 건 3233과 17뿐이다. 공개키만 아는 사람은 3233을 61과 53으로 되돌릴 수 없으니 3120도, d도 구할 수 없다 — 관계는 분명히 있지만 따라갈 수가 없는 것이다.

n = p × q                     (아주 큰 소수 두 개를 곱한다)
φ(n) = (p-1) × (q-1)
e × d ≡ 1  (mod φ(n))         ← 개인키 d는 공개키 e의 "역수"

  공개키 = (n, e)              암호화:  c = me mod n
  개인키 = (n, d)              복호화:  m = cd mod n

앞에서 쓴 61과 53으로 실제로 맞는지 확인해 보자. 잠근 뒤 풀면 원래 숫자로 정확히 돌아온다.

p = 61,  q = 53   →   n = 3233,   φ(n) = 60 × 52 = 3120
e = 17            →   d = 2753     (17 × 2753 = 46801 = 1 + 15 × 3120 ✓)

  평문 65  --암호화-->  6517 mod 3233   = 2790
  암호문 2790 --복호화-->  27902753 mod 3233 = 65   ✓ 원문 복원

1) 빅데이터의 3V

빅데이터는 기존 방식으로는 처리하기 어려운 막대한 양의 데이터셋(또는 그 처리 기술)을 말하며, 세 가지 특징 3V로 요약된다.

• 양(Volume): 데이터 집합의 크기가 테라바이트(TB, 10¹²byte)에서 페타바이트(PB, 10¹⁵byte)에 이른다.
• 속도(Velocity): 센서·인터넷·모바일 등 다양한 곳에서 빠르게 생성·수집된다.
• 다양성(Variety): 데이터베이스 같은 정형 데이터부터 이메일·SNS 게시물 같은 비정형 데이터까지 형태가 다양하다.

2) 내게 필요한 데이터는 어떻게 모을까?

1) 데이터 전처리 — 분석 전 손질하기

데이터 전처리는 원시 데이터를 원하는 형식으로 다듬는 작업이다. 적절히 전처리하면 분석과 기계학습의 정확도·신뢰도가 올라간다.

결측치는 어떻게 생길까 — 서울 기온이 3년 넘게 비어 있다

기상청 기상자료개방포털에서 서울(지점 108)의 일별 기온을 받아 그려 보면, 그래프 한가운데가 뻥 뚫려 있다. 관측 장비가 고장 난 것도, 자료를 잃어버린 것도 아니다. 6·25 전쟁으로 관측 자체가 멈췄던 기간이다.

결측 구간의 앞뒤 실제 기록은 이렇다. 1950년 8월 31일에 끊기고, 1,187일(약 3년 3개월) 뒤인 1953년 12월 1일에 다시 시작된다.

결측치는 한 가지 모습으로 오지 않는다. 같은 1,187일인데도 자료를 열어 보면 두 가지가 섞여 있다.

그래서 "빈칸을 찾아라"만으로는 결측치를 다 못 찾는다. 날짜를 1일 간격으로 쭉 만들어 놓고 있어야 할 날과 실제 있는 날을 맞춰 봐야 빠진 날이 드러난다.

2) 데이터 시각화 — 숫자를 그림으로

데이터 시각화는 수치·통계 데이터를 그래픽으로 표현해 분석 결과를 직관적으로 이해하기 쉽게 만드는 기술이다. 데이터 형태에 따라 알맞은 시각화 방법이 다르다.

정형 데이터(수치·문자·날짜·지리)는 표·그래프로, 비정형 데이터(이미지·텍스트·소리)는 이미지 뷰어·워드 클라우드처럼 형태에 맞는 방법으로 시각화한다.

3) 전체 예시 — 기상청 데이터로 ‘내 생일의 기온’ 그리기

지금까지 나눠서 배운 수집 → 전처리 → 시각화를 하나의 프로그램으로 이어 본다. 120년 가까운 서울 기온 기록에서 내 생일 하루만 뽑아, 그날의 기온이 해마다 어떻게 달라졌는지 그려 볼 것이다.

① 한글이 깨지지 않게

matplotlib은 기본 상태에서 한글을 □로 그린다. 한글 폰트를 붙여 주는 도구를 먼저 설치한다.

# 한글 시각화 도구 설치 (matplotlib은 기본 상태로는 한글이 □로 깨진다)
!pip install koreanize-matplotlib

import koreanize_matplotlib
import matplotlib.pyplot as plt
import csv

② 분석할 자료 가져오기

# 분석할 자료를 코랩으로 바로 내려받는다 (기상청에서 받은 파일 그대로)
!wget -q -O weather.csv https://edu.sunnylab.co.kr/data/weather.csv
!ls -lh weather.csv

from google.colab import drive
drive.mount('/content/drive', force_remount=True)
import os
os.chdir('/content/drive/MyDrive/data/')     # weather.csv 를 올려 둔 폴더로 이동

③ 파일부터 열어 보기

코드를 쓰기 전에 파일이 어떻게 생겼는지 먼저 본다. 첫 줄은 제목 줄이고, 둘째 줄부터 하루에 한 줄씩이다.

날짜,지점,평균기온(℃),최저기온(℃),최고기온(℃)
"→1907-10-01",108,13.5,7.9,20.7
"→1907-10-02",108,16.2,7.9,22
    ⋮
"→1950-08-31",108,25.4,20.1,32.5
"→1950-09-01",108,,,          ← 값이 비어 있다 (결측치)
    ⋮
"→2026-09-05",108,24,19.1,29.4

→ 는 눈에 보이지 않는 탭 문자를 표시한 것

두 가지를 미리 알아 두면 코드가 쉬워진다.

• 날짜 앞에 보이지 않는 탭 문자가 붙어 있다 → 쓸 때 .strip()으로 떼어 낸다.
• 기온 자리가 통째로 비어 있는 날이 759일 있다 → 앞에서 본 그 결측 구간이다.

④ 가장 더웠던 날 찾기 — 결측치를 바꿔서 처리

def 최고온도():
    f = open('weather.csv', mode='r', encoding='cp949')
    data = csv.reader(f, delimiter=',')
    max_date = ''
    max_temp = -999
    header = next(data)   # 첫 줄은 제목 줄이므로 건너뛴다
    print(header)
    for row in data:
        if row[-1] == '':     # ← 결측치 처리 ①  값이 비었으면
            row[-1] = -999    #    '있을 수 없는 값'으로 바꿔 둔다
        row[-1] = float(row[-1])
        if row[-1] > max_temp:
            max_date = row[0].strip()
            max_temp = row[-1]
    print("최고기온일", max_date)
    print("최고온도", max_temp)
    f.close()

row[-1]은 맨 뒤 열(최고기온), row[0]은 날짜다. 뒤에서부터 세면 가운데에 열이 하나 늘어도 코드를 고칠 필요가 없다.

⑤ 내 생일 기온만 모으기 — 결측치를 건너뛰어 처리

def 생일날씨조회():
    f = open('weather.csv', mode='r', encoding='cp949')
    data = csv.reader(f)
    next(data)
    high, low, year = [], [], []
    birth = input('생일을 입력하세요(2000-01-02)')
    if len(birth) < 1:
        birth = "2000-01-03"                 # 그냥 Enter를 누르면 1월 3일로
    [y, m, d] = birth.split("-")
    for row in data:
        if row[-1] != '' and row[-2] != '':  # ← 결측치 처리 ②  최고·최저가 둘 다 있는 날만
            날짜 = row[0].strip()
            if m == 날짜.split("-")[1] and d == 날짜.split("-")[-1]:
                high.append(float(row[-1]))
                low.append(float(row[-2]))
                year.append(날짜.split("-")[0])
    f.close()
    return high, low, year


def show_Plot(high, low, year):
    plt.figure(figsize=(30, 3))
    plt.plot(high, "r", marker='.', label='최고 온도')
    plt.plot(low, 'b', marker='s', label='최저 온도')
    plt.xlabel("년도")
    plt.ylabel("온도")
    x = range(0, len(year), 5)               # 5개마다 눈금 하나
    plt.xticks(x, year[::5], rotation=45, fontsize=14)
    plt.legend()
    plt.title('내 생일의 기온 변화 그래프')
    plt.show()

여기서는 최고·최저가 둘 다 있는 날만 골라 담는다. 하나라도 비면 그 해는 아예 빼는 것이다. ④와 ⑤는 같은 결측치를 서로 다른 방법으로 다룬다.

⑥ 실행

if __name__ == '__main__':
    최고온도()
    high, low, year = 생일날씨조회()
    show_Plot(high, low, year)

실행 결과

['날짜', '지점', '평균기온(℃)', '최저기온(℃)', '최고기온(℃)']
최고기온일 2018-08-01
최고온도 39.6
생일을 입력하세요(2000-01-02)

▲ 1월 3일의 최고(빨강)·최저(파랑) 기온 — 코랩 실행 결과 · 가로로 밀어서 연도 눈금을 확인해 보자

🎯 이 단원의 핵심 질문

• 데이터를 효율적으로 관리하고 보호하는 방법은? → 압축과 암호화
• 빅데이터를 목적에 맞게 처리하여 분석하는 방법은? → 수집 → 전처리 → 시각화

🧭 진로 이야기 — 데이터 마이너

광산에서 광물을 캐내는 광부처럼, 방대한 데이터에서 의미 있는 정보를 찾아내는 직업이 데이터 마이너(data miner)다. 쇼핑몰 구매 기록, 검색 기록, SNS 데이터 같은 빅데이터를 분석해 미래에 도움이 될 정보를 만든다. 통계·프로그래밍에 대한 이해와, 세상을 바라보는 안목(도메인 지식)이 함께 필요한 직업이다.

📋 한눈에 정리

✔️ 역량 체크