4. 파이썬 컬렉션 타입 - 리스트

1. 컬렉션 타입

여러 개의 데이터 항목을 하나의 단위로 관리할 수 있게 해주는 데이터 구조를 의미합니다. 이것은 여러 개의 데이터를 하나의 변수에 저장하고, 관리할 수 있게 해줍니다. 파이썬에서는 리스트, 튜플, 세트, 딕셔너리 등이 기본적인 컬렉션 타입에 속합니다.

 

 

2. 리스트

여러 값들을 하나의 변수에 저장하고 관리할 수 있게 해주는 순차적인 자료구조입니다.

(여러개의 저장공간이 나열되어 있는 것)

 

리스트의 사용 목적

1. 여러 번 선언하지 않고, 한번만 선언하기 위해 사용

2. 규칙성이 없는 값에 규칙성을 부여하기 위해 사용 (순서가 필요하면 리스트에 담는다.)

 

 

 

 

1. 생성

리스트는 대괄호 [ ]를 사용하여 생성하며, 내부에 포함된 각 항목들은 쉼표로 구분됩니다.

list 선언
       list명 = [값, 값2, ...]                   # 어떤 값을 넣을 지 알 때
       list명 = [값] * 칸수                       # 값은 모르지만, 칸 수는 알 때
       list명 = []                              # 어떤 값인지도 모르고, 칸 수도 모를때
       list명 = list(range(start, end, step))

 

 

li1 =[1, 3, 5, 7, 9]
print(li1)
print(type(li1))

[1, 3, 5, 7, 9]

<class 'list'>

 

li2 = list([1, 3, 5, 7, 9])
print(li2)
print(type(li2))

[1, 3, 5, 7, 9]

<class 'list'>

 

li3 = ['푸바오', '아이바오', '러바오']
print(li3)

['푸바오', '아이바오', '러바오']

 

li4 = [1, 50.5, '푸바오', True]
print(li4)

print('=====리스트 안에 있는 개체들 타입 알기======')
print(type(li4[0]))
print(type(li4[1]))
print(type(li4[2]))
print(type(li4[3]))

[1, 50.5, '푸바오', True]

=====리스트 안에 있는 개체들 타입 알기======

<class 'int'>

<class 'float'>

<class 'str'>

<class 'bool'>

 

li1 = [1, 3, 5, 7, 9]
print(li1)
print(li1[0])
print(li1[-1])
print(li1[0] + li1[-1])

[1, 3, 5, 7, 9]

1

9

10

 

2. 인덱싱

리스트의 각 항목은 위치(인덱스)를 가지고 있으며, 인덱스를 사용하여 접근할 수 있습니다. 인덱스는 0부터 시작합니다.

li2 = [1, 2, '파이썬', ['푸바오', '아이바오']] # 리스트 안에 리스트 : 2차원
print(li2)

print("======인덱싱=======")
print(li2[0])
print(li2[3])
print(li2[3][0])

[1, 2, '파이썬', ['푸바오', '아이바오']]

======인덱싱=======

1

['푸바오', '아이바오']

푸바오

 

li3 = ['푸바오', '아이바오', '러바오', ['🐼','🍎','⚽️','☕️']]
print(li3)
print(li3[-1])
print(li3[-1][2])

['푸바오', '아이바오', '러바오', ['🐼', '🍎', '⚽️', '☕️']]

['🐼', '🍎', '⚽️', '☕️']

⚽️

 

li4 = [1,2,3,['푸바오', '아이바오', '러바오', ['🐼','🍎','⚽️','☕️']]]
print(li4)
print("=======인덱싱=====")
print(li4[2])
print(li4[-2])
print(li4[-1][-2])
print(li4[-1][-1][-1])

[1, 2, 3, ['푸바오', '아이바오', '러바오', ['🐼', '🍎', '⚽️', '☕️']]]

=======인덱싱=====

3

3 러바오

☕️

 

3. 슬라이싱

리스트의 일부분만을 추출할 수 있습니다.

li1 = [10, 20, 30, 40 ,50]
print(li1)
print(li1[0:3]) # 인덱스 [0]부터 [2]까지 출력

[10, 20, 30, 40, 50]

[10, 20, 30]

 

 

인덱싱과 슬라이싱 주의점

1. 인덱싱하면 차원 하나 벗겨짐
2. 슬라이싱하면 차원 유지

 

 

4. 변경 가능

리스트의 항목들은 변경할 수 있습니다. 즉, 리스트의 항목들을 수정, 추가, 삭제할 수 있습니다.

li2 = li1
print(li2)
li2[0] = 100 # [0]의 요소를 100으로 변경
print(li1)
print(li2)

[10, 20, 30, 40, 50]

[100, 20, 30, 40, 50]

[100, 20, 30, 40, 50]

 

li3 = [10, 20, 30,['푸바오', '아이바오', '러바오'], 40, ['🐼','🍎','⚽️','☕️']]
print(li3[2:6])

print(li3[5][:1])

[30, ['푸바오', '아이바오', '러바오'], 40, ['🐼', '🍎', '⚽️', '☕️']]

['🐼']

 

 

# 슬라이싱을 이용하여 리스트 데이터를 추가한 경우 리스트에 데이터만 포함

# 차원 유지

# 슬라이싱을 이용하여 리스트 데이터를 추가한 경우 리스트에 데이터만 포함
li4 = [10, 20, 30, 40, 50]
li4[1:2] = ['★','●','▲']
print(li4)
#차원 유지

[10, '★', '●', '▲', 30, 40, 50]

 

 

# 인덱싱을 이용하여 리스트 데이터를 추가한 경우 리스트에 데이터만 포함

# 차원 증가

# 인덱싱을 이용하여 리스트 데이터를 추가한 경우 리스트 안에 리스트를 포함
li4 = [10, 20, 30, 40, 50]
li4[1] = ['★','●','▲']
print(li4)
#차원 증가

[10, ['★', '●', '▲'], 30, 40, 50]

 

li5 = [10, 20, 30, 40, 50]
print(li5[1:3])
li5[1:3] = [] # 빈 리스트를 저장하면 요소가 삭제됨
print(li5)
del li5[2] # 변수 지우기 del
print(li5)

[20, 30]

[10, 40, 50]

[10, 40]

 

 

5. 연산

리스트 간의 + 연산으로 리스트를 결합할 수 있고, * 연산으로 리스트를 반복할 수 있습니다.

# 리스트 병합

#리스트 병합
li6 = [10, 20, 30]
li7 = [40, 50, 60]
print(li6 + li7)
print(li6[2] + li7[1])

[10, 20, 30, 40, 50, 60]

80

 

li6 = [10, 20, 30]

# inplace 연산
# li6 = li6 + [100,200] # li6 += [40, 50]
li6 += [500,600]
print(li6)

[10, 20, 30, 500, 600]

 

li6 = [10, 20, 30]
print(li6 * 3)
print(li6[0] + li6[2])

li6[1] = '푸바오'
print(li6)
#print(li6[0] + li6[1]) # 같은 타입이 아니면 연산이 안됨 
#TypeError: unsupported operand type(s) for +: 'int' and 'str'

[10, 20, 30, 10, 20, 30, 10, 20, 30]

40

[10, '푸바오', 30]

 

 

 

6. 함수와 메서드

리스트를 다루기 위한 여러 함수와 메소드들이 있습니다.

# len(): 객체의 길이(항목의 개수)를 반한하는 내장 함수

# len(): 객체의 길이(항목의 개수)를 반한하는 내장 함수
print(len(li6))

3

 

# append(): 리스트에 사용되며, 리스트의 끝에 새로운 항목을 하나만 추가하는 메서드

# append(): 리스트에 사용되며, 리스트의 끝에 새로운 항목을 하나만 추가하는 메서드
li6= [10, 20, 30]
print(li6)

li6.append(40)
print(li6)
li6.append([200,300])
print(li6)

[10, 20, 30]

[10, 20, 30, 40]

[10, 20, 30, 40, [200, 300]]

 

# extend(): 리스트에 iterable(반복 가능한 객체 : 순서를 부여받는 객체)의 모든 항목을 추가하는 메서드

# extend(): 리스트에 iterable(반복 가능한 객체 : 순서를 부여받는 객체)의 모든 항목을 추가하는 메서드
li6 = [10, 20 ,30]
print(li6)
li6.extend([50])
print(li6)
li6.extend([1000,2000]) # 여러 개 추가
print(li6)

[10, 20, 30]

[10, 20, 30, 50]

[10, 20, 30, 50, 1000, 2000]

 

# pop(): 리스트에서 항목을 삭제하고, 삭제된 항목을 반환하는 메서드

# pop(): 리스트에서 항목을 삭제하고, 삭제된 항목을 반환하는 메서드
li6 = [10, 20, 30]
print(li6)
print(li6.pop()) #인플레이스 연산
print(li6)

[10, 20, 30]

30

[10, 20]

 

li6 = [10, 20, 30]
result = li6.pop()
print(result)

30

 

# insert(): 리스트의 특정 인덱스에 항목을 추가하는 메서드

# insert(): 리스트의 특정 인덱스에 항목을 추가하는 메서드
li6 = [10, 20, 30]
li6.insert(1, 100) # 인덱스 1에 100추가 원래 인덱스1에 있던 요소는 2로 밀림
print(li6)

[10, 100, 20, 30]

li6.insert(1,[1000,2000])
print(li6)

[10, [1000, 2000], 100, 20, 30]

 

# index(): 리스트에서 특정 값의 인덱스를 반환하는 메서드. 특정 값의 인덱스가 없다면 에러발생

# index(): 리스트에서 특정 값의 인덱스를 반환하는 메서드. 특정 값의 인덱스가 없다면 에러발생
li6 = [10, 20, 30]
print(li6.index(20))  # 괄호요소의 인덱스 위치를 알려줌
#print(li6.index(40)) #없는 값은 에러 ValueError : 40 is not i list

1

 

# reverse(): 리스트의 항목들의 순서를 뒤집는 메서드

# reverse(): 리스트의 항목들의 순서를 뒤집는 메서드
li7 = [10, 13, 20, 30, 5]
li7.reverse()
print(li7)

[5, 30, 20, 13, 10]

li7 = ['푸바오', '아이바오', '러바오', '루이바오', '후이바오']
li7.reverse()
print(li7)

['후이바오', '루이바오', '러바오', '아이바오', '푸바오']

 

- 값 삭제
            list명.remove(값)             # 중복 시 먼저 나온 값(낮은 인덱스 값)이 삭제

            del(list명[인덱스])            # 인덱스로 삭제
            del list명[인덱스]

            list명.clear()               # 모든 값 삭제

※ 슬라이싱을 사용하여 리스트의 순서를 뒤집는 방법

슬라이싱(slicing)은 파이썬에서 시퀀스 타입의 객체(예: 리스트, 문자열, 튜플 등)의 일부를 추출하는 방법입니다. 슬라이싱의 기본 구조는 [start:stop:step]입니다.

 

1. start: 슬라이스의 시작 인덱스입니다. 이 인덱스의 요소는 슬라이스에 포함됩니다. start를 생략하면, step이 양수이면 0, step이 음수이면 -1로 간주됩니다.

 

2. stop: 슬라이스의 끝 인덱스입니다. 이 인덱스의 요소는 슬라이스에 포함되지 않습니다. stop을 생략하면, step이 양수이면 시퀀스의 끝, step이 음수이면 시퀀스의 시작으로 간주됩니다.

 

3. step: 슬라이스의 스텝(증감) 값입니다. step을 생략하면 1로 간주됩니다.

li8 = ['푸바오', '아이바오', '러바오', '루이바오', '후이바오']
print(li8[::]) # 데이터 그대로 출력
print(li8[::-1]) # start와 stop을 생략하고 step을 -1로 설정한 슬라이싱

#[start : stop : step]
# start를 생략하면 -1로 간주. 즉, 시퀀스의 마지막 요소부터 시작
# stop을 생략하면 0으로 간주. 즉, 시퀀스의 시작까지 진행
# step이 -1이므로, 시퀀스의 요소를 뒤에서부터 앞으로 하나씩 건너뛰어서 슬라이싱

['푸바오', '아이바오', '러바오', '루이바오', '후이바오']

['후이바오', '루이바오', '러바오', '아이바오', '푸바오']

 

# sort(): 리스트의 항목들을 정렬하는 메서드.

# inplace 연산을 수행 변수에 담지 않아도 오름차순으로 저장이 됨

# sort(): 리스트의 항목들을 정렬하는 메서드. inplace 연산을 수행
li7 = [10, 13, 20, 30, 5]
li7.sort() # 오름차순
print(li7) # inplace연산이므로 재저장 오름차순대로 저장이됨

[5, 10, 13, 20, 30]

 

# sort(reverse=True) #내림차순

#sort(reverse=True) #내림차순
li7 = [10, 13, 20, 30, 5]
li7.sort(reverse=True)
print(li7)

[30, 20, 13, 10, 5]

 

li2 = ['Apple', 'apple', 'orange', 'banana', 'melon']
li2.sort() #아스키코드에 따라 오름차순
print(li2)

['Apple', 'apple', 'banana', 'melon', 'orange']

li8 = ['푸바오', '아이바오', '러바오', '루이바오', '후이바오']
li8.sort() #유니코드에 따라 오름차순
print(li8)

['러바오', '루이바오', '아이바오', '푸바오', '후이바오']

 

# sorted():  iterable(반복 가능한 객체)의 모든 항목들을 정렬한 후, 그 결과를 새로운 리스트에 담아 반환하는 함수

# inplace연산이 아니기 때문에 변화된 모습으로 남지않음, 따라서 변환값을 변수에 담아야함

# ✔ 비교
# sorted():  iterable(반복 가능한 객체)의 모든 항목들을 정렬한 후, 그 결과를 새로운 리스트에 담아 반환하는 함수
li10 = [ 10, 40, 30, 100, 90, 50]
print(sorted(li10)) #오름차순
print(sorted(li10, reverse=True)) #거꾸로
print(li10) #inplace연산이 아니기 때문에 변화된 모습으로 남지않음, 따라서 변환값을 변수에 담아야함

li10 = sorted(li10) # 반환값 변수에 담음
print(li10)

[10, 30, 40, 50, 90, 100]

[100, 90, 50, 40, 30, 10]

[10, 40, 30, 100, 90, 50]

[10, 30, 40, 50, 90, 100]

 

# count(): 리스트에서 특정 값의 개수를 반환하는 메서드

# count(): 리스트에서 특정 값의 개수를 반환하는 메서드
li11 = [10, 20, 30, 50, 20, 40, 30, 20]
print(li11.count(20)) #데이터 안에 똑같은 데이터가 몇개가 있는지 개수를 세줌
print(li11.count(16))

3

0