[python 심화] 6. 자료형 (지능형 리스트, 제너레이터, 가변불변, 정렬)

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

 

<이전 글>

https://silvercoding.tistory.com/22

[python 심화] 5. Special Method (Magic Method)

 

 

• 컨테이너 (Container) : 서로 다른 자료형 포함 가능 

list, tuple, collections.deuqe  (ex) list --->[1, 3.0, 'hi']

• Flat : 한개의 자료형만을 포함 

str, bytes, bytearray, array.array, memoryview 

• 가변 

list, bytearray, array.array, memoryview, deque

• 불변 

tuple, str, bytes 

 

 

나름 파이썬을 배우는 전공자이지만 심화과정 강의를 들으며 아직 모르는 게 정말 많은 것 같다는 생각이 든다. 

위의 자료형들만 봐도! 

 

이번 포스팅에서는 지능형 리스트, 제너레이터, 튜플, 딕셔너리의 내용을 깊게 들어간다. 

 

 

- 지능형 리스트 (Comprehending Lists) 

*** None comprehending LIsts 

chars = '!@#$%^&*()_+'
codes1 = []

for s in chars:
    # 유니코드 변환
    codes1.append(ord(s))

 

지능형 리스트를 사용하지 않고 일반적으로 for문을 이용하여 리스트 안에 값을 넣어주는 예시이다. 

 

*** Comprehending Lists 

엄청 큰 영향을 끼치게 되는 것은 아니지만, 빅데이터 분야와 같이 데이터가 현저하게 많아지면 이 방법을 쓰는 것이 성능, 속도 면에서 더 유리하다고 한다. 

codes2 = [ord(s) for i in chasrs]

리스트 안에서 바로 for문을 사용하는 것이다. 

 

 

*** Comprehending LIst + Map, Filter

이 방법 역시 속도가 약간 우세함 . 

codes3 = [ord(s) for s in chars if ord(s) > 40]
codes4 = list(filter(lambda x : x > 40, map(ord, chars)))

결과적으로 codes3와 codes4 리스트 안의 값들을 같다. codes3는 for문과 if문을 사용 , codes4는 map함수로 chars의 값들에 ord함수를 적용 시킨 후 , lambda, filter를 사용하여 40보다 큰 값들만 나오게 만들어준다.

 

 

*** 출력해보기

print('EX1-1 - ', codes1)
print('EX1-2 - ', codes2)
print('EX1-3 - ', codes3)
print('EX1-4 - ', codes4)
print('EX1-5 - ', [chr(s) for s in codes1])
print('EX1-6 - ', [chr(s) for s in codes2])
print('EX1-7 - ', [chr(s) for s in codes3])
print('EX1-8 - ', [chr(s) for s in codes4])

EX1-5부터는 ord와 반대로 chr()를 이용하여 다시 바꾸어서 리스트에 넣어 주는 코드이다. 

 

 

 

*** 리스트 주의할 점 

marks1 = [['~'] * 3 for n in range(3)]
marks2 = [['~'] * 3] * 3

print("EX4-1 - ", marks1)
print("EX4-2 - ", marks2)

이 두가지를 출력하면 

결과는 같다. 

 

--> 값 하나 변경 

marks1[0][1] = 'X'
marks2[0][1] = 'X'

print('EX4-3 - ', marks1)
print('EX4-3 - ', marks2)

분명 형태는 같았는데, 0번째 리스트의 1번째 값을 변경하는 코드를 작성했지만, 두번째는 0, 1, 2번째의 1번쨰 값이 모두 바뀌었다. 

 

---> 증명 

print('EX4-5 - ', [id(i) for i in marks1])
print('EX4-6 - ', [id(i) for i in marks2])

위와 같이 marks1의 리스트 들은 모두 다른 객체이므로 id값이 다르지만, marks2의 리스트들은 같은 리스트를 3번 반복해 놓은 것과 같기 때문에 id값이 모두 같다. 같은 곳을 바라보고 있기 때문에 0번쨰 리스트의 값만 바꾸면 1, 2번째 리스트의 값도 함께 바뀌는 것이다. 

 

데이터 분석을 할 때 이런 실수를 한다고 생각하면 끔찍하다!

 

 

 

- 제너레이터 , Generator & Array 

(1) 제너레이터

제너레이터는 한 번에 한 개의 항목을 생성하므로 메모리를 유지하지 않는다. 메모리를 차지하지 않기 때문에 빅데이터를 쓸 때는 Generator가 훨씬 우세하다고 한다. 

tuple_g = (ord(s) for s in chars)  # 아직 메모리를 생성한 상태가 아님

 

이처럼 튜플 안에 for문을 써주면 제너레이터 객체가 생성된다. 아직 메모리를 생성한 상태가 아니라는 것! 

 

(2) Array 

import array 
array_g = array.array('I', (ord(s) for s in chars))

 

array를 import해준다. 처음 써보아서 문서를 찾아서 읽어보았다. 

<array.array 참고 문서>

https://docs.python.org/3/library/array.html

array — Efficient arrays of numeric values — Python 3.9.6 documentation

 

*** 출력, 사용해보기 

print('EX2-1 - ', tuple_g)  
print('EX2-2 - ', next(tuple_g))
print('EX2-3 - ', next(tuple_g))
print('EX3-4 - ', array_g)
print('EX3-4 - ', array_g.tolist())

제너레이터는 next 또는 for문을 이용하여 값을 꺼낼 수 있다. 

array를 리스트로 변환하고 싶다면 tolist()를 사용한다. 

 

 

*** 제너레이터 for문으로 사용하기 

print('EX3-1 - ', ('%s' % c + str(n) for c in ['A', 'B', 'C', 'D'] for n in range(1, 11)))

for s in ('%s' % c + str(n) for c in ['A', 'B', 'C', 'D'] for n in range(1, 11)):
    print('EX3-2 - ', s)

for문으로 제너레이터 객체에서 값들을 하나씩 꺼내주는 코드  . 

 

 

 

- Tuple Advanced

*** packing & unpacking

print('EX5-1 - ', divmod(100, 9))
print('EX5-2 - ', divmod(*(100, 9)))
print('EX5-3 - ', *(divmod(100, 9)))

divmod는 몫과 나머지를 튜플로 반환해주는 함수이다. 튜플 앞에 *을 붙이면 unpaking이 된다는 것 !

 

x, y, *rest = range(10)
print('EX5-4 - ', x, y, rest)
x, y, *rest = range(2)
print('EX5-5 - ', x, y, rest)
x, y, *rest = 1, 2, 3, 4, 5
print('EX5-6 - ', x, y, rest)

 

참고) ** ---> dictionary 를 받음 

(ex) def test(*args, **args):

 

 

- Mutable (가변) vs Immutable (불변) 

l = (10, 15, 20)
m = [10, 15, 20]

print('EX6-1 - ', l, m, id(l), id(m))

리스트와 튜플 객체를 각각 생성해준다. 

# 객체를 새로 생성 ---> 메모리를 더 잡아먹을 수도 있다는 것 
l = l * 2
m = m * 2 

print('EX6-2 - ', l, m, id(l), id(m))

# 자체에서 연산 
l *= 2 
m *= 2

print('EX6-3 - ', l, m, id(l), id(m))

l = l*2 와 같은 코드는 객체를 새로 생성한다는 것이다. 출력된 id값을 봐도 리스트와 튜플 모두 새로운 객체가 생성된 것을 알 수 있다. 

 

l *= 2 와 같이 자체에서 연산을 할 때는 가변형인 리스트는 객체를 새로 만들지 않고, 불변형인 튜플은 객체를 새로 만든다. 

 

 

-  sort vs sorted 

f_list = ['ornage', 'apple', 'mango', 'papaya', 'lemon', 'strawberry','coconut']

 

(1) sorted : 정렬 후 새로운 객체 반환

print('EX7-1 - ', sorted(f_list))
print('EX7-2 - ', sorted(f_list, reverse=True)) # 역순으로 정렬 
print('EX7-3 - ', sorted(f_list, key=len)) # 길이순서 
print('EX7-4 - ', sorted(f_list, key=lambda x: x[-1]))
print('EX7-5 - ', sorted(f_list, key=lambda x: x[-1], reverse=True))

print('EX7-6 - ', f_list)

sorted 의 인자에는 정렬할 리스트와 정렬할 조건을 넣어준다. 

객체를 새로 반환하기 때문에, 원본 리스트에는 변화가 없다. 

 

 

(2) sort : 정렬 후 객체 직접 변경 

a = f_list.sort()

print('EX7-7 - ', f_list.sort(), f_list)
print('EX7-8 - ', f_list.sort(reverse=True), f_list)
print('EX7-9 - ', f_list.sort(key=len), f_list)
print('EX7-10 - ', f_list.sort(key=lambda x: x[-1]), f_list)
print('EX7-11 - ', f_list.sort(key=lambda x: x[-1], reverse=True), f_list)

sort는 객체를 직접 변경하기 때문에, f_list.sort() 자체를 출력하면 None이 나온다. (None---> 반환값이 없다는 뜻) 그래서 원본인 f_list를 출력해주어야 변경된 리스트를 볼 수 있다.