Python 정복

4과목 프로그래밍 파트에서 가장 자주 떨어지는 언어가 Python이다. 자료형 특성·슬라이싱·코드 추론이 과목당 20문항 중 3~4문항 고정 출제되는 빈출 핵심이다. 두 황금 규칙 ★인동들★(Python 3대 특징)과 ★시포끝미★(슬라이싱·range 공통 규칙)을 축으로, 자료형 4종·불변 3종·제어문·함수·객체지향·신경향(컴프리헨션·lambda)까지 한 강에 정리한다. 39~42강에서 다룬 C(절차·정적·중괄호)·Java(정적·중괄호)와 대비해, Python의 인터프리터·동적 타입·들여쓰기가 시험 1순위 함정이다.

대단원 1 — Python의 정체성 (★인동들★)

★인동들★ — Python 3대 특징 ·언어 개요·시험 1순위·

[정의] Python = 1991년 귀도 반 로섬(Guido van Rossum)이 발표한 언어. 세 가지 특징으로 정의된다.

[표] ★인동들★ — 인터프리터 · 동적 타이핑 · 들여쓰기

🔑 암기 ★인동들★ — 인터프리터·동적·들여쓰기. 세 글자로 Python 특징 짝짓기 즉답. ⚠️ 함정 "Python은 컴파일 언어 / 정적 타이핑 / 중괄호로 블록 구분" 3종이 단골 오답 보기. 모두 인동들에 어긋난다. 🎯 빈출 Python 특징을 묻는 "옳지 않은 것" 문제가 거의 매 회차 출제. 인동들에 어긋난 보기가 정답.

C · Java · Python 8행 비교 ·언어 개요·시험 1순위·

[정의] 세 언어를 한 표로 정렬한 짝짓기 카드. Python 열의 굵은 항목이 "옳지 않은 것"으로 자주 뒤집혀 출제된다.

[표] 3개 언어 8항목 비교

# C:      int a = 10;    ← 자료형 명시 + 세미콜론
# Java:   int a = 10;    ← 자료형 명시 + 세미콜론
# Python: a = 10         ← 자료형 X · 세미콜론 X

a = 10            # int
a = "Hello"       # 같은 변수에 str 재대입 → Python OK (C/Java는 컴파일 오류)

🔑 암기 Python = 동적 + 들여쓰기 + 세미콜론 없음. C·Java는 정적 + 중괄호 + 세미콜론. ⚠️ 함정 타입 검사는 type(10) → <class 'int'>, isinstance(10, int) → True. Java의 instanceof는 키워드, Python의 isinstance는 내장 함수. 🎯 빈출 ①~⑧ 짝짓기 1문제가 거의 매 회차. 특히 ②③④의 정적/동적·중괄호/들여쓰기 대비.

대단원 2 — 연산과 입력 함정

나눗셈 3종 · 문자열 연산 · input() = str ·기본 문법·시험 1순위·

[정의] Python 연산자 중 나눗셈 3종과 문자열 연산, 그리고 input()의 반환 타입이 코드 추론 함정의 핵심이다.

# 나눗셈 3종
print(7 / 2)      # 3.5    ← / : 실수 나눗셈(항상 float)
print(7 // 2)     # 3      ← // : 정수 나눗셈(몫만)
print(7 % 2)      # 1      ← % : 나머지

# 문자열 연산
print("3" + "5")  # 35       ← 문자열 연결
print(3 + 5)      # 8        ← 정수 덧셈
print("ab" * 3)   # ababab   ← 문자열 반복

# input() 은 항상 str 반환
a = input()       # 25 입력 → a = "25" (str!)
b = int(input())  # 25 입력 → b = 25 (int) → 계산 가능

[표] 형변환 함수

🔑 암기 /는 실수(3.5), //는 몫(3), %는 나머지(1). input()은 무조건 str. ⚠️ 함정 "3" + 5 → TypeError (str + int 불가). 숫자 계산하려면 int()·float() 형변환 필수. 🎯 빈출 7/2=3.5(3이라고 답하면 오답)·input()=str이 코드 추론 문항에서 매 회차 결정.

대단원 3 — 자료형 4종과 불변성

자료형 4종 + 불변 3종 — 가변/불변 마스터 분별표 ·자료형·시험 1순위·

[정의] Python 자료형 4종(리스트·튜플·딕셔너리·집합)과, 한 번 만들면 수정 불가한 불변(Immutable) 3종(숫자·문자열·튜플)을 한 표로 분별한다.

[표] 자료형 6항목 분별

[표] 불변 3종 vs 가변 3종

s = "Hello"
s[0] = "h"    # TypeError — str 불변이라 수정 불가

t = (1, 2, 3)
t[0] = 100    # TypeError — tuple 불변

lst = [1, 2, 3]
lst[0] = 100  # OK → [100, 2, 3] — 리스트는 가변

🔑 암기 불변 3종 = 숫자·문자열·튜플. 나머지(리스트·딕셔너리·집합)는 가변. 본드로 굳은 레고 블럭은 모양 바꾸려면 새로 만들어야 한다. ⚠️ 함정 "Python 불변 자료형은 리스트" → 오답(리스트는 가변). "튜플은 변경 가능" → 오답. 불변 자료형 원소에 대입하면 TypeError. 🎯 빈출 "불변 자료형이 아닌 것은?" / "가변 자료형은?" 짝짓기가 매 회차. 튜플의 불변성이 핵심.

리스트 — pop(2) vs remove(20) 함정 ·자료형·

[정의] 리스트(만능 도시락)는 자료형 4종 중 가장 많이 쓰이는 가변 자료형. 메서드의 "인덱스 기준 / 값 기준 / 반환값" 구분이 함정이다.

lst = [10, 20, 30]
lst.append(40)        # 끝에 추가 → [10, 20, 30, 40]
lst.insert(1, 15)     # 인덱스 1에 삽입 → [10, 15, 20, 30, 40]

lst.pop()             # 마지막 원소 제거 + 반환
lst.pop(2)            # 인덱스 2 위치 원소 제거 (값 2가 아님!)
lst.remove(20)        # 값 20을 첫 번째로 제거 (인덱스 아님!)
del lst[0]            # 인덱스 0 제거 (반환 없음)

lst.sort()            # 원본 정렬 (반환 None)
sorted(lst)           # 새 리스트 반환 (원본 보존)

[표] 메서드 함정 3쌍

🔑 암기 pop은 인덱스, remove는 값, sort()는 원본 바꾸고 None 반환. ⚠️ 함정 x = lst.sort()에서 x는 정렬 리스트가 아니라 None. 정렬 결과를 받으려면 sorted(). 🎯 빈출 pop(2)의 인덱스/값 혼동이 단골. 코드 추론에서 결과 리스트를 묻는다.

튜플 — (1,) 콤마 필수 ·자료형·

[정의] 튜플(잠금 도시락)은 불변 3종 중 하나. 1요소 튜플의 콤마와 언패킹이 함정이다.

t1 = (1, 2, 3)      # 일반 튜플
t2 = (1,)            # 1요소 튜플 — 콤마가 본체
t3 = (1)             # 정수 1 (튜플 X — 그냥 괄호!)
t4 = 1, 2, 3         # 괄호 생략 OK (튜플 패킹)

# 튜플 언패킹
a, b = 1, 2          # a=1, b=2
a, b = b, a          # swap 한 줄! (C/Java는 임시 변수 필요)

[표] 튜플 vs 리스트

🔑 암기 (1) = 정수 / (1,) = 튜플. 콤마가 튜플의 본체. ⚠️ 함정 type((1))은 int, type((1,))은 tuple. 1요소 튜플에 콤마를 빠뜨리면 튜플이 아니다. 🎯 빈출 (1,) 콤마 함정이 매년 1문제. 튜플이 불변이라 dict 키·set 원소로 쓸 수 있다는 점도 출제.

딕셔너리 — d.get vs KeyError ·자료형·시험 1순위·

[정의] 딕셔너리(국어사전)는 "키→값" 쌍으로 저장하는 가변 자료형. 없는 키 조회 시 동작 차이가 핵심 함정이다.

d = {'이름': '홍길동', '나이': 25}

print(d['이름'])               # 홍길동
print(d['주소'])               # KeyError — 없는 키
print(d.get('주소'))           # None — 예외 없이 안전 조회
print(d.get('주소', '미입력'))  # 미입력 — 기본값 반환

d['주소'] = '서울'              # 추가
del d['나이']                  # 삭제
print('이름' in d)             # True (in은 키만 검사 — 값 아님!)

[표] 없는 키 조회 시

🔑 암기 d[키] = KeyError 위험 / d.get(키) = None 안전 / 3.7+는 입력 순서 유지. ⚠️ 함정 딕셔너리 키는 중복 불가(값은 중복 가능). {'a':1, 'a':2} → {'a': 2}로 뒤가 앞을 덮어쓴다. 🎯 빈출 d[키](KeyError)와 d.get(키)(None) 대비가 매 회차 1순위. d.get(키, 기본값) 결과 추론도 단골.

집합 — 중복 자동 제거 + 4대 연산 ·자료형·

[정의] 집합(중복 없는 가방)은 수학의 집합과 같다. 중복 X · 순서 X · 인덱스 접근 X. 데이터 중복 제거와 집합 연산에 쓴다.

s = {1, 1, 2, 2, 3}    # → {1, 2, 3} 중복 자동 제거
e = set()               # 빈 집합 ({} 는 빈 딕셔너리!)

# 4대 연산 (A={1,2,3,4}, B={3,4,5,6})
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
print(A | B)   # {1, 2, 3, 4, 5, 6}   합집합
print(A & B)   # {3, 4}               교집합
print(A - B)   # {1, 2}               차집합
print(A ^ B)   # {1, 2, 5, 6}         대칭 차집합

[표] 집합 4대 연산

🔑 암기 집합 = 중복 X · 순서 X · 인덱스 X. - 차 / & 교 / | 합 / ^ 대칭차. ⚠️ 함정 빈 집합은 set(). {}는 빈 딕셔너리다. 집합은 순서가 없어 s[0] 인덱스 접근 시 TypeError. 🎯 빈출 4대 연산 결과 추론이 매 회차. 종이에 벤다이어그램을 그리면 즉답.

대단원 4 — 인덱싱과 슬라이싱 (★시포끝미★)

인덱스 + ★시포끝미★ 슬라이싱 기본 ·슬라이싱·시험 1순위·

[정의] 인덱스는 0부터 시작, 음수는 -1부터 끝에서 센다. 슬라이싱 [start:end]은 ★시포끝미★ — 시작은 포함, 끝은 미포함.

 문자열 "PYTHON"
 +인덱스:   0   1   2   3   4   5
            P   Y   T   H   O   N
 -인덱스:  -6  -5  -4  -3  -2  -1

s = "PYTHON"
print(s[0])     # P    ← 첫 글자(0부터)
print(s[-1])    # N    ← 마지막(음수는 -1부터)
print(len(s))   # 6    ← 길이는 len()
print(s[6])     # IndexError — 범위 초과

# 슬라이싱 — ★시포끝미★
print(s[2:5])   # THO      ← 인덱스 2·3·4 (5는 미포함)
print(s[:3])    # PYT      ← 0부터 2까지
print(s[3:])    # HON      ← 3부터 끝까지
print(s[:])     # PYTHON   ← 전체 복사

[표] ★시포끝미★ — 슬라이싱 황금 규칙

🔑 암기 ★시포끝미★ — 시작 포함, 끝 미포함. s[2:5]는 2·3·4(3개), 5는 빠진다. end - start = 개수. ⚠️ 함정 s[2:5]를 "인덱스 2·3·4·5(4개)"로 보면 오답. 슬라이싱은 범위를 초과해도 IndexError 없이 빈 문자열 반환(단일 인덱스 s[6]은 IndexError). 🎯 빈출 시포끝미가 매 회차 1순위. 끝값 미포함 한 줄로 슬라이싱 함정 대부분이 풀린다.

슬라이싱 심화 — step · 역순 · 뒤 N개 ·슬라이싱·시험 1순위·

[정의] 슬라이싱 3인자 표기 a[start:end:step]. step이 추가되면 짝수 추출·역순까지 한 줄로 표현한다.

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

print(a[::2])     # [0, 2, 4, 6, 8]            ← step 2 (짝수 인덱스)
print(a[::-1])    # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]   ← 역순 전체
print(a[-3:])     # [7, 8, 9]                  ← 뒤 3개(음수 start)
print(a[5:1:-1])  # [5, 4, 3, 2]               ← 역순에도 시포끝미

[표] 심화 표기

🔑 암기 a[::-1] 역순 · a[::2] 짝수 · a[-3:] 뒤 3개. ⚠️ 함정 a[5:1:-1]은 역순이라도 시포끝미 적용 — start 5 포함, end 1 미포함 → 5·4·3·2(인덱스 1은 빠짐). 🎯 빈출 a[start:end:step]의 step·음수 조합 추론이 신경향 코드 문항에서 단골.

range() — 시포끝미 동일 철학 ·슬라이싱·

[정의] range()는 반복문에서 가장 많이 쓰이며, 슬라이싱과 동일하게 ★시포끝미★를 따른다.

list(range(5))          # [0, 1, 2, 3, 4]        ← 0부터 5 미포함
list(range(1, 5))       # [1, 2, 3, 4]           ← 1 포함, 5 미포함
list(range(1, 10, 2))   # [1, 3, 5, 7, 9]        ← step 2
list(range(10, 0, -1))  # [10, 9, 8, ..., 1]     ← 역순
list(range(5, 1))       # []                     ← start ≥ end (step 양수) → 빈 range

[표] range 표기

🔑 암기 range도 시포끝미. range(1, 11) = 1~10 정확히 10개. end - start = 개수. ⚠️ 함정 range(5, 1)은 step이 양수(기본값 1)인데 start ≥ end라 빈 range. 역순은 range(5, 1, -1). 🎯 빈출 range(2, 11, 2) 같은 step 표기를 for 합산과 묶어 출제(끝값 미포함이 결정).

대단원 5 — 제어문과 함수

조건문 if/elif/else — 들여쓰기가 문법 ·제어문·

[정의] Python의 들여쓰기는 가독성이 아니라 문법이다(PEP 8 권장 공백 4칸). 조건은 if 조건: 콜론 뒤 들여쓰기로 블록을 만든다.

age = 25

if age < 13:
    print("어린이")       # 4칸 들여쓰기 = 같은 블록
elif age < 20:
    print("청소년")
else:
    print("성인")          # age=25 → 성인

# 삼항 표현식 (한 줄 if)
status = "성인" if age >= 20 else "미성년"   # 성인

# 비교·논리 연산자
a and b     # C의 a && b
a or b      # C의 a || b
not a       # C의 !a

[표] Python vs C/Java 조건문

🔑 암기 if 조건: 콜론 + 4칸 들여쓰기 + elif(else if 아님). 논리 연산은 단어 and·or·not. ⚠️ 함정 들여쓰기가 안 맞으면 IndentationError로 실행 자체가 안 된다. C·Java에서 들여쓰기는 권장이지만 Python에서는 문법. 🎯 빈출 elif 표기·삼항 표현식·들여쓰기 블록이 코드 추론과 짝짓기에 출제.

반복문 for · while — for-else 함정 ·제어문·

[정의] Python 반복문은 for x in 시퀀스 패턴이 압도적이다. enumerate·for-else가 Python 고유 기능이다.

for x in [10, 20, 30]:
    print(x)                       # 10, 20, 30

for i in range(5):
    print(i)                       # 0~4

for i, x in enumerate(['사과', '바나나']):
    print(i, x)                    # 0 사과 / 1 바나나

i = 0
while i < 5:
    print(i)
    i += 1                         # i++ 없음 — i += 1

# for-else — break 없이 정상 종료 시 else 실행
for i in range(5):
    if i == 10:
        break
else:
    print("break 안 됨")           # break가 일어나지 않아 실행됨

[표] 반복문 키워드

🔑 암기 for x in seq + range() + i += 1(i++ 없음). enumerate는 인덱스와 값을 함께. ⚠️ 함정 for-else의 else는 break가 안 일어났을 때 실행. break로 빠지면 else는 건너뛴다. 🎯 빈출 enumerate 결과·for-else 동작이 신경향 코드 추론에 등장.

함수 — *args · **kwargs · 오버로딩 없음 ·함수·시험 1순위·

[정의] Python 함수는 def로 정의한다. 기본값 매개변수, 가변 인자(*args·**kwargs)를 지원하지만 메서드 오버로딩은 없다.

def power(base, exp=2):      # 기본값 매개변수
    return base ** exp
power(3)      # 9 (exp 생략 → 2)
power(3, 4)   # 81

def add(*nums):              # *args = 튜플로 받음
    return sum(nums)
add(1, 2)        # 3
add(1, 2, 3, 4)  # 10 — 한 함수로 모든 개수 처리

def info(**data):            # **kwargs = 딕셔너리로 받음
    for k, v in data.items():
        print(k, v)
info(name="홍길동", age=25)   # name 홍길동 / age 25

[표] 매개변수 형태

🔑 암기 *args = 튜플 / **kwargs = 딕셔너리. Python은 오버로딩 ❌(같은 이름 재정의 시 뒤가 앞을 덮어씀). ⚠️ 함정 Java는 메서드 오버로딩(같은 이름·다른 매개변수) 지원, Python은 미지원. return이 없으면 자동으로 None 반환. 🎯 빈출 *args(튜플)·**kwargs(딕셔너리)가 받는 자료형, 기본값 매개변수 동작이 매년 단골.

대단원 6 — Python 객체지향과 신경향

Python OOP — 덕 타이핑과 4대 특성 ·객체지향·시험 1순위·

[정의] Python도 객체지향을 지원하되, 정적 언어와 표현이 다르다. 핵심은 덕 타이핑(Duck Typing) — "오리처럼 행동하면 오리로 취급".

[표] 객체지향 4대 특성 — 정적 언어 vs Python

class Animal:
    def cry(self): print("동물의 울음")

class Dog(Animal):           # 상속 — 괄호로 부모 지정
    def cry(self):           # 오버라이딩
        print("멍멍!")

class Cat:                   # 공통 부모 없음
    def cry(self): print("야옹!")

for a in [Dog(), Cat()]:
    a.cry()                  # 멍멍! / 야옹! — cry() 메서드만 있으면 동작(덕 타이핑)

[표] 정적 언어 vs Python — 핵심 3비교

🔑 암기 Python OOP — 상속·다형성·오버라이딩 지원 / 오버로딩 미지원 / 다중 상속 가능. 캡슐화·추상화는 관습·라이브러리 기반. ⚠️ 함정 "Python은 다중 상속 불가" → 오답(Python은 클래스 다중 상속 가능, Java는 단일 상속 + 인터페이스 다중 구현). 🎯 빈출 덕 타이핑 정의, 오버로딩 미지원, 다중 상속 가능 여부가 시험 1순위.

신경향 — 컴프리헨션 · lambda · map/filter ·신경향·시험 1순위·

[정의] 최근 Python 문항은 한 줄로 압축한 코드의 반환값을 묻는다. 리스트/딕셔너리 컴프리헨션과 lambda·map·filter가 신경향 킬러다.

# 컴프리헨션 — [식 for 변수 in 반복 if 조건]
[x * 2 for x in [1, 2, 3] if x > 1]   # [4, 6]   ← 변환 + 필터
[x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]
{x: x ** 2 for x in range(1, 4)}      # {1: 1, 2: 4, 3: 9}   딕셔너리 컴프리헨션
{x % 3 for x in range(6)}             # {0, 1, 2}            집합 컴프리헨션

# lambda — 이름 없는 한 줄 함수
(lambda x, y: x + y)(3, 4)            # 7
sorted([3, 1, 2], key=lambda x: -x)   # [3, 2, 1]   내림차순

# map / filter — lambda와 결합
list(map(lambda x: x * 2, [1, 2, 3]))         # [2, 4, 6]   각 원소 변환
list(filter(lambda x: x > 2, [1, 2, 3, 4]))   # [3, 4]      조건 통과만

[표] 신경향 한 줄 코드

🔑 암기 컴프리헨션 = [식 for 변수 in seq if 조건]. map은 변환, filter는 선별, lambda는 한 줄 함수. ⚠️ 함정 map·filter는 결과가 이터레이터라 값을 보려면 list()로 감싼다. 컴프리헨션의 if는 조건 필터(통과한 원소만 남김). 🎯 빈출 컴프리헨션 + lambda·map·filter를 혼합한 한 줄 코드의 반환값 추론이 신경향 킬러로 증가 추세. 💡 TIOBE 2025~2026 기준 Python이 사용률 1위 흐름으로 자주 언급되며, AI/ML·데이터 분석 영역에서 표준으로 쓰인다.

기출 다지기

[기출 1 출제] 다음 Python 코드의 실행 결과로 옳은 것은? (코드 실행 결과 예측)

a = [10, 20, 30, 40, 50, 60, 70, 80]
print(a[1:6:2])

• ① [20, 30, 40, 50, 60]
• ② [10, 30, 50, 70]
• ③ [20, 40, 60]
• ④ [30, 50, 70]

[기출 2 출제] Python 자료형에 대한 설명으로 옳지 않은 것은? (옳지 않은 것 고르기)

• ① 리스트(list)는 가변 자료형이며, 원소를 변경할 수 있다
• ② 튜플(tuple)은 불변 자료형이며, 한 번 생성하면 원소를 변경할 수 없다
• ③ 딕셔너리(dict)는 키-값 쌍으로 구성되며, 키는 중복될 수 있다
• ④ 집합(set)은 중복을 허용하지 않으며, 순서가 없다

[기출 3 출제] 다음 Python 코드의 실행 결과로 옳은 것은? (코드 실행 결과 예측)

total = 0
for i in range(2, 11, 2):
    total += i
print(total)

• ① 20
• ② 25
• ③ 30
• ④ 35

[기출 4 출제] 다음 Python 코드의 실행 결과로 옳은 것은? (코드 실행 결과 예측)

d = {'a': 1, 'b': 2, 'c': 3}
d['d'] = 4
del d['a']
print(d.get('z', 0))
print(len(d))

• ① 4 / 3
• ② None / 3
• ③ 0 / 3
• ④ 0 / 4

[기출 5 출제] 다음 Python 코드의 실행 결과로 옳은 것은? (코드 실행 결과 예측)

A = {1, 2, 3, 4, 5}
B = {3, 4, 5, 6, 7}
print(A - B)
print(A & B)
print(A | B)

• ① {1,2} / {3,4,5} / {1,2,3,4,5,6,7}
• ② {6,7} / {3,4,5} / {1,2,3,4,5,6,7}
• ③ {1,2,6,7} / {3,4,5} / {1,2,3,4,5}
• ④ {1,2} / {1,2,6,7} / {3,4,5,6,7}

[기출 6 출제] Python 언어의 특징에 대한 설명으로 옳지 않은 것은? (옳지 않은 것 고르기)

• ① 인터프리터 방식으로 동작하는 언어이다
• ② 변수 선언 시 자료형을 명시하지 않는 동적 타이핑 언어이다
• ③ 코드 블록을 중괄호({})로 구분한다
• ④ 객체지향 프로그래밍을 지원하며, 다중 상속도 가능하다

[기출 7 출제] 다음 Python 코드의 실행 결과로 옳은 것은? (신경향 — 리스트 컴프리헨션)

print([x * 2 for x in [1, 2, 3] if x > 1])

• ① [2, 4, 6]
• ② [4, 6]
• ③ [2, 6]
• ④ [4]

[기출 8 출제] 다음 Python 코드의 실행 결과로 옳은 것은? (신경향 — lambda + map/filter)

result = list(map(lambda x: x + 1, filter(lambda x: x % 2 == 0, range(6))))
print(result)

• ① [1, 3, 5]
• ② [0, 2, 4]
• ③ [2, 4, 6]
• ④ [1, 2, 3, 4, 5]

한 장 요약

핵심 7공식 (시험장 30초 카드)

자료형 분별표

연산·코드 추론

OOP 상속 class Dog(Animal): · 다형성 = 덕 타이핑 · 오버라이딩 O / 오버로딩 X · 클래스 다중 상속 O.