반응형
리스트란 무엇인가?
파이썬에서 리스트는 여러 개의 데이터를 하나의 변수에 저장할 수 있는 매우 유용한 자료형입니다. 마치 여러 개의 상자를 일렬로 나열해서 각각에 다양한 물건을 넣을 수 있는 것과 같습니다.
리스트 생성하기
리스트를 만드는 방법은 매우 간단합니다. 대괄호([])를 사용하고 각 요소를 쉼표(,)로 구분하면 됩니다.
# 기본적인 리스트 생성
numbers = [2, 4, 6, 8, 10]
print(numbers) # [2, 4, 6, 8, 10]
# 다양한 형태의 리스트
empty_list = [] # 빈 리스트
fruits = ['apple', 'banana', 'grape'] # 문자열 리스트
mixed = [1, 'hello', 3.14, True] # 다양한 자료형 혼합
nested = [1, 2, [3, 4, 5]] # 중첩 리스트
또 다른 방법으로는 list() 함수를 사용할 수 있습니다:
# list() 함수로 빈 리스트 생성
empty_list = list()
print(empty_list) # []
리스트 인덱싱과 슬라이싱
인덱싱 기본 사용법
파이썬에서는 0부터 번호를 매기기 때문에 첫 번째 요소의 인덱스는 0입니다.
# 리스트 인덱싱 예제
colors = ['red', 'green', 'blue', 'yellow', 'purple']
print(colors[0]) # red (첫 번째 요소)
print(colors[1]) # green (두 번째 요소)
print(colors[-1]) # purple (마지막 요소)
print(colors[-2]) # yellow (뒤에서 두 번째 요소)
# 리스트 요소들을 이용한 연산
numbers = [10, 20, 30, 40, 50]
print(numbers[0] + numbers[4]) # 10 + 50 = 60
중첩 리스트 인덱싱
리스트 안에 또 다른 리스트가 있는 경우의 인덱싱 방법입니다.
# 중첩 리스트 인덱싱
game_board = [
[1, 2, 3],
['X', 'O', 'X'],
['A', 'B', 'C']
]
print(game_board[0]) # [1, 2, 3]
print(game_board[1][0]) # X
print(game_board[2][2]) # C
# 더 복잡한 중첩 리스트
complex_list = [1, 2, ['apple', 'banana', ['red', 'yellow']]]
print(complex_list[2][2][0]) # red
슬라이싱 활용하기
슬라이싱은 리스트의 일부분을 잘라내는 기능입니다.
# 슬라이싱 기본 예제
alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(alphabet[1:4]) # ['b', 'c', 'd']
print(alphabet[:3]) # ['a', 'b', 'c']
print(alphabet[3:]) # ['d', 'e', 'f', 'g']
print(alphabet[1:6:2]) # ['b', 'd', 'f'] (step 2)
print(alphabet[::-1]) # ['g', 'f', 'e', 'd', 'c', 'b', 'a'] (역순)
리스트 연산하기
리스트 결합하기 (+)
# 리스트 더하기
first_half = [1, 2, 3, 4, 5]
second_half = [6, 7, 8, 9, 10]
complete_list = first_half + second_half
print(complete_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 문자열 리스트 결합
greeting = ['Hello']
name = ['World']
message = greeting + name
print(message) # ['Hello', 'World']
리스트 반복하기 (*)
# 리스트 반복
pattern = ['*', '-']
repeated_pattern = pattern * 5
print(repeated_pattern) # ['*', '-', '*', '-', '*', '-', '*', '-', '*', '-']
# 초기화에 활용
zeros = [0] * 10
print(zeros) # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
리스트 길이 구하기
# len() 함수 사용
shopping_list = ['milk', 'bread', 'eggs', 'butter', 'cheese']
print(f"장보기 목록에 {len(shopping_list)}개의 항목이 있습니다.")
# 장보기 목록에 5개의 항목이 있습니다.
리스트 수정과 삭제
값 수정하기
# 리스트 요소 수정
scores = [85, 90, 78, 92, 88]
print("수정 전:", scores)
scores[2] = 95 # 세 번째 점수를 95로 변경
print("수정 후:", scores) # [85, 90, 95, 92, 88]
del을 사용한 삭제
# del을 사용한 요소 삭제
tasks = ['homework', 'shopping', 'exercise', 'reading', 'cooking']
print("삭제 전:", tasks)
del tasks[1] # 'shopping' 삭제
print("삭제 후:", tasks) # ['homework', 'exercise', 'reading', 'cooking']
# 슬라이싱을 이용한 여러 요소 삭제
del tasks[1:3] # 'exercise', 'reading' 삭제
print("최종:", tasks) # ['homework', 'cooking']
리스트 관련 주요 함수들
append() - 요소 추가
# append() 함수 사용
favorite_movies = ['Avatar', 'Titanic']
favorite_movies.append('Inception')
print(favorite_movies) # ['Avatar', 'Titanic', 'Inception']
# 리스트도 추가 가능
favorite_movies.append(['Interstellar', 'The Matrix'])
print(favorite_movies) # ['Avatar', 'Titanic', 'Inception', ['Interstellar', 'The Matrix']]
insert() - 특정 위치에 요소 삽입
# insert() 함수 사용
languages = ['Python', 'Java', 'C++']
languages.insert(1, 'JavaScript') # 1번 인덱스에 JavaScript 삽입
print(languages) # ['Python', 'JavaScript', 'Java', 'C++']
remove() - 특정 값 제거
# remove() 함수 사용
colors = ['red', 'blue', 'green', 'blue', 'yellow']
colors.remove('blue') # 첫 번째 'blue'만 제거
print(colors) # ['red', 'green', 'blue', 'yellow']
pop() - 요소 제거하고 반환
# pop() 함수 사용
stack = [1, 2, 3, 4, 5]
# 마지막 요소 제거
last_item = stack.pop()
print(f"제거된 요소: {last_item}") # 제거된 요소: 5
print(f"남은 리스트: {stack}") # 남은 리스트: [1, 2, 3, 4]
# 특정 인덱스 요소 제거
second_item = stack.pop(1)
print(f"제거된 요소: {second_item}") # 제거된 요소: 2
print(f"남은 리스트: {stack}") # 남은 리스트: [1, 3, 4]
sort() - 정렬하기
# sort() 함수 사용
numbers = [64, 25, 12, 22, 11]
numbers.sort() # 오름차순 정렬
print(numbers) # [11, 12, 22, 25, 64]
# 내림차순 정렬
numbers.sort(reverse=True)
print(numbers) # [64, 25, 22, 12, 11]
# 문자열 정렬
names = ['Charlie', 'Alice', 'Bob', 'David']
names.sort()
print(names) # ['Alice', 'Bob', 'Charlie', 'David']
reverse() - 순서 뒤집기
# reverse() 함수 사용
countdown = [1, 2, 3, 4, 5]
countdown.reverse()
print(countdown) # [5, 4, 3, 2, 1]
count() - 요소 개수 세기
# count() 함수 사용
grades = ['A', 'B', 'A', 'C', 'B', 'A', 'D']
a_count = grades.count('A')
print(f"A 학점의 개수: {a_count}") # A 학점의 개수: 3
index() - 요소의 위치 찾기
# index() 함수 사용
animals = ['cat', 'dog', 'rabbit', 'hamster']
dog_position = animals.index('dog')
print(f"강아지는 {dog_position}번 인덱스에 있습니다.") # 강아지는 1번 인덱스에 있습니다.
extend() - 리스트 확장
# extend() 함수 사용
fruits = ['apple', 'banana']
vegetables = ['carrot', 'lettuce']
fruits.extend(vegetables)
print(fruits) # ['apple', 'banana', 'carrot', 'lettuce']
# += 연산자와 동일한 효과
fruits += ['tomato', 'cucumber']
print(fruits) # ['apple', 'banana', 'carrot', 'lettuce', 'tomato', 'cucumber']
반응형
실전 예제: 간단한 학생 성적 관리 시스템
# 학생 성적 관리 시스템
class StudentGradeManager:
def __init__(self):
self.students = [] # 학생 이름 리스트
self.grades = [] # 성적 리스트
def add_student(self, name, grade):
"""학생과 성적 추가"""
self.students.append(name)
self.grades.append(grade)
print(f"{name} 학생이 추가되었습니다. (성적: {grade})")
def remove_student(self, name):
"""학생 삭제"""
if name in self.students:
index = self.students.index(name)
removed_grade = self.grades.pop(index)
self.students.remove(name)
print(f"{name} 학생이 삭제되었습니다. (성적: {removed_grade})")
else:
print(f"{name} 학생을 찾을 수 없습니다.")
def update_grade(self, name, new_grade):
"""성적 수정"""
if name in self.students:
index = self.students.index(name)
old_grade = self.grades[index]
self.grades[index] = new_grade
print(f"{name} 학생의 성적이 {old_grade}에서 {new_grade}로 수정되었습니다.")
else:
print(f"{name} 학생을 찾을 수 없습니다.")
def get_average(self):
"""평균 점수 계산"""
if self.grades:
return sum(self.grades) / len(self.grades)
return 0
def get_top_student(self):
"""최고 점수 학생 찾기"""
if self.grades:
max_grade = max(self.grades)
max_index = self.grades.index(max_grade)
return self.students[max_index], max_grade
return None, 0
def display_all(self):
"""모든 학생 정보 출력"""
print("\n=== 학생 성적 현황 ===")
for i in range(len(self.students)):
print(f"{self.students[i]}: {self.grades[i]}점")
print(f"평균 점수: {self.get_average():.1f}점")
top_student, top_grade = self.get_top_student()
if top_student:
print(f"최고 점수: {top_student} ({top_grade}점)")
# 사용 예제
manager = StudentGradeManager()
# 학생 추가
manager.add_student("김철수", 85)
manager.add_student("이영희", 92)
manager.add_student("박민수", 78)
manager.add_student("정소영", 96)
# 전체 현황 출력
manager.display_all()
# 성적 수정
manager.update_grade("박민수", 88)
# 학생 삭제
manager.remove_student("김철수")
# 최종 현황 출력
manager.display_all()
실전 예제: 간단한 숫자 맞추기 게임
import random
def number_guessing_game():
"""숫자 맞추기 게임"""
print("=== 숫자 맞추기 게임 ===")
print("1부터 100 사이의 숫자를 맞춰보세요!")
# 게임 설정
secret_number = random.randint(1, 100)
guess_history = [] # 추측 기록을 저장할 리스트
max_attempts = 7
for attempt in range(1, max_attempts + 1):
print(f"\n시도 {attempt}/{max_attempts}")
# 이전 추측 기록 표시
if guess_history:
print(f"이전 추측: {guess_history}")
try:
guess = int(input("숫자를 입력하세요: "))
# 추측 기록에 추가
guess_history.append(guess)
if guess == secret_number:
print(f"\n🎉 축하합니다! {attempt}번 만에 맞췄습니다!")
print(f"정답: {secret_number}")
print(f"추측 기록: {guess_history}")
return
elif guess < secret_number:
print("더 큰 숫자입니다!")
else:
print("더 작은 숫자입니다!")
except ValueError:
print("올바른 숫자를 입력해주세요!")
continue
print(f"\n💔 게임 오버! 정답은 {secret_number}였습니다.")
print(f"당신의 추측 기록: {guess_history}")
# 게임 실행
number_guessing_game()
실전 예제: 할일 관리 프로그램
def todo_manager():
"""간단한 할일 관리 프로그램"""
todo_list = [] # 할일 목록을 저장할 리스트
completed = [] # 완료된 할일을 저장할 리스트
while True:
print("\n=== 할일 관리 프로그램 ===")
print("1. 할일 추가")
print("2. 할일 목록 보기")
print("3. 할일 완료 처리")
print("4. 할일 삭제")
print("5. 완료된 할일 보기")
print("6. 통계 보기")
print("0. 종료")
choice = input("\n선택하세요: ")
if choice == '1':
# 할일 추가
task = input("추가할 할일을 입력하세요: ")
if task.strip(): # 빈 문자열이 아닌 경우만
todo_list.append(task)
print(f"'{task}'가 할일 목록에 추가되었습니다.")
else:
print("할일을 입력해주세요.")
elif choice == '2':
# 할일 목록 보기
if todo_list:
print("\n📋 현재 할일 목록:")
for i, task in enumerate(todo_list, 1):
print(f"{i}. {task}")
else:
print("할일이 없습니다!")
elif choice == '3':
# 할일 완료 처리
if todo_list:
print("\n현재 할일 목록:")
for i, task in enumerate(todo_list, 1):
print(f"{i}. {task}")
try:
task_num = int(input("완료할 할일 번호를 입력하세요: ")) - 1
if 0 <= task_num < len(todo_list):
completed_task = todo_list.pop(task_num)
completed.append(completed_task)
print(f"'{completed_task}'를 완료했습니다! ✅")
else:
print("올바른 번호를 입력해주세요.")
except ValueError:
print("숫자를 입력해주세요.")
else:
print("완료할 할일이 없습니다.")
elif choice == '4':
# 할일 삭제
if todo_list:
print("\n현재 할일 목록:")
for i, task in enumerate(todo_list, 1):
print(f"{i}. {task}")
try:
task_num = int(input("삭제할 할일 번호를 입력하세요: ")) - 1
if 0 <= task_num < len(todo_list):
deleted_task = todo_list.pop(task_num)
print(f"'{deleted_task}'가 삭제되었습니다.")
else:
print("올바른 번호를 입력해주세요.")
except ValueError:
print("숫자를 입력해주세요.")
else:
print("삭제할 할일이 없습니다.")
elif choice == '5':
# 완료된 할일 보기
if completed:
print("\n✅ 완료된 할일 목록:")
for i, task in enumerate(completed, 1):
print(f"{i}. {task}")
else:
print("완료된 할일이 없습니다.")
elif choice == '6':
# 통계 보기
total_tasks = len(todo_list) + len(completed)
print(f"\n📊 할일 통계")
print(f"전체 할일: {total_tasks}개")
print(f"남은 할일: {len(todo_list)}개")
print(f"완료된 할일: {len(completed)}개")
if total_tasks > 0:
completion_rate = (len(completed) / total_tasks) * 100
print(f"완료율: {completion_rate:.1f}%")
elif choice == '0':
print("프로그램을 종료합니다.")
break
else:
print("올바른 선택지를 입력해주세요.")
# 프로그램 실행
# todo_manager() # 주석을 해제하고 실행해보세요!
리스트 컴프리헨션 (List Comprehension)
리스트 컴프리헨션은 리스트를 간결하게 생성하는 파이썬의 강력한 기능입니다.
# 기본 형태: [표현식 for 항목 in 반복가능객체]
# 1부터 10까지의 제곱수 리스트
squares = [x**2 for x in range(1, 11)]
print(squares) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 짝수만 필터링: [표현식 for 항목 in 반복가능객체 if 조건]
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares) # [4, 16, 36, 64, 100]
# 문자열 리스트 처리
names = ['alice', 'bob', 'charlie', 'diana']
capitalized = [name.capitalize() for name in names]
print(capitalized) # ['Alice', 'Bob', 'Charlie', 'Diana']
# 중첩 반복문 사용
matrix = [[i*j for j in range(1, 4)] for i in range(1, 4)]
print(matrix) # [[1, 2, 3], [2, 4, 6], [3, 6, 9]]
리스트 관련 주요 팁과 주의사항
일반적인 오류 예방
오류 상황 잘못된 예제 올바른 예제
| 정수와 문자열 더하기 | 3 + "hello" | str(3) + "hello" |
| 존재하지 않는 인덱스 | [1,2,3][5] | len(list) > 5 먼저 확인 |
| 빈 리스트에서 pop | [].pop() | if list: 조건 확인 후 실행 |
| remove시 존재하지 않는 값 | [1,2,3].remove(5) | if 5 in list: 먼저 확인 |
리스트 복사 주의사항
# 얕은 복사 vs 깊은 복사
original = [1, 2, [3, 4]]
# 얕은 복사 (참조 복사)
shallow_copy = original.copy()
shallow_copy[2][0] = 999
print(original) # [1, 2, [999, 4]] - 원본도 변경됨!
# 깊은 복사 (완전 복사)
import copy
deep_copy = copy.deepcopy(original)
deep_copy[2][1] = 888
print(original) # [1, 2, [999, 4]] - 원본 변경 안됨
성능 최적화 팁
효율적인 리스트 사용법
# 1. 리스트 초기화시 크기 예측 가능하면 미리 할당
# 비효율적
result = []
for i in range(1000):
result.append(i*2)
# 효율적 (리스트 컴프리헨션)
result = [i*2 for i in range(1000)]
# 2. 앞쪽 요소 삽입/삭제는 비효율적
# 비효율적 (모든 요소를 이동해야 함)
my_list = [1, 2, 3, 4, 5]
my_list.insert(0, 0) # 맨 앞에 삽입
# 효율적 (뒤쪽에서 작업)
my_list.append(6) # 맨 뒤에 추가
# 3. 멤버십 테스트는 set이 더 빠름
# 리스트에서 검색 (느림)
large_list = list(range(10000))
if 5000 in large_list: # O(n) 시간복잡도
print("찾았습니다!")
# 집합에서 검색 (빠름)
large_set = set(range(10000))
if 5000 in large_set: # O(1) 시간복잡도
print("찾았습니다!")
실무에서 자주 사용되는 패턴
# 1. 리스트를 청크(chunk)로 나누기
def chunk_list(lst, chunk_size):
"""리스트를 지정된 크기의 청크로 나누기"""
return [lst[i:i + chunk_size] for i in range(0, len(lst), chunk_size)]
numbers = list(range(1, 21))
chunks = chunk_list(numbers, 5)
print(chunks) # [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]
# 2. 리스트의 중복 제거 (순서 유지)
def remove_duplicates(lst):
"""순서를 유지하면서 중복 제거"""
seen = set()
result = []
for item in lst:
if item not in seen:
seen.add(item)
result.append(item)
return result
data = [1, 2, 2, 3, 1, 4, 3, 5]
unique_data = remove_duplicates(data)
print(unique_data) # [1, 2, 3, 4, 5]
# 3. 두 리스트 병합 및 정렬
def merge_and_sort(list1, list2):
"""두 리스트를 병합하고 정렬"""
merged = list1 + list2
merged.sort()
return merged
grades1 = [85, 92, 78]
grades2 = [91, 87, 95]
all_grades = merge_and_sort(grades1, grades2)
print(all_grades) # [78, 85, 87, 91, 92, 95]
# 4. 조건에 따른 리스트 필터링
scores = [45, 78, 92, 67, 83, 56, 94, 71]
# 합격점 이상만 필터링
passing_scores = [score for score in scores if score >= 70]
print(f"합격 점수: {passing_scores}") # [78, 92, 83, 94, 71]
# 등급별 분류
def classify_grades(scores):
"""점수를 등급별로 분류"""
grade_a = [s for s in scores if s >= 90]
grade_b = [s for s in scores if 80 <= s < 90]
grade_c = [s for s in scores if 70 <= s < 80]
grade_f = [s for s in scores if s < 70]
return {
'A': grade_a,
'B': grade_b,
'C': grade_c,
'F': grade_f
}
classified = classify_grades(scores)
for grade, score_list in classified.items():
print(f"{grade}등급: {score_list}")
이렇게 파이썬 리스트의 기본 사용법부터 실무에서 활용할 수 있는 고급 기법까지 살펴보았습니다. 리스트는 파이썬 프로그래밍의 핵심 자료구조이므로, 이러한 기능들을 충분히 연습하고 익숙해지시기 바랍니다. 실제 프로젝트에서 이런 패턴들을 자주 사용하게 될 것입니다!
반응형
'파이썬' 카테고리의 다른 글
| 4. 파이썬 튜플 기초부터 고급 활용까지 (0) | 2025.05.23 |
|---|---|
| 2. 예제로 공부하는 파이썬 문자열 완전 정복 가이드 | 한번에 끝내는 문자열. (0) | 2025.05.23 |
| 1. 파이썬 숫자형 자료형 완벽 가이드 | 정수형, 실수형, 8진수, 16진수, 사칙연산, 계산기, 숫자 맞추기 (0) | 2025.05.23 |