[python] 자료구조

🌱  리스트  메서드

fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']

fruits.count('apple')
>> 2 # 'apple'의 개수를 셈

fruits.index('banana')
>> 3 # 'banana'의 위치를 반환

fruits.reverse() # 원본을 뒤집어 버림
fruits
>> ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']

fruits.append('grape') # 'grape'를 리스트 마지막에 append
fruits
>> ['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']

fruits.sort() # 리스트 원본을 변경
fruits
>> ['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']

fruits.pop() # 리스트의 마지막 위치의 요소를 삭제하고 돌려줌
'pear'

 

🌱  자료구조 (스택 / 큐 / 리스트 컴프리헨션 / 중첩 리스트 컴프리헨션)

 

▶️ 스택

• last - in , first-out 후입선출 방식

stack = [3, 4, 5]

stack.append(6) # 마지막에 추가
stack.append(7) # 마지막에 추가
stack
>> [3, 4, 5, 6, 7]

stack.pop() # 마지막 요소 삭제
>> 7

stack
>> [3, 4, 5, 6]

 

▶️ 큐

• first - in, first - out 선입선출
• 처음으로 넣은 요소를 처음으로 꺼내는 방식이라 시간이 많이 소요되기 때문에 큐 문제에서는 collections.deque 사용함

from collections import deque

queue = deque(["Eric", "John", "Michael"])

queue.append("Terry")           
queue.append("Graham")  

queue.popleft()     # 가장 왼쪽의 요소, 제일 처음들어간 요소를 삭제 후 반환            
>> 'Eric'
queue.popleft()                 
>> 'John'

print(queue)                           
>> deque(['Michael', 'Terry', 'Graham'])

 

▶️ 리스트 컴프리헨션

# for문을 사용하는 방법
squares = []
for x in range(10):
    squares.append(x**2)

# x라는 변수를 만들고 루프가 종료된 후에도 남아있게 만듦
squares = list(map(lambda x: x**2, range(10)))

# 리스트 컴프리헨션
squares = [x**2 for x in range(10)]


# 위의 식 결과 값은 모두 같음

 

▶️ 중첩 리스트 컴프리헨션

# 이중 for문으로 이중리스트
transposed = []
for i in range(4):
    # the following 3 lines implement the nested listcomp
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)
    
# for문으로 이중리스트
transposed = []
for i in range(4):
    transposed.append([row[i] for row in matrix])

# 리스트 컴프리헨션으로 이중리스트
transposed = [[row[i] for row in matrix] for i in range(4)]

transposed
>> [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

# 위의 복잡한 과정보다 내장함수를 사용하면 다음처럼 간단해짐
list(zip(*matrix))
>> [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

 

🌱  del문

• 값 대신에 인덱스를 사용해서 항목을 삭제하는 방법
• 값을 돌려주는 pop()과 다름
• 인덱싱, 슬라이싱, 전체리스트 삭제 모두 가능

# 인덱싱
a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0]
>> [1, 66.25, 333, 333, 1234.5]

#슬라이싱
del a[2:4]
a
>> [1, 66.25, 1234.5]

#슬라이싱을 통한 전체리스트 삭제
del a[:]
a
>> []

 

🌱  튜플과 시퀀스

• 튜플은 값을 변경할 수 없다(immutable) => TypeError 발생

t = 12345, 54321, 'hello!'
t[0]
>> 12345
t
>> (12345, 54321, 'hello!') # 튜플은 괄호로 둘러싸임

# 튜플의 중첩
u = t, (1, 2, 3, 4, 5)
u
>> ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

empty = ()
singleton = 'hello',    # 튜플은 값 뒤에 쉼표!

print(len(empty))
# 0

print(len(singleton))
# 1

print(singleton)
# ('hello',)

 

🌱  집합

a = set('abracadabra')
b = set('alacazam')

a         # 중복 삭제
>> {'a', 'r', 'b', 'c', 'd'}

a - b     # 차집합
{'r', 'd', 'b'}

a | b     # 합집합
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}

a & b     # 교집합 (a, b 공통요소)
{'a', 'c'}

a ^ b     # 대칭차집합(교집합을 뺀 것)
{'r', 'd', 'b', 'm', 'z', 'l'}

 

🌱  딕셔너리

tel = {'jack': 4098, 'sape': 4139}
tel['guido'] = 4127 # 키와 값 추가하기
tel
>> {'jack': 4098, 'sape': 4139, 'guido': 4127}


del tel['sape']
tel
>> {'jack': 4098, 'guido': 4127}

list(tel) # 딕셔너리 tel을 리스트로 변환
>> ['jack', 'guido', 'irv']

sorted(tel) # 리스트 tel 정렬(원본변경x)
>> ['guido', 'irv', 'jack']

 

🌱  루프 테크닉

# 딕셔너리 loop 돌려서 키와 값을 동시에 출력할 때 : items()
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)
    
>> gallahad the pure
>> robin the brave

# 시퀀스를 loop돌려서 위치와 값 동시에 얻음 : enumerate()
for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

>> 0 tic
>> 1 tac
>> 2 toe

# 둘 이상의 시퀀스를 동시에 loop : zip()
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print(f'What is your {q}?  It is {a}.')

>> What is your name?  It is lancelot.
>> What is your quest?  It is the holy grail.
>> What is your favorite color?  It is blue.

# 시퀀스를 거꾸로 loop : reversed() -- 원본변경x
for i in reversed(range(1, 10, 2)):
    print(i)

>> 9
>> 7
>> 5
>> 3
>> 1

# 정렬된 순서로 시퀀스 loop : sorted() -- 원본변경x
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for i in sorted(basket):
    print(i)

>> apple
>> apple
>> banana
>> orange
>> orange
>> pear

# 시퀀스 중복요소 제거와 정렬
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
    print(f)

>> apple
>> banana
>> orange
>> pear

 

🌱  조건 더보기

# 비교 연산자는 모두 같은 우선 순위를 가진다
# a 가 b 보다 작고, 동시에 b 가 c 같다

a < b == c # 이렇게 사용하는게 파이써닉 하지않을까!

a < b and b == c

 

🌱  시퀀스와 다른 형들을 비교하기

# 시퀀스의 형이 다르지만 비교될 때 사전식 순서를 따르는데 (첫 두 항목, 다음 두 항목 비교 ~)
(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]

# 비교되는 두 항목이 같은 형의 시퀀스라면, 사전식 비교가 재귀적으로 수행 
# 재귀(recursion): 어떠한 것을 정의할 때 자기 자신을 참조하는 것
'ABC' < 'C' < 'Pascal' < 'Python'

# 3과 4를 비교했을 때 4가 더 크다
(1, 2, 3, 4)           < (1, 2, 4)

# 서로 다른 숫자 형들은 그들의 숫자 값에 따라 비교
(1, 2, 3)             == (1.0, 2.0, 3.0)

# 한 시퀀스가 다른 하나의 머리 부분 서브 시퀀스면, 짧은 시퀀스가 작은 것
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)
(1, 2)                 < (1, 2, -1)