정보처리기사 실기 Python 기출문제 정리

정보처리기사 실기 Python 기출문제 정리

목차

1. 2020년 기출문제
2. 2021년 기출문제
3. 2022년 기출문제
4. 2023년 기출문제
5. 2024년 기출문제
6. 유형별 정리
7. 핵심 개념 요약

---

2020년 기출문제

문제 1: 2020년 2회차 - 집합(Set) 연산

문제:

countries = {'일본', '중국', '한국'}        # 초기 국가 집합 생성
countries.add('베트남')                   # '베트남' 추가
countries.add('중국')                     # '중국'은 이미 있으므로 추가되지 않음
countries.remove('일본')                 # '일본' 제거
countries.update(['홍콩', '한국', '태국']) # '홍콩', '한국', '태국' 추가 (중복은 무시)
print(countries)                         # 최종 집합 출력

해설:

• add(): 집합에 요소 추가 (중복 시 무시)
• remove(): 집합에서 요소 제거
• update(): 여러 요소를 한 번에 추가 (리스트, 튜플, 집합 등 가능)
• 집합은 중복을 허용하지 않음

답: {'중국', '베트남', '태국', '홍콩', '한국'}

실행 과정:

1. 초기: {'일본', '중국', '한국'}
2. add('베트남'): {'일본', '중국', '한국', '베트남'}
3. add('중국'): 변화 없음 (중복)
4. remove('일본'): {'중국', '한국', '베트남'}
5. update(['홍콩', '한국', '태국']): {'중국', '한국', '베트남', '홍콩', '태국'}

---

문제 2: 2020년 4회차 - 2차원 리스트와 중첩 반복문

문제:

lol = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]   # 2차원 리스트 생성

print(lol[0])             # 첫 번째 리스트 출력: [1, 2, 3]
print(lol[2][1])          # 세 번째 리스트의 두 번째 요소 출력: 7

for sub in lol:           # lol의 각 하위 리스트 순회
    for item in sub:      # 하위 리스트 내의 각 요소 순회
        print(item, end='') # 요소 출력, 줄바꿈 없이
    print()               # 각 하위 리스트마다 줄바꿈

해설:

• lol[0]: 첫 번째 요소인 [1, 2, 3] 출력
• lol[2][1]: 세 번째 리스트([6, 7, 8, 9])의 인덱스 1 요소인 7 출력
• 중첩 반복문: 외부 반복문은 각 하위 리스트를, 내부 반복문은 각 요소를 순회
• end='': 줄바꿈 없이 출력
• print(): 각 하위 리스트 출력 후 줄바꿈

답:

[1, 2, 3]
7
123
45
6789

실행 과정:

1. print(lol[0]) → [1, 2, 3] 출력
2. print(lol[2][1]) → 7 출력
3. 첫 번째 하위 리스트 [1, 2, 3]: 123 출력 후 줄바꿈
4. 두 번째 하위 리스트 [4, 5]: 45 출력 후 줄바꿈
5. 세 번째 하위 리스트 [6, 7, 8, 9]: 6789 출력 후 줄바꿈

---

2021년 기출문제

문제 3: 2021년 1회차 - 클래스 변수와 문자열 인덱싱

문제:

class Good:                                 # 클래스 정의
    li = ["seoul", "kyeonggi", "inchon", "daejeon", "daegu", "pusan"]  
                                            # 클래스 변수: 지역 이름 리스트

g = Good()                                  # Good 클래스의 인스턴스 생성
str01 = ''                                  # 결과를 저장할 문자열 변수

for i in g.li:                              # 리스트의 각 지역 이름 순회
    str01 = str01 + i[0]                    # 각 문자열의 첫 글자만 이어붙이기

print(str01)                                # 최종 문자열 출력

해설:

• 클래스 변수: 모든 인스턴스가 공유하는 변수
• g.li: 인스턴스를 통해 클래스 변수 접근
• i[0]: 각 문자열의 첫 번째 문자 (인덱스 0)
• 문자열 연결: str01 = str01 + i[0]

답: skiddp

실행 과정:

• "seoul" → 's'
• "kyeonggi" → 'k'
• "inchon" → 'i'
• "daejeon" → 'd'
• "daegu" → 'd'
• "pusan" → 'p'
• 최종: "skiddp"

---

문제 4: 2021년 2회차 - 비트 시프트 연산

문제:

a = 100                     # 초기값 설정
result = 0                  # 결과 변수 초기화

for i in range(1, 3):       # i = 1부터 2까지 반복 (range는 끝 제외)
    result = a >> i         # a를 i만큼 오른쪽으로 비트 시프트
    result = result + 1     # 시프트 결과에 1 더하기

print(result)               # 마지막 반복의 결과 출력

해설:

• >>: 오른쪽 비트 시프트 연산자 (나누기 2의 거듭제곱과 동일)
• 100 >> 1: 100을 2로 나눈 값 = 50
• 100 >> 2: 100을 4로 나눈 값 = 25
• range(1, 3): 1부터 2까지 (3은 제외)

답: 26

실행 과정:

1. i = 1:
   • result = 100 >> 1 = 50
   • result = 50 + 1 = 51
2. i = 2:
   • result = 100 >> 2 = 25
   • result = 25 + 1 = 26
3. 최종 출력: 26

비트 시프트 설명:

• 100 (이진수: 1100100)
• 100 >> 1 = 50 (이진수: 110010)
• 100 >> 2 = 25 (이진수: 11001)

---

문제 5: 2021년 3회차 - 비교 연산자

문제:

a, b = 100, 200       # 변수 a는 100, b는 200으로 초기화
print(a == b)         # a와 b가 같은지 비교하여 결과 출력

해설:

• 다중 할당: a, b = 100, 200은 a = 100, b = 200과 동일
• ==: 같음 비교 연산자
• 100 == 200은 False

답: False

---

2022년 기출문제

문제 6: 2022년 2회차 - 기본값 매개변수

문제:

def exam(num1, num2=2):           # num2는 기본값 2를 가지는 매개변수
    print('a=', num1, 'b=', num2) # 두 인자의 값을 출력

exam(20)                          # num1만 전달 → num2는 기본값 사용

해설:

• 기본값 매개변수: 함수 호출 시 인자를 전달하지 않으면 기본값 사용
• num2=2: num2의 기본값은 2
• exam(20): num1=20, num2=2 (기본값 사용)

답: a= 20 b= 2

---

문제 7: 2022년 2회차 - 문자열 슬라이싱과 포맷팅

문제:

a = "REMEMBER NOVEMBER"       # 문자열 a 선언
b = a[:3] + a[12:15]           # b는 a에서 부분 문자열 추출 후 합치기
c = "R AND %s" % "STR"         # 문자열 포맷팅: %s 자리에 "STR" 삽입

print(b + c)                   # b와 c를 이어붙여 출력

해설:

• a[:3]: 인덱스 0부터 2까지 → "REM"
• a[12:15]: 인덱스 12부터 14까지 → "BER"
• b = "REM" + "BER" = "REMEMBER"
• %s: 문자열 포맷팅, "STR"로 치환 → "R AND STR"
• b + c = "REMEMBER" + "R AND STR" = "REMEMBER AND STR"

답: REMEMBER AND STR

문자열 인덱스:

R E M E M B E R   N O V E M B E R
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

---

문제 8: 2022년 3회차 - map과 lambda 함수

문제:

TestList = [1, 2, 3, 4, 5]                          # 초기 리스트
TestList = list(map(lambda num: num + 100, TestList)) # 각 요소에 100 더하기

print(TestList)                                     # 변환된 리스트 출력

해설:

• lambda num: num + 100: 익명 함수, 각 요소에 100을 더함
• map(): 각 요소에 함수를 적용하여 새로운 이터레이터 반환
• list(): 이터레이터를 리스트로 변환
• map(lambda num: num + 100, TestList): [101, 102, 103, 104, 105]

답: [101, 102, 103, 104, 105]

동작 과정:

1. lambda num: num + 100 함수 정의
2. map()으로 각 요소에 함수 적용:
   • 1 → 101
   • 2 → 102
   • 3 → 103
   • 4 → 104
   • 5 → 105
3. list()로 리스트 변환

---

2023년 기출문제

문제 9: 2023년 1회차 - 집합(Set) 연산

문제:

a = {'한국', '중국', '일본'}                   # 초기 집합 생성
a.add('베트남')                            # '베트남' 추가
a.add('중국')                              # '중국'은 이미 있으므로 무시됨
a.remove('일본')                          # '일본' 제거
a.update({'홍콩', '한국', '태국'})           # 여러 요소 한 번에 추가 (중복은 무시)

print(a)                                  # 최종 집합 출력

해설:

• 2020년 2회차 문제와 유사한 유형
• update(): 집합을 인자로 받아 여러 요소 추가
• 집합은 중복을 허용하지 않음

답: {'한국', '중국', '베트남', '홍콩', '태국'}

실행 과정:

1. 초기: {'한국', '중국', '일본'}
2. add('베트남'): {'한국', '중국', '일본', '베트남'}
3. add('중국'): 변화 없음
4. remove('일본'): {'한국', '중국', '베트남'}
5. update({'홍콩', '한국', '태국'}): {'한국', '중국', '베트남', '홍콩', '태국'}

---

문제 10: 2023년 2회차 - 문자열 슬라이싱

문제:

a = "engineer information processing"   # 문자열: 총 31자
b = a[:3]       # 'eng'
c = a[4:6]      # 'ne'
d = a[28:]      # 'ing'
e = b + c + d   # 'eng' + 'ne' + 'ing'
print(e)

해설:

• a[:3]: 인덱스 0부터 2까지 → "eng"
• a[4:6]: 인덱스 4부터 5까지 → "ne"
• a[28:]: 인덱스 28부터 끝까지 → "ing"
• 문자열 연결: "eng" + "ne" + "ing" = "engneing"

답: engneing

문자열 인덱스:

e n g i n e e r   i n f o r m a t i o n   p r o c e s s i n g
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

---

문제 11: 2023년 3회차 - 입력 처리 (빈칸 채우기)

문제:

조건 : 빈칸에 들어갈 알맞은 말을 쓰시오.

입력 : 3,7

출력 :
파이썬 입출력에 대한 문제입니다.
3 7
3 + 7 = 10

print("파이썬 입출력에 대한 문제입니다.")

num1, num2 = input()._________________()        # 공백 기준으로 두 값을 입력받음
num1 = int(num1)                    
num2 = int(num2)

print(num1, num2)                   # 두 수를 출력

num3 = num1 + num2                  # 합 계산

print(num1, "+", num2, "=", num3)

해설:

• input(): 사용자 입력을 문자열로 받음
• split(): 문자열을 공백 기준으로 분리하여 리스트 반환
• 다중 할당: num1, num2 = input().split()로 두 값을 분리
• 입력 "3 7"을 split()하면 ["3", "7"]이 되고, 각각 num1, num2에 할당

답: split

실행 과정:

1. input(): "3 7" 입력
2. split(): ["3", "7"]로 분리
3. num1, num2 = "3", "7"
4. int() 변환: num1 = 3, num2 = 7
5. 출력: 3 7
6. 계산: num3 = 3 + 7 = 10
7. 출력: 3 + 7 = 10

---

2024년 기출문제

문제 12: 2024년 1회차 - 리스트 순회와 문자열 인덱싱

문제:

a = ["Seoul", "Kyeonggi", "Incheon", "Daejun", "Daegu", "Pusan"]  # 지역 이름 리스트
str = "S"                                                        # 초기 문자열

for i in a:                  # 리스트 a를 순회
    str = str + i[1]         # 각 단어의 두 번째 글자를 str에 추가 (i[1])

print(str)                   # 결과 출력

해설:

• i[1]: 각 문자열의 두 번째 문자 (인덱스 1)
• 문자열 연결: 각 단어의 두 번째 글자를 순서대로 이어붙임

답: Seynaau

실행 과정:

• 초기: str = "S"
• "Seoul" → str = "S" + "e" = "Se"
• "Kyeonggi" → str = "Se" + "y" = "Sey"
• "Incheon" → str = "Sey" + "n" = "Seyn"
• "Daejun" → str = "Seyn" + "a" = "Seyna"
• "Daegu" → str = "Seyna" + "a" = "Seynaa"
• "Pusan" → str = "Seynaa" + "u" = "Seynaau"

---

문제 13: 2024년 2회차 - 문자열 패턴 매칭과 f-string

문제:

def fnCalculation(x, y):               # 문자열 x에서 부분 문자열 y의 등장 횟수를 계산
    result = 0                         # 결과 카운트 초기화
    for i in range(len(x)):            # 문자열 x의 모든 인덱스를 순회
        temp = x[i:i+len(y)]           # x의 현재 위치부터 y의 길이만큼 슬라이스
        if temp == y:                  # 슬라이스가 y와 일치하면
            result += 1                # 카운트 증가
    return result                      # 총 횟수 반환

a = "abdcabcabca"                      # 전체 문자열
p1 = "ab"                              # 찾을 첫 번째 패턴
p2 = "ca"                              # 찾을 두 번째 패턴

out = f"ab{fnCalculation(a, p1)}ca{fnCalculation(a, p2)}" # f-string으로 포맷팅
print(out)                             # 결과 출력

해설:

• fnCalculation(x, y): 문자열 x에서 부분 문자열 y가 나타나는 횟수 계산
• 슬라이싱: x[i:i+len(y)]로 y의 길이만큼 부분 문자열 추출
• f-string: f"ab{fnCalculation(a, p1)}ca{fnCalculation(a, p2)}" 형식

답: ab3ca3

실행 과정:

1. fnCalculation("abdcabcabca", "ab"):

   • i=0: "ab" == "ab" → count = 1
   • i=4: "ab" == "ab" → count = 2
   • i=7: "ab" == "ab" → count = 3
   • 결과: 3

2. fnCalculation("abdcabcabca", "ca"):

   • i=5: "ca" == "ca" → count = 1
   • i=8: "ca" == "ca" → count = 2
   • i=10: "ca" == "ca" → count = 3
   • 결과: 3

3. f-string: f"ab{3}ca{3}" = "ab3ca3"

문자열 인덱스:

a b d c a b c a b c a
0 1 2 3 4 5 6 7 8 9 10

---

문제 14: 2024년 3회차 - 리스트 뒤집기와 슬라이싱

문제:

def func(lst):                                 # 리스트를 뒤집는 함수
    for i in range(len(lst) // 2):             # 절반만 순회
        lst[i], lst[-i-1] = lst[-i-1], lst[i]   # 앞뒤 요소를 swap

lst = [1, 2, 3, 4, 5, 6]                        # 원본 리스트
func(lst)                                       # 리스트를 뒤집음

print(sum(lst[::2]) - sum(lst[1::2]))           # 짝수 인덱스 합 - 홀수 인덱스 합

해설:

• func(lst): 리스트를 제자리에서 뒤집음 (in-place)
• range(len(lst) // 2): 절반만 순회 (중앙을 기준으로 앞뒤 교환)
• lst[i], lst[-i-1] = lst[-i-1], lst[i]: 두 요소 교환 (swap)
• lst[::2]: 짝수 인덱스 (0, 2, 4, ...)
• lst[1::2]: 홀수 인덱스 (1, 3, 5, ...)

답: 3

실행 과정:

1. func(lst) 실행:

   • i=0: lst[0]과 lst[-1] 교환 → [6, 2, 3, 4, 5, 1]
   • i=1: lst[1]과 lst[-2] 교환 → [6, 5, 3, 4, 2, 1]
   • i=2: lst[2]과 lst[-3] 교환 → [6, 5, 4, 3, 2, 1]
   • 최종: [6, 5, 4, 3, 2, 1]

2. lst[::2]: [6, 4, 2] → 합 = 12

3. lst[1::2]: [5, 3, 1] → 합 = 9

4. 결과: 12 - 9 = 3

---

유형별 정리

1. 집합(Set) 연산

• 2020년 2회차: add(), remove(), update()
• 2023년 1회차: 동일 유형 반복 출제

핵심 개념:

• 집합은 중복을 허용하지 않음
• add(): 단일 요소 추가
• update(): 여러 요소 추가 (리스트, 튜플, 집합 등)
• remove(): 요소 제거

---

2. 리스트와 반복문

• 2020년 4회차: 2차원 리스트와 중첩 반복문
• 2021년 1회차: 클래스 변수 리스트 순회
• 2024년 1회차: 리스트 순회와 문자열 인덱싱
• 2024년 3회차: 리스트 뒤집기

핵심 개념:

• 2차원 리스트 인덱싱: list[i][j]
• 중첩 반복문: 외부 반복문 → 내부 반복문
• 리스트 슬라이싱: lst[::2], lst[1::2]
• 리스트 뒤집기: lst[i], lst[-i-1] = lst[-i-1], lst[i]

---

3. 문자열 처리

• 2022년 2회차: 문자열 슬라이싱과 포맷팅
• 2023년 2회차: 문자열 슬라이싱
• 2024년 2회차: 문자열 패턴 매칭

핵심 개념:

• 문자열 슬라이싱: str[start:end], str[:end], str[start:]
• 문자열 포맷팅: %s, f-string
• 문자열 인덱싱: str[i] (i번째 문자)
• 문자열 연결: + 연산자

---

4. 함수와 람다

• 2022년 2회차: 기본값 매개변수
• 2022년 3회차: map()과 lambda
• 2024년 2회차: 사용자 정의 함수

핵심 개념:

• 기본값 매개변수: def func(a, b=2):
• lambda: 익명 함수 정의
• map(): 각 요소에 함수 적용
• 함수 정의와 호출

---

5. 비트 연산

• 2021년 2회차: 오른쪽 비트 시프트 (>>)

핵심 개념:

• >>: 오른쪽 비트 시프트 (나누기 2의 거듭제곱)
• 100 >> 1 = 50 (100 ÷ 2)
• 100 >> 2 = 25 (100 ÷ 4)

---

6. 입출력

• 2023년 3회차: input()과 split()

핵심 개념:

• input(): 사용자 입력 받기
• split(): 문자열 분리
• 다중 할당: a, b = input().split()

---

7. 비교 연산자

• 2021년 3회차: == 연산자

핵심 개념:

• ==: 같음 비교
• !=: 다름 비교
• 다중 할당: a, b = 100, 200

---

핵심 개념 요약

1. 자료구조

집합(Set):

s = {1, 2, 3}
s.add(4)           # 요소 추가
s.remove(2)         # 요소 제거
s.update([5, 6])    # 여러 요소 추가

리스트(List):

lst = [1, 2, 3]
lst[0]              # 인덱싱
lst[1:3]            # 슬라이싱
lst[::2]            # 짝수 인덱스
lst[1::2]           # 홀수 인덱스

2차원 리스트:

lst = [[1, 2], [3, 4]]
lst[0][1]           # 첫 번째 리스트의 두 번째 요소

---

2. 문자열 처리

슬라이싱:

s = "Hello World"
s[:5]               # "Hello"
s[6:]               # "World"
s[0:5]              # "Hello"

인덱싱:

s[0]                # 'H'
s[-1]               # 'd' (마지막 문자)

포맷팅:

"%s" % "text"       # "text"
f"{value}"          # f-string

---

3. 함수

기본값 매개변수:

def func(a, b=2):
    return a + b

func(10)            # 12 (b는 기본값 2 사용)
func(10, 5)         # 15

람다 함수:

lambda x: x + 1     # 익명 함수
map(lambda x: x*2, [1, 2, 3])  # [2, 4, 6]

---

4. 반복문

for 문:

for i in range(1, 3):  # 1, 2
    print(i)

for item in lst:       # 리스트 순회
    print(item)

중첩 반복문:

for sub in lst:
    for item in sub:
        print(item)

---

5. 연산자

비트 시프트:

100 >> 1            # 50 (100 ÷ 2)
100 >> 2            # 25 (100 ÷ 4)

비교 연산자:

a == b              # 같음
a != b              # 다름

---

6. 입출력

입력:

input()             # 문자열 입력
input().split()     # 공백 기준 분리
int(input())        # 정수 입력

출력:

print(value)        # 기본 출력
print(value, end='') # 줄바꿈 없이 출력

---

학습 팁

1. 집합 연산

• 중복 제거에 유용
• add(), remove(), update() 메서드 숙지
• 집합은 순서가 없음 (Python 3.7+에서는 삽입 순서 유지)

2. 문자열 슬라이싱

• 인덱스는 0부터 시작
• [start:end]: start 포함, end 제외
• 음수 인덱스: 뒤에서부터 카운트

3. 리스트 처리

• 2차원 리스트: list[i][j] 형식
• 슬라이싱: [::2] (짝수), [1::2] (홀수)
• 리스트 뒤집기: 절반만 순회하며 교환

4. 함수와 람다

• 기본값 매개변수는 뒤에 위치
• lambda는 간단한 함수 정의에 유용
• map()은 각 요소에 함수 적용

5. 비트 연산

• >>는 나누기 2의 거듭제곱과 동일
• 100 >> n = 100 ÷ (2^n)

---

출제 경향 분석

자주 출제되는 유형

1. 집합 연산 (2020년 2회, 2023년 1회)

   • add(), remove(), update() 메서드
   • 중복 제거 개념

2. 문자열 슬라이싱 (2022년 2회, 2023년 2회)

   • 인덱싱과 슬라이싱
   • 문자열 연결

3. 리스트 처리 (2020년 4회, 2024년 1회, 2024년 3회)

   • 2차원 리스트
   • 리스트 순회
   • 리스트 뒤집기

4. 함수 (2022년 2회, 2022년 3회, 2024년 2회)

   • 기본값 매개변수
   • 람다 함수
   • 사용자 정의 함수

5. 입출력 (2023년 3회)

   • input()과 split()

---

체크리스트

기본 문법

• 변수 할당과 다중 할당
• 자료형 (리스트, 집합, 문자열)
• 인덱싱과 슬라이싱
• 연산자 (비교, 비트 시프트)

자료구조

• 리스트 생성과 접근
• 2차원 리스트
• 집합 연산 (add, remove, update)
• 문자열 처리

제어문

• for 반복문
• 중첩 반복문
• range() 함수

함수

• 함수 정의와 호출
• 기본값 매개변수
• lambda 함수
• map() 함수

입출력

• input() 함수
• split() 메서드
• print() 함수

---

작성일: 2026-01-30
범위: 2020년~2024년 정보처리기사 실기 Python 기출문제
총 문제 수: 14문제