시퀀스 타입의 공통 연산

시퀀스 타입의 공통 연산

리스트와 튜플은 모두 시퀀스 타입이므로 다음과 같은 공통 연산을 지원합니다.

# 문자열도 시퀀스 타입
list_ex = [1, 2, 3]
tuple_ex = (4, 5, 6)
string_ex = "hello"

# 연결 (concatenation)
print(list_ex + [4, 5])     # [1, 2, 3, 4, 5]
print(tuple_ex + (7, 8))    # (4, 5, 6, 7, 8)
print(string_ex + " world") # "hello world"

# 반복 (multiplication)
print(list_ex * 3)   # [1, 2, 3, 1, 2, 3, 1, 2, 3]
print(tuple_ex * 2)  # (4, 5, 6, 4, 5, 6)
print(string_ex * 2) # "hellohello"

# 멤버십 테스트 (in, not in)
print(2 in list_ex)       # True
print(7 in tuple_ex)      # False
print("h" in string_ex)   # True
print("x" not in string_ex) # True

# 길이, 최소값, 최대값
print(len(list_ex))     # 3
print(min(tuple_ex))    # 4
print(max(string_ex))   # 'o' (ASCII 값 기준)

# 카운팅
print(list_ex.count(2))     # 1
print(tuple_ex.count(5))    # 1
print(string_ex.count('l')) # 2

실습 예제

이제 배운 리스트와 튜플을 활용한 실습 예제를 살펴보겠습니다.

예제 1: 학생 성적 관리

# 학생들의 성적을 관리하는 프로그램
students = []  # 학생 정보를 저장할 리스트

# 학생 추가 함수
def add_student(name, scores):
    student = {
        "name": name,
        "scores": scores,
        "average": sum(scores) / len(scores)
    }
    students.append(student)
    print(f"{name} 학생이 추가되었습니다.")

# 학생 정보 출력 함수
def print_student_info():
    print("\n학생 성적 정보")
    print("-" * 30)
    print(f"{'이름':<10}{'평균':>10}{'성적':<10}")
    print("-" * 30)
    
    for student in students:
        print(f"{student['name']:<10}{student['average']:>10.2f}{student['scores']}")

# 성적 순으로 정렬하는 함수
def sort_by_average():
    students.sort(key=lambda s: s["average"], reverse=True)
    print("성적 순으로 정렬되었습니다.")

# 학생 추가
add_student("김철수", [85, 90, 88, 92])
add_student("이영희", [92, 95, 89, 90])
add_student("박민수", [78, 80, 85, 82])
add_student("정지원", [98, 96, 95, 94])

# 학생 정보 출력
print_student_info()

# 성적 순 정렬 후 출력
sort_by_average()
print_student_info()

예제 2: 장바구니 시스템

# 간단한 쇼핑몰 장바구니 시스템
class ShoppingCart:
    def __init__(self):
        self.items = []  # 장바구니 항목 리스트
    
    def add_item(self, item_name, price, quantity=1):
        """장바구니에 상품 추가"""
        # 이미 있는 상품인지 확인
        for item in self.items:
            if item["name"] == item_name:
                item["quantity"] += quantity
                print(f"{item_name}의 수량이 {item['quantity']}개로 업데이트되었습니다.")
                return
        
        # 새 상품 추가
        self.items.append({
            "name": item_name,
            "price": price,
            "quantity": quantity
        })
        print(f"{item_name} {quantity}개가 장바구니에 추가되었습니다.")
    
    def remove_item(self, item_name):
        """장바구니에서 상품 제거"""
        for i, item in enumerate(self.items):
            if item["name"] == item_name:
                del self.items[i]
                print(f"{item_name}이(가) 장바구니에서 제거되었습니다.")
                return
        print(f"{item_name}은(는) 장바구니에 없습니다.")
    
    def update_quantity(self, item_name, quantity):
        """상품 수량 업데이트"""
        for item in self.items:
            if item["name"] == item_name:
                item["quantity"] = quantity
                print(f"{item_name}의 수량이 {quantity}개로 업데이트되었습니다.")
                return
        print(f"{item_name}은(는) 장바구니에 없습니다.")
    
    def calculate_total(self):
        """장바구니 총액 계산"""
        total = 0
        for item in self.items:
            total += item["price"] * item["quantity"]
        return total
    
    def view_cart(self):
        """장바구니 내용 출력"""
        if not self.items:
            print("장바구니가 비어있습니다.")
            return
        
        print("\n현재 장바구니 내용")
        print("-" * 50)
        print(f"{'상품명':<15}{'가격':>10}{'수량':>10}{'소계':>15}")
        print("-" * 50)
        
        for item in self.items:
            subtotal = item["price"] * item["quantity"]
            print(f"{item['name']:<15}{item['price']:>10,}{item['quantity']:>10}{subtotal:>15,}")
        
        print("-" * 50)
        print(f"{'총액':>35}{self.calculate_total():>15,}")

# 장바구니 사용 예시
cart = ShoppingCart()
cart.add_item("노트북", 1200000, 1)
cart.add_item("마우스", 35000, 2)
cart.add_item("키보드", 108000, 1)
cart.view_cart()

cart.update_quantity("마우스", 3)
cart.remove_item("키보드")
cart.add_item("모니터", 350000, 1)
cart.view_cart()

예제 3: 튜플을 활용한 좌표 관리

import math

# 2D 좌표를 튜플로 표현
points = [
    (3, 4),
    (-2, 7),
    (5, -1),
    (0, 0),
    (8, 2)
]

# 원점과의 거리 계산 함수
def distance_from_origin(point):
    """튜플로 표현된 좌표와 원점 사이의 거리를 계산"""
    x, y = point  # 튜플 언패킹
    return math.sqrt(x**2 + y**2)

# 두 점 사이의 거리 계산 함수
def distance_between_points(point1, point2):
    """두 좌표 사이의 거리 계산"""
    x1, y1 = point1
    x2, y2 = point2
    return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)

# 각 좌표와 원점 사이의 거리 출력
print("각 좌표와 원점 사이의 거리:")
for point in points:
    distance = distance_from_origin(point)
    print(f"좌표 {point}: {distance:.2f}")

# 원점으로부터 가장 가까운/먼 좌표 찾기
closest = min(points, key=distance_from_origin)
farthest = max(points, key=distance_from_origin)

print(f"\n원점에서 가장 가까운 좌표: {closest}, 거리: {distance_from_origin(closest):.2f}")
print(f"원점에서 가장 먼 좌표: {farthest}, 거리: {distance_from_origin(farthest):.2f}")

# 모든 점 쌍 사이의 거리 중 가장 짧은 거리 찾기
min_distance = float('inf')  # 무한대로 초기화
closest_pair = None

for i in range(len(points)):
    for j in range(i+1, len(points)):
        distance = distance_between_points(points[i], points[j])
        if distance < min_distance:
            min_distance = distance
            closest_pair = (points[i], points[j])

print(f"\n가장 가까운 두 점: {closest_pair[0]}와 {closest_pair[1]}, 거리: {min_distance:.2f}")

예제 4: 튜플을 활용한 함수 반환 값

def get_statistics(numbers):
    """숫자 리스트의 통계 정보(합계, 평균, 최대, 최소)를 튜플로 반환"""
    if not numbers:
        return (0, 0, None, None)  # 빈 리스트인 경우
    
    total = sum(numbers)
    average = total / len(numbers)
    maximum = max(numbers)
    minimum = min(numbers)
    
    # 통계 정보를 튜플로 반환
    return (total, average, maximum, minimum)

# 함수 사용 예시
data = [78, 92, 65, 87, 91, 76, 84]
stats = get_statistics(data)

# 튜플 언패킹을 통한 결과 접근
total, avg, maximum, minimum = stats

print(f"합계: {total}")
print(f"평균: {avg:.2f}")
print(f"최대값: {maximum}")
print(f"최소값: {minimum}")

# 인덱스로도 접근 가능
print(f"또는, 평균: {stats[1]:.2f}")

이 예제는 함수가 여러 값을 반환할 때 튜플을 사용하는 방법을 보여줍니다. 이는 파이썬에서 매우 일반적인 패턴입니다.