1. 리스트 기본 개념

리스트는 파이썬에서 여러 항목을 순서대로 저장하는 시퀀스 자료형입니다. 대괄호 []로 표현하며, 다양한 데이터 타입을 함께 저장할 수 있습니다.

리스트 생성 및 접근:

# 리스트 생성
heroes = ["스파이더맨", "헐크", "아이언맨"]

# 리스트 요소 접근
first_hero = heroes[0]  # "스파이더맨"

2. 리스트의 주요 연산과 함수

기본 연산자 및 함수

연산자/함수	설명	예시	결과
len()	길이 계산	len(["a", "b", "c"])	3
+	두 리스트 연결	[1, 2] + [3, 4]	[1, 2, 3, 4]
*	리스트 반복//주의!!!! 리스트가 ([1,2]가)3번 반복되어 리스트안에 리스트로 들어가는 게 아니라 리스트안에있는 양이 배가됨	[1, 2] * 3	[1, 2, 1, 2, 1, 2]
in	요소가 포함되어 있는지	"a" in ["a", "b"]	True
not in	요소가 포함되어 있지 않은지	"c" not in ["a", "b"]	True
min()	최소값 찾기	min([5, 1, 3])	1
max()	최대값 찾기	max([5, 1, 3])	5
sum()	모든 요소의 합	sum([1, 2, 3])	6

예제 코드:

marvel_heroes = ["스파이더맨", "헐크", "아이언맨"]
dc_heroes = ["슈퍼맨", "배트맨", "원더우먼"]

# 리스트 연결
heroes = marvel_heroes + dc_heroes
print(heroes)  # ['스파이더맨', '헐크', '아이언맨', '슈퍼맨', '배트맨', '원더우먼']

# 리스트 반복
values = [1, 2, 3] * 3
print(values)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 리스트 길이
print(len(heroes))  # 6

# 포함 여부 확인
if "배트맨" in heroes:
    print("배트맨은 영웅입니다.")  # 출력됨

# 최소/최대/합계
numbers = [11, 2, 13, 4, 5]
print(min(numbers))  # 2
print(max(numbers))  # 13
print(sum(numbers))  # 35

3. 리스트 메소드

메소드	설명
append(item)	리스트 끝에 항목 추가
insert(index, item)	특정 위치에 항목 삽입
remove(item)	특정 항목 삭제
pop([index])	특정 위치의 항목 제거 후 반환 (기본값: 마지막 항목) =⇒걍 숫자넣으면 해당인덱스항목 삭제됨
index(item)	특정 항목의 위치 반환
sort()	원본 리스트 정렬
reverse()	원본 리스트 역순 정렬
count(item)	특정 항목의 개수 반환
clear()	모든 항목 삭제

예제 코드:

# 항목 추가
shopping_list = []
shopping_list.append("두부")
shopping_list.append("양배추")
print(shopping_list)  # ['두부', '양배추']

# 특정 위치에 항목 삽입
a = [1, 2, 3]
a.insert(0, 4)  # 0번 위치에 4 삽입
print(a)  # [4, 1, 2, 3]

# 항목 삭제
heroes = ["스파이더맨", "슈퍼맨", "헐크", "아이언맨", "배트맨", "조커"]
heroes.remove("조커")
print(heroes)  # ['스파이더맨', '슈퍼맨', '헐크', '아이언맨', '배트맨']

# pop으로 항목 삭제 및 반환
hero = heroes.pop(1)  # '슈퍼맨'
print(hero)  # '슈퍼맨'
print(heroes)  # ['스파이더맨', '헐크', '아이언맨', '배트맨']

# 항목 위치 확인
index = heroes.index("헐크")
print(index)  # 1

# 정렬
numbers = [3, 2, 1, 5, 4]
numbers.sort()  # 원본 리스트 변경
print(numbers)  # [1, 2, 3, 4, 5]

# 내림차순 정렬
numbers.sort(reverse=True)
print(numbers)  # [5, 4, 3, 2, 1]

# sorted() 함수 (원본 리스트 유지하며 정렬된 새 리스트 반환)
a = [3, 2, 1, 5, 4]
b = sorted(a)
print(b)  # [1, 2, 3, 4, 5]
print(a)  # [3, 2, 1, 5, 4] - 원본 유지

4. 리스트 복사

얕은 복사(Shallow copy)

scores = [10, 20, 30, 40, 50]
values = scores  # 얕은 복사 - 동일한 객체를 참조
print(id(scores))  # 메모리 주소
print(id(values))  # scores와 동일한 메모리 주소

# 하나의 리스트를 변경하면 다른 리스트도 변경됨
scores[0] = 99
print(values)  # [99, 20, 30, 40, 50]

깊은 복사(Deep copy)

import copy
a = [1, 2, 3, 4]
b = copy.deepcopy(a)  # 깊은 복사 - 새로운 객체 생성

# 메모리 주소 다름
print(id(a))  # 첫 번째 메모리 주소
print(id(b))  # 두 번째 메모리 주소

# 한 리스트 변경해도 다른 리스트는 영향 없음
a.append(500)
print(a)  # [1, 2, 3, 4, 500]
print(b)  # [1, 2, 3, 4]

5. 리스트 컴프리헨션(List Comprehension), 함축!!

리스트 컴프리헨션은 리스트를 간결하게 생성하는 방법입니다.

기본 구문:

[표현식 for 항목 in 반복가능객체 if 조건문]

예제 코드:

# 기본 리스트 컴프리헨션
squares = [x**2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 기존 리스트 변환
list1 = [3, 4, 5]
list2 = [x*2 for x in list1]
print(list2)  # [6, 8, 10]

# 조건문 사용
even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  # [0, 2, 4, 6, 8]

# 다중 반복문
pythagorean_triples = [(x, y, z) for x in range(1, 21)
                       for y in range(x, 21)
                       for z in range(y, 21)
                       if x**2 + y**2 == z**2]
print(pythagorean_triples)  # [(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15)]

6. 함수에서의 리스트 전달

파이썬에서 리스트를 함수에 전달하면 참조 방식으로 전달됩니다. 즉, 함수 내에서 리스트를 변경하면 원본 리스트도 변경됩니다.

def modify_list(lst):
    lst[0] = 99

values = [0, 1, 2, 3, 4]
print("함수 호출 전:", values)  # [0, 1, 2, 3, 4]
modify_list(values)
print("함수 호출 후:", values)  # [99, 1, 2, 3, 4]

7. 실전 예제 프로그램

예제 1: 성적 처리 프로그램

STUDENTS = 5
scores = []
scoreSum = 0

# 성적 입력 받기
for i in range(STUDENTS):
    value = int(input("성적을 입력하시오: "))
    scores.append(value)
    scoreSum += value

# 평균 계산
scoreAvg = scoreSum / len(scores)

# 80점 이상 학생 수 계산
highScoreStudents = 0
for score in scores:
    if score >= 80:
        highScoreStudents += 1

# 결과 출력
print("성적 평균은", scoreAvg, "입니다.")
print("80점 이상 성적을 받은 학생은", highScoreStudents, "명입니다.")

예제 2: 연락처 관리 프로그램

menu = 0
friends = []

while menu != 9:
    print("--------------------")
    print("1. 친구 리스트 출력")
    print("2. 친구 추가")
    print("3. 친구 삭제")
    print("4. 이름 변경")
    print("9. 종료")

    menu = int(input("메뉴를 선택하시오: "))

    if menu == 1:
        print(friends)
    elif menu == 2:
        name = input("이름을 입력하시오: ")
        friends.append(name)
    elif menu == 3:
        del_name = input("삭제하고 싶은 이름을 입력하시오: ")
        if del_name in friends:
            friends.remove(del_name)
        else:
            print("이름이 발견되지 않았음")
    elif menu == 4:
        old_name = input("변경하고 싶은 이름을 입력하시오: ")
        if old_name in friends:
            index = friends.index(old_name)
            new_name = input("새로운 이름을 입력하시오: ")
            friends[index] = new_name
        else:
            print("이름이 발견되지 않았음")

8. 중간고사 예상 문제 및 풀이

파이썬 리스트 중간고사 예상 문제 및 풀이

객관식 문제

문제 1

다음 중 리스트 a = [1, 2, 3, 4, 5]를 복제하여 새로운 리스트 b를 만들고 싶을 때, 독립적인 복사본(깊은 복사)을 만드는 올바른 방법은?

a) b = a
b) b = a[:]
c) b = copy.deepcopy(a)
d) b = list(a)

정답: c) b = copy.deepcopy(a)

해설:

• b = a는 새로운 리스트를 만드는 것이 아니라 같은 객체를 참조(얕은 복사)합니다.
• b = a[:]와 b = list(a)는 1차원 리스트의 경우 독립적인 복사본을 만들지만, 중첩 리스트의 경우 내부 리스트는 여전히 같은 객체를 참조합니다.
• copy.deepcopy(a)는 중첩 리스트를 포함한 모든 구조를 완전히 독립적으로 복사합니다.

문제 2

다음 코드의 실행 결과는?

values = [1, 2, 3]
values.append([4, 5])
print(len(values))

a) 3
b) 4
c) 5
d) 오류 발생

정답: b) 4

해설: values.append([4, 5])는 리스트 [4, 5]를 하나의 요소로 values 리스트에 추가합니다. 따라서 values는 [1, 2, 3, [4, 5]]가 되고, 길이는 4가 됩니다.

문제 3

다음 코드의 실행 결과는?

numbers = [1, 2, 3, 4, 5]
print(numbers[1:-1])

a) [1, 2, 3, 4]
b) [2, 3, 4]
c) [2, 3, 4, 5]
d) [1, 2, 3]

정답: b) [2, 3, 4]

해설: numbers[1:-1]은 인덱스 1부터 마지막 인덱스(-1) 바로 전까지의 요소를 반환합니다. 인덱스 1은 2, 인덱스 -1은 5이므로, 2부터 5 직전까지인 [2, 3, 4]가 출력됩니다.

문제 4

다음 중 리스트 메소드가 아닌 것은?

a) append()
b) insert()
c) add()
d) remove()

정답: c) add()

해설: 파이썬 리스트에는 add() 메소드가 존재하지 않습니다. 요소를 추가하는 메소드는 append()(끝에 추가), insert()(지정된 위치에 추가), extend()(반복 가능한 객체의 요소를 추가)입니다.

문제 5

다음 코드의 출력은?

a = [3, 2, 1, 5, 4]
b = a.sort()
print(b)

a) [1, 2, 3, 4, 5]
b) [3, 2, 1, 5, 4]
c) None
d) 오류 발생

정답: c) None

해설: sort() 메소드는 원본 리스트를 제자리에서 정렬하고 아무것도 반환하지 않습니다(None 반환). 따라서 b에는 None이 할당되고, 이것이 출력됩니다. 정렬된 리스트를 반환받으려면 sorted() 함수를 사용해야 합니다.

서술형 및 코딩 문제

문제 6

다음 조건을 만족하는 리스트 컴프리헨션을 작성하세요:

1. 1부터 50까지의 정수 중
2. 3의 배수이면서
3. 5의 배수가 아닌 수

정답:

result = [x for x in range(1, 51) if x % 3 == 0 and x % 5 != 0]

문제 7

다음 코드가 출력하는 결과를 쓰세요:

heroes = ["아이언맨", "토르", "헐크", "스파이더맨"]
heroes.pop(1)
heroes.insert(0, "블랙위도우")
heroes.append("캡틴아메리카")
print(heroes)

정답: ['블랙위도우', '아이언맨', '헐크', '스파이더맨', '캡틴아메리카']

해설:

1. 초기 heroes = ["아이언맨", "토르", "헐크", "스파이더맨"]
2. heroes.pop(1)로 인덱스 1의 "토르" 제거 → ["아이언맨", "헐크", "스파이더맨"]
3. heroes.insert(0, "블랙위도우")로 인덱스 0에 "블랙위도우" 삽입 → ["블랙위도우", "아이언맨", "헐크", "스파이더맨"]
4. heroes.append("캡틴아메리카")로 끝에 "캡틴아메리카" 추가 → ["블랙위도우", "아이언맨", "헐크", "스파이더맨", "캡틴아메리카"]

문제 8

다음 코드의 출력을 예측하세요:

def modify_scores(scores):
    scores.append(100)
    scores = [50, 60, 70]
    scores.append(80)
    return scores

my_scores = [85, 90, 95]
new_scores = modify_scores(my_scores)
print(my_scores)
print(new_scores)

정답:

[85, 90, 95, 100]
[50, 60, 70, 80]

해설:

1. my_scores가 modify_scores 함수에 전달됩니다.
2. 함수 내에서 scores.append(100)로 my_scores에 100 추가 → my_scores = [85, 90, 95, 100]
3. scores = [50, 60, 70]으로 scores 변수에 새 리스트 할당. 하지만 이것은 my_scores에 영향을 주지 않습니다.
4. scores.append(80)으로 새 리스트에 80 추가 → scores = [50, 60, 70, 80]
5. 함수는 scores 리스트를 반환하므로 new_scores = [50, 60, 70, 80]
6. my_scores에는 첫 번째 append 작업만 영향을 주었으므로 [85, 90, 95, 100]이 됩니다.

문제 9

다음 리스트에서 중복된 요소를 제거하여 유일한 값만 가진 새 리스트를 반환하는 함수를 작성하세요. 원본 리스트 순서를 유지해야 합니다. (힌트: 이미 확인한 요소를 기록하는 새 리스트를 사용하세요)

def remove_duplicates(input_list):
    # 코드 작성
    pass

정답:

def remove_duplicates(input_list):
    result = []
    for item in input_list:
        if item not in result:
            result.append(item)
    return result

또는 리스트 컴프리헨션 사용:

def remove_duplicates(input_list):
    seen = set()
    return [x for x in input_list if not (x in seen or seen.add(x))]

문제 10

피보나치 수열의 처음 20개 항을 계산하여 리스트에 저장하는 코드를 작성하세요. 피보나치 수열은 0, 1로 시작하고, 다음 항은 이전 두 항의 합으로 구성됩니다.

정답:

fibonacci = [0, 1]
for i in range(2, 20):
    fibonacci.append(fibonacci[i-1] + fibonacci[i-2])
print(fibonacci)

또는 리스트 컴프리헨션 사용 (조금 더 복잡):

fibonacci = [0, 1]
[fibonacci.append(fibonacci[-1] + fibonacci[-2]) for _ in range(18)]
print(fibonacci)

문제 11

리스트의 모든 가능한 두 요소의 조합과 그 합을 계산하는 프로그램을 작성하세요. 출력은 튜플 리스트 [(a, b, a+b), ...] 형태여야 합니다.

입력: [1, 2, 3, 4]
출력: [(1, 2, 3), (1, 3, 4), (1, 4, 5), (2, 3, 5), (2, 4, 6), (3, 4, 7)]

정답:

def all_combinations(numbers):
    result = []
    for i in range(len(numbers)):
        for j in range(i+1, len(numbers)):
            result.append((numbers[i], numbers[j], numbers[i] + numbers[j]))
    return result

print(all_combinations([1, 2, 3, 4]))

또는 리스트 컴프리헨션 사용:

def all_combinations(numbers):
    return [(numbers[i], numbers[j], numbers[i] + numbers[j])
            for i in range(len(numbers))
            for j in range(i+1, len(numbers))]

print(all_combinations([1, 2, 3, 4]))

문제 12

다음과 같은 학생 성적 리스트가 있습니다: scores = [78, 65, 89, 93, 87, 45, 92]
평균보다 높은 점수만 출력하는 코드를 작성하세요.

정답:

scores = [78, 65, 89, 93, 87, 45, 92]
average = sum(scores) / len(scores)
above_average = [score for score in scores if score > average]
print(f"평균: {average}")
print(f"평균보다 높은 점수: {above_average}")

9. 중간고사 실전 대비 TIP

리스트 관련 주요 개념 정리

• 리스트 기본 연산: +, , in, not in 등의 사용법 숙지
• 리스트 주요 메소드: append(), insert(), remove(), pop(), index(), sort() 등의 기능과 사용법 숙지
• 리스트 슬라이싱: 인덱싱과 슬라이싱 문법 확실히 이해
• 리스트 복사 방식: 얕은 복사와 깊은 복사의 차이점 명확히 이해
• 리스트 컴프리헨션: 기본 구조와 응용 방법 연습

실전 대비 전략

1. 개념 이해하기: 각 리스트 메소드와 함수의 역할, 반환값을 분명히 이해하세요.
2. 손으로 코드 실행해보기: 복잡한 리스트 조작이 있는 코드는 손으로 한 줄씩 실행해보며 결과를 예측해보세요.
3. 문제 풀이 시간 배분하기: 쉬운 문제를 먼저 풀고 어려운 문제에 시간을 투자하세요.
4. 코드 트레이싱 연습하기: 주어진 코드가 어떤 결과를 내는지 단계별로 예측하는 연습을 하세요.
5. 리스트 컴프리헨션 활용하기: 간결하고 가독성 높은 코드 작성을 위해 리스트 컴프리헨션을 적절히 활용하세요.

자주 나오는 실수

• 인덱스 오류: 리스트 범위를 벗어나는 인덱스 접근
• 얕은 복사와 깊은 복사 혼동: 의도와 다른 복사 방식 사용
• 메소드의 반환값 무시: sort()와 sorted()의 차이 혼동
• 리스트 변경 시 참조 문제: 함수에서 리스트를 변경할 때 발생하는 문제 인지 부족