[ Python ] 리스트 문법 정리

# 리스트 생성

▶ [] : 공백리스트 생성

list1 = []

▶ [요소 1, 요소 2, 요소 3, ...] : 요소들을 쉼표로 나열하여 생성

list2 = [1, 2, 3]

▶ list() : 공백리스트 생성

  → 다른 시퀀스를 리스트로 변경 가능

list3 = list()
list4 = list(range(3))

 

 

# 리스트 항목 추가

▶ 리스트.append(항목) : 리스트 끝에 항목 추가
▶ 리스트.insert(인덱스, 항목) : 인덱스 위치에 항목을 삽입
▶ 리스트.extend(리스트2) : 리스트 마지막에 리스트2 항목들이 추가
▶ + : 두 리스트를 더하여 하나의 리스트를 생성(새로운 리스트)

★ 주의: 두 피연산자 모두 리스트여야함 ★

 

Ex.

list1 = list(range(3))

list2 = [10, 20, 30, 40]

list1.append(10)
list2.insert(2, 50)
print(list1, list2)

출력 결과 : [0, 1, 2, 10]    [10, 20, 50, 30, 40]

list1.extend(list2)
print(list1) 

출력 결과 : [0, 1, 2, 10, 10, 20, 50, 30, 40]

list3 = list1+ list2
print(list3)

출력 결과 : [0, 1, 2, 10, 10, 20, 50, 30, 40, 10, 20, 50, 30, 40]

 

▶ range(3) : [0, 1, 2]와 동일함

 

▶ list1.append(10) : list1 리스트 끝에 항목 '10'을 추가함

 

▶ list2.insert(2, 50) : 2번 index에 항목 '50'을 삽입함

 

▶ list1.extend(list2) : list1 리스트 마지막에 list2 항목들이 추가됨

 

▶ list3 = list1+ list2 : list1과 list2를 더한 값을 list3이라는 새로운 리스트를 생성해 저장

 

 

# 리스트 항목 수정 ( = index와 대입연산자 사용)

Ex.

alist[0] = 5

▶ 연속된 범위 값 수정 가능

alist = [1, 2, 3, 4, 5, 6, 7, 8]

 

▶ 범위로 지정하면 해당 범위의 항목들이 변경

alist[2, 4] = [10, 20, 30]   

출력 결과 : [1, 2, 10, 20, 30, 5, 6, 7, 8]

→ alist[2,4] : 2번 index부터 3번 index까지의 값을 10, 20, 30으로 변경

 

▶ 해당 인덱스 값의 항목이 수정

    ≫ 여기서는 리스트로 저장

alist[2] = [10, 20, 30]   

출력 결과 : [1, 2, [10, 20, 30], 4, 5, 6, 7, 8]

 

★ index 지정과 범위 지정의 차이 ★ 

 

• index 지정

alist[2] : 항목(요소) 1개

 

• 범위 지정

alist[2:3] : 주어진 범위만큼의 (슬라이싱된, 추출된) 리스트

 

 

Ex.

alist = [1, 2, 3, 4, 5, 6, 7, 8]
alist[2:4] = [10, 20, 30]
print(alist)

출력 결과 : [1, 2, 10, 20, 30, 5, 6, 7, 8]


blist = [1, 2, 3, 4, 5, 6, 7, 8]
blist[2] = [10, 20, 30]
print(blist)

출력 결과 : [1, 2, [10, 20, 30], 4, 5, 6, 7, 8]


print(alist[2])

출력 결과 : 10


print(alist[2:3])

출력 결과 : [10]

 

 

# 리스트 항목 삭제

▶ 리스트.remove(항목) : 리스트에 있는 항목을 찾아 삭제

  → 단, 동일한 것이 있더라도 첫 번째 것만 삭제

  → 삭제할 것이 없으면 에러

▶ del 리스트[인덱스] : 인덱스에 해당하는 항목을 삭제
  → del 리스트[인덱스1:인덱스2] : 두 인덱스(인덱스1 ~ (인덱스2-1)) 사이에 있는 항목들을 삭제
  → 리스트.pop() : 리스트의 맨 마지막 항목을 삭제하면서 항목을 반환
  → 리스트.pop(인덱스) : 해 당 인덱스 위치의 항목을 삭제하면서 항목을 반환
  → 리스트.clear() : 리스트의 모든 항목을 삭제.

 

★ 주의 : del list1 이라고 하면 변수 자체가 소멸 ★

 

alist=["사과", "딸기", "오렌지", "메론", "오렌지"]
print(alist)

출력 결과 : ["사과", "딸기", "오렌지", "메론", "오렌지"]


if "오렌지" in alist:
     alist.remove("오렌지")
print(alist)

출력 결과 : ["사과", "딸기", "메론", "오렌지"]


del alist[1]
print(alist)

출력 결과 : ["사과", "메론", "오렌지"]


blist=["사과", "딸기", "오렌지", "메론", "오렌지"]
blist[1:3]=[]
print(blist)

출력 결과 : ["사과", "메론", "오렌지"]


f = blist.pop() 
print(f, blist)

출력 결과 : 오렌지 ['사과', '메론']


f2 = blist.pop(0)
print(f2, blist)

출력 결과 : 사과 ['메론']


alist.clear()
#del alist[ : ]
#alist[ : ] = [ ]
#alist = [ ]
del alist # 변수 자체를 소멸시켜버려서 에러 뜸
print(alist)

 

▶ alist.remove("오렌지") : alist에 있는 '오렌지' 항목을 제거

  → 오렌지가 여러개일 경우 제일 먼저 나오는 항목 제거

 

▶ del alist[1] : alist의 0번 index 항목을 제거

 

▶ blist[1:3] = [] : blist의 1번부터 2번 index 항목을 제거

  → del blist[1:3]과 동일함

 

▶ blist.pop() : blist의 맨 마지막 항목을 삭제하면서 항목을 반환

 

▶ blist.pop(0) : blist의 0번 index 항목을 삭제하면서 항목을 반환

 

▶ alist.clear() : alist의 모든 항목을 삭제함

  → del alist[ : ]과 동일함

  → alist[ : ] = [ ]과 동일함

  → alist = [ ]과 동일함

 

▶ del alist : 변수 자체를 소멸시켜버리면서 에러 발생

 

 

# 리스트 탐색

▶ 리스트.index(항목) : 항목이 몇 번 index에 있는지 찾아 인덱스 값 반환

  → 동일한 항목이 있더라도 첫 번째 찾은 항목의 인덱스만 반환

  → 해당 항목이 없으면 에러

▶ 리스트.index(항목, start, end) : start ~ (end-1) 까지의 위치에서 해당 항목을 찾아 인덱스 위치 반환

 

alist=["사과", "딸기", "오렌지", "메론", "오렌지", "배"]

if "오렌지" in alist:
     print(alist.index("오렌지"))

출력 결과 : 2


if "오렌지" in alist:
     print(alist.index("오렌지", 3, 5))

출력 결과 : 4

 

▶ alist.index("오렌지") : alist에서 '오렌지' 항목이 몇 번 index에 있는지 찾아 index 값을 반환

 

▶ alist.index("오렌지", 3, 5) : alist에서 '오렌지' 항목을 3번 index부터 4번 index까지의 위치에서 찾아 index 값을 반환

 

 

# 리스트 정렬

▶ 리스트.sort() : 리스트를 정렬

  → 원본 리스트를 변경

  → 오름차순 정렬

▶ 리스트.sort(reverse = True) : 내림차순 정렬

  → 리스트.sort() 후 리스트.reverse()도 가능

▶ 리스트.reverse() : 리스트의 항목 순서를 역순으로 변경

  → 정렬이 아님을 주의

  → 원본 리스트를 변경

▶ sorted(리스트) : 정렬된 새로운 리스트가 필요할 때 사용

  → 내림차순으로 정렬하려면 sorted(리스트, reverse = True)

 

Ex.

list2 = list1.sorted() (X)     list2 = sorted(list1) (O)

 

 

Ex.

alist = ["사과", "딸기", "오렌지", "메론", "오렌지", "배"]
blist = [19, 98, 45, 28, 77, 63]
clist = sorted(alist)
alist.reverse()
print(alist)
print(clist)

출력 결과 : ['배', '오렌지', '메론', '오렌지', '딸기', '사과']   ['딸기', '메론', '배', '사과', '오렌지', '오렌지']


dlist = sorted(blist, reverse = True)
print(blist)
print(dlist)

출력 결과 : [19, 98, 45, 28, 77, 63]   [98, 77, 63, 45, 28, 19]


alist.sort()
blist.sort(reverse = True)
print(alist)
print(blist)

출력 결과 : ['딸기', '메론', '배', '사과', '오렌지', '오렌지']   [98, 77, 63, 45, 28, 19]


alist.reverse()
print(alist)

출력 결과 : ['오렌지', '오렌지', '사과', '배', '메론', '딸기']

 

▶ clist = sorted(alist) : alist를 오름차순으로 정렬해 clist에 저장함

 

▶ alist.reverse() : alist의 항목 순서를 역순으로 변경함

 

▶ dlist = sorted(blist, reverse = True) : blist를 내림차순으로 정렬해 dlist에 저장함

 

▶ alist.sort() : alist를 오름차순으로 정렬함

 

▶ blist.sort(reverse = True) : blist를 내림차순으로 정렬함

 

 

# 리스트 항목 개수 세기

▶ 리스트.count(항목) : 리스트 내에 있는 항목의 개수를 반환

 

# 리스트 복사

▶ 리스트2 = 리스트.copy() : 동일 내용으로 새로운 리스트 생성

  → 리스트2 = 리스트 + [] 과 동일함
  → 리스트2 = 리스트[:] 과 동일함

 

★ 주의 ★

리스트2 = 리스트 

→ 동일 내용으로 새로운 이름을 생성(원본리스트에 새 이름을 추가)

 

 

#  곱 연산

▶ 리스트를 반복 → 문자열 반복할 때와 동일

 

Ex.

alist*3

 

 

Ex.

alist = ["사과", "딸기", "오렌지", "메론", "오렌지", "배"]
blist = [19, 98, 45, 28, 77, 63, 45, 11, 45]
print(alist.count("오렌지"))

출력 결과 : 2


print(blist.count(45))

출력 결과 : 3


print(alist.count("파인애플"))

출력 결과 : 0


clist=alist.copy()
print(clist)

출력 결과 : ['사과', '딸기', '오렌지', '메론', '오렌지', '배']


dlist=alist
print(dlist)

출력 결과 : ['사과', '딸기', '오렌지', '메론', '오렌지', '배']


clist[0] = "바나나"
print(clist)
print(alist)

출력 결과 : ['바나나', '딸기', '오렌지', '메론', '오렌지', '배']    ['사과', '딸기', '오렌지', '메론', '오렌지', '배']


dlist[0] = "아보카도"
print(dlist)
print(alist)


출력 결과 :  ['아보카도', '딸기', '오렌지', '메론', '오렌지', '배']    ['아보카도', '딸기', '오렌지', '메론', '오렌지', '배']


print(alist*3)

출력 결과 : ['아보카도', '딸기', '오렌지', '메론', '오렌지', '배', '아보카도', '딸기', '오렌지', '메론', '오렌지', '배', '아보카도', '딸기', '오렌지', '메론', '오렌지', '배']

 

▶ alist.count("오렌지") : alist 내에 있는 '오렌지' 항목의 개수를 반환함

 

▶ blist.count(45) : blist 내에서 '45'가 몇 번째 항목인지를 알려줌

 

▶ alist.count("파인애플") : alist 내에 '파인애플' 항목이 존재하지 않아 0을 반환함

 

▶ clist=alist.copy() : alist를 복사해 동일한 내용을 clist에 저장

  → clist = alist + []과 동일함
  → clist = alist[ : ]과 동일함

  → dlist = alist : alist를 복사해 동일한 내용을 dlist에 저장

 

▶ clist[0] = "바나나" : clist의 0번 index 항목을 '바나나'로 변경함

  → clist는 alist의 복사본으로 동일한 내용을 가지고 있었지만, clist의 내용을 수정해도 alist까지 반영되지 않음

 

▶ dlist[0] = "아보카도" : dlist의 0번 index 항목을 '아보카도'로 변경함

  → dlist는 alist라는 원본 리스트에 새 이름을 추가한 것으로, dlist의 내용을 수정하면 alist에도 반영됨

 

▶ alist*3 : alist를 3번 반복함

 

 

# 리스트 컴프리헨션 ( comprehension )

▶ alist = [저장항목 반복문] : 중간에 ,(콤마)가 들어가는 것이 아니라 공백이 들어감을 주의

 

Ex.

alist = [random.randint(1,10) for i in range(10)]

→ 10개의 랜덤 값이 추출되어 항목으로 저장되면서 리스트 생성

 

▶ 다음과 동일함

alist = []
for i in range(10):
    alist.append(random.randint(1,10))

 

 

# 리스트 안의 리스트 항목 ( 2차원 리스트 )

Ex.

alist = [[0,1],[1,2],[2,3])

 

 

▶ 5X5 2차원 리스트 만들기(각 항목(요소)들은 0)

mlist= [[0]*5 for i in range(5)]

출력 결과 : [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]