[Python 중급] Python 시퀀스

🔊 해당 포스팅은 인프런의 파이썬 중급 강의를 공부하면서 복습차원으로 정리한 포스팅입니다. 해당 내용은 주로 본인의 복습용이라서 자세한 설명은 없는 점 양해 부탁드리겠습니다. 원본 코드는 여기에 있습니다.

 

Python

 

이번 포스팅은 파이썬의 시퀀스 자료구조에 대해서 알아보고 이에 대해 실습도 해보자. 우선 파이썬 데이터 타엡에 대해 세부적으로 분류해보자.

 

• 1번째 기준 : 자료 구성 형태
  • 컨테이너 - 서로 다른 자료형 구성 가능 : 리스트, 튜플, collections의 deque
  • 플랫형(Flat) - 한 개의 자료형으로 구성 : 문자열(str), bytes, bytes array, array, memoryview
• 2번째 기준 : 자료 구조의 변경 가능 여부
  • 가변형 자료구조 : 리스트, bytes array, array, memoryview, deque
  • 불변형 자료구조 : 튜플, 문자열(str), bytes

 

# ord(string)은 문자열의 유니코드 번호를 반환해줌
# 1.일반 list append
chars = '!@$##%$^%$^&'
code_lst1 = []
for c in chars:
    code_lst1.append(ord(c))
print("일반 list append: ", code_lst1)
# List comprehension => 데이터 양이 커지면서 이런 방법이 더 속도가 우세하다고 함!
code_lst2 = [ord(c) for c in chars]
print("list comprehension: ", code_lst2)
print('-'*50)

 

• list comprehension 이 일반 for 문을 사용한 것보다 데이터가 많아질수록 속도가 더 우세

다음은 iterator 객체를 만드는 map, filter 함수를 알아보자.

 

# Map, Filter는 iterator를 만듦!
# filter 함수는 filter(함수, iterable한 객체) => iterator가 결과기 때문에 next()를 이용해 출력 가능
filter_ = filter(lambda x: x > 40, [ord(c) for c in chars])
print("filter에 list감싸준 후 :", list(filter_))
# list로 감싸서 list형태로 만들어주자

# map 함수
map_ = map(ord, chars)
print([ord(c) for c in chars])
print('첫번째 요소:', next(map_))
print('두번째 요소:', next(map_))
print('세번째 요소:', next(map_))

# list comprehension VS Map + Filter
code_lst3 = [ord(c) for c in chars if ord(c) > 40]
code_lst4 = list(filter(lambda x: x > 40, map(ord, chars)))
print("list comprehension: ", code_lst3)
print("Map + Filiter: ", code_lst4)
print('-'*50)

 

• filter(함수, iterative한 객체) 를 인자로 넣어주며 해당 함수 조건을 만족하는 데이터들을 반환하려면 next() 메소드로 하나씩 반환하거나 list()로 감싸주어 list 객체로 반환하는 방법이 있음
• map(함수, iterative한 객체) 를 인자로 넣어주며 list로 감싸주어 데이터가 담긴 것들을 출력할 수 있고 next() 메소드로 하나씩 출력 가능

다음은 Generator를 생성해보자. 제네레이터는 iterator와 같이 메모리를 절약하기 위해 데이터를 생성할 준비만 맞춰놓은 상태라고 할 수 있다. 즉, list comprehension 처럼 한 번에 데이터를 메모리에 올리는 것이 아니라 next() 메소드를 활용해 하나씩만 메모리에 올려놓도록 하여 메모리를 절약할 수 있음

 

# Generator 생성 -> 메모리를 절약하기 위해 데이터를 생성하기 직전 생성할 준비만 맞춰놓은 상태라고 할 수 있음!
# 한개의 자료구조를 갖으면서 가변적인 array 자료구조 사용해보기
# Generator는 list comprehension 표현식에서 대괄호[] -> 소괄호()로 바꿔!

tuple_g = (ord(c) for c in chars)
print(tuple_g, type(tuple_g))
print([ord(c) for c in chars])  # list comprehension은 데이터를 모두 메모리에 올려버림..!
print(next(tuple_g))
print(next(tuple_g))

# Generaotr 이용해 4개의 반과 각 20개의 번호를 갖는 자료구조 생성
students_g = (f"{room}반 {num}번" for room in 'A B C D'.split() for num in range(1, 21))
print(students_g)
for student in students_g:
    print(student)

 

다음은 Tuple을 unpacking 하는 방법이다.

 

# b, a = a, b -> 이것도 일종의 unpacking임!
# *(aster)를 이용해 unpacking 가능
print(divmod(100, 21))  # 몫과 나머지 출력
print(divmod(*(100, 21)))  # tuple (100, 21)을 unpack
print(*(divmod(100, 21)))  # divmod결과값을 unpack
print()

x, y, *rest = range(10)
print(x, y, rest)
x, y, *rest= range(2)  # 부족해도 빈 리스트로 반환
print(x, y, rest)
x, y, *rest = 1, 2, 3, 4, 5
print(x, y, rest)
print()
print()

 

다음은 sorted 와 sort 메소드를 비교해보자. 가장 큰 차이점은 정렬후 새로운 객체를 반환시키느냐 기존의 객체를 정렬시키고 새로운 객체를 반환시키지 않느냐의 차이이다. optional로 들어가는 정렬 인자는 동일하다.

 

# sorted VS sort : 공통인자로 reverse, key=len/str.lower/함수.. 가
# 1. sorted : 정렬 후 새로운 객체를 반환
v_list = ['bus', 'train', 'airplane', 'underground', 'car']
h_list = ['버스', '기차', '비행기', '지하철', '자동차']
print('sorted: ', sorted(v_list)) # 디폴트는 알파벳은 오름차순으로
print('sorted: ', sorted(h_list)) # 디폴트는 한글도 오름차순으로
print('sorted1: ', sorted(v_list, reverse=True))
print('sorted1: ', sorted(h_list, reverse=True))
print('sorted2: ', sorted(v_list, key=len))
print('sorted2: ', sorted(h_list, key=len))
print('sorted3: ', sorted(v_list, key=lambda x: x[-1],
                          reverse=True)) # 문자열 마지막 글자 기준으로 정렬
print('sorted3: ', sorted(h_list, key=lambda x: x[-1],
                          reverse=True))
print()

# 2. sort : 정렬한 후 기존 객체를 변경시킴(새로운 메모리 주소 부여하지 않고 기존 것 사용)
print('sort1: ', v_list.sort(), v_list) # sort() 기존의 것을 변경하기 때문에 None을 출력함
print('sort2: ', v_list.sort(reverse=True), v_list)
print('sort3: ', v_list.sort(key=len), v_list)
print('sort4: ', v_list.sort(key=lambda x: x[-1]), v_list)

 

다음은 Hash table에 대한 내용이다. 파이썬에서는 Dictionary 라는 자료구조로 인해 편리하게 Hash table를 구현할 수 있다. 여기서 Hash 값이란, 데이터의 unique한 key값을 의미하며 hash() 메소드를 활용해 출력할 수 있다. 하지만 자료구조의 가변성 여부에 따라 hash() 값이 추출이 될 수 있고 없을 수 있다. 예를 들어 불변 구조인 튜플은 hash 값을 뽑아낼 수 있지만 가변 구조인 리스트는 뽑아낼 수 없다.

 

# Hash 값(unique한 값) 뽑아내기 -> hash() 메소드 사용!
t1 = (10, 20, (30, 40, 50)) # tuple is immutable
t2 = (10, 20, [30, 40, 50]) # list is mutable
print('t1의 hash: ', hash(t1))
# print('t2의 hash: ', hash(t2)) -> list는 mutable해서 언제든 변경될 수 있기 때문에 해당 데이터가 고유의 값을 갖지 못하기 때문에 에러발생

 

다음은 중복된 key를 갖는 데이터에서 튜플로 주어졌을 때 어떻게 편리하게 Dictionary로 바꿀 수 있는지 살펴보자. 물론 일반적인 for문을 통해 변환이 가능하지만 setdefault 메소드를 활용하면 더 간단한 코드로 변환이 가능하다. 참고로 튜플에 중복된 값이 존재할 때,Dict comprehension을 이용하는 방법은 부적절하다. 왜냐하면 Dict comprehension은 중복된 key의 마지막 값들만 처리하기 때문이다.

 

# Dict의 setdefault 예제 for tuple to dictionary
source = (('k1', 'value1'),
        ('k1', 'value2'),
        ('k2', 'value3'),
        ('k2', 'value4'),
        ('k2', 'value5'))
new_dict1 = {}
new_dict2 = {}

# setdefault를 사용하지 않고 일반적인 방법을 이용해 Dictionary로 전환!
for k, v in source:
    if k in new_dict1:
        new_dict1[k].append(v)
    else:
        new_dict1[k] = [v]
print("일반적인 방법 이용:", new_dict1)

# setdefault를 이용해 자동적으로 중복되는 key값 잘 처리해주기
for k, v in source:
    new_dict2.setdefault(k, []).append(v)
print("setdefault 방법 이용:", new_dict2)

# Dictionary comprehension을 이용하게 되면 중복되는 값들 중 마지막 값들만 처리됨
new_dict3 = {k: v for k, v in source}
print("Dict comprehension 이용:", new_dict3)

 

 

결과 화면

 

다음은 딕셔너리는 기본적으로 mutable한 구조이지만 immutable 한 자료구조로 변경하는 방법을 소개한다. MappingProxyType 라이브러리를 이용해서 변환할 수 있다.

 

# 원래 Dict는 mutable 하지만 Immutable한 Dict로 만들 수 있음!
# 라이브러리 이용
from types import MappingProxyType

d = {'key1': 'value1'}
d_frozen = MappingProxyType(d)
print("d와 d_frozen의 형태는 동일한가?", d == d_frozen)
print("d와 d_frozen의 메모리 주는 동일한가?", d is d_frozen)
print()

# 일반 dict 수정하기
d['key2'] = 'value2'
print("수정 후 d :", d)

# Immutable dict 수정해보기
# d_frozen['key1'] = 'value2' => error 발생

 

마지막으로 집합형 자료구조인 set을 선언하는 방법과 set comprehension에 대해 알아보자.

 

# Set 선언하기
s1 = {'apple', 'banana', 'kiwi', 'apple', 'banana'}
s2 = set(['apple', 'banana', 'kiwi', 'apple', 'banana'])
s3 = {'orange'}
s4 = set() # {}로 선언하면 set이 아닌 empty dict로 정의됨!
# set에 데이터 첨가
s1.add('orange')
s2.add('watermelon')
s2.update(['pear', 'grapes']) # 여러개 첨가할땐 update!
s2.remove('kiwi') # 삭제할땐 삭제할 데이터 인자로 넣기
print(s1)
print(s2)
print(s3)
print(s4)

# Comprehension set => list comprehension과 비슷
result = {i for i in range(10)}
print(result, type(result))
print()

 

번외로, 파이썬은 bytes 코드를 읽고 내부적으로 파이썬 인터프리터를 수행해서 코드를 run하는데, 이 내부적으로 돌아가는 과정을 몇 단계로 거쳐지는지 라이브러리를 이용해 관찰할 수 있다. 그럼으로써 자료구조를 선언할 때 최적화할 수 있게 된다. 간단하게 원소가 하나인 set 집합 자료구조를 2가지 방법으로 선언했을 때, 선언되는 내부적인 구조를 살펴보자.

 

# 자료구조 선언시 최적화 하기
# 어떤 방법이 최적화 방법인지 알기 위한 dis 라이브러리 정의
from dis import dis
# dis 메소드안에 문자열 처럼 따옴표 안에 코드를 넣어주기!
print('-'*40)
print("선언 방법: 1", dis('{10}'))
print('-'*40)
print("선언 방법: 2", dis('set([10])'))

 

결과 화면

 

위 결과화면을 보면 단순히 {}를 이용해 선언하는 것보다 set() 메소드를 사용해서 선언하는 것이 내부적으로 더 많은 단계를 거침을 알 수 있다. 따라서 2가지 방법 중 첫 번째 방법이 좀 더 최적의 방법이라고 할 수 있다.