• 1회차 | 처음 문제 풀이 → 점수 : (19/20)
  • 틀린 문제 : 19번
• 2회차 | 문제 재풀이 → 점수 : (20/20)
  • 틀린 문제 : x
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

📌 2020년 2회차

• 1회차 | 처음 문제 풀이 → 점수 :(16/20)
  • 틀린 문제 :2번, 6번, 11번, 15번
• 2회차 | 문제 재풀이 → 점수 :(19/20)
  • 틀린 문제 : 12번
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

📌 2020년 3회차

• 1회차 | 처음 문제 풀이 → 점수 : (12/20)
  • 틀린 문제 :3번, 7번, 8번, 9번, 10번, 15번, 17번, 20번
• 2회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

📌 2020년 4회차

• 1회차 | 처음 문제 풀이 → 점수 :(14/20)
  • 틀린 문제 :3번, 9번, 10번, 11번, 16번, 19번
• 2회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

📌 2021년 1회차

• 1회차 | 처음 문제 풀이 → 점수 : (10/20)
  • 틀린 문제 : 2, 3, 4, 8, 10, 12, 14, 15, 18, 19번
• 2회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

📌 2021년 2회차

• 1회차 | 처음 문제 풀이 → 점수 : (14/20)
  • 틀린 문제 : 6, 10, 11, 12, 13, 17번
• 2회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

📌 2021년 3회차

• 1회차 | 처음 문제 풀이 → 점수 : (11/20)
  • 틀린 문제 : 1, 2, 5, 6, 7, 8, 11, 13, 15
• 2회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

📌 2022년 1회차

• 1회차 | 처음 문제 풀이 → 점수 :
  • 틀린 문제 :
• 2회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

📌 2022년 2회차

• 1회차 | 처음 문제 풀이 → 점수 :
  • 틀린 문제 :
• 2회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

📌 2022년 3회차

• 1회차 | 처음 문제 풀이 → 점수 :
  • 틀린 문제 :
• 2회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :
• 3회차 | 문제 재풀이 → 점수 :
  • 틀린 문제 :

2026년 목표

• 클라우드 환경 운영 경험(상세 내용은 추후 작성)
• 보안관제 자동화 경험
• 블로그 꾸준히 작성
• 자격증 : 정보처리기사(9월 시작), 정보보안기사, AWS-SAA,/// CISA 및 CISSP(정보 보안 관련 경력 5년 이상 필요 (4년 경력+보안 관련 학위 가능))
• 개발 공부
• 영어 공부
• 운동
• 리팩토링 과정 복습 및 벨로그에 새롭게 작성
• 클라우드 보안 복습 및 벨로그에 작성 <내년 예정 - 석사 과정>

📅 공부 순서 - (Version 10월)

1. 파이썬(점프 투 파이썬) 완강했음 - 지속적인 복습
2. 정보처리기사 실기 - 10월 25일에 시험있음 합격 목표
3. 모의해킹(노말틱 강의) - 10월 말까지 완료 목표
4. 영어 - 11월부터 시작!
5. 혼자공부하는 네트워크(인프런) 완강했음 - 지속적인 복습
6. 리펙토링 과정 복습 시작(실습 및 블로그 재작성)
7. Docker(인프런_devsecops) 강의(모의해킹 끝나고 시작)
8. AWS 보안 가이드(인프런 강의) - (Docker 인프런 끝나고 시작)
9. JAVA - (파이썬 어느 정도 할 줄 알때 시작) → 1 + 2 + 3 + 5 → 1 + 4 + 6 + 7

📅 금주 목표 - (09/28(월)~10/04(일))

• 파이썬(점프 투 파이썬)
  • Youtube 강의 + Ebook 참고
  • 목표 : 점프 투 파이썬 학습 계속 진행 및 진도율 향상
• 정보처리기사 실기
  • 목표 : 2020년도 기출문제 2회차 풀이
  • 범위 : 1회차 ~ 4회차
  • 목표 : 2021년도 기출문제 1회차 풀이
  • 범위 : 1회차 ~ 3회차
  • 목표 : 2022년도 기출문제 1회차 풀이
  • 범위 : 1회차 ~ 3회차
• 모의해킹
  • 목표 : Day 1 ~ Day 2 완료
  • 범위 : 1주차 ~ 2주차

📅 오늘의 목표 : 완료 OR 미완료 OR 진행중

• 모의해킹(노말틱 강의)
  • 1주차 ~ 하는데 까지 + 블로그 정리
• 파이썬(nmap 기능 구현해보기)DAY-3 + 블로그 정리
• household account 작성(23:50분에 작성)
• 정보처리기사 DAY3(2020년도 2회차 문제풀이 및 복습) + 2022년도 1회차 문제풀이
• 방청소
• 분리수거
• 혼자공부하는 네트워크 복습 DAY3
• 파이썬 복습 DAY1
• 빨래(Laundry) 개기

💻 오늘(완료) 한 일

• 분리수거

학습 범위: 네트워크 DAY 1 ~ DAY 11
복습 방식: 20문제 풀이 및 해설
학습 내용: HTTP, TCP/UDP, DNS, ARP, 서브넷, Wireshark, 이중화, 로드 밸런싱, 프록시, TLS, BGP

Q1. HTTP의 Stateless와 로그인 상태 유지

문제: HTTP는 Stateless 프로토콜인데, 웹사이트에서 로그인 상태를 계속 유지할 수 있는 이유는 무엇일까?

정답: 쿠키와 세션 ID를 이용하기 때문이다.

해설

HTTP는 기본적으로 각 요청을 독립적으로 처리하며 이전 요청의 상태를 기억하지 않는다.

하지만 서버에 로그인 세션을 생성하고, 브라우저에 세션 ID를 전달하면 로그인 상태를 유지할 수 있다.

동작 과정

1. 사용자가 아이디와 비밀번호로 로그인한다.
2. 서버가 인증 정보를 확인하고 세션을 생성한다.
3. 서버가 세션 ID를 브라우저에 전달한다.
4. 브라우저가 세션 ID를 보통 쿠키에 저장한다.
5. 이후 요청에서 세션 ID를 서버에 전달한다.
6. 서버는 세션 ID를 이용해 저장된 세션 정보를 조회한다.

핵심: HTTP는 Stateless지만, 쿠키와 세션을 활용하면 로그인 상태를 유지할 수 있다.

Q2. TCP 3-Way Handshake

문제: TCP 연결을 설정할 때 메시지를 주고받는 순서는?

정답

클라이언트                         서버
    |                              |
    | ---------- SYN ------------> |
    |                              |
    | <------ SYN + ACK ----------- |
    |                              |
    | ---------- ACK ------------> |
    |                              |
         TCP 연결 수립 완료

해설

• SYN: 클라이언트가 서버에 연결을 요청한다.
• SYN + ACK: 서버가 요청을 확인하고 자신도 연결을 요청한다.
• ACK: 클라이언트가 서버의 응답을 확인한다.

3-Way Handshake를 통해 양쪽은 통신 준비 상태를 확인하고 초기 순서 번호를 교환한다.

참고로 TCP 연결을 정상적으로 종료할 때는 일반적으로 4-Way Handshake를 수행한다.

Q3. Active-Active와 Active-Standby

문제: 주 서버가 서비스를 제공하고 대기 서버가 장애에 대비하는 이중화 방식은?

정답: Active-Standby

Failover(페일오버)는 주 서버에 장애가 발생했을 때 대기 서버가 서비스를 이어받는 과정을 의미한다.

핵심: 이중화가 구성되어 있어도 자동 장애 감지 및 전환 기능이 없다면 서비스 중단이 발생할 수 있다.

Q4. Wireshark 디스플레이 필터

문제: 출발지 IP가 192.168.10.100이고 TCP 목적지 포트가 443인 패킷만 표시하는 필터는?

정답

ip.src == 192.168.10.100 && tcp.dstport == 443

tcp.dstport 조건은 TCP 프로토콜과 목적지 포트를 함께 지정한다.

핵심: Wireshark의 디스플레이 필터는 src_ip가 아니라 ip.src와 같은 문법을 사용한다.

Q5. HTTP PUT과 PATCH

문제: 기존 프로필에서 나이만 변경하려고 할 때 적합한 HTTP 메서드는?

정답: PATCH

PATCH 요청 예시

PATCH /users/1 HTTP/1.1
Content-Type: application/json

{
  "age": 26
}

핵심: PUT은 전체 대체, PATCH는 부분 수정이다.

Q6. TLS와 대칭 키 암호화

문제: TLS에서 실제 애플리케이션 데이터를 주고받을 때 대칭 키 암호화 방식을 사용하는 이유는?

정답: 공개 키 암호화보다 일반적으로 처리 속도가 빠르기 때문이다.

TLS는 핸드셰이크 과정에서 세션 키를 안전하게 마련하고, 실제 애플리케이션 데이터는 대칭 키 방식으로 암호화한다.

TLS 1.3에서는 일반적으로 (EC)DHE 키 교환으로 공유 비밀을 만들고 인증서와 전자 서명 등을 통해 서버를 인증한다.

핵심: 공개 키 기술은 인증과 안전한 키 교환을 지원하고, 대칭 키는 효율적인 데이터 암호화에 사용된다.

Q7. ARP와 기본 게이트웨이

문제: 서로 다른 네트워크에 있는 PC B로 패킷을 보내려면 PC A는 누구의 MAC 주소를 알아내야 할까?

정답: 기본 게이트웨이의 MAC 주소

네트워크 구성

PC A
IP: 192.168.1.10
       |
       | ARP를 통해 게이트웨이 MAC 확인
       v
라우터
IP: 192.168.1.1
       |
       | 라우팅 후 다음 구간으로 전달
       v
PC B
IP: 192.168.2.10

동작 과정

1. PC A는 목적지 IP가 다른 네트워크에 있다는 것을 확인한다.
2. ARP를 이용해 기본 게이트웨이의 MAC 주소를 알아낸다.
3. 목적지 IP는 PC B의 IP로 유지하고, 목적지 MAC 주소는 기본 게이트웨이의 MAC 주소로 지정한다.
4. 라우터는 라우팅 테이블을 확인한 후 패킷을 다음 구간으로 전달한다.
5. PC B가 직접 연결된 네트워크에 있다면 라우터는 필요할 때 ARP로 PC B의 MAC 주소를 확인한다.

핵심: IP 주소는 최종 목적지를 나타내고, MAC 주소는 현재 구간에서 프레임을 전달할 대상을 나타낸다.

Q8. L4와 L7 로드 밸런서

문제: /images 요청은 이미지 서버로, /api 요청은 API 서버로 전달하려면 어떤 로드 밸런서를 사용해야 할까?

정답: L7 로드 밸런서

L7 로드 밸런서 구성 예시

                클라이언트
                    |
                    v
              L7 로드 밸런서
                    |
          +---------+---------+
          |                   |
          v                   v
       /images              /api
          |                   |
          v                   v
      이미지 서버          API 서버

L4는 주로 IP 주소와 TCP/UDP 포트 등 전송 계층의 정보를 이용해 트래픽을 분산한다.

L7은 HTTP 요청의 URL 경로나 헤더 등 애플리케이션 계층의 정보를 분석해 트래픽을 분산할 수 있다.

핵심: HTTP 요청의 내용에 따라 서버를 선택해야 한다면 L7 로드 밸런서를 활용할 수 있다.

Q9. DNS 조회 과정

문제: DNS 재귀 리졸버가 도메인의 IP 주소를 찾기 위해 조회하는 서버의 순서는?

정답: 루트 네임 서버 → TLD 네임 서버 → 권한 있는 네임 서버

          DNS 재귀 리졸버
                 |
                 v
          루트 네임 서버
                 |
                 v
           TLD 네임 서버
              (.com)
                 |
                 v
        권한 있는 네임 서버
           (example.com)
                 |
                 v
             DNS 레코드
                 |
                 v
           IP 주소 확인

각 서버의 역할

• 루트 네임 서버: 해당 TLD 네임 서버의 위치를 안내한다.
• TLD 네임 서버: 해당 도메인을 담당하는 권한 있는 네임 서버의 위치를 안내한다.
• 권한 있는 네임 서버: 해당 도메인의 DNS 레코드를 제공한다.

실제 조회에서는 DNS 캐시가 존재하면 일부 단계를 생략할 수 있다.

핵심: 루트 → TLD → 권한 있는 네임 서버 순서로 기억한다.

Q10. TCP와 UDP

문제: 실시간 음성 통화에서 일반적으로 UDP가 활용되는 이유는?

정답: UDP는 별도의 연결 설정 과정이 없고 TCP처럼 기본적으로 재전송이나 순서 보장을 수행하지 않기 때문이다.

UDP는 TCP보다 오버헤드가 작고 지연을 줄이는 데 유리하지만 반드시 전송 속도가 더 빠른 것은 아니다.

실제 성능은 네트워크 상태와 애플리케이션 구현에 따라 달라진다.

핵심: TCP는 신뢰성 있는 전송을 제공하고, UDP는 단순한 전송 방식으로 실시간 통신에 유리할 수 있다.

Q11. HTTP 502 Bad Gateway

문제: HTTP 502 Bad Gateway는 어떤 상황에서 발생할까?

정답: 게이트웨이나 프록시 서버가 상위 서버로부터 유효하지 않은 응답을 받았을 때 발생한다.

클라이언트
    |
    v
리버스 프록시
    |
    | 상위 서버 응답 문제
    v
   WAS

=> 클라이언트에 502 응답

실무 점검 항목

• WAS 프로세스가 정상적으로 실행 중인지 확인
• 프록시에서 WAS의 IP와 포트로 접속할 수 있는지 확인
• 프록시의 상위 서버 설정 확인
• 프록시 및 WAS 오류 로그 확인

관련 상태 코드

502는 유효하지 않은 응답을 받았을 때 발생하며, 504는 제한 시간 내에 상위 서버의 응답을 받지 못했을 때 발생한다.

Q12. HTTP 캐시와 304 Not Modified

문제: 브라우저가 304 Not Modified 응답을 받으면 어떻게 동작할까?

정답: 기존에 저장된 캐시 데이터를 재사용한다.

동작 과정

1. 브라우저가 이전에 다운로드한 리소스를 캐시에 저장한다.
2. 캐시가 만료되면 서버에 리소스의 변경 여부를 확인한다.
3. 변경되지 않았다면 서버가 304 Not Modified를 응답한다.
4. 브라우저가 기존 캐시 데이터를 재사용한다.

캐시의 장점

• 불필요한 네트워크 트래픽 감소
• 리소스 응답 속도 향상
• 서버의 데이터 전송 부담 감소

캐시가 아직 유효하다면 서버에 재검증 요청을 보내지 않고 바로 사용할 수도 있다.

핵심: 304는 리소스가 변경되지 않았다는 의미이며, 캐시를 재사용할 수 있다.

Q13. 단일 장애점(SPoF)

문제: WEB 서버 두 대를 이중화했지만 로드 밸런서는 한 대만 운영하는 경우, 로드 밸런서에 장애가 발생하면 어떻게 될까?

정답: 서버 두 대가 모두 정상이더라도 클라이언트가 서비스에 접근하지 못할 수 있다.

이처럼 한 구성 요소의 장애가 전체 서비스에 영향을 줄 수 있는 지점을 단일 장애점(SPoF, Single Point of Failure)이라고 한다.

              클라이언트
                  |
                  v
            로드 밸런서
             (장애 발생)
                  X
                  |
          +-------+-------+
          |               |
          v               v
      WEB 서버 A       WEB 서버 B
        정상             정상

   서버는 정상이지만 요청이 전달되지 않음

대응 방안

로드 밸런서도 이중화하고 장애 감지 및 자동 전환 기능을 구성할 수 있다.

핵심: 일부 장비를 이중화했다고 해서 전체 시스템의 단일 장애점이 사라지는 것은 아니다.

Q14. Forward Proxy와 Reverse Proxy

문제: 회사 직원의 인터넷 요청을 대신 외부 서버에 전달하고 접속 기록 및 접근을 관리하는 프록시는?

정답: Forward Proxy

① Forward Proxy

클라이언트를 대신해 외부 서버에 요청을 전달한다.

클라이언트
    |
    v
Forward Proxy
    |
    v
외부 웹 서버

주요 활용 사례는 인터넷 접근 제어, 접속 기록 관리, 캐싱 등이다.

② Reverse Proxy

외부에서 들어온 요청을 받아 내부 서버에 전달한다.

외부 클라이언트
       |
       v
 Reverse Proxy
       |
   +---+---+
   |       |
   v       v
서버 A   서버 B

주요 활용 사례는 내부 서버 보호, 로드 밸런싱, 캐싱 등이다.

핵심

• Forward Proxy: 클라이언트 측에서 클라이언트를 대신한다.
• Reverse Proxy: 서버 측에서 서버를 대신한다.

Q15. CIDR과 서브넷 계산

문제: 192.168.10.130/26의 네트워크 주소, 브로드캐스트 주소, 사용 가능한 호스트 범위는?

정답

계산 과정

IPv4는 총 32비트이고, /26은 네트워크 비트가 26비트라는 의미다.

호스트 비트 = 32 - 26 = 6비트

전체 IP 주소 수 = 2^6 = 64개

사용 가능한 호스트 수 = 64 - 2 = 62개

서브넷 구간

192.168.10.0   ~ 192.168.10.63
192.168.10.64  ~ 192.168.10.127
192.168.10.128 ~ 192.168.10.191  ← 해당 구간
192.168.10.192 ~ 192.168.10.255

일반적인 IPv4 서브넷에서는 네트워크 주소와 브로드캐스트 주소를 제외하고 호스트에 IP를 할당한다.

Q16. TCP 흐름 제어와 혼잡 제어

문제: 수신자의 버퍼를 보호하는 제어와 네트워크의 혼잡을 방지하는 제어는 각각 무엇일까?

정답: 흐름 제어와 혼잡 제어

① 흐름 제어

송신자가 데이터를 너무 빠르게 보내면 수신자의 버퍼가 가득 찰 수 있다.

수신자가 처리할 수 있는 양을 고려해 송신량을 조절하는 것이 흐름 제어다.

② 혼잡 제어

네트워크에 패킷이 지나치게 많이 몰리면 지연과 패킷 손실이 발생할 수 있다.

네트워크의 혼잡 징후를 고려해 송신량을 조절하는 것이 혼잡 제어다.

핵심

• 흐름 제어: 수신자가 감당할 수 있는가?
• 혼잡 제어: 네트워크가 감당할 수 있는가?

Q17. TCP 빠른 재전송

문제: 동일한 ACK 번호를 반복해서 받은 송신자가 재전송 타이머가 만료되기 전에 손실된 것으로 추정하는 세그먼트를 다시 보내는 기법은?

정답: 빠른 재전송(Fast Retransmit)

동작 예시

송신자                         수신자
   |                              |
   | -------- 데이터 1 ---------> |
   | -------- 데이터 2 ---------> |
   | -------- 데이터 3 --- X      | 손실
   | -------- 데이터 4 ---------> |
   | -------- 데이터 5 ---------> |
   |                              |
   | <------ 중복 ACK ----------- |
   | <------ 중복 ACK ----------- |
   | <------ 중복 ACK ----------- |
   |                              |
   | ---- 데이터 3 재전송 ------> |

TCP는 일반적으로 동일한 ACK 번호를 3번 중복해서 받으면 손실 가능성을 판단해 빠른 재전송을 수행한다.

다만 패킷의 도착 순서가 바뀌었을 때도 중복 ACK가 발생할 수 있다.

핵심: 빠른 재전송은 손실 복구, 슬로 스타트는 혼잡 제어와 관련된 기능이다.

Q18. 디지털 인증서와 CA

문제: CA(Certificate Authority)의 주요 역할은?

정답: 디지털 인증서를 발급하고 전자 서명해 공개 키와 인증서에 기재된 신원 정보를 연결한다.

HTTPS 인증서 검증 과정

        웹 서버
           |
           | 디지털 인증서 전달
           v
       클라이언트
           |
           | 유효기간 및 도메인 확인
           v
      인증서 체인 검증
           |
           | 신뢰할 수 있는 CA 확인
           v
       전자 서명 검증
           |
           v
       서버 인증 확인

CA는 서버의 신원을 검증할 수 있도록 신뢰 체계를 제공한다.

클라이언트는 인증서의 유효기간과 도메인 일치 여부, 인증서 체인, 전자 서명 등을 확인한다.

CA가 클라이언트와 서버 사이의 모든 HTTPS 데이터를 직접 암호화하는 것은 아니다.

핵심: CA는 디지털 인증서의 신뢰성을 검증할 수 있도록 지원하는 인증 기관이다.

Q19. MTU와 IPv4 단편화

문제: 크기가 2,000바이트인 IPv4 패킷이 MTU 1,500바이트인 구간을 통과해야 할 때, DF 비트가 0이면 어떻게 처리할까?

정답: MTU에 맞게 패킷을 단편화할 수 있다.

MTU(Maximum Transmission Unit)는 네트워크 구간에서 한 번에 전송할 수 있는 패킷의 최대 크기를 의미한다.

단편화 개념도

       원본 IPv4 패킷
         2,000바이트
              |
              v
       MTU 1,500바이트
              |
              v
           단편화
              |
        +-----+-----+
        |           |
        v           v
      단편 1      단편 2
    MTU 이하     MTU 이하

단편화된 각 패킷에는 별도의 IPv4 헤더가 붙으며, 최종 목적지에서 재조립한다.

DF(Don't Fragment) 비트

DF가 1인 패킷이 MTU보다 크면 라우터는 해당 패킷을 단편화하지 못하므로 폐기하고 일반적으로 ICMP Fragmentation Needed 메시지를 보낸다.

DF 비트는 경로 MTU 탐색(Path MTU Discovery)에도 활용된다.

핵심: DF는 Don't Fragment, 즉 단편화하지 말라는 의미다.

Q20. BGP와 AS

문제: AS 65001과 AS 65002처럼 서로 다른 AS 사이에서 라우팅 정보를 교환할 때 사용하는 BGP는?

정답: eBGP(External BGP)

AS(Autonomous System)는 공통된 라우팅 정책에 따라 관리되는 네트워크의 집합이다.

BGP는 AS 사이에서 라우팅 정보를 교환하는 데 사용하는 프로토콜이며, iBGP와 eBGP라는 동작 방식이 있다.

핵심

• iBGP: 같은 AS 내부
• eBGP: 서로 다른 AS 사이

📌 DAY 2 — 오답 및 헷갈렸던 개념

🎯 다음 복습 목표 — DAY 3

• Wireshark 디스플레이 필터 직접 작성하기
• PUT과 PATCH의 차이 복습하기
• TCP 흐름 제어와 혼잡 제어 구분하기
• 중복 ACK와 빠른 재전송 이해하기
• Forward Proxy와 Reverse Proxy 구분하기
• 앞서 학습한 내용과 새로운 범위를 섞어 총 20문제 풀이하기

DAY 2 복습 완료! ✅

#네트워크 #혼자공부하는네트워크 #네트워크공부 #TCP #UDP #HTTP #Wireshark #DNS #정보보안 #복습

DAY 1에서는 Python의 socket과 ThreadPoolExecutor를 이용하여 여러 TCP Port를 빠르게 스캔하고 OPEN Port를 탐지했다.
DAY 2에서는 OPEN Port의 서비스 정보를 조회하고, 실제 HTTP 통신을 통해 HTTP Server Banner를 수집하는 기능을 추가한다.

📌 DAY 2 목표

DAY 1의 Scanner는 OPEN Port만 확인할 수 있었다.

[+] 127.0.0.1:135 OPEN
[+] 127.0.0.1:445 OPEN
[+] 127.0.0.1:8000 OPEN

하지만 Port가 열려 있다는 사실만으로는 어떤 서비스가 동작하고 있는지 알기 어렵다.

DAY 2에서는 다음과 같이 정보를 추가하는 것을 목표로 한다.

[+] 127.0.0.1:445 OPEN
| Service: microsoft-ds
| Banner: HTTP Banner 없음

[+] 127.0.0.1:8000 OPEN
| Service: 등록된 서비스 정보가 없음
| Banner: SimpleHTTP/0.6 Python/3.13.3

전체적인 흐름은 다음과 같다.

OPEN Port 탐지
      ↓
등록된 Service 이름 조회
      ↓
HTTP 요청 전송
      ↓
HTTP 응답 수신
      ↓
Server Header 분석
      ↓
HTTP Banner 출력

1. Port 번호로 Service 이름 확인하기

Python의 socket 모듈에는 Port 번호에 대응하는 서비스 이름을 조회할 수 있는 함수가 있다.

socket.getservbyport()

간단하게 테스트해보았다.

import socket

print(socket.getservbyport(22))
print(socket.getservbyport(80))
print(socket.getservbyport(443))

실행 결과

ssh
http
https

즉,

22  → ssh
80  → http
443 → https

와 같이 Port 번호에 등록된 서비스 이름을 확인할 수 있다.

getservbyport()의 특징

여기서 주의해야 할 점이 있다.

getservbyport()는 실제 해당 Port에서 어떤 프로그램이 실행되고 있는지 확인하는 함수가 아니다.

예를 들어,

socket.getservbyport(80)

을 실행하면

80번 Port
   ↓
등록된 서비스 정보 조회
   ↓
http

와 같이 Port 번호에 등록된 서비스 이름을 조회한다.

따라서 실제 80번 Port에서 HTTP Server가 실행되고 있다는 것을 직접 확인한 것은 아니다.

2. 등록된 서비스 정보가 없는 Port 조회

이번에는 9999번 Port를 조회해보았다.

import socket

print(socket.getservbyport(9999))

실행 결과 오류가 발생했다.

OSError: port/proto not found

여기서 중요한 점은 9999번 Port가 존재하지 않는다는 의미가 아니라는 것이다.

9999번 Port도 사용할 수 있지만 getservbyport()가 참조하는 서비스 정보에서 해당 Port에 대응하는 서비스 이름을 찾지 못한 것이다.

9999번 Port를 사용할 수 있는가?
        ↓
       YES

등록된 서비스 이름이 있는가?
        ↓
       NO
        ↓
     OSError

3. try / except를 이용한 예외 처리

Scanner가 수많은 Port를 검사하다 보면 등록된 서비스 정보가 없는 Port를 만날 수 있다.

그때마다 프로그램이 종료되면 안 되기 때문에 try / except를 이용하여 예외를 처리한다.

import socket

try:
    service = socket.getservbyport(9999)
    print(service)

except OSError:
    print("등록된 서비스 정보가 없음")

실행 결과

등록된 서비스 정보가 없음

동작 과정은 다음과 같다.

try
 ↓
getservbyport(9999)
 ↓
OSError 발생
 ↓
except OSError
 ↓
등록된 서비스 정보가 없음

이렇게 하면 오류가 발생해도 프로그램 전체가 종료되지 않는다.

4. Service 조회 함수 만들기

서비스 조회 기능을 Scanner에서 계속 사용하기 위해 함수로 만들었다.

def get_service(port):
    try:
        service = socket.getservbyport(port)
        return service

    except OSError:
        return "등록된 서비스 정보가 없음"

테스트

print(get_service(22))
print(get_service(80))
print(get_service(443))
print(get_service(9999))

실행 결과

ssh
http
https
등록된 서비스 정보가 없음

return을 사용하는 이유

함수 안에서 print()를 사용하면 결과를 화면에 출력하는 것으로 끝난다.

하지만 return을 사용하면 함수에서 얻은 값을 다른 코드에서 다시 사용할 수 있다.

service = get_service(80)

print(service)

동작 과정

get_service(80)
      ↓
port = 80
      ↓
socket.getservbyport(80)
      ↓
service = "http"
      ↓
return service
      ↓
service = "http"

Scanner에서 Service 정보를 받아 출력해야 하기 때문에 return을 사용한다.

5. 기존 Port Scanner에 Service 조회 기능 추가

DAY 1에서 작성한 scan_port()에 get_service()를 연결했다.

if result == 0:
    service = get_service(target_port)

    print(f"[+] {target_ip}:{target_port} OPEN | Service: {service}")

이제 Scanner는 단순히 OPEN 여부만 출력하는 것이 아니라 등록된 Service 정보까지 출력할 수 있다.

실행 결과 예시

[+] 127.0.0.1:135 OPEN | Service: epmap
[+] 127.0.0.1:445 OPEN | Service: microsoft-ds
[+] 127.0.0.1:902 OPEN | Service: 등록된 서비스 정보가 없음

하지만 여기서 새로운 문제가 생긴다.

직접 Python HTTP Server를 실행해보았다.

python -m http.server 8000

분명히 8000번 Port에서 HTTP Server가 실행 중이다.

그런데 Scanner에서는 다음과 같이 출력되었다.

[+] 127.0.0.1:8000 OPEN | Service: 등록된 서비스 정보가 없음

즉,

실제 서비스
python -m http.server 8000
        ↓
       HTTP

하지만

socket.getservbyport(8000)
        ↓
등록된 서비스 정보가 없음

이라는 차이가 발생했다.

이를 통해 getservbyport()는 실제 서비스를 탐지하는 기능이 아니라 등록된 서비스 정보를 조회하는 기능이라는 것을 확인할 수 있었다.

그래서 실제 서버와 통신하여 정보를 받아오는 기능을 추가하기로 했다.

6. HTTP Server와 직접 통신하기

먼저 테스트를 위해 Python HTTP Server를 실행한다.

python -m http.server 8000

8000번 Port에 TCP 연결을 시도한다.

import socket

target_ip = "127.0.0.1"
target_port = 8000

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.settimeout(2)

result = sock.connect_ex((target_ip, target_port))

print(result)

서버가 정상적으로 실행 중이면

0

이 출력된다.

connect_ex()의 반환값이 0이라는 것은 TCP 연결에 성공했다는 의미이다.

7. HTTP 요청 전송하기 - sendall()

TCP 연결에 성공했으므로 이번에는 서버에 실제 HTTP 요청을 보내본다.

HTTP 요청 문자열을 생성한다.

request = "GET / HTTP/1.1\r\nHost: 127.0.0.1\r\n\r\n"

사람이 보기 쉽게 표현하면 다음과 같다.

GET / HTTP/1.1
Host: 127.0.0.1

HTTP에서는 \r\n을 이용하여 줄을 구분한다.

마지막의

\r\n\r\n

은 HTTP Header가 끝났다는 것을 의미한다.

encode()

Socket을 통해 데이터를 전송할 때 문자열을 그대로 전송할 수 없기 때문에 bytes 형태로 변환한다.

request.encode()

변환 과정

str
 ↓
encode()
 ↓
bytes

변환된 데이터를 sendall()을 이용하여 서버에 전송한다.

sock.sendall(request.encode())

전체적인 흐름은 다음과 같다.

"GET / HTTP/1.1..."
        ↓
      str
        ↓
    encode()
        ↓
      bytes
        ↓
   sendall()
        ↓
   HTTP Server

8. HTTP 응답 받기 - recv()

HTTP 요청을 보냈다면 서버의 응답도 받아야 한다.

response = sock.recv(4096)

4096은 Port 번호가 아니라 한 번에 최대 4096 bytes의 데이터를 수신하겠다는 의미이다.

처음에는 응답을 받지 않고 바로

sock.close()

를 실행했더니 HTTP Server에서 다음과 같은 오류가 발생했다.

ConnectionAbortedError
[WinError 10053]

동작 과정을 보면

Client
  │
  │ GET 요청
  ▼
Server
  │
  │ 200 OK 응답 준비
  ▼

Client가 먼저 연결 종료
  ↓
Server가 데이터를 보내지 못함

과 같은 상황이었다.

따라서 recv()를 사용하여 Server의 응답을 받은 후 연결을 종료하도록 수정하였다.

sock.sendall(request.encode())

response = sock.recv(4096)

sock.close()

9. bytes 데이터를 문자열로 변환 - decode()

recv()를 이용해 받은 데이터를 출력해보았다.

print(response)

결과는 다음과 같은 형태였다.

b'HTTP/1.0 200 OK\r\nServer: SimpleHTTP/0.6 Python/3.13.3...'

앞의 b는 해당 데이터가 bytes라는 의미이다.

사람이 읽기 편한 문자열로 변환하기 위해 decode()를 사용한다.

response = response.decode()

변환 과정

서버
 ↓
recv()
 ↓
bytes
 ↓
decode()
 ↓
str

결과

HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/3.13.3
Date: ...
Content-type: text/html; charset=utf-8
Content-Length: 355

HTTP Server가 보낸 실제 응답을 확인할 수 있었다.

10. HTTP 응답에서 Server 정보 찾기

HTTP 응답 전체가 필요한 것은 아니다.

이번 Scanner에서 확인하고 싶은 것은 다음 정보이다.

Server: SimpleHTTP/0.6 Python/3.13.3

먼저 HTTP 응답을 줄 단위로 분리한다.

lines = response.split("\r\n")

예를 들어 다음 문자열이

HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/3.13.3
Date: ...
Content-Type: text/html

split("\r\n")을 거치면 대략 다음과 같은 리스트가 된다.

[
    "HTTP/1.0 200 OK",
    "Server: SimpleHTTP/0.6 Python/3.13.3",
    "Date: ...",
    "Content-Type: text/html"
]

이제 for문으로 한 줄씩 확인한다.

for line in lines:
    print(line)

11. startswith()로 Server Header 찾기

Server:로 시작하는 문자열만 찾기 위해 startswith()를 사용한다.

for line in lines:
    if line.startswith("Server:"):
        print(line)

실행 결과

Server: SimpleHTTP/0.6 Python/3.13.3

startswith()는 문자열이 특정 문자열로 시작하는지 검사한다.

예를 들어

text = "Server: SimpleHTTP/0.6"

print(text.startswith("Server:"))

결과

True

가 된다.

12. Server 문자열에서 Banner만 추출하기

현재 결과는 다음과 같다.

Server: SimpleHTTP/0.6 Python/3.13.3

여기에서 실제 Banner 정보만 필요하다.

SimpleHTTP/0.6 Python/3.13.3

먼저 :을 기준으로 문자열을 분리한다.

line.split(":")

결과

[
    "Server",
    " SimpleHTTP/0.6 Python/3.13.3"
]

두 번째 값이 필요하므로 [1]을 사용한다.

line.split(":")[1]

하지만 문자열 앞에 공백이 남아 있다.

 SimpleHTTP/0.6 Python/3.13.3
↑
공백

따라서 strip()을 사용하여 앞뒤 공백을 제거한다.

banner = line.split(":")[1].strip()

최종 결과

SimpleHTTP/0.6 Python/3.13.3

13. HTTP Banner 조회 함수 만들기

지금까지 작성한 HTTP 통신 코드를 하나의 함수로 만들었다.

def get_http_banner(target_ip, target_port):
    try:
        # HTTP Banner 확인을 위한 TCP 소켓 생성
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        # 최대 2초 동안 응답 대기
        sock.settimeout(2)

        # 전달받은 IP와 Port에 TCP 연결
        result = sock.connect_ex((target_ip, target_port))

        if result == 0:

            # HTTP 요청 생성
            request = f"GET / HTTP/1.1\r\nHost: {target_ip}\r\n\r\n"

            # HTTP 요청 전송
            sock.sendall(request.encode())

            # HTTP 응답 수신
            response = sock.recv(4096)

            # bytes → str
            response = response.decode()

            # HTTP 응답을 한 줄씩 분리
            lines = response.split("\r\n")

            # Server Header 검색
            for line in lines:

                if line.startswith("Server:"):
                    banner = line.split(":")[1].strip()
                    return banner

        return "HTTP Banner 없음"

    except (ConnectionResetError, TimeoutError):
        return "HTTP Banner 없음"

14. HTTP가 아닌 Port에 HTTP 요청을 보내면?

HTTP Banner 함수를 445번 Port에 테스트해보았다.

banner = get_http_banner("127.0.0.1", 445)

print(banner)

TCP 연결 자체는 성공했지만 다음 오류가 발생했다.

ConnectionResetError
[WinError 10054]
현재 연결은 원격 호스트에 의해 강제로 끊겼습니다.

동작 과정

Scanner
   │
   │ TCP 연결
   ▼
445 Port
   │
   └─ 연결 성공

Scanner
   │
   │ GET / HTTP/1.1
   ▼
445 Port
   │
   └─ HTTP 요청을 처리하는 서비스가 아님
          ↓
       연결 종료

Scanner
   │
   └─ recv()
        ↓
ConnectionResetError

즉,

Port OPEN = HTTP Service

가 아니라는 것을 알 수 있다.

OPEN은 단순히 해당 TCP Port에서 연결을 받아주는 서비스가 있다는 의미이다.

따라서 다음과 같이 예외 처리를 추가하였다.

except (ConnectionResetError, TimeoutError):
    return "HTTP Banner 없음"

ConnectionResetError 또는 TimeoutError가 발생하면 프로그램을 종료하지 않고

HTTP Banner 없음

을 반환한다.

15. 445와 8000 비교

두 Port를 비교해보았다.

banner = get_http_banner("127.0.0.1", 445)
print(banner)

banner = get_http_banner("127.0.0.1", 8000)
print(banner)

결과

HTTP Banner 없음
SimpleHTTP/0.6 Python/3.13.3

즉,

445
 ↓
TCP OPEN
 ↓
HTTP 요청
 ↓
HTTP Banner 없음


8000
 ↓
TCP OPEN
 ↓
HTTP 요청
 ↓
HTTP 응답
 ↓
Server Header 발견
 ↓
SimpleHTTP/0.6 Python/3.13.3

으로 동작한다.

16. DAY 1 Scanner와 HTTP Banner 기능 합치기

마지막으로 DAY 1에서 작성한 멀티스레드 Port Scanner와 오늘 만든 기능들을 합쳤다.

구조는 다음과 같다.

scan_port()
    │
    ├── Port OPEN 여부 확인
    │
    ├── get_service()
    │       ↓
    │   등록된 Service 이름 조회
    │
    └── get_http_banner()
            ↓
        실제 HTTP 응답 분석

OPEN Port가 발견되면 다음 두 함수를 호출한다.

if result == 0:

    service = get_service(target_port)

    banner = get_http_banner(target_ip, target_port)

    print(
        f"[+] {target_ip}:{target_port} OPEN "
        f"| Service: {service} "
        f"| Banner: {banner}"
    )

17. DAY 2 최종 코드

import socket
from concurrent.futures import ThreadPoolExecutor


# 스캔할 대상 IP 입력
target_ip = input("스캔할 IP를 입력하세요: ")


# Port 번호에 등록된 Service 이름을 조회하는 함수
def get_service(port):

    try:
        service = socket.getservbyport(port)

        return service

    except OSError:
        return "등록된 서비스 정보가 없음"


# HTTP 응답에서 Server Banner를 확인하는 함수
def get_http_banner(target_ip, target_port):

    try:
        # HTTP Banner 확인을 위한 IPv4 + TCP 소켓 생성
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        # 최대 2초 동안 응답 대기
        sock.settimeout(2)

        # 전달받은 IP와 Port에 TCP 연결
        result = sock.connect_ex((target_ip, target_port))

        if result == 0:

            # HTTP GET 요청 생성
            request = f"GET / HTTP/1.1\r\nHost: {target_ip}\r\n\r\n"

            # 문자열을 bytes로 변환하여 HTTP 요청 전송
            sock.sendall(request.encode())

            # HTTP 응답을 최대 4096 bytes까지 수신
            response = sock.recv(4096)

            # bytes 데이터를 문자열로 변환
            response = response.decode()

            # HTTP 응답을 한 줄씩 분리
            lines = response.split("\r\n")

            # Server Header 검색
            for line in lines:

                if line.startswith("Server:"):

                    # "Server:" 뒤의 Banner 정보만 추출
                    banner = line.split(":")[1].strip()

                    return banner

        return "HTTP Banner 없음"

    except (ConnectionResetError, TimeoutError):

        return "HTTP Banner 없음"


# 하나의 Port를 검사하는 함수
def scan_port(target_ip, target_port):

    # IPv4(AF_INET) + TCP(SOCK_STREAM) 소켓 생성
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # TCP 연결 시 최대 0.5초 동안 응답 대기
    sock.settimeout(0.5)

    # 대상 IP와 Port에 TCP 연결 시도
    result = sock.connect_ex((target_ip, target_port))

    # connect_ex() 반환값이 0이면 TCP 연결 성공
    if result == 0:

        # Port 번호에 등록된 Service 이름 조회
        service = get_service(target_port)

        # 실제 HTTP 통신을 통한 Server Banner 확인
        banner = get_http_banner(target_ip, target_port)

        # OPEN Port + Service + Banner 출력
        print(
            f"[+] {target_ip}:{target_port} OPEN "
            f"| Service: {service} "
            f"| Banner: {banner}"
        )

    # 현재 Port 검사 종료
    sock.close()


# 최대 50개의 작업자 스레드를 사용하는 Thread Pool 생성
with ThreadPoolExecutor(max_workers=50) as executor:

    # 1번부터 8000번 Port까지 반복
    for target_port in range(1, 8001):

        # scan_port() 작업을 Thread Pool에 제출
        executor.submit(scan_port, target_ip, target_port)

18. 최종 실행 결과

테스트를 위해 별도의 Terminal에서 Python HTTP Server를 실행하였다.

python -m http.server 8000

Scanner 실행 결과 일부

[+] 127.0.0.1:4441 OPEN | Service: 등록된 서비스 정보가 없음 | Banner: HTTP Banner 없음

[+] 127.0.0.1:5040 OPEN | Service: 등록된 서비스 정보가 없음 | Banner: HTTP Banner 없음

[+] 127.0.0.1:6463 OPEN | Service: 등록된 서비스 정보가 없음 | Banner: HTTP Banner 없음

[+] 127.0.0.1:7680 OPEN | Service: ms-do | Banner: HTTP Banner 없음

[+] 127.0.0.1:7895 OPEN | Service: 등록된 서비스 정보가 없음 | Banner: Microsoft-HTTPAPI/2.0

[+] 127.0.0.1:8000 OPEN | Service: 등록된 서비스 정보가 없음 | Banner: SimpleHTTP/0.6 Python/3.13.3

특히 8000번 Port를 보면

Service: 등록된 서비스 정보가 없음

이라고 나오지만 실제 HTTP 통신을 통해

Banner: SimpleHTTP/0.6 Python/3.13.3

이라는 정보를 확인할 수 있었다.

또한 테스트 과정에서 7895번 Port에서는

Service: 등록된 서비스 정보가 없음
Banner: Microsoft-HTTPAPI/2.0

이라는 결과도 확인할 수 있었다.

이를 통해 Port 번호에 등록된 서비스 이름을 조회하는 것과 실제 서비스의 응답을 분석하는 것은 서로 다른 과정이라는 것을 확인할 수 있었다.

📌 getservbyport()와 Banner Grabbing 차이

📌 오늘 사용한 주요 함수

📌 encode() / decode() 정리

Socket 통신에서는 문자열을 그대로 전송하는 것이 아니라 bytes 형태의 데이터를 주고받는다.

데이터를 보낼 때

str
 ↓
encode()
 ↓
bytes
 ↓
sendall()
 ↓
Server

데이터를 받을 때

Server
 ↓
recv()
 ↓
bytes
 ↓
decode()
 ↓
str

📌 DAY 1 → DAY 2 변화

DAY 1

Target IP
    ↓
Port Scan
    ↓
OPEN / CLOSED 확인

출력

[+] 127.0.0.1:8000 OPEN

DAY 2

Target IP
    ↓
Port Scan
    ↓
OPEN Port
    ↓
Service 조회
    ↓
HTTP 요청
    ↓
HTTP 응답 분석
    ↓
Server Banner 추출

출력

[+] 127.0.0.1:8000 OPEN
| Service: 등록된 서비스 정보가 없음
| Banner: SimpleHTTP/0.6 Python/3.13.3

📌 DAY 2에서 배운 점

DAY 2에서는 단순히 새로운 기능만 추가한 것이 아니라 이전에 공부했던 Python 문법들이 실제 프로그램에서 어떻게 사용되는지 확인할 수 있었다.

함수
 ↓
매개변수
 ↓
return
 ↓
try / except
 ↓
for
 ↓
if
 ↓
f-string
 ↓
split()
 ↓
startswith()
 ↓
strip()

또한 Network Programming과 관련하여

Socket 생성
 ↓
TCP 연결
 ↓
HTTP Request
 ↓
sendall()
 ↓
Server
 ↓
HTTP Response
 ↓
recv()
 ↓
Banner 분석

과정을 직접 구현하였다.

특히 다음 차이를 이해하는 것이 중요했다.

Port가 OPEN이다.
≠
어떤 서비스인지 정확히 알고 있다.

그리고

getservbyport()
→ Port 번호에 등록된 서비스 정보 조회

HTTP Banner 확인
→ 실제 Server와 통신하여 응답 정보 확인

이라는 차이도 확인할 수 있었다.

🚀 DAY 2 완료

DAY 1에서 만들었던 단순 TCP Port Scanner에

✔ Service 이름 조회
✔ OSError 예외 처리
✔ HTTP Request 전송
✔ HTTP Response 수신
✔ bytes ↔ str 변환
✔ HTTP Server Header 분석
✔ Banner 추출
✔ ConnectionResetError / TimeoutError 처리
✔ 기존 Multi Thread Scanner와 결합

기능을 추가하였다.

현재 Scanner의 구조는 다음과 같다.

Python Security Scanner
        │
        ├── ThreadPoolExecutor
        │
        └── scan_port()
                │
                ├── TCP Port Scan
                │
                ├── get_service()
                │       └── Service 이름 조회
                │
                └── get_http_banner()
                        ├── HTTP Request
                        ├── HTTP Response
                        └── Server Banner 추출

DAY 1에서는 "Port가 열려 있는가?"를 확인했다면,

DAY 2에서는 한 단계 발전하여 "열린 Port에서 어떤 서비스 정보를 얻을 수 있는가?"까지 확인할 수 있게 되었다.

🔧 오늘 발견한 오류와 해결

1. 등록되지 않은 Port에서 OSError 발생

처음 socket.getservbyport()를 테스트하면서 9999번 Port를 조회했더니 다음 오류가 발생했다.

OSError: port/proto not found

원인

getservbyport()는 실제 Port가 열려 있는지 확인하는 함수가 아니라 Port 번호에 등록된 서비스 이름을 조회하는 함수이다.

따라서 해당 Port에 등록된 서비스 정보가 없으면 OSError가 발생한다.

해결

try / except를 사용하여 예외를 처리했다.

def get_service(port):
    try:
        service = socket.getservbyport(port)
        return service

    except OSError:
        return "등록된 서비스 정보가 없음"

결과

9999 → 등록된 서비스 정보가 없음

이 과정을 통해 Scanner는 등록되지 않은 Port를 만나더라도 종료되지 않고 계속 실행할 수 있게 되었다.

2. HTTP 요청 후 연결을 바로 종료하여 오류 발생

Python HTTP Server를 실행한 뒤 HTTP 요청을 전송했는데 Server Terminal에서 다음과 같은 오류가 발생했다.

ConnectionAbortedError
[WinError 10053]
현재 연결은 사용자의 호스트 시스템의 소프트웨어에 의해 중단되었습니다.

원인

처음 작성한 코드에서는 HTTP 요청을 보낸 후 Server의 응답을 제대로 받지 않고 Socket 연결을 종료했다.

Scanner
   │
   │ HTTP Request
   ▼
HTTP Server
   │
   │ HTTP Response 전송
   ▼
Scanner가 먼저 연결 종료

Server 입장에서는 응답 데이터를 보내는 도중 연결이 종료된 것이다.

해결

recv()를 이용하여 Server의 응답을 받은 후 Socket을 종료하도록 수정했다.

sock.sendall(request.encode())

response = sock.recv(4096)

sock.close()

이를 통해 HTTP의 기본적인 요청 → 응답 과정도 직접 확인할 수 있었다.

3. HTTP가 아닌 Port에서 ConnectionResetError 발생

445번 Port가 OPEN 상태였기 때문에 HTTP Banner 함수를 테스트해보았다.

하지만 다음 오류가 발생했다.

ConnectionResetError
[WinError 10054]
현재 연결은 원격 호스트에 의해 강제로 끊겼습니다.

원인

445번 Port에 TCP 연결하는 것 자체는 성공했다.

connect_ex()
      ↓
result == 0
      ↓
TCP 연결 성공

하지만 이후 Scanner가 HTTP 요청을 전송했다.

GET / HTTP/1.1

445번에서 동작하는 서비스는 HTTP 요청을 처리하는 웹 서버가 아니기 때문에 연결이 종료되었고, 이후 recv() 과정에서 ConnectionResetError가 발생했다.

즉,

Port OPEN
   ≠
HTTP Service

라는 것을 확인할 수 있었다.

해결

try / except를 이용하여 연결 종료와 Timeout을 처리했다.

except (ConnectionResetError, TimeoutError):
    return "HTTP Banner 없음"

이제 HTTP가 아닌 서비스에 요청을 보내더라도 Scanner 전체가 종료되지 않는다.

[+] 127.0.0.1:445 OPEN
| Service: microsoft-ds
| Banner: HTTP Banner 없음

4. getservbyport()로는 8000번의 실제 서비스를 확인하지 못함

테스트를 위해 직접 HTTP Server를 실행했다.

python -m http.server 8000

하지만 getservbyport()의 결과는 다음과 같았다.

Service: 등록된 서비스 정보가 없음

실제로는 HTTP Server가 실행되고 있는데 Service 정보를 확인하지 못한 것이다.

원인

getservbyport()는 실제 동작 중인 서비스를 분석하는 것이 아니라 Port 번호에 등록된 서비스 이름을 조회하기 때문이다.

해결

실제 서비스에 HTTP Request를 전송하고 HTTP Response의 Server: Header를 분석하는 Banner 확인 기능을 직접 구현했다.

결과

[+] 127.0.0.1:8000 OPEN
| Service: 등록된 서비스 정보가 없음
| Banner: SimpleHTTP/0.6 Python/3.13.3

이를 통해

Port 번호 기반 정보
        ↓
getservbyport()

실제 서비스 응답 기반 정보
        ↓
Banner Grabbing

의 차이를 확인할 수 있었다.

💡 오늘의 핵심 정리

DAY 2에서 가장 중요하게 느낀 부분은 단순히 Port 번호만으로 실제 서비스를 판단할 수 없다는 점이다.

DAY 1에서는

8000 OPEN

까지만 알 수 있었다.

DAY 2에서는

8000 OPEN
   ↓
등록된 Service 정보 확인
   ↓
실제 HTTP Request 전송
   ↓
HTTP Response 수신
   ↓
Server Header 분석
   ↓
SimpleHTTP/0.6 Python/3.13.3

까지 확인할 수 있게 되었다.

또한 Python을 공부하면서 각각 따로 배웠던

함수
return
try / except
for
if
f-string
split()
startswith()
strip()

등의 문법이 실제 프로그램 안에서 어떤 목적으로 사용되는지도 조금씩 이해할 수 있었다.

특히 이번 DAY 2에서는 예외 처리가 왜 필요한지 직접 경험할 수 있었다.

Scanner처럼 여러 Port와 통신하는 프로그램에서는 모든 Port가 예상한 대로 응답하지 않는다.

따라서

정상적인 상황만 처리하는 코드

뿐만 아니라

응답이 없으면?
연결이 끊기면?
서비스 정보가 없으면?
HTTP 서비스가 아니면?

같은 상황도 처리해야 안정적인 프로그램을 만들 수 있다는 것을 알게 되었다.

🎯 DAY 3 목표

현재 Scanner는 다음 단계까지 구현되어 있다.

Target IP 입력
      ↓
Multi Thread Port Scan
      ↓
OPEN Port 탐지
      ↓
Service 이름 조회
      ↓
HTTP Request 전송
      ↓
HTTP Banner 확인

하지만 아직 개선해야 할 부분이 있다.

현재는 OPEN Port가 발견되면 HTTP 서비스인지 알 수 없는 상태에서도 get_http_banner()를 실행한다.

445 OPEN
 ↓
HTTP 요청 전송
 ↓
HTTP가 아님
 ↓
예외 처리

8000 OPEN
 ↓
HTTP 요청 전송
 ↓
HTTP Server
 ↓
Banner 획득

또한 현재 결과는 Terminal에만 출력되고 프로그램이 종료되면 결과가 남지 않는다.

따라서 DAY 3에서는 Scanner의 결과를 조금 더 체계적으로 관리하는 방향으로 발전시켜 볼 예정이다.

DAY 3 예정

• Socket 자원 처리 방식 개선
• HTTP Banner 탐지 로직 개선
• 스캔 결과를 List 또는 Dictionary에 저장
• OPEN Port 개수 확인
• 스캔 시작/종료 시간 및 소요 시간 출력
• 결과를 파일로 저장하는 기능 추가
• Scanner 결과를 보기 좋은 형태로 정리

예를 들어 최종적으로 다음과 같은 결과를 만들어보는 것이 목표이다.

========================================
        Python Security Scanner
========================================

Target : 127.0.0.1

[+] 135 OPEN
    Service : epmap
    Banner  : -

[+] 445 OPEN
    Service : microsoft-ds
    Banner  : -

[+] 7895 OPEN
    Service : Unknown
    Banner  : Microsoft-HTTPAPI/2.0

[+] 8000 OPEN
    Service : Unknown
    Banner  : SimpleHTTP/0.6 Python/3.13.3

----------------------------------------
Open Ports : 4
Scan Time  : 3.21 sec
----------------------------------------

그리고 이후에는 단순히 Port를 찾는 Scanner에서 끝나는 것이 아니라,

Port Scan
   ↓
Service Detection
   ↓
Banner Grabbing
   ↓
결과 저장
   ↓
결과 분석

처럼 하나씩 기능을 확장해 볼 예정이다.

📝 DAY 2 한 줄 정리

DAY 1에서 "어떤 Port가 열려 있는가?"를 확인했다면, DAY 2에서는 실제 서비스와 통신하여 "열린 Port에서 어떤 정보를 얻을 수 있는가?"까지 확인해보았다.

다음은 DAY 3 - 스캔 결과 관리 및 Scanner 기능 개선 🚀

2026년 목표

• 클라우드 환경 운영 경험(상세 내용은 추후 작성)
• 보안관제 자동화 경험
• 블로그 꾸준히 작성
• 자격증 : 정보처리기사(9월 시작), 정보보안기사, AWS-SAA,/// CISA 및 CISSP(정보 보안 관련 경력 5년 이상 필요 (4년 경력+보안 관련 학위 가능))
• 개발 공부
• 영어 공부
• 운동
• 리팩토링 과정 복습 및 벨로그에 새롭게 작성
• 클라우드 보안 복습 및 벨로그에 작성 <내년 예정 - 석사 과정>

📅 공부 순서 - (Version 10월)

1. 파이썬(점프 투 파이썬) 완강했음 - 지속적인 복습
2. 정보처리기사 실기 - 10월 25일에 시험있음 합격 목표
3. 모의해킹(노말틱 강의) - 10월 말까지 완료 목표
4. 영어 - 11월부터 시작!
5. 혼자공부하는 네트워크(인프런) 완강했음 - 지속적인 복습
6. 리펙토링 과정 복습 시작(실습 및 블로그 재작성)
7. Docker(인프런_devsecops) 강의(모의해킹 끝나고 시작)
8. AWS 보안 가이드(인프런 강의) - (Docker 인프런 끝나고 시작)
9. JAVA - (파이썬 어느 정도 할 줄 알때 시작) → 1 + 2 + 3 + 5 → 1 + 4 + 6 + 7

📅 금주 목표 - (09/28(월)~10/04(일))

• 파이썬(점프 투 파이썬)
  • Youtube 강의 + Ebook 참고
  • 목표 : 점프 투 파이썬 학습 계속 진행 및 진도율 향상
• 정보처리기사 실기
  • 목표 : 2020년도 기출문제 2회차 풀이
  • 범위 : 1회차 ~ 4회차
  • 목표 : 2021년도 기출문제 1회차 풀이
  • 범위 : 1회차 ~ 3회차
  • 목표 : 2022년도 기출문제 1회차 풀이
  • 범위 : 1회차 ~ 3회차
• 모의해킹
  • 목표 : Day 1 ~ Day 2 완료
  • 범위 : 1주차 ~ 2주차

📅 오늘의 목표 : 완료 OR 미완료 OR 진행중

• 모의해킹(노말틱 강의)
  • 1주차 ~ 하는데 까지 + 블로그 정리
• 파이썬(nmap 기능 구현해보기)DAY-2 + 블로그 정리
• household account 작성(23:50분에 작성)
• 정보처리기사 DAY3(2020년도 2회차 문제풀이 및 복습) + 2021년도 1회차 문제풀이 + 2022년도 1회차 문제풀이
• 방청소
• 분리수거
• 혼자공부하는 네트워크 복습 DAY2
• 빨래(Laundry)

💻 오늘(완료) 한 일

• 정보처리기사 DAY3 : 2021년도 1회차 문제풀이
• household account 작성(23:50분에 작성)
• 파이썬(nmap 기능 구현해보기)DAY-2 + 블로그 정리
• 빨래(Laundry)
• 혼자공부하는 네트워크 복습 DAY2

기존에 공부했던 네트워크 내용을 다시 복습해보자.

이번 복습은 하루에 20문제씩 풀면서 기억이 나지 않거나 헷갈리는 부분을 다시 정리하는 방식으로 진행한다.

Q1. 노드(Node)란?

네트워크를 구성하는 기본 요소 중 노드(Node)란 무엇일까?

풀이

노드는 네트워크 장비 같은 것으로 이해하고 있었다.

예를 들어

• 라우터
• 스위치

등이 노드에 해당한다고 생각했다.

하지만 노드는 네트워크 장비만을 의미하는 것이 아니라 네트워크에 연결되어 정보를 주고받을 수 있는 장치를 의미한다.

따라서

• PC
• 서버
• 스위치
• 라우터

등도 모두 노드가 될 수 있다.

노드(Node) : 네트워크에 연결되어 정보를 주고받을 수 있는 장치

Q2. LAN과 WAN

다음 중 LAN과 WAN에 대한 설명으로 올바른 것은?

① LAN은 국가 간 네트워크이고 WAN은 가정이나 회사 내부의 네트워크이다.
② LAN은 비교적 가까운 지역의 네트워크이고 WAN은 LAN보다 넓은 범위를 연결한다.
③ LAN과 WAN은 범위의 차이가 없고 사용하는 프로토콜만 다르다.
④ WAN은 반드시 무선으로 구성해야 한다.

풀이

정답은 ②번

• LAN(Local Area Network) : 비교적 가까운 범위에서 구성되는 네트워크
• WAN(Wide Area Network) : LAN보다 넓은 범위를 연결하는 네트워크

Q3. 패킷 교환 방식

패킷 교환 방식(Packet Switching)은 데이터를 어떤 방식으로 전송할까?

풀이

패킷 교환 방식과 회선 교환 방식이 있다는 것은 기억났지만, 처음에는 패킷 교환을 1:1로 패킷을 전달하는 방식이라고 생각했다.

하지만 1:1 통신은 패킷 교환의 핵심 개념이 아니다.

패킷 교환 방식은 전송하려는 데이터를 작은 패킷 단위로 나누어 전송하는 방식이다.

큰 데이터
   ↓
Packet 1
Packet 2
Packet 3
   ↓
전송

반대로 회선 교환 방식은 통신하기 전에 두 장치 사이에서 사용할 통신 경로를 확보하여 사용하는 방식이다.

Q4. 브로드캐스트

다음 설명이 맞으면 O, 틀리면 X.

브로드캐스트는 한 송신자가 특정한 하나의 수신자에게만 데이터를 전송하는 방식이다.

풀이

정답은 X

브로드캐스트는 한 송신자가 네트워크의 모든 대상에게 데이터를 전송하는 방식이다.

Unicast     → 1 : 1
Broadcast   → 1 : 모든 대상
Multicast   → 1 : 특정 그룹

Q5. 캡슐화(Encapsulation)

OSI 모델에서 데이터가 하위 계층으로 내려갈 때 왜 헤더 등의 정보를 계속 추가할까?

풀이

처음에는

문제가 발생했을 때 어떤 계층에서 문제가 발생했는지 확인하기 위해서?

라고 생각했다.

이것은 계층화의 장점과 관련된 내용이고, 캡슐화의 목적과는 조금 다르다.

캡슐화는 데이터가 각 계층을 지나면서 해당 계층의 통신에 필요한 정보를 추가하는 과정이다.

세그먼트
   ↓
패킷
   ↓
프레임

수신 측에서는 반대로 각 계층의 정보를 확인하고 제거하는 역캡슐화(Decapsulation)가 이루어진다.

캡슐화 : 각 계층에서 통신에 필요한 제어 정보를 데이터에 추가하는 과정

Q6. OSI 3계층의 주소

OSI 모델의 네트워크 계층(Layer 3)에서 사용하는 대표적인 주소는?

① MAC 주소
② IP 주소
③ Port 번호
④ URL

풀이

정답은 ② IP 주소

L2 스위치는 MAC 주소를 이용하고 L3에서는 IP 주소를 사용한다고 기억하고 있었다.

L2 → MAC Address → Switch
L3 → IP Address  → Router
L4 → Port Number

Q7. TTL

IP 패킷이 여러 라우터를 지나면서 TTL 값이 0이 되면 어떻게 될까?

풀이

TTL이 Time To Live라는 것과 라우터 하나를 지나는 것을 1 Hop이라고 한다는 것은 기억하고 있었다.

하지만 TTL이 0이 되었을 때 어떻게 되는지는 기억하지 못했다.

라우터를 거칠 때마다 TTL 값이 감소하고 TTL이 0이 되면 패킷은 폐기된다.

TTL이 없다면 라우팅 문제로 패킷이 네트워크를 계속 돌아다니는 상황이 발생할 수 있다.

Router
TTL 3
  ↓
Router
TTL 2
  ↓
Router
TTL 1
  ↓
TTL 0
  ↓
패킷 폐기

TTL : 패킷이 네트워크에서 무한히 돌아다니는 것을 방지하기 위한 값

Q8. MTU와 단편화

MTU보다 큰 IP 패킷을 전송해야 한다면 어떻게 될까?

풀이

MTU가 최대 전송 단위라는 것은 기억하고 있었다.

다만 약자를 처음에 Maximum Transport Unit으로 기억했는데 정확한 명칭은 다음과 같다.

MTU = Maximum Transmission Unit

MTU보다 큰 IP 패킷을 전송해야 하는 경우 패킷을 작은 크기로 나누는 것을 단편화(Fragmentation)라고 한다.

큰 IP Packet
     ↓
Fragmentation
     ↓
[조각 1] [조각 2] [조각 3]
     ↓
전송
     ↓
목적지에서 재조립

Q9. ARP

PC-A가 같은 네트워크의 PC-B에게 데이터를 보내려고 한다.

PC-B의 IP 주소는 알고 있지만 MAC 주소를 모른다면 어떻게 해야 할까?

풀이

이 경우 ARP(Address Resolution Protocol)를 사용한다.

ARP는 알고 있는 IP 주소를 이용하여 해당 장치의 MAC 주소를 알아내는 프로토콜이다.

처음에는 공유기의 ARP 테이블에서 목적지 MAC 주소를 알아낸다고 생각했다.

하지만 같은 네트워크에 있는 장치를 찾는 경우 통신하려는 장치가 직접 ARP를 이용한다.

PC-A

"192.168.0.20 사용하는 장치 누구야?"
            ↓
       ARP Request
            ↓
          PC-B

"나야. 내 MAC 주소는 BB-BB-BB-BB-BB-BB"
            ↓
        ARP Reply

알아낸 정보는 ARP 테이블에 저장할 수 있다.

192.168.0.20
→ BB-BB-BB-BB-BB-BB

Q10. 다른 네트워크와 ARP

이번에는 목적지가 다른 네트워크에 있는 서버이다.

PC가 ARP를 통해 알아내야 하는 MAC 주소는?

① 목적지 서버의 MAC 주소
② DNS 서버의 MAC 주소
③ Default Gateway의 MAC 주소
④ 자신의 MAC 주소

풀이

정답은 ③ Default Gateway의 MAC 주소

다른 네트워크로 나가기 위해서는 우선 Default Gateway를 거쳐야 한다.

따라서 PC는 ARP를 이용해

Default Gateway IP
        ↓
       ARP
        ↓
Default Gateway MAC

을 알아낸다.

여기서 중요한 점은 최종 목적지 IP 주소와 현재 전달할 프레임의 목적지 MAC 주소를 구분하는 것이다.

Q11. CIDR 계산

다음 IP 주소의 네트워크 주소, 브로드캐스트 주소, 사용 가능한 호스트 범위를 구하자.

192.168.10.130/26

풀이

IPv4는 총 32bit이다.

32 - 26 = 6bit

호스트 영역이 6bit이므로

2^6 = 64

64개 단위로 주소를 구분할 수 있다.

0   ~ 63
64  ~ 127
128 ~ 191
192 ~ 255

130은 128 ~ 191 범위에 포함된다.

따라서

네트워크 주소
→ 192.168.10.128

브로드캐스트 주소
→ 192.168.10.191

사용 가능한 호스트
→ 192.168.10.129 ~ 192.168.10.190

사용 가능한 호스트 수는

2^6 - 2
= 62개

이다.

Q12. NAT

사설 IP를 사용하는 PC가 인터넷과 통신할 때 NAT는 어떤 역할을 할까?

풀이

사설 IP는 여러 내부 네트워크에서 중복해서 사용할 수 있다.

인터넷과 통신할 때는 공인 IP가 필요하며 이때 IP 주소를 변환하는 기술이 NAT(Network Address Translation)이다.

사설 IP
   ↓
  NAT
   ↓
공인 IP

Q13. Port Forwarding

공유기의 특정 포트로 들어온 요청을 내부의 특정 IP와 Port로 전달하도록 설정하는 기능은?

풀이

정답은 Port Forwarding

예를 들어

공인 IP:5000
      ↓
공유기
      ↓
Port Forwarding
      ↓
192.168.0.100:8080

처럼 외부에서 특정 포트로 들어온 요청을 내부의 지정된 장치와 포트로 전달할 수 있다.

Q14. DHCP DORA

DHCP를 통해 IP 주소를 할당받는 순서를 맞혀보자.

DHCP ACK
DHCP Discover
DHCP Request
DHCP Offer

풀이

처음에는

Discover
→ Request
→ ACK
→ Offer

라고 생각했다.

정확한 순서는 다음과 같다.

Discover
   ↓
Offer
   ↓
Request
   ↓
ACK

앞글자를 따서 DORA라고 기억하면 된다.

Discover

클라이언트

DHCP 서버 있나요?

Offer

DHCP 서버

이 IP를 사용하는 건 어때?

Request

클라이언트

그 IP를 사용하겠습니다.

ACK

DHCP 서버

확인. 해당 IP를 사용해.

Q15. DHCP 임대 기간

DHCP의 임대 기간이 끝나면 무조건 IP 주소가 변경될까?

풀이

예전에 이 부분이 궁금해서 직접 PC의 DHCP 임대 기간을 확인했던 기억이 있다.

DHCP의 임대 기간이 끝난다고 해서 무조건 새로운 IP 주소로 변경되는 것은 아니다.

클라이언트는 임대가 끝나기 전에 기존 IP 주소를 계속 사용하기 위해 갱신을 시도할 수 있다.

IP 할당
   ↓
임대 기간 사용
   ↓
갱신 시도
   ↓
갱신 성공
   ↓
기존 IP 계속 사용

DHCP 임대 만료 = 무조건 IP 변경은 아니다.

Q16. Default Route

라우팅 테이블에 다음과 같은 경로가 있다.

0.0.0.0/0 → Gateway A

0.0.0.0/0은 무엇일까?

풀이

처음에는 127.0.0.1과 헷갈렸다.

127.0.0.1
→ Loopback
→ 자기 자신

반면

0.0.0.0/0
→ Default Route

이다.

목적지로 가는 더 구체적인 경로가 라우팅 테이블에 없다면 Default Route를 이용할 수 있다.

쉽게 생각하면

어디로 보내야 할지 모르겠으면 일단 여기로 보내!

라고 이해할 수 있다.

Q17. 정적 라우팅과 동적 라우팅

라우터가 수십 대로 증가하고 네트워크 경로도 자주 변경된다면 어떤 라우팅 방식이 관리하기 좋을까?

풀이

정답은 동적 라우팅(Dynamic Routing)

정적 라우팅은 관리자가 경로를 직접 등록한다.

라우터가 몇 대 없는 작은 네트워크에서는 관리할 수 있지만 네트워크 규모가 커지면 관리해야 하는 경로도 증가한다.

동적 라우팅에서는 라우터들이 라우팅 프로토콜을 이용해 경로 정보를 교환하고 네트워크 변화에 대응할 수 있다.

소규모 / 변화 적음
→ Static Routing

규모 증가 / 경로 변화 많음
→ Dynamic Routing

Q18. IGP / RIP / OSPF / BGP

RIP와 OSPF는 어떤 종류의 라우팅 프로토콜이고 BGP는 어디에서 사용할까?

풀이

RIP가 내부 라우팅이고 Distance Vector 방식이라는 것은 기억하고 있었다.

RIP와 OSPF는 IGP(Interior Gateway Protocol)에 속한다.

AS 내부
   ↓
IGP
 ├─ RIP
 └─ OSPF

반면 BGP는 AS와 AS 사이의 경로 교환에 사용된다.

Q19. AS(Autonomous System)

AS란 무엇일까?

풀이

용어 자체는 기억나지 않았지만 예전에 공부했던 그림은 기억났다.

동그란 영역 안에 여러 라우터가 있고 각각의 영역이 나누어져 있었던 그림이다.

AS는 하나의 관리 주체와 라우팅 정책 아래 관리되는 네트워크 영역으로 이해할 수 있다.

┌────── AS 100 ──────┐
│                    │
│ R1 ─── R2 ─── R3   │
│                    │
└────────────────────┘

          ↕

┌────── AS 200 ──────┐
│                    │
│ R4 ─── R5 ─── R6   │
│                    │
└────────────────────┘

Q20. EGP / BGP / eBGP / iBGP

EGP와 BGP는 같은 것일까?

그리고 eBGP는 무엇일까?

풀이

BGP가 AS와 AS 사이의 라우팅과 관련된 프로토콜이라는 것은 기억하고 있었다.

하지만 EGP와 eBGP의 관계는 헷갈렸다.

추가로 공부한 내용

EGP(Exterior Gateway Protocol)는 AS 간 외부 라우팅 프로토콜을 구분할 때 사용하는 개념이다.

BGP(Border Gateway Protocol)는 AS 간 경로 정보를 교환하는 데 사용되는 대표적인 라우팅 프로토콜이다.

BGP는 사용되는 관계에 따라 다음과 같이 구분할 수 있다.

BGP
├─ eBGP
└─ iBGP

eBGP

External BGP

서로 다른 AS의 BGP 라우터 사이에서 BGP 경로 정보를 교환한다.

AS 100 ←── eBGP ──→ AS 200

iBGP

Internal BGP

같은 AS 내부의 BGP 라우터들이 BGP 경로 정보를 교환한다.

여기서 주의할 점은

iBGP ≠ IGP

이다.

iBGP의 Internal은 같은 AS 내부에서 BGP 정보를 교환한다는 의미이며 RIP, OSPF와 같은 IGP와는 구분해야 한다.

오늘의 핵심 복습

오늘 특히 헷갈렸던 내용만 다시 정리해보자.

캡슐화

각 계층에서 필요한 정보를 추가
→ Encapsulation

TTL

Router를 지날 때 TTL 감소
→ TTL 0
→ Packet 폐기

ARP

IP 주소는 알고 있음
MAC 주소를 모름
        ↓
       ARP
        ↓
MAC 주소 확인

다른 네트워크로 통신한다면 우선 Default Gateway의 MAC 주소가 필요하다.

DHCP

Discover
→ Offer
→ Request
→ ACK

DORA

Default Route

127.0.0.1
→ Loopback

0.0.0.0/0
→ Default Route

라우팅 프로토콜

                Routing Protocol
                       │
             ┌─────────┴─────────┐
             │                   │
            IGP                 EGP
             │                   │
        ┌────┴────┐             BGP
       RIP       OSPF         ┌──┴──┐
                             eBGP  iBGP

AS 기준으로 다시 보기

┌──────────── AS 100 ────────────┐
│                                │
│      RIP / OSPF 등 IGP         │
│                                │
│   Router ─ Router ─ Router     │
│                       │        │
└───────────────────────│────────┘
                        │
                       eBGP
                        │
┌───────────────────────│────────┐
│                       │        │
│   Router ─ Router ─ Router     │
│                                │
│           AS 200               │
└────────────────────────────────┘

오늘은 기본적인 개념은 어느 정도 기억하고 있었지만 DHCP DORA, TTL, Default Route, AS와 BGP의 관계처럼 정확한 동작 과정이나 용어 관계에서 헷갈리는 부분이 있었다.

다음 복습에서는 오늘 헷갈렸던 개념들도 다시 문제로 만나면서 반복해서 익혀보자.

2026년 목표

• 클라우드 환경 운영 경험(상세 내용은 추후 작성)
• 보안관제 자동화 경험
• 블로그 꾸준히 작성
• 자격증 : 정보처리기사(9월 시작), 정보보안기사, AWS-SAA,/// CISA 및 CISSP(정보 보안 관련 경력 5년 이상 필요 (4년 경력+보안 관련 학위 가능))
• 개발 공부
• 영어 공부
• 운동
• 리팩토링 과정 복습 및 벨로그에 새롭게 작성
• 클라우드 보안 복습 및 벨로그에 작성 <내년 예정 - 석사 과정>

📅 공부 순서 - (Version 9-10월)

1. 파이썬(점프 투 파이썬) 완강했음
2. 정보처리기사 실기 - 10월 25일에 시험있음 합격 목표
3. 모의해킹(노말틱 강의) - 10월 말까지 완료 목표
4. 영어 - 11월부터 시작!
5. 혼자공부하는 네트워크(인프런) 완강했음 - 10월에 지속적인 복습
6. 리펙토링 과정 복습 시작(실습 및 블로그 재작성)
7. Docker(인프런_devsecops) 강의(모의해킹 끝나고 시작)
8. AWS 보안 가이드(인프런 강의) - (Docker 인프런 끝나고 시작)
9. JAVA - (파이썬 끝나고 시작)

📅 금주 목표 - (09/28(월)~10/04(일))

• 파이썬(점프 투 파이썬)
  • Youtube 강의 + Ebook 참고
  • 목표 : 점프 투 파이썬 학습 계속 진행 및 진도율 향상
• 정보처리기사 실기
  • 목표 : 2020년도 기출문제 2회차 풀이
  • 범위 : 1회차 ~ 4회차
  • 목표 : 2021년도 기출문제 1회차 풀이
  • 범위 : 1회차 ~ 3회차
  • 목표 : 2022년도 기출문제 1회차 풀이
  • 범위 : 1회차 ~ 3회차
• 모의해킹
  • 목표 : Day 1 ~ Day 2 완료
  • 범위 : 1주차 ~ 2주차

📅 오늘의 목표 : 완료 OR 미완료 OR 진행중

• 모의해킹(노말틱 강의)
  • 1주차 ~ 하는데 까지 + 블로그 정리
• 파이썬(nmap 기능 구현해보기)DAY-1 + 블로그 정리
• household account 작성(23:50분에 작성)
• 정보처리기사 DAY3(2020년도 2회차 문제풀이 및 복습) + 2021년도 1회차 문제풀이 + 2022년도 1회차 문제풀이
• 방청소
• JAVA 뭘로 공부할지 찾아보기
• 혼자공부하는 네트워크 복습 DAY1

💻 오늘(완료) 한 일

• 파이썬(nmap 기능 구현해보기)DAY-1 + 블로그 정리
• 혼자공부하는 네트워크 복습 DAY1 + 블로그 정리
• household account 작성(23:50분에 작성)

🐍 Python Security Scanner 프로젝트 - Day 1

점프 투 파이썬 학습을 마친 후 배운 내용을 실제로 활용하기 위해 시작한 개인 프로젝트이다.
Python의 socket을 이용해 TCP Port Scanner를 직접 구현하고, 순차 스캔의 속도 문제를 ThreadPoolExecutor를 이용한 멀티스레딩으로 개선해보았다.

📌 Day 1 목표

오늘의 목표는 다음과 같다.

• Python socket 모듈 이해
• 특정 IP / Port에 TCP 연결 시도
• OPEN Port 판단
• 여러 Port를 자동으로 스캔
• 함수로 Port Scan 기능 분리
• timeout 설정
• ThreadPoolExecutor를 이용한 멀티스레딩
• 스캔 실행 시간 측정
• 직접 테스트 서버를 만들어 OPEN Port 탐지 검증

⚠️ 포트 스캔 실습은 본인의 PC 또는 직접 관리하는 테스트 환경을 대상으로 진행한다.

1. 프로젝트 생성

프로젝트 폴더를 생성하고 main.py 파일부터 시작했다.

python-security-scanner/
└── main.py

처음부터 복잡하게 파일을 나누기보다는 하나의 파일에서 기능을 구현하고, 프로젝트가 커지면 추후 모듈화할 예정이다.

2. IP와 Port 입력받기

가장 먼저 스캔할 대상의 IP와 Port를 사용자에게 입력받았다.

target_ip = input("스캔할 IP를 입력하세요: ")
target_port = int(input("스캔할 Port를 입력하세요: "))

여기서 IP와 Port의 자료형이 다르다는 점이 중요하다.

IP
"127.0.0.1"
→ str

Port
80
→ int

IP 주소는 127.0.0.1처럼 .이 포함되어 있기 때문에 정수로 변환할 수 없다.

따라서 IP는 문자열 그대로 입력받고, Port만 int()를 이용해 정수로 변환한다.

출력에는 f-string을 사용했다.

print(f"[+] {target_ip}:{target_port}")

실행 예시:

스캔할 IP를 입력하세요: 127.0.0.1
스캔할 Port를 입력하세요: 80

[+] 127.0.0.1:80

3. TCP Socket 생성

실제로 네트워크 연결을 시도하기 위해 Python의 socket 모듈을 사용했다.

import socket

그리고 다음과 같이 Socket을 생성한다.

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

각 옵션의 의미는 다음과 같다.

즉,

socket.socket(socket.AF_INET, socket.SOCK_STREAM)

은 쉽게 말하면

IPv4 주소를 사용하는 TCP Socket을 생성한다.

라는 의미이다.

4. connect_ex()를 이용한 TCP 연결

생성한 Socket을 이용해 대상 IP와 Port에 TCP 연결을 시도한다.

result = sock.connect_ex((target_ip, target_port))

connect_ex()에는 IP와 Port를 하나의 튜플로 전달한다.

("127.0.0.1", 80)

구조는 다음과 같다.

sock.connect_ex(
    (target_ip, target_port)
)

connect_ex()는 연결 결과를 숫자로 반환한다.

TCP 연결 성공
    ↓
result == 0

TCP 연결 실패
    ↓
result != 0

따라서 if문을 이용해 Port의 상태를 판단할 수 있다.

if result == 0:
    print(f"[+] {target_ip}:{target_port} OPEN")
else:
    print(f"[-] {target_ip}:{target_port} CLOSED")

단, 정확히 말하면 result != 0은 무조건 하나의 의미인 CLOSED만 나타내는 것은 아니다.

Connection Refused, Timeout 등 여러 이유로 TCP 연결이 성공하지 않을 수 있기 때문에 이후에는 OPEN 여부를 중심으로 판단하도록 구현했다.

5. Socket 종료

생성한 Socket은 사용이 끝나면 종료해준다.

sock.close()

기본적인 흐름은 다음과 같다.

Socket 생성
    ↓
TCP 연결 시도
    ↓
결과 확인
    ↓
Socket 종료

6. 여러 Port 자동 스캔

처음에는 하나의 Port만 입력받았다.

target_port = int(input("스캔할 Port를 입력하세요: "))

하지만 Port Scanner라면 여러 Port를 자동으로 검사할 수 있어야 한다.

따라서 for문과 range()를 이용했다.

for target_port in range(1, 101):

range()의 마지막 숫자는 포함되지 않기 때문에

range(1, 101)

은 실제로

1
2
3
...
99
100

까지 반복한다.

각 Port마다 새로운 TCP 연결을 시도해야 하기 때문에 Socket 역시 반복문 내부에서 생성하고 종료했다.

for target_port in range(1, 101):

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    result = sock.connect_ex((target_ip, target_port))

    if result == 0:
        print(f"[+] {target_ip}:{target_port} OPEN")

    sock.close()

CLOSED Port까지 모두 출력하면 결과가 너무 많아지기 때문에 이후에는 OPEN Port만 출력하도록 했다.

7. Timeout 설정

여러 Port를 검사해보니 스캔 속도가 매우 느린 문제가 발생했다.

TCP 연결을 시도했는데 상대방이 바로 응답하지 않으면 프로그램이 응답을 기다릴 수 있기 때문이다.

이를 방지하기 위해 Timeout을 설정했다.

sock.settimeout(0.5)

의미는 다음과 같다.

TCP 연결 시도
    ↓
최대 0.5초 동안 기다림
    ↓
응답이 없으면 연결 시도를 계속 기다리지 않음

따라서 Socket 생성 이후 다음과 같이 Timeout을 설정했다.

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.settimeout(0.5)

result = sock.connect_ex((target_ip, target_port))

Timeout 값을 너무 크게 설정하면 스캔 속도가 느려질 수 있고, 반대로 너무 작게 설정하면 응답이 느린 서비스의 연결 성공 여부를 놓칠 수 있다.

8. 직접 8000번 Port 열어보기

Scanner가 실제로 OPEN Port를 탐지하는지 검증하기 위해 Python의 간단한 HTTP Server를 사용했다.

새로운 터미널에서 다음 명령어를 실행했다.

python -m http.server 8000

실행하면 Python HTTP Server가 TCP 8000번 Port에서 연결을 기다린다.

Python HTTP Server
        ↓
TCP 8000
        ↓
OPEN

브라우저에서도 다음 주소로 접근할 수 있다.

http://127.0.0.1:8000

Scanner의 범위도 테스트를 위해 다음과 같이 변경했다.

for target_port in range(7995, 8006):

그러면 다음 Port들을 검사한다.

7995
7996
7997
7998
7999
8000
8001
8002
8003
8004
8005

실행 결과:

[+] 127.0.0.1:8000 OPEN

정상적으로 8000번 Port가 탐지되었다.

HTTP Server를 Ctrl + C로 종료한 뒤 다시 Scanner를 실행하면 8000번 Port가 더 이상 OPEN으로 탐지되지 않는다.

이를 통해 직접 만든 Scanner가 실제 TCP 연결 상태를 기준으로 동작한다는 것을 확인했다.

9. Port Scan 기능 함수화

기존에는 모든 코드를 for문 안에서 처리했다.

이후 멀티스레딩을 적용하기 위해 Port 하나를 검사하는 기능을 함수로 분리했다.

def scan_port(target_ip, target_port):

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    sock.settimeout(0.5)

    result = sock.connect_ex((target_ip, target_port))

    if result == 0:
        print(f"[+] {target_ip}:{target_port} OPEN")

    sock.close()

함수에 필요한 매개변수는 두 개이다.

def scan_port(target_ip, target_port):

• target_ip : 검사할 대상 IP
• target_port : 검사할 Port

예를 들어

scan_port("127.0.0.1", 8000)

을 실행하면

target_ip   = "127.0.0.1"
target_port = 8000

이 함수 내부로 전달된다.

여기서는 return을 사용하지 않았다.

현재 함수의 목적은 결과값을 다른 곳에 반환하는 것이 아니라 OPEN Port가 발견되었을 때 직접 print()로 출력하는 것이기 때문이다.

10. 함수 정의와 함수 호출

함수를 사용하면서 다시 정리한 중요한 개념이다.

다음 코드는 함수를 정의하는 것이다.

def scan_port(target_ip, target_port):

함수를 정의했다고 바로 실행되는 것은 아니다.

실제로 실행하려면 함수를 호출해야 한다.

scan_port(target_ip, target_port)

따라서 반복문과 함수를 다음과 같이 분리할 수 있다.

def scan_port(target_ip, target_port):
    # Port 하나 검사
    ...


for target_port in range(1, 101):
    scan_port(target_ip, target_port)

구조는 다음과 같다.

Port 1
 ↓
scan_port(IP, 1)

Port 2
 ↓
scan_port(IP, 2)

Port 3
 ↓
scan_port(IP, 3)

...

즉,

함수는 한 번 정의하고, for문에서 필요한 만큼 호출한다.

11. 순차 스캔의 문제

함수화를 했지만 여전히 Port는 순서대로 검사한다.

Port 1 검사
    ↓
완료
    ↓
Port 2 검사
    ↓
완료
    ↓
Port 3 검사

Timeout이 0.5초라고 가정하면 응답이 늦은 Port가 많을 경우 시간이 상당히 오래 걸릴 수 있다.

예를 들어 1000개의 Port가 각각 최대 0.5초를 기다린다면 이론적으로 상당한 시간이 필요할 수 있다.

따라서 여러 Port를 동시에 검사하도록 개선하기로 했다.

12. ThreadPoolExecutor

Python의 concurrent.futures 모듈에서 ThreadPoolExecutor를 사용했다.

from concurrent.futures import ThreadPoolExecutor

ThreadPoolExecutor는 여러 Worker Thread가 작업을 나눠 처리할 수 있도록 해준다.

예를 들어

ThreadPoolExecutor(max_workers=10)

은 최대 10개의 Worker Thread를 이용해 작업을 처리한다.

기존 방식:

Worker 1 → Port 1 → 완료
                    ↓
           Port 2 → 완료
                    ↓
           Port 3 → 완료

멀티스레딩:

Worker 1  → Port 1
Worker 2  → Port 2
Worker 3  → Port 3
Worker 4  → Port 4
...
Worker 10 → Port 10

네트워크 연결처럼 응답을 기다리는 시간이 많은 I/O 작업에서는 여러 연결을 동시에 진행할 수 있기 때문에 성능 개선 효과를 얻을 수 있다.

13. executor.submit()

Thread Pool에 작업을 전달하기 위해 submit()을 사용했다.

executor.submit(scan_port, target_ip, target_port)

구조를 풀어보면 다음과 같다.

executor.submit(
    scan_port,      ← 실행할 함수
    target_ip,      ← 첫 번째 인수
    target_port     ← 두 번째 인수
)

즉 Worker에게

scan_port(target_ip, target_port)

작업을 실행하도록 요청하는 것이다.

14. 멀티스레딩 Port Scanner

for문과 ThreadPoolExecutor를 결합했다.

with ThreadPoolExecutor(max_workers=10) as executor:

    for target_port in range(1, 1001):

        executor.submit(scan_port, target_ip, target_port)

with 블록을 사용하면 Thread Pool을 사용한 뒤 필요한 정리를 처리할 수 있고, 블록을 빠져나올 때 제출된 작업들이 완료될 때까지 기다린다.

이제 하나의 Worker가 Port를 순서대로 검사하는 대신 여러 Worker가 Port Scan 작업을 나누어 처리한다.

15. 스캔 시간 측정

멀티스레딩 적용 전후의 성능을 확인하기 위해 time 모듈을 사용했다.

import time

스캔 직전에 시작 시간을 기록한다.

start_time = time.time()

모든 작업이 완료된 이후 종료 시간을 기록한다.

end_time = time.time()

그리고 두 값의 차이를 계산한다.

print(f"스캔 소요 시간: {end_time - start_time}초")

중요한 점은 start_time과 end_time의 위치이다.

start_time
    ↓

전체 Port Scan

    ↓
모든 Thread 작업 완료
    ↓

end_time

각 Port를 검사할 때마다 시간을 측정하는 것이 아니라 전체 Port Scan 작업의 시작과 끝을 한 번씩 측정해야 한다.

16. 멀티스레딩 성능 비교

127.0.0.1의 1~1000번 Port를 대상으로 테스트했다.

Timeout:

sock.settimeout(0.5)

10 Workers

ThreadPoolExecutor(max_workers=10)

실행 결과:

스캔 소요 시간: 약 51.03초

50 Workers

ThreadPoolExecutor(max_workers=50)

실행 결과:

스캔 소요 시간: 약 10.22초

결과를 정리하면 다음과 같다.

50 Workers를 사용했을 때 10 Workers보다 약 5배 빠른 결과를 확인할 수 있었다.

대략적으로 생각하면 10 Workers의 경우:

1000개 Port ÷ 10 Workers
= Worker당 약 100개

100개 × 최대 0.5초
≈ 50초

실제 결과는 약 51초였다.

50 Workers의 경우:

1000개 Port ÷ 50 Workers
= Worker당 약 20개

20개 × 최대 0.5초
≈ 10초

실제 결과 역시 약 10.22초였다.

따라서 단순히 "멀티스레딩이 빠르다"가 아니라 실제 실행 시간을 측정하여 성능 차이를 확인할 수 있었다.

단, Worker 수를 무조건 크게 설정한다고 항상 좋은 것은 아니므로 이후 적절한 Worker 수와 Timeout 값도 테스트해볼 예정이다.

17. 실제로 탐지된 OPEN Port

1~1000번 Port를 스캔하면서 내 PC에서 다음과 같은 OPEN Port들이 탐지되었다.

[+] 127.0.0.1:135 OPEN
[+] 127.0.0.1:445 OPEN
[+] 127.0.0.1:902 OPEN
[+] 127.0.0.1:912 OPEN
[+] 127.0.0.1:945 OPEN

현재 단계에서는 TCP 연결 성공 여부만 판단하고 있기 때문에 각 Port에서 실제로 어떤 서비스가 동작하고 있는지는 확인하지 않는다.

서비스 식별은 이후 기능으로 추가할 예정이다.

18. Day 1 최종 코드

import time
import socket
from concurrent.futures import ThreadPoolExecutor

# 스캔할 대상 IP 입력
target_ip = input("스캔할 IP를 입력하세요: ")


# 하나의 Port를 검사하는 함수
def scan_port(target_ip, target_port):

    # IPv4(AF_INET) + TCP(SOCK_STREAM) 소켓 생성
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # TCP 연결 시 최대 0.5초까지만 응답을 기다림
    sock.settimeout(0.5)

    # 대상 IP와 Port에 TCP 연결을 시도하고 결과 코드 반환
    result = sock.connect_ex((target_ip, target_port))

    # connect_ex()의 반환값이 0이면 TCP 연결 성공
    if result == 0:
        print(f"[+] {target_ip}:{target_port} OPEN")

    # 현재 Port 검사가 끝났으므로 Socket 종료
    sock.close()


# 전체 Port Scan 시작 시간 기록
start_time = time.time()


# 최대 50개의 작업자 Thread를 사용하는 Thread Pool 생성
with ThreadPoolExecutor(max_workers=50) as executor:

    # 1번부터 1000번 Port까지 반복
    for target_port in range(1, 1001):

        # scan_port() 작업을 Thread Pool에 제출
        executor.submit(scan_port, target_ip, target_port)


# 모든 Port Scan 작업 완료 후 종료 시간 기록
end_time = time.time()


# 전체 Port Scan 소요 시간 출력
print(f"스캔 소요 시간: {end_time - start_time}초")

📊 Day 1 프로그램 동작 흐름

사용자에게 Target IP 입력
            ↓
      Port 1 ~ 1000
            ↓
   ThreadPoolExecutor
       (50 Workers)
            ↓
      scan_port()
            ↓
     TCP Socket 생성
            ↓
      Timeout 설정
            ↓
      connect_ex()
            ↓
       TCP 연결 시도
            ↓
      ┌─────┴─────┐
      ↓           ↓
 result == 0   result != 0
      ↓           ↓
    OPEN       출력하지 않음
      ↓
  Socket 종료
            ↓
    모든 작업 완료
            ↓
     실행 시간 출력

💡 Day 1에서 배운 내용

이번 프로젝트를 진행하면서 기존에 공부했던 Python 문법이 실제 프로그램에서 어떻게 사용되는지 확인할 수 있었다.

그리고 새롭게 다음 내용을 접했다.

• TCP Socket
• AF_INET
• SOCK_STREAM
• connect_ex()
• Timeout
• Thread
• Thread Pool
• ThreadPoolExecutor
• executor.submit()
• 프로그램 실행 시간 측정

🔍 오늘 발생했던 문제와 해결

1. IP에 int()를 사용함

처음에는 다음과 같이 작성했다.

target_ip = int(input(...))

하지만 IP는 127.0.0.1과 같은 문자열이므로 int()로 변환할 수 없다.

target_ip = input(...)

로 수정했다.

2. sock.close()를 for문 밖에 작성

Port마다 새로운 Socket을 생성하면서 close()를 반복문 밖에 작성하면 마지막 Socket만 종료하게 된다.

따라서 각 Port의 검사가 끝날 때마다 Socket을 종료하도록 반복문 내부에 배치했다.

3. 함수 내부에 for문을 작성

처음 함수화할 때

def scan_port(target_ip, target_port):
    for target_port in range(...):

형태로 작성했다.

하지만 scan_port()의 역할은 Port 하나를 검사하는 것으로 정하고 반복은 함수 외부에서 담당하도록 분리했다.

for target_port in range(...):
    scan_port(target_ip, target_port)

4. start_time을 함수 내부에 작성

함수 내부에서 시작 시간을 기록하면 Port마다 새로운 시작 시간이 만들어진다.

내가 측정하고 싶은 것은 전체 Port Scan 시간이므로 스캔 시작 직전에 한 번만 기록하도록 수정했다.

5. end_time을 for문 내부에 작성

executor.submit()은 작업을 Thread Pool에 제출하는 것이므로 작업 제출 직후가 전체 Scan 종료 시점은 아니다.

따라서 with ThreadPoolExecutor(...) 블록이 종료된 이후 end_time을 기록했다.

🚀 다음 목표 - Day 2

현재 Scanner는

IP 입력
↓
1~1000 Port Scan
↓
OPEN Port 탐지

까지 구현했다.

Day 2에서는 여기서 기능을 조금 더 발전시켜볼 예정이다.

OPEN Port
   ↓
어떤 서비스인가?
   ↓
22   → SSH
80   → HTTP
443  → HTTPS
...

단순히

[+] 127.0.0.1:445 OPEN

이라고 출력하는 것을 넘어

[+] 127.0.0.1:445 OPEN
    Service : ?

처럼 열린 Port의 서비스 정보를 확인하는 기능을 만들어보는 것이 다음 목표다.

이후에는 결과 저장, 예외 처리, 입력값 검증 등을 하나씩 추가하면서 Scanner를 발전시켜볼 예정이다.

📝 Day 1 한줄 정리

Python socket으로 TCP Port Scanner를 구현하고, 순차 스캔에서 발생한 속도 문제를 ThreadPoolExecutor 기반 멀티스레딩으로 개선한 뒤 실제 실행 시간을 측정해 성능 차이를 확인했다.

목차

• 1. AI를 파이썬 공부에 활용하기
• 2. AI가 도움이 되는 순간
• 3. 질문을 잘하는 방법
• 4. 오류 원인 찾기
• 5. 코드 수정하기
• 6. 코드 설명 받기
• 7. 연습문제 만들기
• 8. 코드 스타일 개선하기
• 9. AI 답변 검증하기
• 10. AI를 이용한 공부 방법 정리

1. AI를 파이썬 공부에 활용하기

파이썬을 공부하다 보면 책이나 강의를 보면서도 이해되지 않는 부분이 생긴다.

예를 들어

왜 오류가 발생하지?

왜 결과가 내가 생각한 것과 다르지?

이 코드는 왜 이렇게 작성하지?

이 개념을 더 쉽게 설명할 수 없을까?

와 같은 궁금증이 생긴다.

과거에는 이런 문제가 생기면

검색
 ↓
여러 글 확인
 ↓
내 상황과 비슷한 내용 찾기
 ↓
직접 해결

하는 과정이 필요했다.

하지만 AI를 활용하면 현재 작성하고 있는 코드와 오류 내용을 그대로 보여 주면서 질문할 수 있다.

즉 AI를

모르는 내용을 바로 질문할 수 있는 개인 학습 도우미

처럼 활용할 수 있다.

2. AI가 특히 도움이 되는 순간

파이썬을 처음 공부할 때 자주 막히는 상황은 크게 세 가지이다.

1. 오류 메시지를 이해하지 못할 때

IndexError
TypeError
KeyError
NameError

등의 오류가 발생했지만 원인을 모르겠을 때이다.

2. 코드가 원하는 대로 동작하지 않을 때

코드는 실행되지만

내가 기대한 결과
≠
실제 결과

인 경우이다.

3. 개념을 이해하기 어려울 때

예를 들어

클래스
클로저
데코레이터
이터레이터
제너레이터
정규 표현식

같은 개념이 책의 설명만으로 잘 이해되지 않을 수 있다.

이때 AI에게

더 쉽게 설명해 줘

예제를 추가해서 설명해 줘

한 줄씩 설명해 줘

처럼 요청할 수 있다.

3. 질문을 잘하는 방법

AI에게 질문할 때 단순히

이거 왜 안 돼?

라고 물어보는 것보다 필요한 정보를 함께 제공하는 것이 좋다.

특히 다음 네 가지를 알려 주면 된다.

1. 내가 하고 싶은 것

2. 내가 작성한 코드

3. 실제 실행 결과 또는 오류 메시지

4. 내가 기대한 결과

질문 구조

예를 들어 다음과 같은 형태이다.

목표
↓
리스트의 모든 값을 더하고 싶습니다.

코드
↓
numbers = [1, 2, 3]
...

실제 결과
↓
IndexError가 발생합니다.

원하는 결과
↓
6이 출력되었으면 좋겠습니다.

이렇게 질문하면 AI도

무엇을 만들고 있는지

어디에서 문제가 발생했는지

어떤 결과를 원하는지

를 정확하게 파악할 수 있다.

4. 오류 원인 찾기

다음 코드를 실행했다고 해보자.

numbers = [1, 2, 3]

print(numbers[3])

오류가 발생한다.

IndexError: list index out of range

이럴 때 AI에게 코드와 오류를 함께 전달한다.

왜 오류가 발생할까?

리스트가

numbers = [1, 2, 3]

이라면 인덱스는 다음과 같다.

값       1   2   3
인덱스   0   1   2

따라서

numbers[3]

은 존재하지 않는 네 번째 위치를 요청하는 것이다.

그래서

IndexError

가 발생한다.

정상적인 마지막 값은

numbers[2]

이다.

오류를 질문할 때 중요한 점

오류 메시지가 길더라도 가능하면 중간 부분을 임의로 제거하지 않는 것이 좋다.

예를 들어

Traceback ...
파일 위치
오류가 발생한 줄
오류 종류
오류 메시지

에는 문제를 찾는 데 필요한 정보가 포함되어 있다.

따라서

코드
+
전체 오류 메시지

를 같이 전달하는 것이 좋다.

5. 코드 수정하기

다음 코드를 보자.

numbers = [1, 2, 3]

total = 0

for i in range(4):
    total += numbers[i]

print(total)

목표는

1 + 2 + 3
=
6

을 출력하는 것이다.

하지만 오류가 발생한다.

문제 원인

range(4)

는

0
1
2
3

을 생성한다.

따라서 반복 과정은

numbers[0] → 1
numbers[1] → 2
numbers[2] → 3
numbers[3] → 오류

가 된다.

numbers[3]은 존재하지 않는다.

수정 방법 1

numbers = [1, 2, 3]

total = 0

for i in range(3):
    total += numbers[i]

print(total)

결과

6

수정 방법 2

리스트의 길이를 직접 사용하면 더 좋다.

numbers = [1, 2, 3]

total = 0

for i in range(len(numbers)):
    total += numbers[i]

print(total)

이렇게 하면 리스트 길이가 바뀌어도 사용할 수 있다.

수정 방법 3

인덱스가 필요 없다면 값을 직접 반복할 수 있다.

numbers = [1, 2, 3]

total = 0

for number in numbers:
    total += number

print(total)

결과

6

이 방법이 가장 읽기 쉽다.

6. AI에게 코드를 수정해 달라고 할 때

단순히

이 코드 고쳐 줘.

라고 요청하는 것보다

현재 결과
+
원하는 결과

를 알려 주는 것이 중요하다.

예를 들어

현재는 IndexError가 발생합니다.

리스트의 숫자를 모두 더해서
6이 출력되도록 수정해 주세요.

수정한 이유도 설명해 주세요.

처럼 질문할 수 있다.

그러면 단순히 정답 코드만 얻는 것이 아니라 왜 문제가 발생했는지도 함께 공부할 수 있다.

7. 코드 설명 받기

처음 보는 코드를 만났을 때 AI에게 한 줄씩 설명해 달라고 요청할 수도 있다.

예를 들어

for i in range(1, 6):
    if i % 2 == 0:
        print(i, "는 짝수입니다.")
    else:
        print(i, "는 홀수입니다.")

한 줄씩 살펴보기

range()

range(1, 6)

은

1, 2, 3, 4, 5

를 만든다.

for

for i in range(1, 6):

i에 숫자가 하나씩 들어간다.

i = 1
i = 2
i = 3
i = 4
i = 5

나머지 연산자

i % 2

숫자를 2로 나눈 나머지를 구한다.

짝수라면

나머지 = 0

이다.

따라서

if i % 2 == 0:

은

i가 짝수인가?

를 검사하는 코드이다.

전체 흐름

1부터 5까지 반복
       ↓
현재 숫자를 2로 나눔
       ↓
나머지가 0인가?
   ↙           ↘
 Yes           No
 ↓              ↓
짝수 출력      홀수 출력

8. 이해 수준을 지정해서 질문하기

AI의 설명이 너무 어렵다면 질문할 때 이해 수준을 지정할 수 있다.

예를 들어

파이썬을 처음 배우는 사람 기준으로 설명해 줘.

중학생도 이해할 수 있게 설명해 줘.

코드를 한 줄씩 실행 순서대로 설명해 줘.

변수 값이 어떻게 바뀌는지 표로 보여 줘.

처럼 요청할 수 있다.

특히 코드를 공부할 때는

실행 순서
+
변수 변화

를 같이 보는 것이 이해에 도움이 된다.

9. 연습문제 만들기

AI는 현재 배운 범위에 맞는 문제를 만드는 데도 활용할 수 있다.

예를 들어 현재

if문
for문
함수

까지만 공부했다고 해보자.

이때

if문, for문, 함수까지만 사용해서
풀 수 있는 연습문제를 만들어 줘.

라고 요청할 수 있다.

난이도도 지정 가능

초급 문제 3개 만들어 줘.

중간 난이도로 만들어 줘.

한 문제씩 내 줘.

내가 답을 말하기 전까지 정답은 알려 주지 마.

틀렸을 때는 힌트만 줘.

처럼 공부 방식까지 지정할 수 있다.

10. 문제 풀이에 AI를 사용하는 좋은 방법

AI가 문제를 만들자마자 정답까지 보여 주면 직접 생각할 시간이 줄어든다.

따라서 다음과 같은 방식이 좋다.

문제 출제
   ↓
직접 풀이
   ↓
코드 실행
   ↓
결과 확인
   ↓
모르겠으면 힌트 요청
   ↓
다시 풀이
   ↓
마지막에 정답과 비교

AI를 답을 바로 알려 주는 도구가 아니라

문제 출제자
+
힌트를 주는 선생님

처럼 사용할 수 있다.

11. 코드 스타일 개선하기

프로그램이 정상적으로 동작하더라도 코드가 읽기 어려울 수 있다.

예를 들어

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

b = 0

for c in a:
    b += c

print(b)

결과 자체는 정상이다.

15

하지만 변수 이름만 보면 각각 무엇을 의미하는지 알기 어렵다.

읽기 쉽게 수정

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

total = 0

for number in numbers:
    total += number

print(total)

기능은 동일하지만 훨씬 쉽게 읽을 수 있다.

a → numbers
b → total
c → number

처럼 변수의 역할을 알 수 있기 때문이다.

12. 리팩터링

기존 프로그램의 기능은 유지하면서 코드 구조를 개선하는 것을 리팩터링(Refactoring) 이라고 한다.

AI에게 다음과 같이 요청할 수 있다.

기능은 그대로 유지해 주세요.

코드를 더 읽기 쉽게 수정해 주세요.

변수 이름도 역할을 알 수 있게 바꿔 주세요.

수정 전후의 차이도 설명해 주세요.

단순히 짧은 코드가 항상 좋은 코드는 아니다.

중요한 것은

읽기 쉬운가?

의도를 알 수 있는가?

수정하기 쉬운가?

이다.

13. AI의 답변을 그대로 믿으면 안 되는 이유

AI는 매우 유용하지만 항상 정확한 답변만 하는 것은 아니다.

예를 들어

존재하지 않는 함수

잘못된 문법

논리적으로 틀린 코드

현재 버전에서는 동작하지 않는 코드

를 제시할 수도 있다.

따라서 AI가 코드를 만들어 줬다면 반드시 직접 실행해야 한다.

14. 직접 실행하기

AI가 다음과 같은 코드를 알려 주었다고 해도

numbers = [1, 2, 3]

print(sum(numbers))

눈으로만 보고

맞겠지

라고 생각하는 것이 아니라 실제로 실행한다.

실행 결과

6

처럼 확인한다.

15. 입력값을 바꿔서 테스트하기

한 번 정상 동작했다고 해서 모든 상황에서 정상이라고 볼 수는 없다.

예를 들어

def divide(a, b):
    return a / b

다음 코드는 정상이다.

divide(10, 2)

5.0

하지만

divide(10, 0)

을 실행하면

ZeroDivisionError

가 발생한다.

따라서 여러 입력값을 사용해 보는 것이 중요하다.

정상적인 값
경계값
예외적인 값

등을 테스트해 본다.

16. 테스트하는 습관

예를 들어 양수를 판별하는 함수를 만들었다고 해보자.

def is_positive(number):
    return number > 0

한 가지 값만 확인하지 않는다.

print(is_positive(10))
print(is_positive(-10))
print(is_positive(0))

결과

True
False
False

처럼 여러 상황에서 확인한다.

17. 이해가 안 되면 다시 질문하기

AI가 설명했지만 여전히 이해되지 않는다면 그대로 넘어가지 않는다.

예를 들어

왜 이렇게 되는지 모르겠어.

더 쉽게 설명해 줘.

변수 값이 어떻게 변하는지 단계별로 보여 줘.

작은 숫자로 예시를 들어 줘.

그림처럼 흐름으로 보여 줘.

처럼 다시 질문하면 된다.

같은 개념도 설명 방법을 바꾸면 훨씬 쉽게 이해될 수 있다.

18. 초보자에게 좋은 질문 방식

처음부터 너무 많은 내용을 한 번에 질문하면 답변도 복잡해질 수 있다.

따라서 하나씩 질문하는 것이 좋다.

예를 들어

파이썬 함수, 클래스, 상속, 오버라이딩,
클로저, 데코레이터를 전부 설명해 줘.

보다는

클래스가 무엇인지 먼저 설명해 줘.

그리고 이해한 뒤

이번에는 상속을 설명해 줘.

처럼 진행한다.

19. 코드만 받지 않기

AI에게 코드를 요청하면 정답 코드를 빠르게 얻을 수 있다.

하지만

코드 복사
 ↓
실행
 ↓
끝

으로 공부하면 실력이 잘 늘지 않는다.

더 좋은 방법은

코드 확인
 ↓
왜 이렇게 작성했는지 이해
 ↓
직접 다시 작성
 ↓
값을 변경해서 테스트

하는 것이다.

20. 좋은 질문과 좋지 않은 질문 비교

좋지 않은 질문

이거 왜 안 돼?

문제 상황을 알기 어렵다.

더 좋은 질문

리스트 [1, 2, 3]의 합계를 구하려고 합니다.

현재 코드는 다음과 같습니다.

numbers = [1, 2, 3]
total = 0

for i in range(4):
    total += numbers[i]

print(total)

IndexError가 발생합니다.

원하는 결과는 6입니다.

왜 오류가 발생하는지
초보자 기준으로 설명해 주세요.

AI가 문제 상황을 훨씬 정확하게 이해할 수 있다.

21. 질문 템플릿

파이썬 공부 중 오류가 발생했다면 다음 형식을 사용할 수 있다.

[목표]

제가 만들고 싶은 것은 ______ 입니다.


[현재 코드]

코드는 다음과 같습니다.

```python
코드 작성

[현재 결과]

실행하면 __ 결과가 나오거나 __ 오류가 발생합니다.

[원하는 결과]

제가 원하는 결과는 __ 입니다.

[질문]

왜 이런 문제가 발생하는지 파이썬 초보자 기준으로 설명해 주세요.

수정 코드뿐 아니라 수정하는 이유도 같이 설명해 주세요.

---

# 22. 코드 공부용 질문 템플릿

코드를 이해하고 싶을 때는 다음처럼 사용할 수 있다.

```text
다음 파이썬 코드를 공부하고 있습니다.

```python
코드 작성

다음 순서로 설명해 주세요.

1. 전체 코드의 목적
2. 한 줄씩 설명
3. 실행 순서
4. 변수 값이 어떻게 변하는지
5. 핵심 문법
6. 초보자가 헷갈릴 만한 부분

23. 연습문제용 질문 템플릿

현재 파이썬에서 다음 내용을 공부했습니다.

- 리스트
- if문
- for문
- 함수

이 범위 안에서만 풀 수 있는
연습문제 3개를 만들어 주세요.

조건

- 쉬운 문제부터 순서대로
- 정답은 바로 알려 주지 않기
- 한 문제씩 출제
- 틀리면 힌트만 제공
- 마지막에 전체 풀이 설명

이런 방식으로 AI를 개인 문제 출제 도구처럼 사용할 수 있다.

24. AI를 이용한 추천 학습 흐름

파이썬을 공부할 때 다음과 같은 흐름으로 활용할 수 있다.

책 / 강의 공부
      ↓
직접 코드 작성
      ↓
직접 실행
      ↓
이해됨?
 ↙          ↘
Yes          No
 ↓            ↓
다음 내용     AI에게 질문
              ↓
          설명 확인
              ↓
          코드 수정
              ↓
          다시 직접 실행
              ↓
          값 변경 테스트
              ↓
          직접 다시 작성

핵심은 항상

AI 답변
 ↓
직접 확인

과정을 거치는 것이다.

25. AI에게 질문할 때 기억할 것

좋은 질문에는 보통 다음 정보가 포함된다.

무엇을 하려고 하는가?

현재 코드는 무엇인가?

현재 어떤 일이 발생하는가?

어떤 결과를 원하는가?

그리고 답변을 받은 뒤에는

직접 실행

다른 값으로 테스트

이해되지 않는 부분 재질문

과정을 거친다.

📌 핵심 정리

AI가 유용한 상황

오류 원인을 모를 때

코드가 원하는 대로 동작하지 않을 때

개념이 이해되지 않을 때

코드 설명이 필요할 때

연습문제가 필요할 때

코드를 더 읽기 쉽게 만들고 싶을 때

좋은 질문의 4가지 요소

1. 목표

2. 현재 코드

3. 실제 결과 / 오류 메시지

4. 기대하는 결과

오류 질문

코드
+
전체 오류 메시지
+
원하는 동작

을 함께 전달한다.

코드 설명

한 줄씩 설명해 줘

실행 순서대로 설명해 줘

변수 값이 어떻게 변하는지 보여 줘

처럼 구체적으로 요청한다.

연습문제

현재 배운 범위를 알려 주고

정답은 바로 말하지 않기

힌트만 제공

한 문제씩 진행

처럼 학습 방식까지 지정할 수 있다.

코드 개선

AI에게 단순히 코드를 짧게 만들어 달라고 하기보다

가독성

변수 이름

중복 코드

코드 구조

를 개선해 달라고 요청한다.

AI 답변 검증

AI가 알려 준 답변은 반드시

직접 실행
   ↓
입력값 변경
   ↓
2~3번 추가 테스트
   ↓
이상하면 다시 확인

하는 과정이 필요하다.

⭐ 09-2 전체 흐름

파이썬 공부
    ↓
직접 생각하고 코드 작성
    ↓
문제 발생
    ↓
AI에게 질문
    ↓
┌─────────────────┐
│ 목표             │
│ 코드             │
│ 실제 결과        │
│ 원하는 결과      │
└─────────────────┘
    ↓
AI의 설명 확인
    ↓
직접 코드 수정
    ↓
직접 실행
    ↓
다른 값으로 테스트
    ↓
왜 동작하는지 이해
    ↓
직접 다시 작성

AI는 정답을 대신 작성해 주는 도구로 사용하기보다, 막힌 부분을 설명받고 스스로 이해할 수 있도록 돕는 학습 도구로 사용하는 것이 가장 좋다.

결국 중요한 것은

질문
→ 답변 복사
→ 끝

이 아니라

질문
→ 원리 이해
→ 직접 실행
→ 테스트
→ 직접 다시 작성

의 과정을 반복하는 것이다.

목차

• Q1. 문자열 바꾸기
• Q2. 딕셔너리 값 추출하기
• Q3. 리스트 더하기와 extend()
• Q4. 리스트 총합 구하기
• Q5. 피보나치 수열
• Q6. 숫자의 총합 구하기
• Q7. 한 줄 구구단
• Q8. 파일 역순 저장
• Q9. 총합과 평균 구하기
• Q10. Calculator 클래스
• Q11. 모듈 불러오기
• Q12. 오류와 예외 처리
• Q13. DashInsert
• Q16. 모스 부호 해독
• Q17. 기초 메타 문자
• Q18. 문자열 검색
• Q19. 그루핑
• Q20. 전방 탐색

Q1. 문자열 바꾸기

문자열

a:b:c:d

에서 :을 기준으로 문자열을 나누고 다시 #으로 연결한다.

풀이

a = "a:b:c:d"

result = "#".join(a.split(":"))

print(result)

실행 결과

a#b#c#d

동작 과정

먼저

a.split(":")

을 실행하면

['a', 'b', 'c', 'd']

가 된다.

그리고

"#".join(...)

을 사용하면

a#b#c#d

처럼 리스트의 요소 사이에 #을 넣어 다시 문자열로 만든다.

"a:b:c:d"
     ↓
 split(":")
     ↓
['a', 'b', 'c', 'd']
     ↓
"#".join()
     ↓
"a#b#c#d"

핵심

split()

→ 문자열 나누기

join()

→ 문자열 연결하기

Q2. 딕셔너리 값 추출하기

딕셔너리에 존재하지 않는 Key를

a['C']

처럼 조회하면 KeyError가 발생한다.

a = {
    'A': 90,
    'B': 80
}

이때 C가 없다면 기본값 70을 얻고 싶다.

풀이

get()을 사용하면 간단하다.

a = {
    'A': 90,
    'B': 80
}

print(a.get('C', 70))

실행 결과

70

get()

딕셔너리.get(Key, 기본값)

형태로 사용할 수 있다.

a.get('A', 70)

A가 존재하므로

90

을 반환한다.

반면

a.get('C', 70)

에서는 C가 없기 때문에

70

을 반환한다.

핵심

a['C']
→ Key가 없으면 오류

a.get('C')
→ Key가 없으면 None

a.get('C', 70)
→ Key가 없으면 70

Q3. 리스트 더하기와 extend()

다음 두 코드는 결과만 보면 동일하다.

+

a = [1, 2, 3]

a = a + [4, 5]

print(a)

[1, 2, 3, 4, 5]

extend()

a = [1, 2, 3]

a.extend([4, 5])

print(a)

[1, 2, 3, 4, 5]

하지만 동작 방식에는 차이가 있다.

+

a = a + [4, 5]

은 기존 리스트를 수정하는 것이 아니라 새로운 리스트를 만들어 a가 다시 가리키게 한다.

a = [1, 2, 3]

print(id(a))

a = a + [4, 5]

print(id(a))

두 id() 값이 달라진다.

기존 리스트
[1, 2, 3]

      +

[4, 5]

      ↓

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

extend()

a.extend([4, 5])

는 기존 리스트 자체에 값을 추가한다.

a = [1, 2, 3]

print(id(a))

a.extend([4, 5])

print(id(a))

객체의 id()가 유지된다.

핵심

Q4. 리스트 총합 구하기

점수 중에서 50점 이상인 값만 더한다.

A = [20, 55, 67, 82, 45, 33, 90, 87, 100, 25]

풀이

A = [20, 55, 67, 82, 45, 33, 90, 87, 100, 25]

result = 0

for score in A:
    if score >= 50:
        result += score

print(result)

실행 결과

481

동작 과정

20  → X
55  → +55
67  → +67
82  → +82
45  → X
33  → X
90  → +90
87  → +87
100 → +100
25  → X

조금 더 간단하게

result = sum(score for score in A if score >= 50)

하지만 지금 단계에서는 for + if 방식의 흐름을 정확히 이해하는 것이 더 중요하다.

Q5. 피보나치 수열

피보나치 수열은 앞의 두 값을 더해 다음 값을 만든다.

0, 1, 1, 2, 3, 5, 8, 13 ...

즉

0 + 1 = 1
1 + 1 = 2
1 + 2 = 3
2 + 3 = 5
...

형태이다.

n개의 피보나치 수 만들기

def fibonacci(n):
    result = []

    a = 0
    b = 1

    for _ in range(n):
        result.append(a)

        a, b = b, a + b

    return result


n = int(input("숫자 입력: "))

print(fibonacci(n))

예를 들어

숫자 입력: 8

결과

[0, 1, 1, 2, 3, 5, 8, 13]

핵심 코드

a, b = b, a + b

예를 들어

a = 0
b = 1

이라면

a = 1
b = 1

이 되고 다음에는

a = 1
b = 2

가 된다.

Q6. 숫자의 총합 구하기

사용자가 다음과 같이 입력한다고 해보자.

65,45,2,3,45,8

콤마를 기준으로 값을 나눈 후 숫자로 변환하여 합계를 구한다.

풀이

data = input("값을 입력하세요: ")

numbers = map(int, data.split(","))

result = sum(numbers)

print(result)

실행 결과

168

동작 과정

"65,45,2,3,45,8"

        ↓ split(",")

['65', '45', '2', '3', '45', '8']

        ↓ map(int, ...)

65, 45, 2, 3, 45, 8

        ↓ sum()

168

Q7. 한 줄 구구단

사용자로부터 2~9 중 하나를 입력받아 해당 구구단의 결과를 한 줄로 출력한다.

풀이

dan = int(
    input("구구단을 출력할 숫자를 입력하세요(2~9): ")
)

for i in range(1, 10):
    print(dan * i, end=" ")

예를 들어

2

를 입력하면

2 4 6 8 10 12 14 16 18

이 출력된다.

end=" "

기본적인 print()는 출력이 끝나면 줄을 바꾼다.

print(1)
print(2)

1
2

하지만

print(1, end=" ")
print(2, end=" ")

처럼 사용하면

1 2

한 줄로 출력할 수 있다.

Q8. 파일 역순 저장

파일 내용이 다음과 같다고 해보자.

AAA
BBB
CCC
DDD
EEE

이를 역순으로 변경한다.

EEE
DDD
CCC
BBB
AAA

풀이

with open("abc.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()

lines.reverse()

with open("abc.txt", "w", encoding="utf-8") as f:
    f.writelines(lines)

readlines()

f.readlines()

파일을 줄 단위로 읽어 리스트로 반환한다.

예를 들어

[
    "AAA\n",
    "BBB\n",
    "CCC\n",
    "DDD\n",
    "EEE\n"
]

와 같은 형태이다.

reverse()

lines.reverse()

리스트의 순서를 실제로 뒤집는다.

AAA       EEE
BBB       DDD
CCC  →    CCC
DDD       BBB
EEE       AAA

주의할 점

텍스트 파일의 마지막 줄에 \n이 없다면 역순 저장 후

EEEDDD

처럼 두 줄이 붙는 문제가 생길 수 있다.

즉 파일에서 줄바꿈 문자 \n도 데이터의 일부라는 점을 기억하자.

Q9. 총합과 평균 구하기

파일에 숫자가 한 줄에 하나씩 저장되어 있다고 해보자.

70
60
55
75
95
90
80
80
85
100

이 값을 읽어

• 총합
• 평균

을 계산하고 평균을 result.txt에 저장한다.

풀이

with open(
    "sample.txt",
    "r",
    encoding="utf-8"
) as f:
    numbers = [
        int(line.strip())
        for line in f
    ]

total = sum(numbers)
average = total / len(numbers)

print("총합:", total)
print("평균:", average)

with open(
    "result.txt",
    "w",
    encoding="utf-8"
) as f:
    f.write(str(average))

실행 결과

총합: 790
평균: 79.0

result.txt

79.0

평균 공식

평균
=
전체 합계 / 데이터 개수

즉

790 / 10
=
79.0

이다.

Q10. Calculator 클래스

숫자 리스트를 입력받아

sum()
avg()

기능을 제공하는 클래스를 만든다.

풀이

class Calculator:

    def __init__(self, numbers):
        self.numbers = numbers

    def sum(self):
        return sum(self.numbers)

    def avg(self):
        return sum(self.numbers) / len(self.numbers)


cal1 = Calculator([1, 2, 3, 4, 5])

print(cal1.sum())
print(cal1.avg())

cal2 = Calculator([6, 7, 8, 9, 10])

print(cal2.sum())
print(cal2.avg())

실행 결과

15
3.0
40
8.0

왜 self.result를 계속 누적하면 안 될까?

예를 들어

def sum(self):
    for i in self.numbers:
        self.result += i

를 실행한 뒤 다시 avg()에서

self.result += i

를 하면 앞에서 계산했던 값이 남아 있어 중복으로 더해진다.

따라서 합계와 평균처럼 단순 계산은 매번

sum(self.numbers)

를 사용하는 것이 훨씬 깔끔하다.

Q11. 모듈 불러오기

다음 위치에

C:\doit\mymod.py

모듈이 있다고 가정해 보자.

파이썬에서

import mymod

를 사용할 수 있도록 하는 대표적인 방법은 세 가지가 있다.

1. sys.path 추가

import sys

sys.path.append(r"C:\doit")

import mymod

파이썬이 모듈을 검색하는 경로에 C:\doit을 추가한다.

2. PYTHONPATH

Windows 명령 프롬프트에서

set PYTHONPATH=C:\doit

환경 변수를 설정한 후

python

을 실행하면

import mymod

를 사용할 수 있다.

3. 모듈이 있는 위치에서 실행

cd C:\doit
python

이후

import mymod

를 실행한다.

핵심

파이썬은 모듈을

sys.path

에 등록된 경로에서 찾는다.

확인하려면

import sys

print(sys.path)

를 사용할 수 있다.

Q12. 오류와 예외 처리

다음 코드를 살펴보자.

result = 0

try:
    [1, 2, 3][3]
    "a" + 1
    4 / 0

except TypeError:
    result += 1

except ZeroDivisionError:
    result += 2

except IndexError:
    result += 3

finally:
    result += 4

print(result)

실행 과정

초기값

result = 0

먼저

[1, 2, 3][3]

이 실행된다.

리스트 인덱스는

0  1  2
↓  ↓  ↓
1  2  3

까지만 존재한다.

따라서

IndexError

가 발생한다.

except 이동

except IndexError:
    result += 3

가 실행된다.

0 + 3 = 3

그리고 try 블록의 나머지 코드는 실행하지 않는다.

따라서

"a" + 1

과

4 / 0

은 실행되지 않는다.

finally

finally는 오류 발생 여부와 관계없이 실행된다.

finally:
    result += 4

따라서

3 + 4 = 7

최종 결과

7

이다.

Q13. DashInsert

숫자로 이루어진 문자열에서

홀수 + 홀수

가 연속되면

-

를 넣고,

짝수 + 짝수

가 연속되면

*

을 넣는다.

예를 들어

4546793

을 처리하면

454*67-9-3

이 된다.

풀이

data = "4546793"

numbers = list(map(int, data))

result = []

for i, num in enumerate(numbers):
    result.append(str(num))

    if i == len(numbers) - 1:
        continue

    next_num = numbers[i + 1]

    if num % 2 == 1 and next_num % 2 == 1:
        result.append("-")

    elif num % 2 == 0 and next_num % 2 == 0:
        result.append("*")

print("".join(result))

실행 결과

454*67-9-3

enumerate()

for i, num in enumerate(numbers):

을 사용하면

인덱스 + 값

을 동시에 가져올 수 있다.

예를 들어

numbers = [4, 5, 4]

이면

i=0, num=4
i=1, num=5
i=2, num=4

순서로 반복한다.

홀수 판별

num % 2 == 1

나머지가 1이면 홀수이다.

짝수 판별

num % 2 == 0

나머지가 0이면 짝수이다.

Q14 / Q15

참고한 게시글에는 Q13 다음이 바로 Q16으로 이어져 있어 Q14와 Q15 문제 및 풀이가 포함되어 있지 않다.

Q16. 모스 부호 해독

모스 부호를 영어 문자로 변경하려면

모스 부호 → 알파벳

형태의 딕셔너리를 만들 수 있다.

모스 부호 딕셔너리

morse_code = {
    '.-': 'A',
    '-...': 'B',
    '-.-.': 'C',
    '-..': 'D',
    '.': 'E',
    '..-.': 'F',
    '--.': 'G',
    '....': 'H',
    '..': 'I',
    '.---': 'J',
    '-.-': 'K',
    '.-..': 'L',
    '--': 'M',
    '-.': 'N',
    '---': 'O',
    '.--.': 'P',
    '--.-': 'Q',
    '.-.': 'R',
    '...': 'S',
    '-': 'T',
    '..-': 'U',
    '...-': 'V',
    '.--': 'W',
    '-..-': 'X',
    '-.--': 'Y',
    '--..': 'Z'
}

해독 함수

def morse(src):
    result = []

    words = src.split("  ")

    for word in words:
        chars = word.split()

        decoded = ""

        for char in chars:
            decoded += morse_code[char]

        result.append(decoded)

    return " ".join(result)

즉

모스 부호
    ↓
단어 단위 분리
    ↓
문자 단위 분리
    ↓
딕셔너리 조회
    ↓
영어 문자 변환
    ↓
다시 합치기

순서로 처리한다.

Q17. 기초 메타 문자

정규식

a[.]{3,}b

를 해석해 보자.

[.]

실제 점(.) 문자

를 의미한다.

{3,}

앞의 패턴이 3번 이상

이라는 의미이다.

따라서 전체적으로

a
+
점(.) 3개 이상
+
b

이다.

보기 중

a....b

가 조건을 만족한다.

정답

2번

코드 확인

import re

p = re.compile(r"a[.]{3,}b")

print(p.match("acccb"))
print(p.match("a....b"))
print(p.match("aaab"))
print(p.match("a.cccb"))

a....b만 정상적으로 매치된다.

Q18. 문자열 검색

import re

p = re.compile(r"[a-z]+")

m = p.search("5 python")

print(m.start() + m.end())

패턴 분석

[a-z]+

는

영문 소문자가
1개 이상 연속

이라는 의미이다.

따라서

5 python

에서

python

이 매치된다.

인덱스

문자     5   공백   p   y   t   h   o   n
인덱스   0    1    2   3   4   5   6   7

따라서

m.start()

은

2

이고,

m.end()

는 마지막 문자의 다음 위치이므로

8

이다.

따라서

2 + 8
=
10

정답

10

Q19. 그루핑

다음과 같은 데이터가 있다고 해보자.

park 010-9999-9998
kim 010-9909-7789
lee 010-8789-7768

전화번호의 마지막 네 자리를

####

로 변경한다.

정규식 작성

전화번호의 앞부분을 그룹으로 만든다.

r"(\d{3}-\d{4})-\d{4}"

해석하면

(
  숫자 3개
  -
  숫자 4개
)
      ↓
그룹 1

-

숫자 4개

이다.

풀이

import re

data = """
park 010-9999-9998
kim 010-9909-7789
lee 010-8789-7768
"""

pattern = re.compile(
    r"(\d{3}-\d{4})-\d{4}"
)

result = pattern.sub(
    r"\g<1>-####",
    data
)

print(result)

결과

park 010-9999-####
kim 010-9909-####
lee 010-8789-####

\g<1>

첫 번째 그룹에서
매치된 문자열

을 의미한다.

따라서

010-9999

부분은 그대로 유지하고

9998

부분만

####

로 변경한다.

Q20. 전방 탐색

이메일 주소 중에서 마지막 도메인이

.com
.net

인 경우만 매치하도록 만든다.

기본 패턴

.*[@].*[.].*$

대략적으로

문자들
@
문자들
.
문자들

형태의 이메일을 찾는다.

긍정형 전방 탐색

(?=...)

은

뒤에 특정 패턴이 있는지 확인하지만 해당 문자열 자체는 소비하지 않는다.

이를 이용하면

r".*[@].*[.](?=com$|net$).*$"

처럼 작성할 수 있다.

코드

import re

pattern = re.compile(
    r".*[@].*[.](?=com$|net$).*$"
)

print(
    pattern.match("test@gmail.com")
)

print(
    pattern.match("test@daum.net")
)

print(
    pattern.match("test@myhome.co.kr")
)

결과는 개념적으로

test@gmail.com
→ Match O

test@daum.net
→ Match O

test@myhome.co.kr
→ Match X

가 된다.

핵심 부분

(?=com$|net$)

을 해석하면

뒤에

com으로 끝나거나
또는
net으로 끝나야 한다.

라는 의미이다.

(?=...)
→ 긍정형 전방 탐색

|
→ OR

$
→ 문자열 끝

📌 코딩 면허시험 핵심 정리

이번 문제들을 통해 지금까지 배운 파이썬 문법을 전체적으로 복습할 수 있다.

⭐ 전체 학습 흐름

파이썬 기초
   ↓
자료형
   ↓
문자열 / 리스트 / 딕셔너리
   ↓
if / while / for
   ↓
함수
   ↓
파일 입출력
   ↓
클래스
   ↓
모듈
   ↓
예외 처리
   ↓
정규 표현식
   ↓
종합 문제 풀이

이번 문제에서 특히 다시 확인하면 좋은 부분은

split / join
get
extend
map
enumerate
파일 입출력
클래스
try-except-finally
정규 표현식

이다.

코딩 문제를 풀 때는 바로 정답 코드를 작성하려고 하기보다 입력값 → 필요한 처리 → 출력값으로 문제를 먼저 나눈 뒤, 지금까지 배운 문법 중 무엇을 사용할지 생각하는 습관을 들이는 것이 중요하다.

목차

• 1. 문자열 소비가 없는 메타 문자
• 2. |, ^, $
• 3. \A, \Z, \b, \B
• 4. 그루핑 ()
• 5. 그룹 재참조
• 6. 이름 있는 그룹
• 7. 전방 탐색
• 8. sub()를 이용한 문자열 변경
• 9. Greedy와 Non-Greedy

1. 문자열 소비가 없는 메타 문자

앞에서 배운

+
*
[]
{}

같은 메타 문자는 문자열과 매치되면 해당 문자열을 실제로 소비한다.

예를 들어

aac

에서

a+

를 찾으면

aa

가 매치된다.

그리고 문자열을 읽고 있는 현재 위치도 aa 뒤쪽으로 이동한다.

aac
^^
매치

  ↑
  다음 위치

하지만 이번에 배우는 일부 메타 문자는

특정 조건을 확인만 하고 실제 문자를 소비하지 않는다.

이러한 개념은 뒤에서 배우는 전방 탐색을 이해할 때 특히 중요하다.

2. | - OR

|

는

또는(OR)

이라는 의미이다.

기본 구조는

A|B

이고

A 또는 B

를 의미한다.

예를 들어

import re

p = re.compile(r"cat|dog")

은

cat 또는 dog

를 찾는다.

print(p.search("I have a dog"))

dog가 있으므로 매치된다.

여러 개의 조건

cat|dog|bird

라면

cat
또는
dog
또는
bird

중 하나와 매치된다.

3. ^ - 문자열의 시작

^

는

문자열의 시작

을 의미한다.

예를 들어

^Life

는

Life로 시작하는 문자열

을 의미한다.

import re

print(re.search(r"^Life", "Life is too short"))

매치된다.

하지만

print(re.search(r"^Life", "My Life"))

에서는 Life가 존재하더라도 문자열 처음에 있지 않기 때문에 매치되지 않는다.

쉽게 이해하기

Life is too short
^^^^
O

하지만

My Life
   ^^^^

Life가 문자열 중간에 있으므로

^Life

와는 매치되지 않는다.

4. $ - 문자열의 끝

$

는 ^와 반대로

문자열의 끝

을 의미한다.

예를 들어

short$

는

short로 끝나는 문자열

을 의미한다.

import re

print(re.search(r"short$", "Life is too short"))

매치된다.

하지만

print(re.search(
    r"short$",
    "Life is too short, you need python"
))

에서는 short 뒤에 문자열이 더 있으므로 매치되지 않는다.

^, $ 정리

^python

python으로 시작

python$

python으로 끝남

둘을 같이 사용하면

^python$

문자열 전체가 정확히 python

이라는 의미로 사용할 수 있다.

5. \A

\A

도 문자열의 시작을 의미한다.

\Apython

은

전체 문자열이 python으로 시작

하는지 확인한다.

기본적으로 ^와 비슷하지만 re.MULTILINE 옵션을 사용할 때 차이가 생긴다.

^와 \A 차이

여러 줄 문자열에서 re.MULTILINE을 사용하면

^

는 각 줄의 시작을 의미한다.

반면

\A

는 항상 전체 문자열의 시작 한 곳만 의미한다.

^
→ 각 줄의 처음 가능

\A
→ 전체 문자열의 처음만

6. \Z

\Z

는

전체 문자열의 끝

을 의미한다.

$와 비슷하지만 MULTILINE 환경에서도 전체 문자열의 끝을 기준으로 한다.

정리하면

^  → 문자열 시작
$  → 문자열 끝

\A → 전체 문자열 시작
\Z → 전체 문자열 끝

이라고 생각하면 된다.

7. \b - 단어 경계

\b

는 Word Boundary, 즉

단어와 단어가 아닌 부분의 경계

를 의미한다.

예를 들어

import re

p = re.compile(r"\bclass\b")

이 정규식은 class라는 하나의 독립된 단어를 찾는다.

print(p.search("no class at all"))

에서는

class

가 독립된 단어이므로 매치된다.

문자열 안에 class가 있어도 매치되지 않을 수 있다

print(p.search("declassified"))

declassified 안에

class

문자열은 포함되어 있다.

하지만 독립된 단어가 아니므로 매치되지 않는다.

마찬가지로

subclass

에서도 class가 하나의 독립된 단어가 아니므로

\bclass\b

와 매치되지 않는다.

왜 Raw String을 사용할까?

파이썬에서

\b

는 문자열 문법상 백스페이스를 의미할 수도 있다.

따라서 정규식의 단어 경계를 의미하도록

r"\bclass\b"

처럼 Raw String으로 작성하는 습관이 중요하다.

8. \B

\B

는 \b의 반대이다.

즉

단어 경계가 아닌 위치

를 의미한다.

예를 들어

declassified

에서는 class 앞과 뒤에 다른 단어 문자가 연결되어 있다.

따라서

r"\Bclass\B"

와 매치될 수 있다.

\b와 \B

\b
→ 단어의 경계

\B
→ 단어의 경계가 아닌 곳

이라고 기억하면 된다.

9. 그루핑 ()

정규식에서 매우 중요한 기능 중 하나가 그루핑(Grouping) 이다.

그룹은

()

를 사용한다.

그루핑을 사용하는 대표적인 이유는 두 가지이다.

• 여러 문자를 하나의 단위로 묶기
• 매치된 문자열 중 원하는 부분만 추출하기

10. 여러 문자를 하나로 묶기

예를 들어

ABC

라는 문자열이 반복되는 형태를 찾고 싶다고 해보자.

다음처럼 그룹으로 묶는다.

(ABC)+

의미는

ABC라는 묶음이
1번 이상 반복

이다.

따라서

ABC
ABCABC
ABCABCABC

등과 매치된다.

코드

import re

p = re.compile(r"(ABC)+")

m = p.search("ABCABCABC OK?")

print(m.group())

결과

ABCABCABC

이다.

11. 그룹으로 원하는 부분만 추출하기

다음 문자열이 있다고 해보자.

park 010-1234-1234

구조는

이름
+
공백
+
전화번호

이다.

정규식으로 표현하면 다음과 같은 형태가 된다.

r"\w+\s+\d+[-]\d+[-]\d+"

하지만 여기서 이름만 가져오고 싶다면?

이름 부분을 그룹으로 묶는다.

r"(\w+)\s+\d+[-]\d+[-]\d+"

group(1)

import re

p = re.compile(
    r"(\w+)\s+\d+[-]\d+[-]\d+"
)

m = p.search(
    "park 010-1234-1234"
)

print(m.group(1))

결과

park

이다.

12. group() 번호 이해하기

그룹은 만들어진 순서에 따라 번호가 붙는다.

예를 들어

r"(\w+)\s+(\d+[-]\d+[-]\d+)"

에는 그룹이 두 개 있다.

(\w+)
 ↑
그룹 1

(\d+[-]\d+[-]\d+)
 ↑
그룹 2

따라서

m.group(1)

은 이름,

m.group(2)

는 전화번호를 반환한다.

13. 그룹 안에 그룹 만들기

그룹을 중첩할 수도 있다.

r"(\w+)\s+((\d+)[-]\d+[-]\d+)"

구조를 보면

(\w+)
→ 그룹 1 : 이름

((\d+)-...)
→ 그룹 2 : 전체 전화번호

그리고 그룹 2 내부의

(\d+)

는

그룹 3 : 010

이 된다.

따라서

m.group(3)

을 사용하면

010

만 가져올 수 있다.

14. 그룹 재참조

이미 매치된 그룹의 내용을 다시 사용할 수 있다.

이것을 재참조(Backreference) 라고 한다.

예를 들어 다음 문장에서 중복된 단어를 찾아보자.

Paris in the the spring

the가 두 번 연속 사용되었다.

정규식은

r"(\b\w+)\s+\1"

처럼 작성할 수 있다.

해석

먼저

(\b\w+)

는 단어 하나를 그룹 1에 저장한다.

\s+

는 하나 이상의 공백이다.

그리고

\1

은

첫 번째 그룹에서 매치된 것과 동일한 문자열

을 의미한다.

따라서

the the

처럼 같은 단어가 연속으로 있는 부분을 찾을 수 있다.

코드

import re

p = re.compile(
    r"(\b\w+)\s+\1"
)

m = p.search(
    "Paris in the the spring"
)

print(m.group())

결과

the the

이다.

15. 재참조 번호

\1

은 첫 번째 그룹을 의미한다.

\2

는 두 번째 그룹,

\3

은 세 번째 그룹을 의미한다.

즉

그룹 1 → \1
그룹 2 → \2
그룹 3 → \3

이다.

16. 이름 있는 그룹

그룹이 많아지면

group(1)
group(2)
group(3)
...

만으로는 어떤 그룹인지 알아보기 어려워진다.

그래서 그룹에 이름을 붙일 수 있다.

기본 구조는

(?P<그룹이름>정규식)

이다.

예를 들어

r"(?P<name>\w+)"

은

\w+

그룹의 이름을

name

으로 지정한 것이다.

17. 이름 있는 그룹 사용하기

import re

p = re.compile(
    r"(?P<name>\w+)\s+"
    r"(?P<phone>\d+[-]\d+[-]\d+)"
)

m = p.search(
    "park 010-1234-1234"
)

이제 숫자가 아니라 이름으로 가져올 수 있다.

print(m.group("name"))

결과

park

이다.

전화번호는

print(m.group("phone"))

으로 가져올 수 있다.

18. 이름 있는 그룹 재참조

이름 있는 그룹도 정규식 안에서 다시 참조할 수 있다.

구조는

(?P=그룹이름)

이다.

예를 들어

r"(?P<word>\b\w+)\s+(?P=word)"

은

단어 하나
+
공백
+
앞에서 나온 동일한 단어

를 찾는다.

따라서

the the

와 매치된다.

19. 전방 탐색

전방 탐색(Lookahead) 은 정규식에서 매우 유용한 기능이다.

쉽게 설명하면

뒤에 특정 패턴이 존재하는지 확인은 하지만 그 문자열 자체는 결과에 포함하지 않는 기능

이다.

20. 기본 예제

다음 문자열이 있다고 해보자.

http://google.com

그리고

r".+:"

로 검색한다.

.+
→ 아무 문자 1개 이상

:
→ 콜론

따라서 결과는

http:

가 된다.

그런데 우리가 원하는 결과가

http

이고

:

은 존재 여부만 확인하고 결과에서는 제외하고 싶다면 전방 탐색을 사용한다.

21. 긍정형 전방 탐색 (?=...)

긍정형 전방 탐색의 구조는

(?=...)

이다.

뜻은

뒤에 ...가 존재하는 경우

이다.

예를 들어

r".+(?=:)"

를 사용한다.

해석하면

.+
→ 문자 1개 이상

(?=:)
→ 뒤에 :가 있는지 확인
   단, :는 매치 결과에 포함하지 않음

이다.

결과

import re

p = re.compile(r".+(?=:)")

m = p.search(
    "http://google.com"
)

print(m.group())

결과

http

이다.

:이 있는지는 확인했지만 실제 결과에는 포함시키지 않았다.

22. 긍정형 전방 탐색 쉽게 이해하기

http://google.com
^^^^
결과

    :
    ↑
    존재 여부만 확인

즉

"뒤에 :가 오는 문자열을 찾아줘.
하지만 :는 결과에 넣지 마."

라고 이해하면 된다.

23. 부정형 전방 탐색 (?!...)

부정형 전방 탐색은

(?!...)

을 사용한다.

뜻은

뒤에 ...가 오지 않는 경우

이다.

24. 특정 확장자 제외하기

예를 들어 파일 이름에서

.bat

확장자를 제외하고 싶다고 해보자.

기본적인 파일 이름 형태를

.*[.].*$

처럼 표현할 수 있다.

하지만 .bat 파일을 제외하고 싶다면

.*[.](?!bat$).*$

처럼 부정형 전방 탐색을 사용할 수 있다.

(?!bat$) 해석

(?!bat$)

은

뒤에 bat가 오지 않는 경우

라는 의미이다.

따라서

test.txt   → O
test.jpg   → O
test.bat   → X

처럼 사용할 수 있다.

25. 여러 확장자 제외하기

이번에는

.bat
.exe

둘 다 제외하고 싶다고 해보자.

.*[.](?!bat$|exe$).*$

처럼 작성할 수 있다.

|는 OR이므로

bat 또는 exe

가 뒤에 오는 경우를 제외한다.

26. 전방 탐색 정리

긍정형

(?=...)

뒤에 ...가 있어야 함
하지만 결과에는 포함하지 않음

부정형

(?!...)

뒤에 ...가 없어야 함

둘 다 중요한 특징은

조건은 확인하지만 해당 문자를 직접 소비하지 않는다.

는 것이다.

27. sub() - 문자열 바꾸기

정규식에 일치하는 문자열을 다른 문자열로 바꿀 때

sub()

를 사용할 수 있다.

예를 들어

import re

p = re.compile(
    r"blue|white|red"
)

result = p.sub(
    "colour",
    "blue socks and red shoes"
)

print(result)

결과

colour socks and colour shoes

가 된다.

28. sub() 기본 구조

패턴.sub(
    "바꿀 문자열",
    "대상 문자열"
)

이다.

즉

정규식과 일치하는 부분 찾기
          ↓
지정한 문자열로 교체

한다.

29. 변경 횟수 제한하기

모든 문자열을 변경하는 것이 아니라 처음 한 번만 변경하고 싶을 수도 있다.

이때

count=

를 사용한다.

p.sub(
    "colour",
    "blue socks and red shoes",
    count=1
)

결과

colour socks and red shoes

이다.

첫 번째 blue만 변경된다.

30. subn()

subn()도 sub()와 비슷하게 문자열을 변경한다.

차이점은 결과를 튜플로 반환한다는 것이다.

result = p.subn(
    "colour",
    "blue socks and red shoes"
)

형태는

(
    변경된 문자열,
    변경 횟수
)

이다.

즉

('colour socks and colour shoes', 2)

와 같은 형태를 얻을 수 있다.

31. sub()에서 그룹 참조하기

sub()에서도 앞에서 만든 그룹을 사용할 수 있다.

예를 들어

park 010-1234-1234

을

010-1234-1234 park

처럼 순서를 바꾸고 싶다고 해보자.

먼저 그룹을 만든다.

p = re.compile(
    r"(?P<name>\w+)\s+"
    r"(?P<phone>\d+[-]\d+[-]\d+)"
)

그리고

p.sub(
    r"\g<phone> \g<name>",
    "park 010-1234-1234"
)

처럼 작성할 수 있다.

결과

010-1234-1234 park

이다.

즉

\g<phone>

으로 phone 그룹을,

\g<name>

으로 name 그룹을 참조한다.

32. 그룹 번호로도 참조 가능

이름 대신 번호를 사용할 수도 있다.

\g<1>
\g<2>

예를 들어

p.sub(
    r"\g<2> \g<1>",
    "park 010-1234-1234"
)

처럼 사용할 수 있다.

33. sub()에 함수 전달하기

sub()의 첫 번째 인수에는 문자열뿐 아니라 함수도 넣을 수 있다.

예를 들어 문자열 안의 10진수를 16진수로 변경해 보자.

import re

def hexrepl(match):
    value = int(match.group())
    return hex(value)


p = re.compile(r"\d+")

result = p.sub(
    hexrepl,
    "Call 65490 for printing, "
    "49152 for user code."
)

print(result)

매치되는 숫자가 발견될 때마다 hexrepl() 함수가 실행된다.

34. 동작 과정

첫 번째 숫자

65490

가 발견된다.

\d+
 ↓
65490 매치
 ↓
hexrepl(match)
 ↓
int("65490")
 ↓
hex(...)
 ↓
16진수 문자열 반환
 ↓
원래 숫자 교체

다음 숫자도 같은 방법으로 처리된다.

즉 sub()에 함수를 전달하면

각 매치 결과를 원하는 로직으로 가공한 뒤 교체

할 수 있다.

35. Greedy란?

정규식을 배우다 보면 Greedy, 즉 탐욕적이라는 표현이 나온다.

다음 문자열을 살펴보자.

s = "<html><head><title>Title</title>"

그리고

<.*>

정규식을 사용한다고 해보자.

우리는 처음의

<html>

만 매치될 것이라고 생각할 수 있다.

하지만 실제로는 훨씬 긴 문자열이 매치된다.

36. 왜 전체가 매치될까?

.*

에서

*

은 가능한 한 많이 반복하려고 한다.

즉

<.*>

은

<
+
가능한 많은 문자
+
>

를 찾는다.

따라서 가능한 마지막 >까지 가져간다.

<html><head><title>Title</title>
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

이것을

Greedy Matching

이라고 한다.

37. Non-Greedy

가능한 최소한만 매치하도록 만들고 싶다면

?

를 반복 메타 문자 뒤에 붙인다.

<.*?>

로 변경하면 된다.

결과 비교

Greedy

<.*>

결과

<html><head><title>Title</title>

Non-Greedy

<.*?>

결과

<html>

이다.

38. Non-Greedy 표현

다음과 같이 사용할 수 있다.

Non-Greedy는

조건을 만족하는 범위에서 가능한 최소한으로 매치

한다.

39. ?의 두 가지 역할에 주의

앞에서 배운

a?

는

a가 0번 또는 1번

이라는 의미이다.

하지만

.*?

에서 ?는

*를 Non-Greedy 방식으로 변경

한다.

즉 같은 ?라도 위치에 따라 의미가 다르다.

비교

a?

a가 0~1회 등장

반면

a*?

a를 0회 이상 반복하되
가능한 최소한으로 매치

이다.

40. 이번 장 메타 문자 정리

41. 그룹 관련 문법 정리

그룹 만들기

(...)

첫 번째 그룹 가져오기

m.group(1)

이름 있는 그룹

(?P<name>...)

이름으로 값 가져오기

m.group("name")

그룹 번호 재참조

\1

이름 있는 그룹 재참조

(?P=name)

42. 전방 탐색 정리

(?=ABC)

뒤에 ABC가 있어야 함
하지만 ABC는 결과에 포함하지 않음

(?!ABC)

뒤에 ABC가 오면 안 됨

예를 들어

.+(?=:)

은

뒤에 :가 있는 문자열을 찾되
:는 결과에서 제외

한다.

43. 문자열 변경 정리

pattern.sub(
    "변경값",
    "문자열"
)

패턴과 일치하는 내용을 변경한다.

pattern.sub(
    "변경값",
    "문자열",
    count=1
)

처럼 횟수를 제한할 수 있다.

subn()을 사용하면

변경된 문자열
+
변경 횟수

를 함께 얻을 수 있다.

44. 보안 관점에서 보면

이번 장에서 배우는 기능은 보안 룰이나 로그 분석에서도 자주 볼 수 있다.

예를 들어

^GET

이라면

GET으로 시작

하는 문자열을 찾는다.

\.exe$

라면

.exe로 끝남

을 의미한다.

(cmd|powershell)

은

cmd 또는 powershell

을 찾는다.

\badmin\b

은 다른 문자열 안에 포함된 admin이 아니라 독립된 admin 단어를 찾을 때 사용할 수 있다.

따라서 Snort나 PCRE 룰을 볼 때도 이번 장에서 배운 개념이 많이 등장한다.

📌 핵심 정리

OR

A|B

A 또는 B

문자열 시작과 끝

^abc
→ abc로 시작

abc$
→ abc로 끝

단어 경계

\bclass\b

class라는 독립된 단어를 찾는다.

그룹

(\w+)

매치된 부분을 하나의 그룹으로 저장한다.

m.group(1)

으로 가져올 수 있다.

재참조

(\b\w+)\s+\1

앞에서 찾은 단어와 같은 단어가 다시 등장하는지 검사한다.

이름 있는 그룹

(?P<name>\w+)

그룹에 이름을 붙인다.

m.group("name")

으로 값을 가져온다.

긍정형 전방 탐색

(?=...)

해당 내용이 뒤에 있어야 한다.
하지만 결과에는 포함하지 않는다.

부정형 전방 탐색

(?!...)

해당 내용이 뒤에 없어야 한다.

sub()

p.sub(
    "바꿀 값",
    "대상 문자열"
)

정규식과 매치되는 문자열을 변경한다.

Greedy

.*

가능한 범위에서 최대한 많이 가져온다.

Non-Greedy

.*?

가능한 범위에서 최소한만 가져온다.

⭐ 08-3 전체 흐름

정규식 고급 기능
      ↓
 ┌──────────────┐
 │ 위치 / 조건   │
 └──────────────┘
      ↓
|  ^  $
\A \Z
\b \B

      ↓

 ┌──────────────┐
 │ 그룹          │
 └──────────────┘
      ↓
(...)
group()
\1
(?P<name>...)

      ↓

 ┌──────────────┐
 │ 전방 탐색     │
 └──────────────┘
      ↓
(?=...)
(?!...)

      ↓

 ┌──────────────┐
 │ 문자열 변경   │
 └──────────────┘
      ↓
sub()
subn()

      ↓

 ┌──────────────┐
 │ 반복 범위     │
 └──────────────┘
      ↓
Greedy
.*
      ↕

Non-Greedy
.*?

08-3의 핵심은 단순히 문자를 찾는 것을 넘어, 원하는 부분을 그룹으로 저장하고 다시 참조하거나, 특정 조건을 확인하면서 실제 결과에는 포함하지 않는 등 더 정교하게 문자열을 제어하는 방법을 이해하는 것이다.

목차

• 1. 메타 문자란?
• 2. 문자 클래스 [ ]
• 3. 자주 사용하는 문자 클래스 \d, \s, \w
• 4. Dot .
• 5. 반복 *, +, {}, ?
• 6. 파이썬 re 모듈
• 7. match()와 search()
• 8. findall()과 finditer()
• 9. Match 객체
• 10. 정규식 컴파일 옵션
• 11. 역슬래시와 Raw String

1. 메타 문자란?

정규 표현식에서는 일반적인 문자 외에도 특별한 의미를 가진 문자를 사용한다.

이러한 문자를 메타 문자(Meta Character) 라고 한다.

대표적인 메타 문자는 다음과 같다.

. ^ $ * + ? { } [ ] \ | ( )

예를 들어 일반 문자열에서

*

은 단순한 별표 문자이지만 정규식에서는

앞의 문자가 0번 이상 반복

이라는 특별한 의미를 가진다.

따라서 정규식을 공부할 때는

각 메타 문자가 어떤 규칙을 표현하는지 이해하는 것이 핵심이다.

2. 매치(Match)란?

정규식에서는 매치된다라는 표현을 많이 사용한다.

매치란

문자열이 정규식에서 지정한 패턴과 일치한다

라는 의미이다.

예를 들어 정규식이

abc

이고 문자열도

abc

라면

정규식 : abc
문자열 : abc

→ Match O

라고 할 수 있다.

3. 문자 클래스 [ ]

가장 먼저 알아볼 메타 문자는

[ ]

이다.

[]는

대괄호 안에 있는 문자 중 하나

와 매치한다.

예를 들어

[abc]

는

a 또는 b 또는 c

중 하나를 의미한다.

[abc] 예제

정규식 : [abc]

문자열을 비교해 보자.

"a"
→ a가 존재
→ Match O

"banana"
→ b 또는 a가 존재
→ Match O

"dog"
→ a, b, c가 없음
→ Match X

여기서 중요한 점은

[abc]

가 문자열 "abc" 전체를 의미하는 것이 아니라는 것이다.

[abc]

= a 또는 b 또는 c 중 한 문자

이다.

4. [ ]에서 범위 지정하기

문자를 하나씩 모두 적어야 한다면 불편할 수 있다.

예를 들어 모든 숫자를 표현하려면

[0123456789]

라고 작성할 수도 있지만 다음처럼 간단하게 표현할 수 있다.

[0-9]

-를 사용하면 범위를 지정할 수 있다.

문자 범위

[a-z]

a부터 z까지의 소문자

[A-Z]

A부터 Z까지의 대문자

[0-9]

0부터 9까지의 숫자

대소문자 모두 표현하기

[a-zA-Z]

는

영문 소문자 또는 영문 대문자

를 의미한다.

한글 범위

한글 문자를 대상으로 다음과 같은 패턴도 볼 수 있다.

[가-힣]

즉 한글 음절 범위를 표현할 때 사용할 수 있다.

5. 문자 클래스 안의 ^

문자 클래스 []의 맨 앞에서 ^를 사용하면 의미가 반대가 된다.

[^0-9]

는

숫자가 아닌 문자

를 의미한다.

즉

[0-9]
→ 숫자

[^0-9]
→ 숫자가 아닌 것

이다.

예제

[^abc]

는

a, b, c가 아닌 문자

를 의미한다.

[^A-Z]

는

영문 대문자가 아닌 문자

를 의미한다.

6. 자주 사용하는 문자 클래스

정규식에서는 자주 사용하는 패턴을 더 짧게 표현할 수 있다.

대문자로 바뀌면 대부분 반대 의미라고 생각하면 이해하기 쉽다.

7. \d

\d는 숫자를 의미한다.

\d

일반적으로 숫자 한 글자를 찾는 데 사용할 수 있다.

예를 들어

import re

p = re.compile(r"\d")

print(p.findall("abc123"))

결과

['1', '2', '3']

이다.

여러 숫자를 한 번에 찾으려면?

현재

\d

는 숫자 한 글자씩 찾는다.

숫자가 여러 개 연속된 부분을 찾고 싶다면 뒤에서 배우는 +를 붙인다.

\d+

예를 들어

import re

p = re.compile(r"\d+")

print(p.findall("age=25 score=100"))

결과

['25', '100']

이다.

8. \D

대문자인

\D

는 \d의 반대이다.

즉

숫자가 아닌 문자

를 의미한다.

\d  → 숫자
\D  → 숫자가 아닌 것

9. \s

\s

는 Whitespace 문자와 매치한다.

대표적으로

공백
탭
줄바꿈

등이 포함된다.

예를 들어

import re

p = re.compile(r"\s")

print(p.findall("hello python"))

문자열 중간의 공백이 매치된다.

10. \S

\S

는 \s의 반대이다.

즉

공백 문자가 아닌 것

을 의미한다.

11. \w

\w

는 일반적으로 단어를 구성하는 문자를 찾을 때 사용한다.

예를 들어

import re

p = re.compile(r"\w+")

print(p.findall("python_2026"))

결과

['python_2026']

처럼 사용할 수 있다.

Python 3의 re에서는 기본적으로 유니코드를 사용하기 때문에 \w가 영문자와 숫자뿐 아니라 한글과 같은 유니코드 문자에도 매치될 수 있다.

12. \W

\W

는 \w의 반대이다.

즉

단어를 구성하지 않는 문자

를 의미한다.

예를 들면 공백이나 일부 특수문자를 찾는 데 활용할 수 있다.

13. . Dot 메타 문자

정규식에서

.

은

줄바꿈 \n을 제외한 거의 모든 문자 한 개

를 의미한다.

예를 들어

a.b

라는 정규식이 있다고 해보자.

구조는

a
+
아무 문자 1개
+
b

이다.

예제

aab

a + a + b

→ Match O

a7b

a + 7 + b

→ Match O

a-b

a + - + b

→ Match O

하지만

ab

는 중간에 문자가 없으므로 매치되지 않는다.

14. . 자체를 찾고 싶다면?

다음 두 정규식은 의미가 다르다.

a.b

a + 아무 문자 + b

반면

a[.]b

는

a + 실제 점(.) + b

를 의미한다.

따라서

a.b

문자열 자체를 찾을 때 사용할 수 있다.

15. 반복 메타 문자 *

*

는

바로 앞의 문자가 0번 이상 반복

된다는 의미이다.

예를 들어

ca*t

를 살펴보자.

여기서 *는 바로 앞의 a에 적용된다.

c
+
a가 0번 이상
+
t

라는 의미이다.

매치 예제

가장 중요한 부분은

0번도 가능

하다는 것이다.

따라서

ct

도 매치된다.

16. 반복 메타 문자 +

+

는

바로 앞의 문자가 1번 이상 반복

된다는 의미이다.

예를 들어

ca+t

는

c
+
a가 1번 이상
+
t

이다.

*와 비교

차이는

*

0번 이상

+

1번 이상

이다.

이 차이를 꼭 기억하자.

17. {m}

반복 횟수를 정확하게 지정하고 싶을 때

{}

를 사용할 수 있다.

예를 들어

a{3}

은

a가 정확히 3번

이라는 의미이다.

예제

ca{2}t

는

c
+
a 두 번
+
t

이므로

caat

과 매치된다.

하지만

cat

은 a가 한 번이므로 매치되지 않는다.

18. {m,n}

반복 횟수의 범위를 지정할 수도 있다.

{m,n}

은

최소 m번
~
최대 n번

이라는 의미이다.

예를 들어

a{2,4}

는

aa
aaa
aaaa

처럼 a가 2~4번 반복되는 경우를 의미한다.

한쪽을 생략할 수도 있다

a{3,}

a가 3번 이상

a{,3}

a가 3번 이하

라고 이해할 수 있다.

19. ?

?

는

바로 앞의 문자가 0번 또는 1번

나타난다는 의미이다.

즉

있어도 되고
없어도 된다

라고 생각하면 쉽다.

예를 들어

colou?r

에서 u?는

u가 없어도 되고
u가 한 번 있어도 됨

이라는 의미이다.

따라서

color

와

colour

둘 다 매치할 수 있다.

20. 반복 메타 문자 한 번에 정리

특히

*
+
?

세 개를 많이 사용한다.

21. *, +, ? 관계

다음처럼 생각할 수도 있다.

*

{0,}

+

{1,}

?

{0,1}

즉 간단하게 자주 사용하는 반복 표현을

*
+
?

로 줄여 놓았다고 생각하면 된다.

22. 파이썬 re 모듈

파이썬에서 정규식을 사용하려면

import re

를 사용한다.

re는 Regular Expression의 약자이다.

파이썬 표준 라이브러리이므로 별도의 설치는 필요 없다.

23. re.compile()

정규 표현식을 사용할 때 다음과 같이 패턴을 만들 수 있다.

import re

p = re.compile(r"[a-z]+")

여기서

re.compile()

은 작성한 정규식을 파이썬에서 사용할 수 있는 패턴 객체로 만들어 준다.

흐름은 다음과 같다.

정규 표현식

[a-z]+
   ↓
re.compile()
   ↓
Pattern 객체
   ↓
검색 수행

24. [a-z]+ 해석하기

앞에서 배운 문법으로 다음 정규식을 해석해 보자.

[a-z]+

먼저

[a-z]

는

영문 소문자 한 글자

이다.

뒤에

+

가 붙었으므로

한 번 이상 반복

이다.

따라서 최종적으로

[a-z]+

= 영문 소문자가 1글자 이상 연속된 문자열

이라는 의미이다.

25. 정규식을 이용한 문자열 검색

컴파일한 패턴 객체에서는 대표적으로 다음 메서드를 사용할 수 있다.

이 네 개의 차이는 꼭 기억하자.

26. match()

match()는

문자열의 처음부터 패턴과 일치하는지 검사

한다.

먼저 패턴을 만든다.

import re

p = re.compile(r"[a-z]+")

그리고

m = p.match("python")

을 실행한다.

python은 처음부터 영문 소문자로 이루어져 있으므로 매치된다.

매치되지 않는 경우

m = p.match("3 python")

print(m)

결과

None

이 된다.

왜냐하면 문자열의 첫 번째 글자가

3

이기 때문이다.

현재 패턴은

[a-z]+

이므로 첫 번째 위치에서 바로 실패한다.

27. match()의 핵심

정규식

[a-z]+


문자열

python
↑
처음부터 확인

→ O

하지만

3 python
↑
처음 문자가 숫자

→ X

이다.

즉

match()는 문자열 시작 부분이 패턴과 일치해야 한다.

28. match() 결과 활용하기

match()는 성공하면 Match 객체를 반환하고 실패하면 None을 반환한다.

따라서 다음과 같이 사용할 수 있다.

import re

p = re.compile(r"[a-z]+")

m = p.match("python")

if m:
    print("매치되었습니다.")
else:
    print("매치되지 않았습니다.")

29. search()

search()는 match()와 다르게

문자열 전체를 검색

한다.

import re

p = re.compile(r"[a-z]+")

m = p.search("3 python")

print(m)

이번에는 python을 찾을 수 있다.

30. match()와 search() 비교

이 둘은 매우 중요하다.

p.match("3 python")

결과

None

하지만

p.search("3 python")

에서는

python

부분을 찾는다.

정리하면

match()

문자열 시작부터 검사

search()

문자열 전체에서 검색

이다.

그림으로 보면

문자열

3 python
01234567

match()

↓
3 python

첫 위치부터 검사
3이 [a-z]가 아니므로 실패

search()

3 python
  ↑↑↑↑↑↑

문자열 전체를 검색
python 발견

31. findall()

findall()은

정규식과 일치하는 모든 문자열을 찾아 리스트로 반환

한다.

예를 들어

import re

p = re.compile(r"[a-z]+")

result = p.findall("python is very easy")

print(result)

결과

['python', 'is', 'very', 'easy']

이다.

findall의 특징

search()는 일치하는 위치 하나를 찾는 데 주로 사용하는 반면

findall()

은 모든 결과가 필요할 때 유용하다.

문자열

python is very easy

↓ findall()

python
is
very
easy

↓ 리스트

['python', 'is', 'very', 'easy']

32. 숫자를 모두 추출하기

실제 사용에서는 다음처럼 활용할 수 있다.

import re

data = "WEB01=80 WAS01=8080 DB01=3306"

result = re.findall(r"\d+", data)

print(result)

결과

['01', '80', '01', '8080', '01', '3306']

처럼 숫자 패턴을 모두 추출할 수 있다.

33. finditer()

finditer()도 매치되는 결과를 모두 찾는다.

하지만 findall()과 차이가 있다.

import re

p = re.compile(r"[a-z]+")

result = p.finditer("python is easy")

for m in result:
    print(m)

각 결과가 Match 객체 형태로 반환된다.

34. findall()과 finditer() 비교

특히 위치까지 확인해야 한다면

finditer()

가 유용하다.

35. Match 객체

match(), search(), finditer() 등을 사용하면 Match 객체를 얻게 된다.

Match 객체에서는 매치 결과에 대한 정보를 확인할 수 있다.

대표적인 메서드는 다음과 같다.

36. group()

import re

p = re.compile(r"[a-z]+")

m = p.search("3 python")

print(m.group())

결과

python

즉

group()

은 실제로 매치된 문자열을 반환한다.

37. start()

print(m.start())

매치가 시작된 위치를 반환한다.

문자열이

3 python

이라면 인덱스는

3   p y t h o n
0 1 2 3 4 5 6 7

이므로 python의 시작 위치는

2

이다.

38. end()

print(m.end())

매치가 끝나는 위치를 반환한다.

여기서 주의할 점은 마지막 문자의 인덱스가 아니라 그 다음 위치라는 것이다.

예를 들어

python

이 인덱스 2~7에 있다면

start() → 2
end()   → 8

이 된다.

이 방식은 파이썬 슬라이싱과 같다.

text[2:8]

39. span()

print(m.span())

결과는

(2, 8)

처럼 나온다.

즉

(start(), end())

를 한 번에 튜플로 반환한다.

40. Match 객체 한 번에 보기

import re

p = re.compile(r"[a-z]+")

m = p.search("3 python")

print(m.group())
print(m.start())
print(m.end())
print(m.span())

결과

python
2
8
(2, 8)

따라서

group() → 무엇을 찾았는가?
start() → 어디서 시작했는가?
end()   → 어디까지인가?
span()  → 시작과 끝을 한 번에

라고 기억하면 된다.

41. re.compile() 없이 사용하는 방법

지금까지는

p = re.compile(r"[a-z]+")

m = p.match("python")

처럼 사용했다.

하지만 다음처럼 한 번에 작성할 수도 있다.

m = re.match(r"[a-z]+", "python")

즉

re.compile()
+
match()

↓

re.match()

형태로 사용할 수 있다.

언제 compile을 사용할까?

같은 정규식을 여러 번 사용할 예정이라면

p = re.compile(...)

처럼 패턴 객체를 만들어 두면 코드가 깔끔하다.

간단하게 한 번 검색하는 경우라면

re.search(...)
re.findall(...)

처럼 직접 사용할 수도 있다.

42. 컴파일 옵션

정규식을 사용할 때 동작 방식을 변경하기 위한 옵션이 있다.

대표적인 옵션은 다음과 같다.

43. DOTALL

기본적으로

.

은 줄바꿈

\n

과 매치되지 않는다.

예를 들어

import re

p = re.compile(r"a.b")

print(p.match("a\nb"))

에서는 매치되지 않는다.

re.DOTALL

다음처럼 옵션을 사용한다.

p = re.compile(r"a.b", re.DOTALL)

또는

p = re.compile(r"a.b", re.S)

그러면

.

이 줄바꿈까지 포함해 매치할 수 있다.

a
\n
b

에서도 매치할 수 있게 된다.

44. IGNORECASE

기본적으로 정규식에서는 대소문자를 구분한다.

python
Python
PYTHON

은 서로 다른 문자열이다.

대소문자를 구분하고 싶지 않다면

re.IGNORECASE

또는

re.I

를 사용한다.

import re

p = re.compile(r"python", re.I)

print(p.match("python"))
print(p.match("Python"))
print(p.match("PYTHON"))

모두 매치할 수 있다.

45. MULTILINE

다음 메타 문자도 자주 사용한다.

^

문자열의 시작

그리고

$

는

문자열의 끝

을 의미한다.

예를 들어

^python

은

python으로 시작

이라는 의미이다.

여러 줄 문자열

다음 데이터가 있다고 해보자.

data = """python one
java two
python three"""

그리고

p = re.compile(r"^python")

을 사용하면 기본적으로 문자열 전체의 처음을 기준으로 한다.

하지만

p = re.compile(r"^python", re.MULTILINE)

또는

p = re.compile(r"^python", re.M)

을 사용하면

각 줄의 시작

을 기준으로 검사할 수 있다.

따라서

python one

과

python three

의 python을 각각 찾을 수 있다.

46. VERBOSE

정규식이 짧을 때는 문제가 없다.

하지만 정규식이 길어지면

^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$

처럼 매우 읽기 어려워진다.

이럴 때

re.VERBOSE

또는

re.X

를 사용할 수 있다.

예제

import re

email_pattern = re.compile(
    r"""
    ^                       # 문자열 시작
    [A-Za-z0-9._%+-]+       # 사용자 이름
    @                       # @
    [A-Za-z0-9.-]+          # 도메인
    \.                      # 실제 점
    [A-Za-z]{2,}            # 최상위 도메인
    $                       # 문자열 끝
    """,
    re.VERBOSE
)

이렇게 작성하면 복잡한 정규식을 여러 줄로 나누고 주석까지 작성할 수 있어 훨씬 이해하기 쉽다.

47. 역슬래시 \ 문제

정규식에서 가장 헷갈릴 수 있는 부분 중 하나가

\

이다.

정규식에서도 역슬래시에 특별한 의미가 있고 파이썬 문자열에서도 역슬래시는 이스케이프 문자로 사용된다.

즉

Python 문자열 해석
        +
정규식 해석

두 단계가 겹칠 수 있다.

그래서 코드가 복잡해질 수 있다.

48. 예를 들어 \section을 찾는다면?

문자열 안에 실제로

\section

이라는 문자가 있다고 해보자.

정규식에서

\section

이라고 그대로 사용하면 문제가 발생할 수 있다.

왜냐하면 정규식 엔진은 앞부분

\s

를

Whitespace

라는 특별한 정규식으로 해석할 수 있기 때문이다.

49. 역슬래시 자체 표현하기

정규식에서 실제 역슬래시를 의미하도록 만들려면 역슬래시를 이스케이프해야 한다.

즉 정규식 수준에서는

\\section

처럼 표현한다.

그런데 일반적인 파이썬 문자열에서도 \가 특별한 의미를 가지므로 코드가 더 복잡해질 수 있다.

이 문제를 쉽게 해결하는 방법이 Raw String이다.

50. Raw String

정규식을 작성할 때 다음처럼 문자열 앞에

r

을 붙이는 경우가 많다.

r"\d+"

이것을 Raw String이라고 한다.

일반 문자열

"\n"

은

줄바꿈

으로 처리된다.

하지만

r"\n"

은 문자열 안의 역슬래시를 정규식 작성에 보다 편리하게 사용할 수 있게 해 준다.

51. 정규식에서는 Raw String을 쓰는 습관

정규식에서는 다음처럼 쓰는 습관을 들이는 것이 좋다.

re.compile(r"\d+")

re.findall(r"[0-9]+", text)

re.search(r"\w+", text)

즉

정규식 문자열
      ↓
가능하면 r"..."

형태로 작성한다고 기억하면 된다.

52. 지금까지 배운 메타 문자

53. 예제를 직접 해석해 보기

다음 정규식을 살펴보자.

\d{3}-\d{4}-\d{4}

하나씩 나누면

\d{3}
 ↓
숫자 3개

-
 ↓
하이픈

\d{4}
 ↓
숫자 4개

-
 ↓
하이픈

\d{4}
 ↓
숫자 4개

따라서 전체적으로

숫자 3개
-
숫자 4개
-
숫자 4개

라는 형태를 찾는다.

54. IP 주소 형태 찾기

아주 단순하게 IP처럼 생긴 문자열을 찾는다면

\d+\.\d+\.\d+\.\d+

처럼 표현할 수도 있다.

하나씩 보면

\d+
 ↓
숫자가 1개 이상

\.
 ↓
실제 점

이 구조가 반복된다.

따라서

192.168.0.1

과 같은 형태를 찾을 수 있다.

다만 이 정규식은 999.999.999.999도 매치할 수 있기 때문에 IPv4 주소의 실제 유효 범위인 0~255까지 검증하는 정규식은 더 복잡하다.

55. 보안 로그 예제로 보기

예를 들어 다음 로그가 있다고 해보자.

SRC=192.168.10.20 DST=10.0.0.10 PORT=443

숫자들을 가져오려면

import re

log = "SRC=192.168.10.20 DST=10.0.0.10 PORT=443"

result = re.findall(r"\d+", log)

print(result)

결과는

['192', '168', '10', '20', '10', '0', '0', '10', '443']

처럼 나온다.

정규식을 조금씩 조합하면 나중에는 로그나 보안 이벤트에서도 원하는 패턴을 추출할 수 있다.

56. 08-2에서 가장 중요한 흐름

정규식을 실제 파이썬 코드에서 사용하면 기본적으로 다음과 같은 흐름이 된다.

정규식 작성
   ↓
re.compile()
   ↓
Pattern 객체
   ↓
문자열 검색
   ↓
match()
search()
findall()
finditer()
   ↓
결과 확인

또는 간단한 경우

re.match()
re.search()
re.findall()

처럼 바로 사용할 수도 있다.

📌 핵심 정리

문자 클래스

[abc]

a 또는 b 또는 c

[a-z]

영문 소문자

[^0-9]

숫자가 아닌 문자

자주 사용하는 문자 클래스

\d → 숫자
\D → 숫자가 아닌 것

\s → 공백 계열
\S → 공백 계열이 아닌 것

\w → 단어 문자
\W → 단어 문자가 아닌 것

반복

*

0번 이상

+

1번 이상

?

0번 또는 1번

{3}

정확히 3번

{2,5}

2~5번

match와 search

match()

문자열 처음부터 확인

search()

문자열 전체에서 검색

이 차이가 가장 중요하다.

findall

re.findall(r"\d+", "abc 100 def 200")

['100', '200']

매치되는 모든 문자열을 리스트로 반환한다.

finditer

모든 결과를 찾지만 각각의 결과를 Match 객체 형태로 다룰 수 있다.

Match 객체

group()
→ 매치된 문자열

start()
→ 시작 위치

end()
→ 끝 위치

span()
→ (시작 위치, 끝 위치)

컴파일 옵션

re.S
→ .에 줄바꿈 포함

re.I
→ 대소문자 무시

re.M
→ 각 줄에 ^, $ 적용

re.X
→ 복잡한 정규식을 여러 줄과 주석으로 작성

Raw String

정규식에서는 역슬래시가 자주 등장하므로

r"\d+"

처럼 r"..." 형태로 작성하는 습관을 들이면 좋다.

⭐ 08-2 전체 흐름

문자열에서 원하는 규칙 정의
        ↓
정규 표현식 작성
        ↓
[ ]
.
*
+
?
{}
\d
\s
\w
        ↓
re.compile()
        ↓
Pattern 객체 생성
        ↓
 ┌───────────┬───────────┬────────────┬────────────┐
 │           │           │            │
match()   search()    findall()    finditer()
 │           │           │            │
처음부터   전체 검색    모두 리스트   모두 Iterator

그리고 match()나 search()로 얻은 Match 객체에서는

group()
start()
end()
span()

을 이용해

무엇이 매치되었는지
+
어디에서 매치되었는지

확인할 수 있다.

08-2의 핵심은 정규식 기호를 단순히 외우는 것이 아니라 [a-z]+처럼 하나씩 분해해서 읽는 습관을 만드는 것이다.

예를 들어

[a-z]+

를 보면 바로

[a-z]
→ 영문 소문자

+

→ 1번 이상

따라서

영문 소문자가 1글자 이상 연속

이라고 해석할 수 있어야 한다.

목차

• 1. 정규 표현식이란?
• 2. 문자열의 패턴
• 3. 정규 표현식은 왜 필요한가?
• 4. 정규식 없이 문자열 처리하기
• 5. 정규식을 사용하여 처리하기
• 6. 일반 문자열 처리와 정규식 비교

1. 정규 표현식이란?

정규 표현식(Regular Expression) 은

문자열에서 특정한 규칙을 가진 패턴을 표현하는 방법

이다.

줄여서 정규식이라고도 한다.

예를 들어 다음과 같은 문자열을 찾고 싶다고 해보자.

숫자 6개
+
하이픈(-)
+
숫자 7개

일반적인 말로 표현하면 상당히 길지만 정규식에서는 다음처럼 표현할 수 있다.

\d{6}-\d{7}

즉,

\d{6}
  ↓
숫자 6개

-

\d{7}
  ↓
숫자 7개

라는 의미이다.

아직 각각의 문법을 외울 필요는 없다.

이번 장에서는 우선

"정규식은 문자열의 모양이나 규칙을 표현하는 문법이다."

정도로 이해하면 된다.

2. 문자열의 패턴

정규식에서 중요한 단어가 바로 패턴(Pattern) 이다.

예를 들어 다음과 같은 데이터가 있다고 해보자.

010-1234-5678
010-9876-1234

두 문자열의 실제 숫자는 서로 다르다.

하지만 형태를 보면

숫자 3개
-
숫자 4개
-
숫자 4개

라는 동일한 규칙을 가지고 있다.

이러한 일정한 형태를 패턴이라고 생각하면 된다.

또 다른 예

이메일 주소를 생각해 보자.

pingu@example.com
python@test.co.kr
hello@gmail.com

각각의 내용은 다르지만 대략적으로

문자열
  ↓
@
  ↓
도메인
  ↓
.
  ↓
확장자

라는 공통적인 형태가 있다.

정규식은 이런 문자열의 규칙을 찾아내거나 검사할 때 사용할 수 있다.

3. 정규 표현식은 파이썬만 사용하는가?

정규 표현식은 파이썬에서만 사용하는 기능이 아니다.

다양한 프로그래밍 언어에서 사용한다.

예를 들어

Python
JavaScript
Java
C#
...

등에서도 정규식을 사용할 수 있다.

따라서 정규식의 기본 문법을 익혀 두면 다른 프로그래밍 언어에서도 활용할 수 있다.

4. 정규 표현식은 왜 필요한가?

다음과 같은 문제를 생각해 보자.

문자열에 특정 번호 형식이 포함되어 있다.

앞의 숫자 6자리는 그대로 두고
뒤의 숫자 7자리를 * 문자로 변경하고 싶다.

예를 들어

hong 800905-1234567
kim  700905-2345678

이라는 데이터가 있다면

hong 800905-*******
kim  700905-*******

처럼 변경하고 싶은 것이다.

5. 정규식 없이 해결하려면?

정규식을 사용하지 않는다면 문자열을 하나씩 직접 검사해야 한다.

전체적인 흐름은 다음과 같다.

전체 문자열
    ↓
줄 단위로 나누기
    ↓
공백을 기준으로 단어 나누기
    ↓
각 단어 길이 확인
    ↓
앞 6자리가 숫자인지 확인
    ↓
하이픈 위치 확인
    ↓
뒤 7자리가 숫자인지 확인
    ↓
조건을 만족하면 뒤쪽을 *로 변경
    ↓
다시 문자열 합치기

코드로 만들어 보자.

data = """
hong 800905-1234567
kim  700905-2345678
"""

result = []

for line in data.split("\n"):
    words = []

    for word in line.split(" "):
        if (
            len(word) == 14
            and word[:6].isdigit()
            and word[6] == "-"
            and word[7:].isdigit()
        ):
            word = word[:7] + "*******"

        words.append(word)

    result.append(" ".join(words))

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

실행 결과

hong 800905-*******
kim  700905-*******

원하는 결과는 얻을 수 있다.

하지만 코드를 보면 확인해야 하는 조건이 많다.

len(word) == 14

word[:6].isdigit()

word[6] == "-"

word[7:].isdigit()

즉 우리가 원하는 문자열의 형태를 하나하나 직접 검사하고 있다.

6. 코드 동작 과정

예를 들어

800905-1234567

을 검사한다고 해보자.

먼저 길이를 확인한다.

len(word) == 14

14글자인가?
→ O

그다음 앞의 6글자를 확인한다.

word[:6]

결과

800905

숫자인지 확인한다.

word[:6].isdigit()

True

하이픈도 확인한다.

word[6] == "-"

True

마지막으로 뒤의 7글자가 숫자인지 확인한다.

word[7:].isdigit()

결과

True

모든 조건을 만족했으므로

word = word[:7] + "*******"

을 실행한다.

결과

800905-*******

가 된다.

7. 문제점

현재 코드도 정상적으로 동작한다.

하지만 문자열 규칙이 복잡해질수록 확인해야 할 조건이 계속 늘어난다.

예를 들어

숫자인가?
문자인가?
몇 글자인가?
하이픈이 있는가?
특수문자가 있는가?
특정 위치에 문자가 있는가?

등을 직접 검사해야 한다.

따라서 코드가 점점 길고 복잡해질 수 있다.

이럴 때 정규 표현식을 사용하면 편리하다.

8. 정규식을 사용해 보기

파이썬에서는 정규 표현식을 사용할 때 re 모듈을 사용한다.

import re

그리고 찾으려는 패턴을 정규식으로 작성한다.

pattern = re.compile(r"(\d{6})-\d{7}")

아직 이 정규식의 문법을 모두 이해하지 않아도 된다.

현재는 대략

(\d{6})
   ↓
숫자 6개

-

\d{7}
   ↓
숫자 7개

라고 이해하면 된다.

9. 정규식을 이용한 변환

예를 들어 다음과 같이 작성할 수 있다.

import re

data = """
hong 800905-1234567
kim  700905-2345678
"""

pattern = re.compile(r"(\d{6})-\d{7}")

result = pattern.sub(r"\1-*******", data)

print(result)

실행 결과

hong 800905-*******
kim  700905-*******

정규식을 사용하지 않았을 때보다 코드가 훨씬 짧아졌다.

10. re.compile()

다음 코드를 살펴보자.

pattern = re.compile(r"(\d{6})-\d{7}")

re.compile()은

정규 표현식 패턴을 만들어 사용할 수 있도록 준비하는 함수

라고 생각하면 된다.

즉,

정규식 문자열
      ↓
re.compile()
      ↓
정규식 패턴 객체

의 형태이다.

이후 패턴 객체를 이용해 문자열을 검색하거나 변경할 수 있다.

11. sub()

다음 코드를 보자.

pattern.sub(r"\1-*******", data)

sub()는 쉽게 말하면

정규식과 일치하는 문자열을 다른 문자열로 바꾸는 기능

이다.

전체적인 흐름만 보면

data에서
    ↓
정규식에 해당하는 문자열 찾기
    ↓
찾은 문자열 변경
    ↓
새로운 문자열 반환

이라고 생각하면 된다.

sub()에 대한 자세한 문법은 뒤에서 다시 학습하게 된다.

12. r"..."은 무엇일까?

정규식에서는 다음과 같은 코드를 자주 볼 수 있다.

r"\d{6}"

문자열 앞에

r

이 붙어 있다.

이것을 Raw String이라고 한다.

일반적인 파이썬 문자열에서는

"\n"

이 줄바꿈을 의미한다.

하지만

r"\n"

처럼 r을 붙이면 \를 특별하게 처리하지 않고 문자 그대로 다루기 쉬워진다.

정규식에서는

\d
\s
\w

처럼 역슬래시 \를 많이 사용하기 때문에 Raw String을 자주 사용한다.

따라서 정규식을 볼 때

r"..."

형태가 자주 등장한다는 것을 기억해 두자.

13. 일반 문자열 처리와 정규식 비교

정규식 없이 처리

문자열 분리
 ↓
길이 확인
 ↓
숫자인지 확인
 ↓
특정 위치 확인
 ↓
조건 검사
 ↓
문자열 변경
 ↓
다시 합치기

여러 조건을 직접 코드로 만들어야 한다.

정규식 사용

원하는 패턴 정의
       ↓
정규식으로 검색
       ↓
일치하는 문자열 처리

문자열의 규칙 자체를 하나의 패턴으로 표현할 수 있다.

14. 정규식은 언제 유용할까?

정규 표현식은 특히 일정한 규칙을 가진 문자열을 처리할 때 유용하다.

예를 들어

전화번호
이메일 주소
IP 주소
URL
날짜
시간
로그 데이터
특정 문자열 패턴

등을

찾기
검사하기
추출하기
바꾸기

위해 사용할 수 있다.

15. 보안에서도 많이 사용한다

정규식은 보안 분야에서도 자주 볼 수 있다.

예를 들어 로그나 네트워크 데이터에서

특정 URL 패턴
특정 User-Agent
IP 주소
명령어 패턴
파일 확장자
공격 문자열

등을 찾을 때 정규식을 활용할 수 있다.

예를 들어 단순한 IPv4 형태를 찾는다면 다음과 같은 정규식을 볼 수도 있다.

\d+\.\d+\.\d+\.\d+

지금은 문법을 외우기보다

정규식
 ↓
문자열의 특정 패턴 탐지

라는 개념을 기억해 두면 된다.

16. 정규식의 장점

정규식을 사용하면 복잡한 문자열 패턴을 비교적 짧게 표현할 수 있다.

예를 들어

숫자 6개
+
-
+
숫자 7개

라는 설명을

\d{6}-\d{7}

처럼 표현할 수 있다.

따라서

복잡한 문자열 검색
문자열 검증
문자열 추출
문자열 치환

작업에서 유용하다.

17. 정규식의 단점

정규식은 강력하지만 처음 보면 읽기가 어렵다.

예를 들어

\d{6}-\d{7}

도 정규식 문법을 모르면 무슨 의미인지 알기 어렵다.

더 복잡해지면

^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$

처럼 한눈에 이해하기 어려운 형태가 될 수 있다.

따라서

정규식은 무작정 외우기보다 각각의 기호가 무엇을 의미하는지 하나씩 이해하는 것이 중요하다.

18. 이번 장에서 알아둘 것

아직 다음 문법을 완벽하게 이해할 필요는 없다.

\d
{}
()
\

다음 장부터 하나씩 배우게 된다.

현재 가장 중요한 것은

정규식 = 문자열의 규칙을 표현하는 방법

이라는 개념이다.

📌 핵심 정리

정규 표현식

문자열의 특정한 패턴을 표현하는 문법이다.

숫자 6개 - 숫자 7개

        ↓

\d{6}-\d{7}

Pattern

문자열이 가지고 있는 일정한 규칙을 의미한다.

010-1234-5678

숫자 3개
   ↓
-
   ↓
숫자 4개
   ↓
-
   ↓
숫자 4개

파이썬의 re 모듈

정규식을 사용할 때

import re

를 사용한다.

re.compile()

정규식 패턴을 준비한다.

pattern = re.compile(r"\d{6}-\d{7}")

sub()

정규식에 일치하는 문자열을 다른 문자열로 변경할 때 사용할 수 있다.

pattern.sub(...)

Raw String

정규식에서는 역슬래시를 많이 사용하기 때문에

r"..."

형태의 Raw String을 자주 사용한다.

⭐ 08-1 전체 흐름

문자열 데이터
      ↓
특정한 규칙을 가진 문자열을 찾고 싶음
      ↓
일반 코드 사용
      ↓
split / isdigit / 길이 검사 등
여러 조건을 직접 작성
      ↓
코드가 복잡해짐

            또는

문자열 데이터
      ↓
원하는 규칙 정의
      ↓
정규 표현식
      ↓
패턴 검색 / 추출 / 변경
      ↓
코드 간결화

정규 표현식은 "특정 문자열 자체"를 찾는 것이 아니라, 내가 원하는 "문자열의 형태와 규칙"을 표현해 찾는 방법이라고 이해하면 된다.

목차

• 1. 동적 언어와 정적 언어
• 2. 동적 언어의 장단점
• 3. 타입 어노테이션이란?
• 4. 변수에 타입 지정하기
• 5. 함수에 타입 지정하기
• 6. 리스트와 딕셔너리 타입 지정하기
• 7. typing 모듈
• 8. Optional과 Union
• 9. Callable과 Any
• 10. mypy를 이용한 타입 검사

1. 동적 언어와 정적 언어

파이썬은 동적 타입 언어(Dynamically Typed Language) 이다.

다음 코드를 살펴보자.

a = 1

print(type(a))

실행 결과

<class 'int'>

현재 a에는 정수 1이 저장되어 있으므로 자료형은 int이다.

이번에는 같은 변수에 문자열을 저장해 보자.

a = "1"

print(type(a))

실행 결과

<class 'str'>

처음에는

a → int

였지만 새로운 값을 대입하면서

a → str

처럼 사용할 수 있다.

즉 파이썬에서는 프로그램 실행 중에도 변수에 서로 다른 타입의 값을 대입할 수 있다.

a = 10
a = "Python"
a = [1, 2, 3]

이것이 파이썬을 동적 타입 언어라고 부르는 이유이다.

2. 정적 타입 언어

반대로 자바와 같은 언어는 정적 타입 언어(Statically Typed Language) 이다.

예를 들어 자바에서는

int a = 1;

처럼 변수의 타입을 미리 지정한다.

여기서 a는 int형이므로

a = "1";

처럼 문자열을 저장할 수 없다.

즉,

정적 타입 언어

변수 생성
   ↓
타입 지정
   ↓
지정된 타입의 값만 사용

하는 방식이다.

3. 동적 언어와 정적 언어 비교

4. 동적 언어의 장점

파이썬과 같은 동적 타입 언어는 타입을 일일이 지정하지 않아도 된다.

예를 들어

name = "pingu"
age = 20
scores = [90, 80, 100]

처럼 바로 값을 저장할 수 있다.

따라서

• 코드가 간단함
• 빠르게 프로그램 작성 가능
• 타입에 비교적 자유로움
• 코드가 간결함

이라는 장점이 있다.

5. 동적 언어의 단점

하지만 프로그램의 규모가 커지면 문제가 발생할 수 있다.

다음 함수를 보자.

def add(a, b):
    return a + b

코드만 보면

a에는 어떤 값이 들어와야 하지?
b는 숫자인가?
문자열인가?
결과는 어떤 자료형이지?

를 바로 알기 어렵다.

특히 여러 사람이 함께 개발하는 큰 프로젝트에서는 타입을 잘못 사용해 버그가 발생할 가능성이 커질 수 있다.

이러한 문제를 보완하기 위해 사용하는 것이

타입 어노테이션(Type Annotation)

이다.

6. 타입 어노테이션이란?

타입 어노테이션은 변수나 함수에

어떤 타입을 사용할 것인지 표시해 주는 기능

이다.

예를 들어

num: int = 1

이라고 작성한다.

여기서

: int

부분이 타입 어노테이션이다.

뜻은

num 변수에는
int 타입의 값을 사용할 예정이다.

라고 알려 주는 것이다.

7. 타입 어노테이션은 강제 규칙이 아니다

이 부분이 매우 중요하다.

num: int = 1

이라고 작성했다고 해서 파이썬이 반드시 int만 사용하도록 강제하는 것은 아니다.

예를 들어

num: int = 1

num = "Python"

print(num)

실행 결과

Python

정상적으로 실행된다.

즉,

타입 어노테이션
     ↓
타입 강제 X
     ↓
타입에 대한 힌트 O

이다.

그래서 Type Hint라고도 부른다.

8. 변수에 타입 지정하기

기본적인 변수 타입은 다음과 같이 지정할 수 있다.

num: int = 1

name: str = "홍길동"

height: float = 175.5

is_student: bool = True

각각 의미는 다음과 같다.

9. 기본 자료형 타입 어노테이션

자주 사용하는 타입은 다음과 같다.

int   → 정수
float → 실수
str   → 문자열
bool  → 불
list  → 리스트
tuple → 튜플
dict  → 딕셔너리
set   → 집합

예를 들어

number: int = 10
name: str = "Python"
numbers: list = [1, 2, 3]

처럼 사용할 수 있다.

10. 함수에 타입 지정하기

타입 어노테이션은 함수에서도 많이 사용한다.

다음 함수를 살펴보자.

def add(a: int, b: int) -> int:
    return a + b

하나씩 보면

a: int

은

a는 int 타입

이라는 의미이다.

b: int

은

b는 int 타입

이라는 의미이다.

그리고

-> int

는

이 함수는 int 타입을 반환한다.

라는 뜻이다.

11. 함수 타입 어노테이션 구조

기본 구조는 다음과 같다.

def 함수이름(매개변수: 타입) -> 반환타입:
    ...

예를 들어

def greet(name: str) -> str:
    return f"안녕하세요, {name}님!"

뜻은

name
 ↓
str 입력

greet()
 ↓

str 반환

이다.

12. 타입 어노테이션이 없는 경우

다음 코드를 보자.

def add(a, b):
    return a + b

이 함수만 보면

a = ?
b = ?
return = ?

를 바로 알기 어렵다.

하지만

def add(a: int, b: int) -> int:
    return a + b

라고 작성하면

입력
a → int
b → int

출력
return → int

이라는 사실을 쉽게 알 수 있다.

즉 타입 어노테이션은 코드의 가독성을 높여 준다.

13. 리스트 내부 타입 지정하기

단순히

numbers: list

라고 작성하면 리스트라는 사실만 알 수 있다.

하지만 리스트 안에 어떤 타입이 들어 있는지도 지정할 수 있다.

numbers: list[int] = [1, 2, 3]

뜻은

numbers
 ↓
list
 ↓
리스트 내부 값은 int

이다.

14. 다양한 컬렉션 타입

리스트

numbers: list[int] = [1, 2, 3]

int를 저장하는 리스트

딕셔너리

user_info: dict[str, int] = {
    "age": 30
}

뜻은

key   → str
value → int

이다.

튜플

coordinates: tuple[float, float] = (3.5, 7.2)

뜻은

첫 번째 값 → float
두 번째 값 → float

이다.

집합

numbers: set[int] = {1, 2, 3}

int 값을 저장하는 집합이라는 의미이다.

15. 타입을 자세하게 적는 이유

다음 두 코드를 비교해 보자.

users: list

이 코드만 보면

리스트인 것은 알겠는데
안에 무엇이 들어 있지?

라는 의문이 생긴다.

하지만

users: list[str]

라고 작성하면

문자열을 저장하는 리스트

라는 사실을 바로 알 수 있다.

따라서 코드를 읽고 이해하기 쉬워진다.

16. typing 모듈

타입 어노테이션을 보다 다양하게 사용하기 위해

typing

모듈을 사용할 수 있다.

과거 파이썬에서는 다음과 같은 형태를 많이 사용했다.

from typing import List, Dict, Tuple

numbers: List[int] = [1, 2, 3]

user_info: Dict[str, int] = {
    "age": 30
}

17. 최신 파이썬에서는?

Python 3.9 이상에서는

List[int]
Dict[str, int]
Tuple[int, int]

대신 기본 자료형을 직접 사용할 수 있다.

list[int]
dict[str, int]
tuple[int, int]

따라서 현재는 다음처럼 작성하는 방식이 일반적이다.

numbers: list[int] = [1, 2, 3]

user_info: dict[str, int] = {
    "age": 30
}

즉

과거

List[int]
Dict[str, int]
Tuple[int, int]

에서

현재

list[int]
dict[str, int]
tuple[int, int]

형태로 사용할 수 있다.

18. typing 모듈이 여전히 필요한 경우

기본 자료형은

list[int]
dict[str, int]

처럼 사용할 수 있지만 좀 더 특별한 타입을 표현할 때는 typing 모듈을 사용할 수 있다.

대표적으로

Optional
Union
Callable
Any

등이 있다.

19. Optional

다음 상황을 생각해 보자.

사용자 이름을 저장하는 변수인데 사용자 이름이 없을 수도 있다.

즉

문자열일 수도 있음
또는
None일 수도 있음

이다.

이럴 때 Optional을 사용할 수 있다.

from typing import Optional

user_name: Optional[str] = None

Optional[str]은

str 또는 None

이라는 의미이다.

값이 있는 경우

user_name: Optional[str] = "pingu"

가능하다.

값이 없는 경우

user_name: Optional[str] = None

이것도 가능하다.

따라서

Optional[str]

      ┌─ str
      │
      └─ None

이라고 생각하면 된다.

20. Union

하나의 값에 여러 타입이 들어올 수 있다고 표시할 때 Union을 사용한다.

from typing import Union

user_id: Union[int, str]

뜻은

user_id
   ↓
int 또는 str

이다.

따라서

user_id = 100

도 가능하고

user_id = "pingu"

도 가능하다.

21. Optional과 Union 관계

사실

Optional[str]

은 개념적으로

Union[str, None]

과 같은 의미라고 이해하면 된다.

즉

Optional[str]

str 또는 None

이다.

22. 최신 파이썬 문법

최근 파이썬에서는 Union 대신 |를 사용할 수도 있다.

예를 들어

user_id: int | str

은

int 또는 str

을 의미한다.

그리고

user_name: str | None

은

str 또는 None

이라는 의미이다.

따라서 다음처럼 대응해서 이해하면 된다.

Optional[str]
      ↓
str | None

Union[int, str]
      ↓
int | str

23. Callable

함수 자체의 타입도 표현할 수 있다.

이때 Callable을 사용할 수 있다.

from typing import Callable

예를 들어

def process_data(
    callback: Callable[[int], str]
) -> str:

    return callback(42)

여기서

Callable[[int], str]

은

int를 입력받고
     ↓
str을 반환하는 함수

라는 의미이다.

구조

Callable[[매개변수 타입], 반환 타입]

예를 들어

Callable[[int, int], int]

은

int, int
   ↓
함수
   ↓
int 반환

이라는 의미이다.

24. Any

어떤 타입이 들어와도 괜찮다고 표현할 때는

Any

를 사용할 수 있다.

from typing import Any

data: Any

다음과 같은 값이 모두 가능하다.

data = 10
data = "Python"
data = [1, 2, 3]
data = {"name": "pingu"}

즉

Any
 ↓
어떤 타입이든 허용

이라는 의미이다.

25. 실무 형태 예제

예를 들어 사용자를 찾는 함수를 만들어 보자.

from typing import Optional

def find_user(user_id: int) -> Optional[dict[str, str]]:

    if user_id > 0:
        return {
            "name": "홍길동",
            "email": "hong@example.com"
        }

    return None

반환 타입을 보면

Optional[dict[str, str]]

이다.

즉 이 함수의 결과는

사용자를 찾음
      ↓
dict[str, str]

사용자를 못 찾음
      ↓
None

중 하나이다.

26. 타입 어노테이션은 실제로 검사할까?

다음 코드를 살펴보자.

def add(a: int, b: int) -> int:
    return a + b

a와 b 모두 int라고 지정했다.

그런데 다음처럼 실행해 보자.

result = add(3, 3.4)

print(result)

실행 결과

6.4

정상적으로 실행된다.

왜 그럴까?

파이썬의 타입 어노테이션은

타입 강제 기능

이 아니라

타입에 대한 정보와 힌트

이기 때문이다.

27. 타입을 잘못 넣어도 파이썬은 실행한다

다음 코드에서

def add(a: int, b: int) -> int:
    return a + b

분명 b는

int

라고 표시되어 있다.

하지만

add(3, 3.4)

처럼 float을 사용해도 파이썬은 타입 어노테이션만 보고 실행을 막지 않는다.

즉

타입 어노테이션
       ↓
사람 / IDE / 검사 도구에게 정보 제공
       ↓
파이썬 실행 자체를 강제로 제한하지 않음

이다.

28. mypy

그렇다면 타입이 제대로 사용되고 있는지 어떻게 검사할까?

대표적인 도구가

mypy

이다.

mypy는 파이썬 코드를 실행하기 전에 타입 어노테이션을 분석하는 정적 타입 검사 도구이다.

29. mypy 설치하기

mypy는 파이썬 표준 라이브러리가 아니므로 설치해야 한다.

pip install mypy

설치 후 파이썬 파일을 검사할 수 있다.

예를 들어

typing_sample.py

파일을 만들었다고 해보자.

def add(a: int, b: int) -> int:
    return a + b


result = add(3, 3.4)

print(result)

30. mypy로 검사하기

터미널에서 실행한다.

mypy typing_sample.py

그러면 mypy는

b는 int를 사용한다고 했는데
float 값이 전달되었다.

라는 문제를 발견할 수 있다.

즉

add(3, 3.4)

에서

3   → int O
3.4 → float X

가 되는 것이다.

31. 코드 수정하기

다음처럼 수정한다.

def add(a: int, b: int) -> int:
    return a + b


result = add(3, 4)

print(result)

다시 검사하면

mypy typing_sample.py

타입 문제가 없다는 결과를 확인할 수 있다.

32. 파이썬과 mypy의 차이

이 부분을 확실히 구분해야 한다.

Python 실행

python typing_sample.py

실제 프로그램 실행

mypy 검사

mypy typing_sample.py

프로그램을 실행하기 전
타입 어노테이션 검사

즉

코드 작성
   ↓
mypy
   ↓
타입 검사
   ↓
문제 수정
   ↓
Python 실행

과 같은 흐름으로 사용할 수 있다.

33. 타입 어노테이션을 사용하는 이유

타입 어노테이션의 가장 큰 목적은 코드를 이해하기 쉽게 만드는 것이다.

다음 함수를 비교해 보자.

타입 어노테이션이 없는 함수

def get_user(user_id):
    ...

이것만 보면

user_id가 숫자인가?
문자열인가?

무엇을 반환하지?

를 바로 알기 어렵다.

타입 어노테이션이 있는 함수

def get_user(user_id: int) -> dict[str, str]:
    ...

이제 코드만 보고도

입력
 ↓
user_id = int

출력
 ↓
dict[str, str]

이라는 사실을 알 수 있다.

34. 특히 팀 개발에서 유용하다

혼자 작성한 작은 프로그램이라면 자신이 작성한 코드를 기억하고 있을 수 있다.

하지만 규모가 커지면

개발자 A
개발자 B
개발자 C
개발자 D
...

여러 사람이 하나의 코드를 함께 사용한다.

이때 타입 어노테이션이 있다면 함수가 어떤 값을 요구하는지 쉽게 확인할 수 있다.

def login(
    username: str,
    password: str
) -> bool:
    ...

코드만 보고도

username → str
password → str
return   → bool

이라는 구조를 알 수 있다.

35. IDE에서도 활용된다

VSCode나 PyCharm과 같은 개발 도구는 타입 어노테이션을 이용하여

• 자동 완성
• 타입 정보 표시
• 잘못된 타입 경고
• 함수 사용 방법 표시

등을 제공할 수 있다.

따라서 타입 어노테이션은 단순한 주석보다 훨씬 유용하다.

36. 타입 어노테이션 전체 구조

변수

변수명: 타입 = 값

예

age: int = 20

함수 매개변수

def 함수(매개변수: 타입):

예

def hello(name: str):

함수 반환값

def 함수() -> 타입:

예

def get_age() -> int:

매개변수와 반환값

def add(a: int, b: int) -> int:
    return a + b

37. 여러 타입 표현하기

int 리스트

numbers: list[int]

문자열 딕셔너리

user: dict[str, str]

int 또는 str

user_id: int | str

str 또는 None

name: str | None

모든 타입

from typing import Any

data: Any

함수

from typing import Callable

callback: Callable[[int], str]

📌 핵심 정리

동적 타입 언어

파이썬은 변수에 서로 다른 타입의 값을 대입할 수 있다.

a = 1
a = "Python"

타입 어노테이션

변수나 함수가 어떤 타입을 사용할 것인지 알려 주는 타입 힌트이다.

age: int = 20

함수 타입 어노테이션

def add(a: int, b: int) -> int:
    return a + b

a      → int
b      → int
return → int

컬렉션 타입

numbers: list[int]

user: dict[str, str]

position: tuple[float, float]

numbers: set[int]

Optional

from typing import Optional

name: Optional[str]

str 또는 None

Union

from typing import Union

user_id: Union[int, str]

int 또는 str

최근 파이썬에서는 다음처럼 표현할 수도 있다.

user_id: int | str

name: str | None

Callable

from typing import Callable

callback: Callable[[int], str]

int 입력
   ↓
함수
   ↓
str 반환

Any

from typing import Any

data: Any

어떤 타입이든 사용할 수 있다는 의미이다.

mypy

타입 어노테이션이 올바르게 사용되었는지 검사하는 도구이다.

pip install mypy

검사

mypy typing_sample.py

💡 가장 중요한 부분

타입 어노테이션을 작성했다고 해서 파이썬이 타입을 강제로 제한하는 것은 아니다.

def add(a: int, b: int) -> int:
    return a + b

여기서

add(3, 3.4)

를 실행해도 파이썬 자체는 실행할 수 있다.

따라서

Type Annotation
       ↓
타입을 강제한다 X

Type Annotation
       ↓
어떤 타입을 사용할지 알려 주는 힌트 O

이다.

실제로 타입이 올바르게 사용되고 있는지 확인하려면

IDE
mypy

와 같은 도구를 함께 사용한다.

⭐ 07-4 전체 흐름

Python
  ↓
동적 타입 언어
  ↓
타입 사용이 자유로움
  ↓
코드가 커지면 타입 파악이 어려울 수 있음
  ↓
Type Annotation
  ↓
변수와 함수에 타입 정보 표시
  ↓
코드 이해가 쉬워짐
  ↓
mypy
  ↓
타입 오류를 실행 전에 검사

타입 어노테이션은 파이썬을 정적 타입 언어로 만드는 기능이 아니라, 동적 타입의 장점을 유지하면서 코드에 타입 정보를 추가하는 기능이라고 이해하면 된다.

2026년 목표

• 클라우드 환경 운영 경험(상세 내용은 추후 작성)
• 보안관제 자동화 경험
• 블로그 꾸준히 작성
• 자격증 : 정보처리기사(9월 시작), 정보보안기사, AWS-SAA,/// CISA 및 CISSP(정보 보안 관련 경력 5년 이상 필요 (4년 경력+보안 관련 학위 가능))
• 개발 공부
• 영어 공부
• 운동
• 리팩토링 과정 복습 및 벨로그에 새롭게 작성
• 클라우드 보안 복습 및 벨로그에 작성 <내년 예정 - 석사 과정>

📅 공부 순서 - (Version 9-10월)

1. 파이썬(점프 투 파이썬) - 9월 말까지 완료 목표
2. 정보처리기사 실기 - 10월 25일에 시험있음 합격 목표
3. 모의해킹(노말틱 강의) - 10월 말까지 완료 목표
4. 영어 - 10월부터 시작!
5. 혼자공부하는 네트워크(인프런) 완강했음 - 10월에 지속적인 복습
6. 리펙토링 과정 복습 시작(실습 및 블로그 재작성)
7. Docker(인프런_devsecops) 강의(모의해킹 끝나고 시작)
8. AWS 보안 가이드(인프런 강의) - (Docker 인프런 끝나고 시작)
9. JAVA - (파이썬 끝나고 시작)

📅 금주 목표 - (09/28(월)~10/04(일))

• 파이썬(점프 투 파이썬)
  • Youtube 강의 + Ebook 참고
  • 목표 : 점프 투 파이썬 학습 계속 진행 및 진도율 향상
• 정보처리기사 실기
  • 목표 : 2020년도 기출문제 2회차 풀이
  • 범위 : 1회차 ~ 4회차
  • 목표 : 2021년도 기출문제 1회차 풀이
  • 범위 : 1회차 ~ 3회차
  • 목표 : 2022년도 기출문제 1회차 풀이
  • 범위 : 1회차 ~ 3회차
• 모의해킹
  • 목표 : Day 1 ~ Day 2 완료
  • 범위 : 1주차 ~ 2주차

📅 오늘의 목표 : 완료 OR 미완료 OR 진행중

• 모의해킹(노말틱 강의)
  • 1주차 ~ 하는데 까지 + 블로그 정리
• 파이썬(점프 투 파이썬)
  • 07장 04 ~ 하는데 까지 + 블로그 정리
• household account 작성(23:50분에 작성)
• 정보처리기사 DAY3(2020년도 2회차 문제풀이 및 복습) + 2021년도 1회차 문제풀이 + 2022년도 1회차 문제풀이
• 방청소