데이터 분석 파이썬 종합반 요약 (2) 리스트, 튜플

 

■ 00. 리스트, 튜플, 딕셔너리를 통해 무엇을 할 수 있을까

□ 데이터를 담고, 정리하고, 꺼낼 때 필요

설명딥러닝 모델 반복 학습 → 결과 리스트에 추가데이터 불러오기, 경로 처리  → split 사용데이터를 임의의 범위만큼 선택 → 슬라이싱, 인덱싱 사용데이터를 변경 불가능하게 사용하고 싶을 때 등

 

목적맨 처음 데이터를 불러오고 가공할 때 사용, 결과 저장할 때 사용

 

■ 01. 리스트 기본 사용법

□ 리스트(List)란?

1. 리스트란

정의 파이썬에서 가장 자주 사용되는 데이터 구조 중 하나

특징 여러 항목들을 담을 수 있는 가변(mutable)한 시퀀스(sequence)

        대괄호 [ ] 를  사용

2. 리스트의 기본 구조

여러 값을 순서대로 담을 수 있음

각 값은 쉼표로 구분, 대괄호 안에 들어감

# 1. 리스트 생성
my_list = [1, 2, 3, 4, 5]

$ 2. 리스트의 기본 구조
print(my_list) # 출력: [1, 2, 3, 4, 5]

□ 리스트의 기본 사용법

1. 리스트의 인덱싱 ( indexing )

인덱싱: 리스트에서 특정 위치의 값에 접근하는 방법

★ 주의: indexing 처음은 list[0]

★ 주의: indexing 마지막 값의 경우,

     - 내가 지정할 때(출력을 원할 때): 마지막 인덱싱에서 +1 

       ex) 99번 데이터까지 원한다면 [:100]

     - 문제에서 지정되어 내가 출력을 구할 때: 마지막 인덱싱에서 -1

       ex) [:100]을 요구한다면, 답은 99임

# 리스트 생성
numbers = [1,2,3,4,5]

# 첫 번째 요소 접근
first_number = numbers[0]
print("First number:", first_number) #출력) First number: 1

# 두 번째 요소 접근
second_number = numbers[1]
print("Second number:", second_number) #출력) Second number: 2

# 마지막 요소 접근
last_number = numbers[-1]
print("Last number:", last_number) #출력) Last number: 5

# 음수를 활용한 역순 요소 접근
second_last_number = numbers[-2]
print("Second last number:", second_last_number) #출력) Second last number: 4

2. 리스트의 다양한 메서드 ( methods )

2-1) 추가/삽입

append( 항목 )          리스트에 항목을 추가

extend( 리스트 )        리스트에 다른 리스트(모든 항목) 추가

insert( 위치, 요소 )     리스트의 특정 위치에 항목을 삽입 

-- 위치: index // 요소: element

추가/삽입 (예시) my_list = [ 1,2,3,4,5 ]
append ( )	리스트에 항목 추가	my_list.append(6) print(my_list)  #출력) [1,2,3,4,5,6]
extend ( )	리스트에 다른 리스트(모든 항목) 추가	my_list.extend( [ 7, 8, 9 ] ) print(my_list)  #출력) [1,2,3,4,5,6,7,8,9]
insert ( 위치, 값 )	리스트의 특정 위치에 항목 삽입	my_list.insert( [ 2, 10 ] ) print(my_list)  #출력) [1,2,10, 3,4,5,6,7,8,9]

 

2-2) 삭제/반환

remove( )     리스트에서 특정 값을 삭제

pop( )           리스트에서 특정 위치의 값을 제거하고 반환

clear ( )        리스트 내 값들의 모든 항목 제거

--------------

del                리스트의 항목 삭제

삭제/반환 (예시) my_list = [ 1,2,3,4,5 ]
remove ( )	리스트에서 특정 값을 삭제	my_list.remove(3) print(my_list)                #출력) [1,2,4,5]  3
pop ( )	리스트에서 특정 위치의 값을 제거하고 반환	popped_value = my_list.pop(3) print(popped_value)    #출력) 4 print(my_list)                #출력) [1,2,3,5]
clear ( )	리스트 내 값들의 모든 항목 제거	my_list.clear() print(my_list)                #출력) []

del ( )

리스트의 특정 위치에 항목 삽입

del my_list[0] print(my_list)  #출력) [2,3,4,5]

 

2-3) 기타 (인덱스 찾기, 개수 세기, 정렬)

index( )      특정 값의 인덱스를 찾음

count( )      특정 값의 등장 횟수를 세어줌 ---> len ( ) : 전체 요소의 개수

sort( )         리스트의 항목 정렬

reverse( )   리스트의 항목들을 역순으로 정렬

기타 (인덱스 찾기, 개수 세기, 정렬) (예시) my_list = [ 1,2,3,4,5 ]
index ( )	특정 값의 인덱스(위치)를 찾음	my_list.index(3) print(my_list)                   #출력) 2
count ( )	특정 값의 개수를 세어줌	print(my_list.count(3))    #출력) 1
sort ( )	리스트의 항목을 정렬	my_list.sort() print(my_list)                    #출력) [ 1,2,3,4,5 ]
reverse ( )	리스트의 항목을 역순으로 정렬	my_list.reverse() print(my_list)                    #출력) [ 5,4,3,2,1 ]

3. 리스트 값 변경

특정 위치의 리스트 값을 다른 값으로 변경

예시) [3]인 date가 dragonfruit로 바뀜

my_fruits = ['apple', 'banana', 'cherry', 'date', 'berry']

my_fruits[3] = 'dragonfruit'
print(my_fruits) 
#출력: ['apple', 'banana', 'cherry', 'dragonfruit', 'berry']

4. 중첩된 리스트에서 인덱싱

두 개 이사으이 중첩된 리스트에서도 인덱싱 가능

예시) 3개 리스트 중 [1] = [4,5,6] 그 중에서 [0]은 4

nested_list = [[1,2,3],[4,5,6],[7,8,9]]
print(nested_list[1][0])  #출력: 4

 

예시

★ len(요소) : 개수 카운트해주는거임

grades = [85, 92, 88, 78, 90]
average_grade = sum(grades) / len(grades)   *참고 print(len(grades))는 5
print("평균 성적:", average_grade)
print(len(grades)) #출력 86.6

 

□ 리스트의 고급 사용법

1. 슬라이싱 ★

리스트의 일부분을 추출

리스트에서 특정 범위의 항목을 선택하거나 리스트를 자르는 등의 작업

★ new_list = old_list[start : end : step]

- 중요 start: 처음 인덱스는 0

- 중요 end : 내가 선택할 인덱스보다 +1을 해주기 ★ ★ ★ 

my_list = [1,2,3,4,5,6,7,8,9,10]

# 일부 추출
print(my_list[2:5])  #출력: [3, 4, 5]

# 시작 인덱스 생략(=처음부터 추출)
print(my_list[:5])   #출력: [1, 2, 3, 4, 5]  ★5까지 나옴

# 끝 인덱스 생략(=끝까지 추출)
print(my_list[5:])   #출력: [6, 7, 8, 9, 10] ★6부터 나옴

# 음수 인덱스 사용하기(=뒤에서부터 추출)
print(my_list[-3:])   #출력:[8, 9, 10] ★음수라고 해서 출력 방향이 바뀌는건 아님

# 간격 설정하기(=특정 간격 추출)
print(my_list[1:9:2]) # 출력: [2, 4, 6, 8]   ★2부터 나옴, 9까지 나옴

# 리스트 전체 복사
copy_of_list = my_list[:]
print(copy_of_list)   # 출력: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 리스트 거꾸로 뒤집기
reversed_list = my_list[::-1]
print(reversed_list)  # 출력: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]


my_list2 = [10, 20, 30, 40, 50, 60, 70, 80, 90]

# 짝수, 홀수 출력 = 시작점 차이, 간격은 2
even_index_values = my_list2[1::2]
print(even_index_values)  # 출력: [20, 40, 60, 80]

odd_index_values = my_list2[::2]
print(odd_index_values)   # 출력: [10, 30, 50, 70, 90]

2. 정렬

- sort() 를 통한 리스트 항목 정렬

- 문자열에 대해서는 오름차순 정렬

- 리스트 항목들이 동일한 형태일 경우에만 정렬

- reverse : 오름차순(기본값) False / 내림차순 True

# 숫자로 이루어진 리스트 정렬 예시
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
numbers.sort()
print("정렬된 리스트:", numbers)
# 출력) 정렬된 리스트: [1, 1, 2, 3, 4, 5, 5, 6, 9]

# 문자열로 이루어진 리스트 정렬 예시
words = ['apple', 'banana', 'orange', 'grape', 'cherry']
words.sort()
print("정렬된 리스트:", words) 
# 출력) 정렬된 리스트: ['apple', 'banana', 'cherry', 'grape', 'orange']

# 내림차순으로 리스트 정렬 예시
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
numbers.sort(reverse=True)
print("내림차순으로 정렬된 리스트:", numbers)
#출력) 내림차순으로 정렬된 리스트: [9, 6, 5, 5, 4, 3, 2, 1, 1]

# 리스트의 문자열 길이로 정렬 예시
words = ['apple', 'banana', 'orange', 'grape', 'cherry']
words.sort(key=len)
print("문자열 길이로 정렬된 리스트:", words) 
# 문자열 길이로 정렬된 리스트: ['apple', 'grape', 'banana', 'orange', 'cherry']

예시

- 실제 iris공용 데이터셋을 활용해 뎅터 중의 일부를 train dataset, 나머지를 test dataset으로 구분하는 작업

- 참고) AI모델 학습할 때 train dataset으로 학습하고 test dataset으로 평가 진행함!

  두 데이터가 절대 섞이면 안 되고 따로 구분함)

- 예시 설명)

   data[:100] = 99번째까지 / data[100:] 100부터

from sklearn.datasets import load_iris
# Iris 데이터셋 불러오기
iris = load_iris()

# Iris 데이터셋에서 특정 범위의 데이터 슬라이싱하기
train_data = iris.data[:100] # 인덱스 0부터 99까지의 데이터 추출
print("학습 데이터:", train_data)
test_data = iris.data[100:] # 인덱스 100부터 끝까지의 데이터 추
print("학습 데이터:", test_data)

 

728x90

■ 02. 튜플 사용법

□ 튜플이란

특징 변경할 수 없는(immutable) 시퀀스(sequence) 자료형 /  여러 개의 요소를 저장하는 컨테이너

        소괄호( )를 사용하여 생성, 각 요소는 쉼표 , 로 구분

리스트와 차이점 한 버 생성된 이후에는 요소 추가, 삭제, 수정 불가 = 데이터를 보호하고 싶을 때 주로 사용

□ 튜플 인덱싱, 슬라이싱

리스트와 공통점 인덱스는 0으로 시작, 음수를 사용해서 뒤에서부터 접근 가능

리스트와 차이점 변경할 수 없기 때문에 요소 추가, 삭제, 수정 불가 - 에러 뜸  = 데이터 불변성 보장, 데이터 무결성 유지

my_tuple = (1,2,3,'hello','world')

print(my_tuple[0])    #출력) 1
print(my_tuple[-1])   #출력) world
print(my_tuple[2:4])  #출력) (3,'hello')   ★[4]전까지 줌

□ 튜플에서 자주 사용하는 메서드

count() 지정된 요소의 개수를 반환  ---> 리스트에서는 len()을 썼었음 주의

index() 지정된 요소의 '처음' 인덱스를 반환 ---> 아래 예시에서 3은 2개지만 첫 번째 3의 위치만 나옴

# 튜플 생성
my_tuple = (1, 2, 3, 4, 1, 2, 3)

# count() 메서드 예제 - 1은 몇 개?
count_of_1 = my_tuple.count(1)
print("Count of 1:", count_of_1) # 출력: 2

# index() 메서드 예제 - 3의 위치?
index_of_3 = my_tuple.index(3)
print("Index of 3:", index_of_3) # 출력: 2

 

□ 튜플과 리스트의 차이점: 불변성 예시 (합치기, 반복은 됨)

합치기나 반복은 됨. 데이터 추가, 수정, 제거 등은 안 됨

tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')

new_tuple = tuple1 + tuple2 # 두 개의 튜플을 합치기
print(new_tuple)

repeated_tuple = tuple1 * 3 # 튜플을 반복하기
print(repeated_tuple)

□ 튜플 → 리스트, 리스트 → 튜플 변경

튜플 → 리스트 : list()

리스트 → 튜플 : tuple()

# 튜플을 리스트로 변경하기
my_tuple = (1, 2, 3, 4, 5)
my_list = list(my_tuple)
print(my_list) # 출력: [1, 2, 3, 4, 5]

# 리스트를 튜플로 변경하기
my_list = [1, 2, 3, 4, 5]
my_tuple = tuple(my_list)
print(my_tuple) # 출력: (1, 2, 3, 4, 5)

□ 예시

데이터 불변성을 보장, 데이터 일관성을 유지해야 하는 경우 (예. 고객 정보)

# 데이터 표현 예시
record = ('John', 30, 'john@example.com')

 

■ 03. 딕셔너리

□ 딕셔너리란?

정의 키-밸류(값) 쌍의 데이터를 저장하는 자료구조

특징 중괄호 { } 로 둘러싸여 있으며 각 요소는 쉼표로 구분

중요 키는 유일해야 하지만 밸류(값)은 중복될 수 있음

□ 딕셔너리 기본기

★ 인덱싱할 때  ['(따옴표로 KEY값 넣어줌)' ]

# 빈 딕셔너리 생성
empty_dict = {}

# 학생 성적표
grades = {
'Alice': 90,
'Bob': 85,
'Charlie': 88
}

# 접근하기
print(grades['Alice']) # 출력: 90

# 값 수정하기
grades['Bob'] = 95

# 요소 추가하기
grades['David'] = 78

# 요소 삭제하기
del grades['Charlie']

 

□ 딕셔너리에서 자주 사용되는 메서드

keys( )         모든 키를 dict_keys 객체로 반환

values( )      모든 값을 dict_values객체로 반환

items( )       모든 키-값 쌍을 (키, 값) 튜플로 구성된 dict_items 객체로 반환

get( )          지정된 키에 대한 값을 반환. 키가 존재하지 않으면 기본값을 반환

pop( )         지정된 키와 해당 값을 딕셔너리에서 제거하고 값을 반환

popitem( )  딕셔너리에서 마지막 키-값 쌍을 제거하고 반환

# 딕셔너리 생성
my_dict = {
    'name': 'John', 
    'age': 30, 
    'city': 'New York'
}

# keys() 메서드 예제
keys = my_dict.keys()
print("Keys:", keys)  # 출력: dict_keys(['name', 'age', 'city'])

# values() 메서드 예제
values = my_dict.values()
print("Values:", values)  # 출력: dict_values(['John', 30, 'New York'])

# items() 메서드 예제
items = my_dict.items()
print("Items:", items)  # 출력: dict_items([('name', 'John'), ('age', 30), ('city', 'New York')])

# get() 메서드 예제
age = my_dict.get('age')
print("Age:", age)  # 출력: 30

# pop() 메서드 예제
city = my_dict.pop('city')
print("City:", city) # 출력: New York
print("Dictionary after pop:", my_dict)  # 출력: {'name': 'John', 'age': 30}

# popitem() 메서드 예제
last_item = my_dict.popitem()
print("Last item popped:", last_item)  # 출력: ('age', 30)
print("Dictionary after popitem:", my_dict)  # 출력: {'name': 'John'}

 

□ 실전 사용 예시: 데이터를 사전처럼 저장하고 싶을 때

사용자 정보 관리 / 제품 카탈로그 / 날짜별 이벤트 관리 / 영화 정보 저장

# --- 사용자 정보 관리
user_info = {
    'username': 'john_doe',
    'email': 'john@example.com',
    'age': 30,
    'is_active': True
}
# --- 제품 카탈로그
products = {
    '1001': {'name': 'Keyboard', 'price': 20.99, 'stock': 50},
    '1002': {'name': 'Mouse', 'price': 15.50, 'stock': 70},
    '1003': {'name': 'Monitor', 'price': 199.99, 'stock': 30}
}
# --- 날짜별 이벤트 관리
events = {
    '2024-04-01': ['Meeting with client', 'Team lunch'],
    '2024-04-02': ['Presentation preparation', 'Project review'],
    '2024-04-03': ['Training session', 'Code debugging']
}
#--- 영화 정보 저장
movies = {
    'Interstellar': {'genre': 'Sci-Fi', 'director': 'Christopher Nolan', 'year': 2014},
    'Inception': {'genre': 'Sci-Fi', 'director': 'Christopher Nolan', 'year': 2010},
    'The Shawshank Redemption': {'genre': 'Drama', 'director': 'Frank Darabont', 'year': 1994}
}

 

■ QUIZ

* 공통

count( ) : 특정 값의 등장 횟수를 세어줌 ---> len ( ) : 전체 요소의 개수

□ 리스트

1. 다음 리스트에서 세 번째 요소를 출력하세요.

my_list = [10, 20, 30, 40, 50]

정답: print(my_list[2])

 

2. 다음 리스트에서 60을 추가하세요.

my_list = [10, 20, 30, 40, 50]

정답: my_list.append(60)

 

3. 다음 리스트의 길이를 출력하세요.

my_list = ['apple', 'banana', 'orange', 'grape']

정답: print(len(my_list))

 

4. 다음 리스트의 마지막 요소를 제거하세요.

my_list = ['car', 'bus', 'bike', 'train']

정답: my_list.pop(-1)

 

5. 다음 리스트를 역순으로 출력하세요.

my_list = ['red', 'green', 'blue', 'yellow']

정답1

new_list = my_list[::-1]

print(new_list)

정답2

my_list.reverse()

print(my_list)

 

□ 튜플

1. 다음 튜플에서 세 번째 요소를 출력하세요.

my_tuple = (10, 20, 30, 40, 50)

정답: print(my_typle([2])

 

2. 다음 튜플의 길이를 출력하세요.

my_tuple = ('apple', 'banana', 'orange', 'grape')

정답: print(len(my_tuple))

 

3. 다음 튜플을 역순으로 출력하세요.

my_tuple = ('red', 'green', 'blue', 'yellow')

정답1

reversed_tuple = my_tuple[::-1]

print(reversed_tuple)

 

정답2

my_tuple_list = list(my_tuple)

reversed_list = my_tuple_list[::-1]

reversed_tuple = tuple(reversed_list)

print(reversed_tuple)

 

정답3

reversed_tuple = tuple(reversed(my_tuple))

print(reversed_tuple)

 

4. 다음 튜플을 리스트로 변환하세요.

my_tuple = (1, 2, 3, 4, 5)

정답 list(my_tuple)

 

5. 다음 튜플과 다른 튜플을 연결해 새로운 튜플을 만드세요.

my_tuple1 = ('a', 'b', 'c')
my_tuple2 = ('d', 'e', 'f')

정답 combined_tuple = my_tuple1 + my_tuple2

□ 딕셔너리

1. 다음 딕셔너리에서 'name'에 해당하는 값을 출력하세요.

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

정답

name_value = my_dict['name']

print(name_value)

 

2. 다음 딕셔너리에서 'gender'를 추가하세요.

my_dict = {'name': 'Bob', 'age': 25, 'city': 'Los Angeles'}

정답

my_dict['gender'] = '값은 아무거나'
print(my_dict)

 

3.다음 딕셔너리의 길이를 출력하세요.

my_dict = {'a': 100, 'b': 200, 'c': 300}

정답

dict_length = len(my_dict)
print(dict_length)

 

4. 다음 딕셔너리에서 'age'를 제거하세요.

my_dict = {'name': 'Charlie', 'age': 35, 'city': 'Chicago'}
정답

del my_dict['age']