🤍

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

<이전 글>

https://silvercoding.tistory.com/27

- Class  Getter & Setter 

* 클래스 선언 

class VectorP(object):
    def __init__(self, x, y):
        self.__x = float(x)
        self.__y = float(y)

    def __iter__(self):
        return (i for i in (self.__x, self.__y)) # Generator

* 객체 선언 

v = VectorP(20, 40)

* 오류

print('EX1-1 - ', v.__x, v.__y)  # ---> 직접 접근 불가

 AttributeError: 'VectorP' object has no attribute '__x' 

 언더바 2개로 선언한 인스턴스 변수는 객체를 통한 직접 접근이 불가능 하다. 

- Getter & Setter 

: 더 안전한 프로그래밍을 할 수 있다. 

class VectorP(object):
    def __init__(self, x, y):
        self.__x = float(x)
        self.__y = float(y)

    def __iter__(self):
        return (i for i in (self.__x, self.__y)) # Generator

    @property
    def x(self):
        print('Called Property X')
        return self.__x

    @x.setter
    def x(self, v):
        print('Called Property X setter')
        self.__x = float(v)
    
    @property
    def y(self):
        print('Called Property Y')
        return self.__y

    @y.setter
    def y(self, v):
        print('Called Property Y setter')        
        if v < 30: 
            raise ValueError('30 Below is not possible')
        self.__y = float(v)

데코레이터를 사용하여 @property, @x.setter @y.setter 밑에 x와 y를 정의해 준다. 

print('EX1-2 - ', dir(v), v.__dict__)
v.x = 10
print('EX1-3 - ', v.x, v.y)

 EX1-2 -  ['_VectorP__x', '_VectorP__y', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'x', 'y'] {'_VectorP__x': 20.0, '_VectorP__y': 40.0} 
 Called Property X 
 Called Property Y 
 EX1-3 -  10.0 40.0 

Getter와 Setter를 이용하여 self.__x 변수에 self.x 의 형태로 접근이 가능해 졌다. v.x=10 을 이용하여 값을 바꿀 수 있는 것 또한 볼 수 있다. 

# Iter 확인 
for val in v:
    print('EX1-4 - ', val)

 EX1-4 -  10.0 
 EX1-4 -  40.0 

구현해 놓은 __iter__ 메소드를 확인하였다. 

- __slot__ 

: 파이썬 인터프리터에게 통보 , 해당 클래스가 가지는 속성을 제한 

* __dict__ 

: 속성 최적화 -> 다수 객체 생성 시 메모리 사용 공간 대폭 감소 

: 해당 클래스에 만들어진 인스턴스 속성 관리에 딕셔너리 대신 set 형태를 사용 

class TestA(object):
    __slots__ = ('a', )

class TestB(object):
    pass

* 객체 생성 

use_slot = TestA()
no_slot = TestB()

* 사용

print('EX2-1 - ', use_slot)
# print('EX2-2 - ', use_slot.__dict__)  # 속성 값 확인 --> dictionary이기 때문에 안됨 
print('EX2-3 - ', no_slot)
print('EX2-3 - ', no_slot.__dict__)

 EX2-1 -  <__main__.TestA object at 0x000001BE68801C78> 
 EX2-3 -  <__main__.TestB object at 0x000001BE68A4D6A0> 
 EX2-3 -  {} 

* 메모리 사용량 비교

import timeit

# 측정을 위한 함수 선언 
def repeat_outer(obj):
    def repeat_inner():
        obj.a = 'TEST'
        del obj.a
    return repeat_inner

obj.a = 'TEST' 를 선언하고 obj.a를 삭제하는 시간을 측정하기 위한 함수를 생성한다. 

print(min(timeit.repeat(repeat_outer(use_slot), number=100000))) 
print(min(timeit.repeat(repeat_outer(no_slot), number=100000)))

 0.015717999999999982 
 0.018735899999999972 

100000번을 반복하여 가장 작은 시간을 출력해 보았을 때, slot을 사용한 클래스의 객체가 더 빠른 것을 알 수 있다. 

- 객체 슬라이싱

class ObjectS:
    def __init__(self):
        self._numbers = [n for n in range(1, 100, 3)]

    def __len__(self):
        return len(self._numbers)

    def __getitem__(self, idx):
        return self._numbers[idx]

인스턴스 변수를 리스트 타입으로 생성하고, __len__, __getitem__ 메소드를 선언해 놓은 ObjectS 클래스를 생성한다. 

* 객체 생성

s = ObjectS()

print('EX3-1 - ', s.__dict__)    
print('EX3-2 - ', len(s))
print('EX3-3 - ', len(s._numbers))  # __len__ 이 없으면 . 
print('EX3-4 - ', s[1:100])
print('EX3-5 - ', s[-1])
print('EX3-6 - ', s[::10])

 EX3-1 -  {'_numbers': [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49,  
 52, 55, 58, 61, 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97]} 

 EX3-2 -  33 
 EX3-3 -  33 

__len__ 메소드를 선언해 놓지 않는다면 EX3-3과 같이 작성하여 리스트의 길이를 확인할 수 있다. 
 EX3-4 -  [4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58, 61,  
 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97] 
 EX3-5 -  97 
 EX3-6 -  [1, 31, 61, 91] 

__getitem__ 메소드를 사용하여 객체 자체에서 인덱싱과 슬라이싱을 가능하게 만들었다. 만약 __getitem__ 메소드를 생성하지 않았다면 다음과 같은 에러가 난다.

 Traceback (most recent call last): 
  File "c:/Users/sooki/Desktop/python_high/chapter05_02.py", line 114, in <module>      
    print('EX3-4 - ', s[1:100])
 TypeError: 'ObjectS' object is not subscriptable 

- 파이썬 추상 클래스 

https://docs.python.org/3/library/collections.abc.html

1. 자체적으로 객체 생성 불가 

2. 상속을 통해서 '자식 클래스' 에서 생성해야 함 

3. 개발과 관련된 공통된 내용 (필드, 메소드) 추출 및 통합해서 공통된 내용으로 작성하게 하는 것

** Sequence 상속 받지 않았지만, 자동으로 __iter__, __contain__ 기능 작동 

** 객체 전체를 자동으로 조사 -> 시퀀스 프로토콜 

class IterTestA():
    def __getitem__(self, idx):
        return range(1, 50, 2)[idx] # range(1, 50, 2)

__getitem__ 메소드를 선언한 IterTestA 클래스를 생성한다. 

* 객체 생성

i1 = IterTestA()

print('EX4-1 - ', i1[4])
print('EX4-2 - ', i1[4:10])
print('EX4-3 - ', 3 in i1[1:10])  # __contain__ 구현하지 않아도 사용됨 
print('EX4-4 - ', [i for i in i1]) # 구현하지 않은 __iter__ 실행

 EX4-1 -  9 
 EX4-2 -  range(9, 21, 2) 
 EX4-3 -  True 
 EX4-4 -  [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49] 

인덱싱과 슬라이싱이 가능하도록 __getitem__ 메소드만 생성을 해 놓았지만 , 4-3, 4-4 가 실행이 되는 것을 볼 수 있다. __contain__과 __iter__메소드를 클래스 내에 생성하지 않았어도 실행이 된 것이다. 

- Sequence 상속 

: 요구사항인 추상메소드를 모두 구현해야 동작 

from collections.abc import Sequence

class IterTestB(Sequence):
    def __getitem__(self, idx):
        return range(1, 50, 2)[idx] # range(1, 50, 2)

    def __len__(self, idx):
        return len(range(1, 50, 2)[idx])

Sequence를 상속 받는 IterTestB 클래스를 생성한다.  __getitem__, __len__ <--- 이 두개의 메소드를 구현하지 않으면 동작하지 않는다. 

i2 = IterTestB()  # ---> __getitem__, __len__ 함수가 없으면 객체 생성 불가. (강제성을 띈다.)

두개의 메소드를 하나라도 구현하지 않으면 다음과 같은 에러가 난다. 

TypeError: Can't instantiate abstract class IterTestB with abstract methods __len__  

print('EX4-5 - ', i2[4])
print('EX4-6 - ', i2[4:10])
print('EX4-7 - ', 3 in i2[1:10])

 EX4-5 -  9 
 EX4-6 -  range(9, 21, 2) 
 EX4-7 -  True 

- abc 활용 예제 

https://docs.python.org/ko/3/library/abc.html

import abc

class RandomMachine(abc.ABC): # metaclass=abc.ABCMeta(3.4 이하)
    # __metaclass__ = abc.ABCMeta

    #추상 메소드  ---> 데코레이터가 붙은 건 무조건 자식 클래스에서 구현해주어야 한다.
    @abc.abstractmethod
    def load(self, iterobj):
        '''Iterable 항목 추가'''

    # 추상 메소드 
    @abc.abstractmethod
    def pick(self, iterobj):
        '''무작위 항목 뽑기'''

    def inspect(self):
        items = []
        while True:
            try:
                items.append(self.pick())
            except LookupError:
                break
            return tuple(sorted(items))

데코레이터로 @abc.abstractmethod 가 붙은 메소드는 무조건 자식 클래스에서 구현 해주어야 하는 메소드이다 . load와 pick 메소드에 데코레이터가 달려있다. 위와 같이 abc를 상속받는 추상클래스에 데코레이터 메소드를 구현하고, 메소드에 주석 설명을 달아 놓으면 자식 클래스에서 자세한 구현을 하게되는 방식이다. 

import random

class CraneMachine(RandomMachine):
    def __init__(self, items):
        self._randomizer = random.SystemRandom()
        self._items = []
        self.load(items)
        
    def load(self, items):
        self._items.extend(items)
        self._randomizer.shuffle(self._items)

    def pick(self):
        try:
            return self._items.pop()
        except IndexError:
            raise LookupError('Empty Crane Box')

    def __call__(self):
        return self.pick()

이와 같이 abc를 상속받았던 RandomMachine 클래스를 상속받는 CraneMachine 을 생성한다. 입력한 아이템 리스트 중에서 랜덤 뽑기를 하는 클래스이다. RandomMachine에서 구현해놓았던 추상 메소드 load, pick 함수는 필수로 구현해주어야 한다. 

* 서브 클래스 확인 

print('EX5-1 - ', issubclass(RandomMachine, CraneMachine))
print('EX5-2 - ', issubclass(CraneMachine, RandomMachine))

 EX5-1 -  False 
 EX5-2 -  True 

issubclass를 사용하여 서브클래스인지 확인 해본다. issubclass(RandomMachine, CraneMachine)은 RandomMachine이 CraneMachine의 서브클래스냐? 라는 뜻이다. 

* 상속 구조 확인 

print('EX5-3 - ', CraneMachine.__mro__)  # 가계도를 보여준다. 상속을 받은 순서를 보여줌

 EX5-3 -  (<class '__main__.CraneMachine'>, <class '__main__.RandomMachine'>, <class 'abc.ABC'>, <class 'object'>) 

* 객체 생성

cm = CraneMachine(range(1, 100)) # 추상 메소드 구현 안하면 에러

Sequence를 상속했을 때 __getitem__, __len__ 메소드가 필수였다면, abc를 상속할 때는 추상 메소드를 필수로 구현해 주어야 한다는 강제성을 띈다. 

print('EX5-4 - ', cm._items)
print('EX5-5 - ', cm.pick())
print('EX5-6 - ', cm())
print('EX5-7 - ', cm.inspect()) # --> 부모의 메소드가 실행된다.

 EX5-4 -  [53, 83, 95, 24, 97, 2, 43, 89, 85, 3, 59, 15, 78, 12, 46, 11, 29, 72, 6, 60, 41, 51, 1, 67, 10, 88, 5, 62, 33, 18, 55, 61, 13, 63, 90, 81, 32, 65, 86, 75, 94, 71, 93, 70, 26, 54, 31, 20, 91, 35, 34, 68, 57, 42, 23, 8, 77, 69, 36, 28, 99, 17, 98, 56, 44, 22, 14, 27, 30, 48, 37, 80, 87, 52, 49, 50, 40, 74, 25, 47, 96, 9, 45, 73, 4, 16, 21, 7, 82, 39, 58, 66, 84, 19, 79, 76, 38, 64, 92] 
 EX5-5 -  92 
 EX5-6 -  64 
 EX5-7 -  (38,) 

inspect메소드는 자식클래스에서 구현해주지 않아도 부모의 클래스의 메소드가 실행된다. 

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

<이전 글>

https://silvercoding.tistory.com/26

- 얕은 복사 & is  vs  __eq__ (==) 

x = {'name': 'Kim','age': 33, 'city' : 'Seoul'}
y = x  # ---> 얕은 복사

우선 x에 딕셔너리를 저장한다. 그다음 단순한 복사를 한다. 

print('EX2-1', id(x), id(y))  
print('EX2-2 - ', x == y)
print('EX2-3 - ', x is y)
print('EX2-4 - ', x, y)

 EX2-1 2324412065760 2324412065760 

우선 id 값을 출력해보니 두 값이 완전히 같았다. 

 EX2-2 -  True 

 EX2-3 -  True 

2-2와 2-3은 직관적으로 봐도 x와 y가 같은지를 물어보는 코드인 것 같다. 하지만 다른 종류의 확인법이다. __eq__ (==) 와 같은 경우는 x와 y의 값이 같은지를 확인하는 것이고 , is는 x와 y의 id값이 같은지를 확인하는 것이다. 

** 정리 

==(__eq__) : 값을 비교  vs  is : 객체 주소 (정체성) 비교

 EX2-4 -  {'name': 'Kim', 'age': 33, 'city': 'Seoul'} {'name': 'Kim', 'age': 33, 'city': 'Seoul'} 

위 예제에서는 값, id 모두 같다. x와 y를 출력하면 당연한 결과로 같은 딕셔너리가 나오는 것을 볼 수 있다. 

x의 값을 수정하거나 추가하면 y도 바뀔까? id값이 같으므로 바뀔 것으로 추정할 수 있다. 

x['class'] = 10 
print('EX2-5 - ', x, y)

 EX2-5 -  {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} 

x에 값을 추가했더니 y도 똑같이 추가되는 것을 알 수 있다. 

z = {'name': 'Kim','age': 33, 'city' : 'Seoul', 'class' : 10}

새 딕셔너리 객체를 만들어 본다. 값은 x와 같도록! 

print('EX2-6 - ', x, z)
print('EX2-7 - ', x is z)  # 같은 객체냐 
print('EX2-8 - ', x is not z)  
print('EX2-9 - ', x == z)  # 값이 같냐

 EX2-6 -  {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} 
 EX2-7 -  False 
 EX2-8 -  True 
 EX2-9 -  True 

x와 z를 비교해 보면 id값은 다르고, 값만 같다고 나오는 것을 볼 수 있다. 이 경우에는 x의 값을 변경하여도 z의 값은 변하지 않을 것이다. (당연한 소리) 

*** cf ) 튜플 (불변형) 비교 

tuple1 = (10, 15, [100, 1000])
tuple2 = (10, 15, [100, 1000])

print('EX3-1 - ', id(tuple1), id(tuple2))
print('EX3-2 - ', tuple1 is tuple2)
print('EX3-3 - ', tuple1 == tuple2)
print('EX3-4 - ', tuple1.__eq__(tuple2))

 EX3-1 -  2324415315832 2324415315544 
 EX3-2 -  False 
 EX3-3 -  True 
 EX3-4 -  True 

- Copy & DeepCopy (얕은 복사 , 깊은 복사) 

tl1 = [10, [100, 105], (5, 10, 15)]
tl2 = tl1
tl3 = list(tl1)

리스트 안에 숫자, 리스트, 튜플을 각각 넣은 후, tl2에는 얕은 복사를 , tl3에는 list의 인자에 넣어 새 객체를 생성해 준다. 

print('EX4-1 - ', tl1 == tl2)
print('EX4-2 - ', tl1 is tl2)
print('EX4-3 - ', tl1 == tl3)
print('EX4-4 - ', tl1 is tl3)

 EX4-1 -  True 
 EX4-2 -  True 
 EX4-3 -  True 
 EX4-4 -  False 

4-3과 4-4와 같은 경우는 값은 같지만, 객체는 다르다는 것을 알 수 있다. 

tl1.append(1000)
tl1[1].remove(105)

tl1에 1000을 추가하고, 1번째 리스트에서 105를 제거하면 어떻게 될까 ! 

print('EX4-5 - ', tl1)
print('EX4-6 - ', tl2)
print('EX4-7 - ', tl3)

 EX4-5 -  [10, [100], (5, 10, 15), 1000] 
 EX4-6 -  [10, [100], (5, 10, 15), 1000] 
 EX4-7 -  [10, [100], (5, 10, 15)] 

tl2는 같은 객체로 복사되어 있기 때문에 tl1과 같은 것을 볼 수 있다. 그런데 tl3는 반만 똑같다! 왜 그럴까? 

print(id(tl1[1])) # tl1과 tl3의 id는 다르지만 안에 있는 리스트의 id값은 같다. ! 
print(id(tl3[1]))

 2324415643528 
 2324415643528 

아 . tl1과 tl3 자체 객체의 id값은 달랐지만, 그 안에 있는 1번째 리스트의 id값은 같았다. 점점 이 방법으로 하는 복사의 허점이 보이기 시작한다. 

tl1[1] += [110, 120]
tl1[2] += (110, 120)

tl1의 리스트와 튜플에 각각 값을 추가해준다. 

print('EX4-8 - ', tl1)
print('EX4-9 - ', tl2) # 튜플 재 할당 (깩체 새로 생성) ---> 데이터가 현저히 많을 떈 주의 해야 한다. 객체를 새로 생성한다는 것은 데이터 손실이 있을 수도 있고 , 메모리를 더 차지할 수도 있게 되기 때문 !
print('EX4-10 - ', tl3)

 EX4-8 -  [10, [100, 110, 120], (5, 10, 15, 110, 120), 1000] 
 EX4-9 -  [10, [100, 110, 120], (5, 10, 15, 110, 120), 1000] 
 EX4-10 -  [10, [100, 110, 120], (5, 10, 15)] 

우선 tl1, tl2는 여기서도 똑같이 움직인 다는 것을 알 수 있다. 그런데 tl3에서는 조금 이상한 현상이 일어났다. 리스트는 값이 추가되었지만 , 튜플은 값이 추가되지 않았다. 답은 코드 주석에 써있듯이, 튜플은 객체를 새로 생성하여 재 할당이 되기 때문인데, 이해를 위하여 id값을 출력해보았다. 

# 리스트, 튜플에 값 추가 전 
print(id(tl1[2]))
print(id(tl2[2]))
print(id(tl3[2]))

...

# 리스트, 튜플에 값 추가 후
print(id(tl1[2]))
print(id(tl2[2]))
print(id(tl3[2]))

 1367137568664 
 1367137568664 
 1367137568664 

 1367137218056 
 1367137218056 
 1367137568664 

리스트처럼 tl1, tl3의 튜플 id값은 같았다. 튜플에선 이게 이슈가 되는 것이다! tl1[2] += (110, 120) <--- 이 코드가 실행되면 튜플이 재할당되어 새 객체가 생성된다. 그래서 id값을 보면 이 코드 전과 후의 tl1, tl2 id값이 달라진 것을 볼 수 있다. 그래서 전과 같은 id값을 가진 tl3의 튜플은 변화하지 않는 것이다. 

*** copy & Deep copy (깊은 복사) 실습해보기 

(ex) 장바구니 클래스 

class Basket:
    def __init__(self, products=None):
        if products is None:
            self._products = []
        else:
            self._products = list(products)  # 새로운 객체 생성

    def put_prod(self, prod_name):
        self._products.append(prod_name)

    def del_prod(self, prod_name):
        self._products.remove(prod_name)

_products에 물건을 담고, put_prod 메소드로 물건 추가 , del_prod 메소드로 물건 삭제를 하는 클래스 생성! 

import copy

basket1 = Basket(['Apple', 'Bag', 'TV', 'Snack', 'Water'])
basket2 = copy.copy(basket1)  # 얕은 복사 
basket3 = copy.deepcopy(basket1)  # 깊은 복사 ---> 객체 안에 있는 인스턴스 변수까지 참조

copy를 import하여 얕은 복사(copy.copy) 와 깊은 복사(copy.deepcopy) 를 해본다. 

print('EX5-1 - ', id(basket1), id(basket2), id(basket3))
print('EX5-2 - ', id(basket1._products), id(basket2._products), id(basket3._products))

 EX5-1 -  1367137770520 1367137770464 1367137771304 
 EX5-2 -  1367137799240 1367137799240 1367137626888 

copy를 사용하면 객체 자체는 모두 다르게 나오는 것을 볼 수 있다. EX5-2에서 얕은 복사와 깊은복사의 차이점이 보인다. deepcopy는 객체 안에 있는 인스턴스 변수까지 참조를 하기 때문에 변수의 객체까지 id의 값이 다르다! 

basket1.put_prod('Orange')
basket2.del_prod('Snack')

basket1에 Orange를 넣고, Snack을 삭제하면 어떻게 변하는지 확인해 보자! 

# 빅데이터나, 웹개발할 떄 주의해야 한다. 
print('EX5-3 - ', basket1._products)
print('EX5-4 - ', basket2._products)  
print('EX5-5 - ', basket3._products)

 EX5-3 -  ['Apple', 'Bag', 'TV', 'Water', 'Orange'] 
 EX5-4 -  ['Apple', 'Bag', 'TV', 'Water', 'Orange'] 
 EX5-5 -  ['Apple', 'Bag', 'TV', 'Snack', 'Water'] 

이렇게 basket1과 basket2는 서로 영향을 받는다. 깊은복사를 한 basket3는 영향을 받지 않는다. 

이는 빅데이터 또는 웹개발을 할 때 주의해야 한다. 예를 들어 빅데이터 분석을 할 때 원본은 손상시키지 않고 복사를 하여 전처리를 할 경우 얕은 복사를 하게 되면 생각만 해도 아찔하다. 

- 함수 매개변수 전달 주의 

def mul(x, y):
    x += y
    return x

x에 y를 더해서 x에 넣고, x를 return해주는 mul 함수 생성 

x = 10 
y = 5

print('EX6-1 - ', mul(x, y), x, y)

 EX6-1 -  15 10 5 

함수 안의 x가 15라고 해서 전역변수 x의 값이 변경되지는 않는다. 

* 가변형 a -> 원본 데이터 변경/ 함수에 전달할 때 원본의 주소까지 넘김

a = [10, 100]
b = [5, 10]

print('Ex6-2 - ', mul(a, b), a, b)  # ---> 확장! ! ! ! !

 Ex6-2 -  [10, 100, 5, 10] [10, 100, 5, 10] [5, 10] 

하지만 가변형인 리스트 타입의 a를 mul에 넣으면 전역변수인 a의 값까지 변해버린다. 즉 원본데이터가 변경되는 것이다. 함수에 이 데이터를 전달할 때 원본의 주소까지 넘기기 때문이다. 

* 불변형 c ---> 원본 데이터 변경 안됨

c = (10, 100)
d = (5, 10)
print('Ex6-2 - ', mul(c, d), c, d)

불변형인 튜플타입의 c같은 경우에는 원본 데이터의 변경이 되지 않는다. 위에서 배웠듯이 튜플의 내용이 갱신될 때는 새로운 주소에 할당이 되기 때문이다. 

- 파이썬 불변형 예외 

: str, bytes, frozenset, Tuple ---> 사본 생성 X ---> 참조 반환 (같은 값이면 id 도 같다) 

tt1 = (1, 2, 3, 4, 5)
tt2 = tuple(tt1)
tt3 = tt1[:]

이번엔 튜플을 각각 다른 방법으로 복사하여 tt2와 tt3를 생성하였다. 

print('EX7-1 - ', tt1 is tt2, id(tt1), id(tt2))
print('EX7-2 - ', tt1 is tt3, id(tt1), id(tt3))

 EX7-1 -  True 1367134857000 1367134857000 
 EX7-2 -  True 1367134857000 1367134857000 

리스트는 위와 같은 방법으로 객체를 생성하면 새로운 주소가 부여됐었다. 튜플은 불변형이므로 같은 값이면 id는 같다. 따라서 모든 id값이 같게 나왔다. 튜플은 불변형이기 때문에 튜플에 튜플을 더할 때 기존 튜플에 값이 추가되는 개념이기 보다는 새로운 튜플 객체가 만들어지는 것이라고 보면 된다.  

tt4 = (10, 20, 30, 40, 50)
tt5 = (10, 20, 30, 40, 50)
ss1 = 'Apple'
ss2 = 'Apple'

튜플과 또다른 불변형 str로 검증을 해보고 마친다. 

print('EX7-3 - ', tt4 is tt5, tt4 == tt5, id(tt4), id(tt5))
print('EX7-4 - ', ss1 is ss2, ss1 == ss2, id(ss1), id(ss2))

 EX7-3 -  True True 1367137216648 1367137216648 
 EX7-4 -  True True 1367137769320 1367137769320 

값이 같으면 다른 변수에 따로 생성을 해도 같은 주소를 갖고 있다는 것을 알 수 있다. 

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

<이전 글>

https://silvercoding.tistory.com/25

이번 포스트에서는 데코레이터를 알아볼 것이다. 데코레이터는 어렵다고 느끼는 것이 당연하다. 데코레이터에 들어가기 전에는 변수의 범위와 클로저 개념을 알아야 하므로 이 둘을 먼저 살펴보자.

- 파이썬 변수 범위 

*** 전역변수 vs 지역변수 참고 

https://wikidocs.net/62

여기 이해하기 쉽게 정리가 되어있다! 

직접 실습해보자 

# 예제 1
def func_v1(a):
    print(a)
    print(b)


# 오류
# func_v1(5)

 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 19, in <module>
    func_v1(5) 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 15, in func_v1       
    print(b) 
 NameError: name 'b' is not defined 

예제1과 같은 함수를 작성하고, 호출하면 당연한 결과로 NameError가 난다. b가 정의되어 있지 않은데 b를 출력하라고 작성하였기 때문이다. 

# 예제 2 
b = 10

def func_v2(a):
    print(a)
    print(b)

func_v2(5)

그렇다면 이렇게 함수 밖에 b를 선언하고 함수 안에서 b를 출력하면 어떻게 될까? 

 5  
 10  

위와 같이 출력이 되는 것을 볼 수 있다. 이때의 b를 전역변수라고 한다.

# 예제3 
b = 10

def func_v3(a):
    print(a)
    print(b)
    b = 5
    
func_v3(5)

이렇게 작성한다면 어떻게 될까? 

Traceback (most recent call last):
  File "c:/Users/sooki/Desktop/python_high/chapter04_02.py", line 42, in <module>      
    func_v3(5) 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 39, in func_v3       
    print(b) 
UnboundLocalError: local variable 'b' referenced before assignment

오! UnboundLocalError 가 난다. 할당되기 전에 지역변수 'b'가 참조되었다는 것이다. 

함수 내에 b가 있는 건 체크가 되었는데, b에 값을 할당하기 전에 b를 출력했기 때문에 에러가 난다. 

같은 이름의 전역변수와 지역변수가 있으면 함수 내에서는 지역변수가 우선이며, 런타임의 인터프리터가 b가 있는 것을 체크했지만, 할당은 위에서부터 아래로 이루어지기 때문이다.

* 증명

from dis import dis

print('EX1-1 - ')
print(dis(func_v3))

EX1-1 -
 38           0 LOAD_GLOBAL              0 (print) 
              2 LOAD_FAST                0 (a) 
              4 CALL_FUNCTION            1 
              6 POP_TOP 

 39           8 LOAD_GLOBAL              0 (print) 
             10 LOAD_FAST                1 (b) 
             12 CALL_FUNCTION            1 
             14 POP_TOP 
 
 40          16 LOAD_CONST               1 (5) 
             18 STORE_FAST               1 (b)  
             20 LOAD_CONST               0 (None) 
             22 RETURN_VALUE 
 None 

- Closure (클로저) 

1. 반환되는 내부 함수에 대해서 선언된 연결 정보를 가지고 참조하는 방식 

2. 반환 당시 함수의 유효범위를 벗어난 변수 또는 메소드에 직접 접근이 가능 

글로 읽으면 이해가 어려우니 직접 실습해보기 . 

a = 10 

print('EX2-1 - ', a + 10)
print('EX2-2 - ', a + 100)
print('EX2-3 - ', sum(range(1, 51)))
print('EX2-4 - ', sum(range(51, 101)))

 EX2-1 -  20 
 EX2-2 -  110 
 EX2-3 -  1275 
 EX2-4 -  3775 

a라는 변수를 선언하고 , 따로 따로 10, 100을 더하고 출력하면 당연한 결과로 20, 110이 나온다. 

위의 예제들 처럼 개별적인 계산이 이루어지게 된다. 

이와 다르게 결과를 누적할 수는 없을까? 에 대한 답으로 사용할 수 있는 것이 클로저이다. 

Q) 결과를 누적할 수는 없을까 ? 

A1) 클래스 이용 

class Averager():
    def __init__(self):
        self._series = []

    def __call__(self, v):
        self._series.append(v)
        print('class >>> {} / {}'.format(self._series, len(self._series)))
        return sum(self._series) / len(self._series)

우선 Averager 클래스는 숫자를 넣으면 리스트에 추가하여 평균을 구해주는 클래스이다. 

객체를 생성하면 _series 에 빈 리스트를 생성한다. 

저번 글에서 배운 __call__ 메소드는 객체를 메소드 형태로 호출할 수 있도록 해 주는 것이었다. 

# 인스턴스 생성 
avg_cls = Averager()

print('EX3-1 - ', avg_cls(15))
print('EX3-2 - ', avg_cls(35))
print('EX3-2 - ', avg_cls(40))

 class >>> [15] / 1 
 EX3-1 -  15.0 
 class >>> [15, 35] / 2 
 EX3-2 -  25.0 
 class >>> [15, 35, 40] / 3 
 EX3-2 -  30.0 

이렇게 누적으로 저장해두었다가 평균을 구해준다. 

A2) 클로저 이용 

이번엔 클로저를 사용한다. 클로저를 사용하면 

1. 전역변수 사용 감소 

2. 디자인 패턴 적용 

def closure_avg1():
    # Free Variable
    # 클로저 영역
    series = []
    def averager(v):
        # 여기에 series가 없는데 계속 참조하고 있음 
        # series = [] 여기에 쓴다면 계속 초기화된 후 append됨 
        series.append(v)
        print('def1 >>> {} / {}'.format(series, len(series)))
        return sum(series) / len(series)
    return averager # 함수 자체를 리턴 averager() 이게 아님

클로저 영역에서 series를 선언한 것 빼고는 다른 게 없어보인다. 원래 함수안에서 선언한 변수는 함수 리턴과 동시에 초기화된다. 하지만 클로저 영역에서 선언한 변수는 초기화 되지 않아 이러한 누적으로 추가되는 코드를 짤 때 사용할 수 있다. 

avg_closuer1 = closure_avg1()

print('EX4-1 - ', avg_closuer1(15))
print('EX4-1 - ', avg_closuer1(35))
print('EX4-1 - ', avg_closuer1(40))

지금보니 오타가 났다 closuer 이라고 되어있다! 

def1 >>> [15] / 1
EX4-1 -  15.0
def1 >>> [15, 35] / 2
EX4-1 -  25.0
def1 >>> [15, 35, 40] / 3
EX4-1 -  30.0

결과가 잘 나오는 것을 볼 수 있다. 

print('EX5-1 - ', dir(avg_closuer1))
print()
print('EX5-2 - ', dir(avg_closuer1.__code__))
print()
print('EX5-3- ', avg_closuer1.__code__.co_freevars)  # 클로저에 접근
print()
print('EX5-4 - ', dir(avg_closuer1.__closure__[0]))  
print()
print('EX5-5 - ', dir(avg_closuer1.__closure__[0].cell_contents[1]))

EX5-1 -  ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

__code__ 에 접근
EX5-2 -  ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_kwonlyargcount', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames']
co_vars 에 접근 ---> 클로저에 접근 
EX5-3-  ('series',)
series가 나오는 것을 볼 수 있다.
EX5-4 -  ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'cell_contents']

EX5-5 -  ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', 
'__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

*** 잘못된 클로저 사용 예 

def closure_avg2():
    # Free variable
    # 클로저 영역 
    cnt = 0 
    total = 0 
    
    def averager(v):
        cnt += 1
        total += v 
        print('def2 >>> {} / {}'.format(total, cnt))
        return total / cnt 
    return averager

 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 155, in <module>     
    print('EX5-5 - ', avg_closure2(15)) 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 147, in averager     
    cnt += 1 
 UnboundLocalError: local variable 'cnt' referenced before assignment 

이렇게 사용하는 경우에는 UnboundLocalError가 실행된다. 

---> 해결방법 

def closure_avg2():
    # Free variable
    # 클로저 영역 
    cnt = 0 
    total = 0 
    def averager(v):
        nonlocal cnt, total  
        cnt += 1
        total += v 
        print('def2 >>> {} / {}'.format(total, cnt))
        return total / cnt 
    return averager

<nonlocal 변수명> 을 붙여주면 클로저 영역을 사용하여 변수를 선언해줄 수 있다. 

avg_closure2 = closure_avg2()

print('EX5-5 - ', avg_closure2(15))
print('EX5-5 - ', avg_closure2(35))
print('EX5-5 - ', avg_closure2(40))

 def2 >>> 15 / 1 
 EX5-5 -  15.0 
 def2 >>> 50 / 2 
 EX5-5 -  25.0 
 def2 >>> 90 / 3 
 EX5-5 -  30.0 

그럼 결과 값이 잘 나오는 것을 볼 수 있다. 

- 데코레이터 , Decorator 

장점

1. 중복제거, 코드 간결 

2. 클로저보다 문법 간결 

3. 조합해서 사용할 때 용이 

단점 

1. 디버깅이 어려움 

2. 에러의 모호함 

import time 

def perf_clock(func): 
    def perf_clocked(*args):
        # 시작 시간 
        st = time.perf_counter()
        result = func(*args)
        # 종료 시간 
        et = time.perf_counter() - st
        # 함수명 
        name = func.__name__ 
        # 매개변수 
        arg_str = ','.join(repr(arg) for arg in args)
        # 출력 
        print('Result : [%0.5fs] %s(%s) -> %r' % (et, name, arg_str, result))
        return result
    return perf_clocked

우선 perf_clock 이라는 함수를 생성한다. 함수를 입력하면 그 함수가 실행되는 데 걸리는 시간과 그 함수의 반환 결과를 반환해 주는 함수이다. 

* 데코레이터 미사용 

def time_func(seconds):
    time.sleep(seconds)


def sum_func(*numbers):
    return sum(numbers)


def fact_func(n):
    return 1 if n < 2 else n * fact_func(n-1)

총 3가지의 함수로 실험을 해본다. time_func : 2초 sleep , sum_fun : 숫자 합하기, fact_func : 팩토리얼 계산 

non_deco1 = perf_clock(time_func)
non_deco2 = perf_clock(sum_func)
non_deco3 = perf_clock(fact_func)

print('EX7-1 - ', non_deco1, non_deco1.__code__.co_freevars)
print('EX7-2 - ', non_deco2, non_deco2.__code__.co_freevars)
print('EX7-3 - ', non_deco3, non_deco3.__code__.co_freevars)

print('*' * 40, 'Called Non Deco -> time_func')
print('EX7-4 - ')
non_deco1(2)
print('EX7-5 - ')
non_deco2(100, 200, 300, 500)
print('EX7-6 - ')
non_deco3(100)

EX7-1 -  <function perf_clock.<locals>.perf_clocked at 0x0000029029B70EA0> ('func',)   
EX7-2 -  <function perf_clock.<locals>.perf_clocked at 0x0000029029B70F28> ('func',)   
EX7-3 -  <function perf_clock.<locals>.perf_clocked at 0x0000029029B74048> ('func',)   
**************************************** Called Non Deco -> time_func

 EX7-4 - Result : [2.00830s] time_func(2) -> None 
 EX7-5 -  Result : [0.00001s] sum_func(100,200,300,500) -> 1100 
 EX7-6 - Result : [0.00017s] fact_func(100) ->   93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 

perf_clock의 인자로 각 함수를 넣어 변수를 선언해준다. 그 다음 함수를 사용하면 , 원하던 결과가 잘 나온다! 

* 데코레이터 사용 

@perf_clock
def time_func(seconds):
    time.sleep(seconds)


@perf_clock
def sum_func(*numbers):
    return sum(numbers)


@perf_clock
def fact_func(n):
    return 1 if n < 2 else n * fact_func(n-1)

데코레이터를 사용하기 위해 함수 위에 @perf_clock 을 작성한다. 

print('*' * 40, 'Called Deco -> time_func')
print('EX7-7 - ')
time_func(2)

print('*' * 40, 'Called Deco -> sum_func')
print('EX7-7 - ')
sum_func(10, 20, 30, 40, 50)

print('*' * 40, 'Called Deco -> fact_func')
print('EX7-7 - ')
fact_func(5)

**************************************** Called Deco -> time_func 
EX7-7 -
Result : [2.01093s] time_func(2) -> None 
**************************************** Called Deco -> sum_func 
EX7-7 -
Result : [0.00002s] sum_func(10,20,30,40,50) -> 150 
**************************************** Called Deco -> fact_func 
EX7-7 -
Result : [0.00000s] fact_func(1) -> 1 
Result : [0.00026s] fact_func(2) -> 2 
Result : [0.00058s] fact_func(3) -> 6 
Result : [0.00087s] fact_func(4) -> 24 
Result : [0.00110s] fact_func(5) -> 120 

그럼 이렇게 변수를 생성해주지 않아도 간단하게 결과를 얻을 수 있다. 

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

<이전 글>

https://silvercoding.tistory.com/24

예전 글에서도 다루었듯이 파이썬의 모든 것은 객체 라는 개념은 아주 중요한 개념이었다. 이를 통해 함수 또한 객체라는 것을 알 수 있다. 

일급함수(일급 객체) - 파이썬 함수의 특징 

1. 런타임 초기화 가능 

2. 변수에 할당 가능 

3. 함수 인수에 전달 가능 (ex) sorted(keys=len) --- 함수 안에 함수 

4. 함수 결과로 반환 가능 (ex) return function  

- 팩토리얼 함수 구현 예제 

def factorial(n):
    print("run")
    '''Factorial Function -> n:int'''
    if n ==1: # n < 2 
        return 1 
    return n * factorial(n-1)
    
    
class A: 
    pass 

위에서 보았던 일급함수의 특징 중 4번을 사용하였다. 함수의 결과로 함수를 반환해서 팩토리얼을 구현한 것이다. 

A클래스는 함수와 비교해 보기 위해서 생성한 것 . 

* 사용해보기

print('EX1-1 - ', factorial(5))
print('EX1-2 - ', factorial.__doc__)
print('EX1-3 - ', type(factorial), type(A))
print('EX1-4 - ', set(sorted(dir(factorial)))-set(sorted(dir(A)))) # 클래스와 다르게 함수가 갖고있는 메소드들
print('EX1-5 - ', factorial.__name__) # 함수 이름 
print('EX1-6 - ', factorial.__code__) # 함수 코드 위치 

EX1-1 에서 볼 수 있듯이 factorial(5) 를 하면 run이 5번 호출 되는 것을 볼 수 있다. 

* 변수 할당 / 함수 인자 전달

val_func = factorial
print('EX2-1 - ', val_func)
print('EX2-2 - ', val_func(5))
print('EX2-3 - ', map(val_func, range(1, 6)))
print('EX2-4 - ', list(map(val_func, range(1, 6))))

일급함수의 특징 2번과 같이 변수에 할당할 수 있다. 변수에 함수를 넣고, 기존 만들어 놓았던 함수와 똑같이 사용해 주면 된다. EX2-3, 4 에서는 특징 3번과 같이 map함수의 인자에 factorial 함수를 넣어 사용한 것이다.

EX2-4는 위와같이 리스트로 결과 값을 볼 수 있다. 

# 함수 인수 전달 및 함수로 결과 반환 -> 고위 함수 (Higher-order Function)
print('EX3-1 - ', list(map(val_func, filter(lambda x: x%2, range(1, 6))))) # --> 함수 안에 함수 전달 
print('EX3-2 - ', [val_func(i) for i in range(1, 6) if i % 2])

EX2-4 에서 더 나아가 1-6 중에서 홀수인 숫자들만 factorial을 적용시키는 코드이다. 

EX3-1과 EX3-2 는 같은 결과가 나오는 코드이지만, EX3-2는 list comprehension을 사용하였고, EX3-1은 함수의 인수로 함수를 전달한다는 점에서 차이가 있다. 

- reduce 

from functools import reduce
import functools
from operator import add

print('EX3-3 - ', reduce(add, range(1, 11))) # 누적 
print('EX3-4 - ', sum(range(1, 11)))

1부터 10까지 더하는 코드를 짜야한다고 하면 EX3-4 처럼 sum함수를 사용하여 짜는 것이 일반적이다. 이 방법 말고도 functools의 reduce를 사용하여 구현할 수도 있다. 1부터 11까지 차례대로 더해가며 줄여나가는 방식이다. 

* 익명함수 (lambda) 와 reduce 

*** 익명함수 (lambda) 

1. 가급적 주석 사용 (가독성이 떨어지기 때문) 

2. 가급적 함수 사용 

3. 일반 함수 형태로 리팩토링 권장 

print('EX3-5 - ', reduce(lambda x, t: x + t, range(1, 11)))

위에서의 add함수 대신 lambda함수를 사용할 수 있다. 1 + 2 ---> 3 + 3 ---> 6 + 4 ---> 10 + 5 이런 식으로 더해진 값에 누적으로 다음 수를 더해주는 원리이다. 

<lambda, map(), reduce(), filter() 참고>

https://wikidocs.net/64

어려움을 느낄 땐 예시를 보고 오기! 

- Callable : 호출 연산자 

* 메소드 형태로 호출 가능한지 확인 

---- 로또 추첨 클래스 예제 ----

* 클래스 선언 

import random

class LottoGame:
    def __init__(self):
        self._balls = [n for n in range(1, 46)]

    def pick(self):
        random.shuffle(self._balls)
        return sorted([random.choice(self._balls) for n in range(6)])

우선 random을 import 해준다. 객체를 초기 생성했을 때 _balls에는 1부터 45까지의 숫자를 리스트를 넣어준다. 

pick 함수에서는 random.shuffle을 사용하여 _balls를 섞어 준다. 그다음 6개를 뽑아준다. 

* 객체 생성 

game = LottoGame()

* 로또추첨 실행 

print('EX4-2 - ', game.pick())

 EX4-2 -  [1, 5, 14, 24, 30, 34] 

이렇게 6개가 잘 뽑히는 것을 알 수 있다. 

--- callable 사용 

print('EX4-1 - ', callable(str), callable(list), callable(factorial), callable(3.14), callable(game))

위에서 말했듯이 callable을 사용하여 메소트 형태로 호출 가능한지 알 수 있다. 

 EX4-1 -  True True True False False 

str, list, factorial은 모두 메소드 형태로 호출이 가능하지만, 실수인 3.14 또는 객체가 들어가 있는 변수인 game 같은 경우는 메소드 형태로 호출이 불가능 하다. 3.14(), game() <--- 이와 같은 형태로 사용할 수 없다는 소리이다. 

하지만 클래스에서 __call__메소드를 사용하면 game같은 객체가 담긴 변수는 메소드 형태로 호출을 가능하게 만들 수 있다. 

--- __call__ 메소드 사용하기 (매우 중요한 개념임) 

class LottoGame:

    ...

    def __call__(self):
        return self.pick()

LottoGame 클래스에 __call__메소드를 추가해 준다. self.pick을 return 해주는 것으로 작성하였으므로, game()을 호출하면 pick 이 실행될 것이다. 

*** 사용해보기 

print('EX4-3 - ', game())
print('EX4-4 - ', callable(game))

 EX4-3 -  [14, 18, 42, 44, 44, 45] 
 EX4-4 -  True 

-- 매개변수 입력 (*args, **kwargs) 

def args_test(name, *contents, point=None, **attrs):
    return '<args_test> -> ({}) ({}) ({}) ({})'.format(name, contents, point, attrs)

볼 때마다 헷갈렸던 별표! 함수의 인자에 별 하나 (*) 가 붙으면 튜플을 받고, 별 두개 (**) 가 붙으면 딕셔너리를 받는다. 

테스트를 하기 위해 일반 변수 name, 튜플을 받는 contents, default 값이 정해져 있는 point, 딕셔너리를 받는 attrs, 총 4개의 인자를 받는 함수 args_test를 생성하였다. 

print('EX5-1 - ', args_test('test1'))
print('EX5-2 - ', args_test('test1', 'test2'))
print('EX5-3 - ', args_test('test1', 'test2', 'test3', id='admin'))
print('EX5-4 - ', args_test('test1', 'test2', 'test3', id='admin', point=7))
print('EX5-4 - ', args_test('test1', 'test2', 'test3', id='admin', point=7, password='1234'))

* 하나씩 풀어서 정리 

 EX5-1 -  <args_test> -> (test1) (()) (None) ({}) 

'test1' 하나를 넣었더니 name에 들어 갔다. 

 EX5-2 -  <args_test> -> (test1) (('test2',)) (None) ({}) 

'test1', 'test2' 를 넣었더니 name, contents 튜플에 들어갔다. (default값이 있는 point는 point를 명시해 주어야 하며, attr은 딕셔너리를 받으므로 key, value값을 적어주어야 한다.)  

 EX5-3 -  <args_test> -> (test1) (('test2', 'test3')) (None) ({'id': 'admin'}) 

'test1', 'test2', 'test3' 를 연속적으로 적어 주었더니 name에 test1, contents 튜플에 test2, test3가 들어간 것을 볼 수 있다. 차례대로 적더라도 point에는 들어가지 않는다. key와 value를 넣어주니 attr 딕셔너리에 들어간 것 또한 볼 수 있다. 

 EX5-4 -  <args_test> -> (test1) (('test2', 'test3')) (7) ({'id': 'admin'}) 

이번에는 point를 명시해주어 값을 넣었더니 잘 들어 가 있다. 

 EX5-4 -  <args_test> -> (test1) (('test2', 'test3')) (7) ({'id': 'admin', 'password': '1234'}) 

순서와 상관 없이 key, value 를 넣어주면 딕셔너리에 들어 가 있다. 

- 함수 Signature

: 함수의 인자에 대한 정보를 표시해줄 수 있는 클래스 형태의 메소드 

from inspect import signature

우선 inspect의 signature를 import 해준다. 

sg = signature(args_test)

print('EX6-1 - ', sg)
print('EX6-2 - ', sg.parameters)

 EX6-1 -  (name, *contents, point=None, **attrs) 
 EX6-2 -  OrderedDict([('name', <Parameter "name">), ('contents', <Parameter "*contents">), ('point', <Parameter "point=None">), ('attrs', <Parameter "**attrs">)]) 

위와 같이 함수의 인자에 대한 정보를 확인할 수 있다. 

* 인자의 모든 정보 출력해보기 

# 모든 정보 출력 

for name, param in sg.parameters.items():
    print('EX6-3 - ', name, param.kind, param.default)

 EX6-3 -  name  POSITIONAL_OR_KEYWORD  <class 'inspect._empty'> 
 EX6-3 -  contents  VAR_POSITIONAL  <class 'inspect._empty'> 
 EX6-3 -  point  KEYWORD_ONLY  None 
 EX6-3 -  attrs  VAR_KEYWORD  <class 'inspect._empty'> 

- partial 

1. 주로 특정 인수를 고정한 후 콜백함수에 사용

2. 하나 이상의 인수가 이미 할당된 함수의 새 버전(새 버전의 함수) 반환 

3. 함수의 새 객체 타입은 이전함수의 자체를 기술하고 있음 

글로 읽으면 이해가 잘 가지 않을 수 있다. 사용해 보자! 

from functools import partial

우선 functools의 partial을 import 해준다. 

*** cf ) mul 함수는 왜 있나 

from operator import mul 

print('EX7-1 - ', mul(10, 100))

위 코드 같은 경우는 10 * 100 을 하면 같은 결과가 나올텐데, 굳이 mul과 같은 함수가 존재하는 이유는 무엇인가. 

---> mul과 같은 함수를 인수로 받는 경우가 있기 때문이다. 

* 인수 고정 

five = partial(mul, 5)

이렇게 partial함수의 인자에 mul함수를 넣어주기 위한 용도로 쓰일 수 있다. 

그래서 partial 함수가 무엇인가! 

인수를 고정시켜 놓는 역할을 한다. partial(mul, 5) 는 mul(5) <--- 이 상태로 5를 고정시켜 놓겠다는 소리이다. 

* 고정 추가 

six = partial(five, 6)

이렇게 하면 mul(5, 6) <--- 이 상태로 고정이 되는 것이다. 

* 사용

print('EX7-2 - ', five(100)) # 한개만 받을 수 있음 
# print(six(100)) # ---> 오류 남 . 아무것도 받을 수 없음 
print('EX7-3 - ', six())
print('EX7-4 - ', [five(i) for i in range(1, 11)])
print('EX7-5 - ', list(map(five, range(1, 11)))) 

EX7-4, 5 와 같이 5에 1~10의 숫자를 곱하는 것과 비슷한 상황에서 편리하게 코드를 짤 수 있다. 

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

<이전 글>

https://silvercoding.tistory.com/23

- 해시테이블 (hashtable) 

해시테이블은 작은 리소스로 많은 데이터를 효율적으로 관리한다. 

해시 테이블은 key와 value를 기반으로 데이터를 저장한다. 

*** Hash값을 확인 함으로써 중복이 허용되는지 안되는지 알 수 있음 . 

# Hash 값 확인  ---> 중복이 허용되는지 안되는지 , 
t1 = (10, 20, (30, 40, 50))
t2 = (10, 20, [30, 40, 50])

print('EX1-2 - ', hash(t1))
# print('EX1-3 - ', hash(t2))  #---> 리스트가 포함되어 있기 때문에 해쉬 쓸 수 없음 

- 지능형 딕셔너리 (Comprehending Dict) 

(예제) 국가코드 csv 파일 -> tuple 변환 -> Dictionary 변환 

(1) csv 파일 불러와서 tuple로 변환하기 ( 파일: 패캠 제공 ) 

import csv
from os import kill
from typing import Counter 

# 외부 CSV TO List of tuple  
with open('./resources/test1.csv', 'r', encoding='UTF-8') as f:
    temp = csv.reader(f)
    # Header Skip
    next(temp)
    print()
    # 변환 
    NA_CODES = [tuple(x) for x in temp]

print('EX2-1 - ')
print(NA_CODES)

두줄까지만 캡쳐. 최종적으로 나라 코드 튜플이 들어간 리스트를 만들었다. 

(2) Dictionary 로 변환 (지능형 Dictionary 사용) 

n_code1 = {country: code for country, code in NA_CODES}
n_code2 = {country.upper() : code for country, code in NA_CODES}

n_code2는 key값을 대문자로 바꿔주기까지 한 것. 

- Dict Setdefault  

source = (('k1', 'val1'),
            ('k1', 'val2'),
            ('k2', 'val3'),
            ('k2', 'val4'),
            ('k2', 'val5'))

new_dict1 = {}
new_dict2 = {}

(1) No use setdefault 

for k, v in source:
    if k in new_dict1:
        new_dict1[k].append(v)
    else:
        new_dict1[k] = [v]

print('EX3-1 - ', new_dict1)

중복되는 key가 있으면, 리스트에 append해서 dict를 만드는 코드이다. 

(2) Use setdefault ( 이것의 성능이 더 좋다고 한다. ) 

for k, v in source:
    new_dict2.setdefault(k, []).append(v)

print('EX3-2 - ', new_dict2)

setdefault를 사용하면 if문을 사용하지 않고도 이렇게 간단하게 한줄로 구현할 수가 있다.

- 사용자 정의 dict 상속 

class UserDict(dict):
    def __missing__(self, key):
        print('Called : __missing__')
        if isinstance(key, str):
            raise KeyError(key)
        return self[str(key)]

    def get(self, key, default=None):
        print("Called : __getitem__")
        try:
            return self[key]
        except KeyError:
            return default

    def __contains__(self, key):
        print("Called : __contains__")
        return key in self.keys() or str(key) in self.keys()

dict를 상속받아서 클래스를 생성할 수 있다. 

user_dict1 = UserDict(one=1, two=2)
user_dict2 = UserDict({"one" : 1, "two" : 2})
user_dict3 = UserDict([('one', 1), ('two', 2)])

이렇게 딕셔너리 객체를 만들어 줄 수 있다. 

print('EX4-1 - ', user_dict1, user_dict2, user_dict3)
print('EX4-2 - ', user_dict2.get("two"))
print('EX4-3 - ', 'one' in user_dict3)
# print('EX4-4 - ', user_dict3['three'])
print('EX4-5 - ', user_dict3.get('three'))
print('EX4-6 - ', 'three' in user_dict3)

주석처리한 EX4-4 를 실행하면 

__missing__ 이 호출되면서 위에서 정의했던 키에러가 발생하게 된다. 

- Immutable Dict 

from types import MappingProxyType

d = {'key1' : 'TEST1'}
# Read Only
d_frozen = MappingProxyType(d)

print('EX5-1 - ', d, id(d))
print('EX5-2 - ', d_frozen, id(d_frozen))
print('EX5-3 - ', d is d_frozen, d == d_frozen)

# d_frozen['key1'] = 'TEST2'  # ===> 바뀌지 않음 

# 원본은 수정 가능 
d['key2'] = 'TEST2'
print('EX5-4 - ', d)

d와 d_frozen 은 다른 객체 (다른 id) 이고, 값(내용)은 같다고 나오는 것을 볼 수 있다. 

d_frozen을 수정하려고 시도하면 에러가 난다. 읽기만 가능한 것이다. 

원본인 d는 수정(추가, 삭제, 변경)이 가능하다. 

- Set 

s1 = {'Apple', 'Orange', 'Apple', 'Orange', 'Kiwi'}
s2 = set(['Apple', 'Orange', 'Apple', 'Orange', 'Kiwi'])
s3 = {3}
s4 = set()  # Not {}
s5 = frozenset({'Apple', 'Orange', 'Apple', 'Orange', 'Kiwi'})

한가지 주의할 점은 비어있는 set객체를 만들 땐 set() 을 사용하여야 한다. {} 으로 생성하면 dict 객체가 생성된다. 

# 추가 
s1.add('Melon')

# 추가 불가 
# s5.add('Melon')

print('EX6-1 - ',  s1, type(s1))
print('EX6-2 - ',  s2, type(s2))
print('EX6-3 - ',  s3, type(s3))
print('EX6-4 - ',  s4, type(s4))
print('EX6-5 - ',  s5, type(s5))

Immutable Dict와 같이 frozenset으로 수정이 불가하게 만들 수 있다. 

- 선언 최적화 

a = {5}  # ---> 이게 더 빠르다. 
b = set([10])

 *** 증명 

from dis import dis 
print('EX6-5 - ')
print(dis('{10}'))

print('EX6-6 - ')
print(dis("set([10])"))

dis를 사용하면 실행되는 순서를 볼 수 있다. 

{10} 의 절차가 더 적다!

- 지능형 집합 (Comprehending Set) 

from unicodedata import name

print('EX7-1 - ')
print({name(chr(i), "") for i in range(0, 256)})

딕셔너리와 비슷하게 for문을 {}안에 넣어주어 지능형 집합을 생성할 수 있다. 

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

<이전 글>

https://silvercoding.tistory.com/22

• 컨테이너 (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

*** 출력, 사용해보기 

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를 출력해주어야 변경된 리스트를 볼 수 있다. 

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

<이전 글>

https://silvercoding.tistory.com/21

<매직 메소드 관련 문서>

https://docs.python.org/3/reference/datamodel.html#special-method-names

https://www.tutorialsteacher.com/python/magic-methods-in-python

파이썬의 중요한 핵심 프레임 워크 : 시퀀스(Sequence), 반복(Iterator), 함수(Functions), 클래스(Class) 

- 매직메소드 

n = 100 
print(dir(n)) # 모든 속성 및 메소드 출력 

__xxx__ ----> 매직 메소드 

*** 사용 

print('EX1-1 - ', n + 200)
print('EX1-2 - ', n.__add__(200))
print('EX1-3 - ', n.__doc__)
print('EX1-4 - ', n.__bool__(), bool(n))
print('EX1-5 - ', n * 100, n.__mul__(100))

매직 메소드는 파이썬에서 이미 정의된 메서드라고 보면 된다. 이보다도 더 다양한 매직 메소드들이 있다. 

이러한 정수형 타입의 객체는 그냥 + , * 이러한 기호들로 사용할 수 있겠지만, 직접 클래스를 만들어 사용할 때는 직접 정의를 해서 유용하게 사용할 수 있다. 

- 클래스 매직 메소드 예제 

(1) 클래스 생성 

class Student:
    # 매직 메서드임. 파이썬에서 이미 정의된 멘서드 
    def __init__(self, name, height):
        self._name = name
        self._height = height

    def __str__(self):
        return 'Student Class Info : {}, {}'.format(self._name, self._height)

    def __ge__(self, x):
        print("Called >> __ge__ Method.")
        if self._height >= x._height:
            return True
        else:
            return False

    def __le__(self, x):
        print("Called >> __le__ Method")
        if self._height <= x._height:
            return True
        else:
            return False

    def __sub__(self, x):
        print('Called >> __sub__ Method.')
        return self._height - x._height

위의 문서에서 가져온 매직 메서드 의미 

__str__ ---> To get called by built-int str() method to return a string representation of a type.

__le__ ---> To get called on comparison using <= operator.

__ge__ ---> To get called on comparison using >= operator.

__sub__ ---> To get called on subtraction operation using - operator.

(2) 사용 

*** 인스턴스 생성 

s1 = Student('James', 181)
s2 = Student('Mie', 165)

Student 클래스의 인스턴스 생성!

*** 매직 메소드 출력 

print('EX2-1 - ', s1 >= s2)
print('EX2-2 - ', s1 <= s2)
print('EX2-3 - ', s1 - s2)
print('EX2-4 - ', s2 - s1)
print('EX2-5 - ', s1)
print('EX2-6 - ', s2)

클래스에 매직메소드를 정의하지 않았다면 객체와 객체간의 비교로 받아들이기 때문에 오류가 난다. 

클래스에서 직접 정의를 해놨으므로 오류가 나지 않고 정의한 대로 나온다. 

이와같이 매직메소드를 직접 정의하여 유용한 활용이 가능하다. 

- 클래스 메직메소드 사용 예제 2

(1) 클래스 생성 

class Vector(object):
    def __init__(self, *args):
        '''Create a vector, example : v = Vector(1, 2)'''
        if len(args) == 0:
            self._x, self._y = 0, 0
        else:
            self._x, self._y = args

    def __repr__(self):
        '''Returns the Vector information'''
        return 'Vector(%r, %r)' % (self._x, self._y)

    def __add__(self, other):
        '''Returns the vector addition of self and other'''
        return Vector(self._x + other._x, self._y + other._y)

    def __mul__(self, t):
        '''Returns the vector addition of self and other'''
        return Vector(self._x * t, self._y * t)

    def __bool__(self):
        return bool(max(self._x, self._y))

벡터를 생성해주는 클래스이다. 

__add__메소드는 벡터끼리 각 좌표에 대한 덧셈, __mul__메소드는 실수를 인자에 넣어주면 각 좌표에 곱해지는 것을 구현한 것이다. __bool__메소드는 x, y 좌표 중 큰 값이 0이 아니면 True를 반환하게 해준다. (정말 구현하고 싶은 대로 구현하면 된다!)

(2) 사용 

# Vector 인스턴스 생성
v1 = Vector(3, 5)
v2 = Vector(15, 20)
v3 = Vector()

# 매직 메소드 출력 
print("EX3-1 - ", Vector.__init__.__doc__)
print("EX3-2 - ", Vector.__repr__.__doc__)
print("EX3-3 - ", Vector.__add__.__doc__)
print("EX3-4 - ", v1, v2, v3)
print("EX3-5 - ", v1 + v2)
print("EX3-6 - ", v1 * 4)
print("EX3-7 - ", v2 * 10)
print('EX3-8 - ', bool(v1), bool(v2))
print('EX3-9 - ', bool(v3))

__doc__ 를 사용하면 위에서 작성했던 주석 설명이 출력된다. 나머지도 잘 실행되면 성공!

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

<이전 글>

https://silvercoding.tistory.com/20

<데이터 모델 참고 문서> 

https://docs.python.org/3/reference/datamodel.html

[ 객체 (Objects)는 파이썬이 데이터(data)를 추상화한 것(abstraction)입니다. 파이썬 프로그램의 모든 데이터는 객체나 객체 간의 관계로 표현됩니다.

모든 객체는 아이덴티티(identity), 형(type), 값(value)을 갖습니다. 객체의 아이덴티티 는 한 번 만들어진 후에는 변경되지 않습니다. 메모리상에서의 객체의 주소로 생각해도 좋습니다. 〈is〉 연산자는 두 객체의 아이덴티티를 비교합니다. id() 함수는 아이덴티티를 정수로 표현한 값을 돌려줍니다. ]

위의 문서에서 나와있는 객체의 설명이다. 모든 객체는 id, type, value를 갖는다. 예를 들어 

a = 7 
print(id(a), type(a), dir(a))

이러한 a라는 변수도 객체라는 것이다. 따라서 id, type, value를 모두 갖고 있다는 것을 알 수 있다. 

- 네임트 튜플 

<두 점 사이의 거리를 구하는 예제>

(1) 일반적인 튜플 사용

pt1 = (1.0, 5.0)
pt2 = (2.5, 1.5)

from math import sqrt
from typing import ClassVar
line_leng1 = sqrt((pt2[0] - pt1[0]) ** 2 + (pt2[1] - pt1[1]) ** 2)
print('EX1-1 : ', line_leng1)

이렇게 인덱스를 이욯하여 구하게 된다. 이렇게 간단한 예제에서는 상관이 없긴 하지만 가독성이 떨어지는 것 같긴 하다. 조금 더 복잡한 수식이라면 실수하기 딱좋다! x값 끼리 빼주고 , y값 끼리 빼주는 것을 더 명시적으로 적어줄 수 있는 named tuple을 사용해 보자! 

(2) 네임드 튜플 사용 

*** named tuple 선언법 

from collections import namedtuple

Point1 = namedtuple('Point', ['x', 'y'])
Point2 = namedtuple('Point', 'x, y')
Point3 = namedtuple('Point', 'x y')
Point4 = namedtuple('Point', 'x y x class', rename=True) # Defalult=False

# 출력 
print('EX2-1 - ', Point1, Point2, Point3, Point4)

# Dict to Unpacking
temp_dict = {'x' : 75, 'y' : 55}

# 객체 생성 
print()
p1 = Point1(x=10, y=35)
p2 = Point2(20, 40)
p3 = Point3(45, y=20)
p4 = Point4(10, 20, 30, 40)
p5 = Point3(**temp_dict)



print('EX2-2 - ', p1, p2, p3, p4, p5)

collections의 namedtuple을 import해준다. 네임드 튜플은 클래스로 하기엔 너무 헤비하고, 튜플에 이름을 주고 싶을 때 사용한다. 

point4에서는 x가 중복으로 들어 가 있고, class도 변수명으로 사용할 수 없으므로 rename=True를 설정해 놓지 않는다면 오류가 날 것이다. 

rename=True를 설정해 놓으면 위와같이 알아서 변수명이 바뀌게 된다. 

*** 사용

print('EX3-1 - ', p1[0] + p2[1])  # Index Error 주의 
print('EX3-2 - ', p1.x + p2.y) # 클래스 변수 접근 방식

# Unpacking 
x, y = p3

print('EX3-3 - ', x + y)

기존 tuple과 같이 Unpacking도 가능하다. 

*** 네임드튜플의 메소드 

• _make() : 새로운 객체를 생성 (리스트 ---> 네임드튜플) 

p4 = Point1._make(temp)
print('EX4-1 - ', p4)

• _field : 필드  네임 확인 

print('EX4-2 - ', p1._fields, p2._fields, p3._fields)

• _asdict() : OrderDict 반환 

# _asdict() : OrderDict 반환 
print('EX4-3 - ', p1._asdict(), p1._asdict(), p3._asdict(), p4._asdict())

• _replace() : 수정된 '새로운' 객체 반환 

print('EX4-4 - ', p2._replace(y=100)) 

이렇게 필드에 대한 값을 변경해줄 수 있는데, 이는 리스트 처럼 값이 변경되는 것이 아니라 , 아예 새로운 객체를 반환해 주는 것이다. 

*** 예제

# 네임드 튜플 선언 
Point = namedtuple('Point', 'x y')

# 두 점 선언 
pt1 = Point(1.0, 5.0)
pt2 = Point(2.5, 1.5)

# 두 점 사이의 거리 계산
line_leng2 = sqrt((pt2.x - pt1.x) ** 2 + (pt2.y - pt1.y) ** 2)

# 출력
print("EX1-2 - ", line_leng2)
print("EX1-3 - ", line_leng1 == line_leng2)

그래서 원래 하려했던 예제를 네임드 튜플을 사용하면 위와 같다. 네임드튜플을 사용하면 위와같이 더 명시적으로 수식을 작성해줄 수 있다. 

- 네임드 튜플 실습 

학생 그룹을 생성하는 예제, 4개의 반(A, B, C, D) 에서 각각 20명의 학생이 존재

(1) 네임드 튜플 선언 

Classes = namedtuple('Classed', ['rank', 'number'])

(2) 그룹 리스트 선언 (List Comprehension 사용)

# List Comprehension
numbers = [str(n) for n in range(1, 21)]
ranks = 'A B C D'.split()
print(ranks, numbers)

print()

# List Comprehension
students = [Classes(rank, number) for rank in ranks for number in numbers]

print('EX5-1 - ', len(students))
print('EX5-2 - ', students[4].rank)

number는 1~20의 문자를 담고있는 리스트, ranks는 A~B의 문자를 담고 있는 리스트이다. 

이제 네임드 튜플의 객체들을 list comprehension을 사용하여 생성해 준다. 총 20 * 4 = 80 개의 객체가 리스트 안에 생성될 것이다. 

*** 가독성이 떨어지지만 한번에 그룹리스트를 만드는법 

students2 = [Classes(rank, number) for rank in 'A B C D'.split() for number in [str(n) for n in range(1, 21)]]

print('EX6-1 - ', len(students2))
print('EX6-1 - ', students2)

리스트에 한번에 때려박아 주는 법이다. 뭐든지 과하면 독이 되는 것 같다. 가독성이 떨어지지만 이런 방법도 있다는 것을 알아두기.