Polpid's Pensieve

겨울 스키 시즌이 끝나고 스키 장비를 어떻게 보관을 할까라는 고민에 빠졌다. 베란다에 보관하기에는 햇빛이 들고 온도차가 많이 나기 때문에 장비가 상해서 보관이 불가능했다. 그리고 창고가 없어서 방에 보관했던 선풍기들이 자리를 많이 차지하는것 같아서 선반이 필요하다는 생각이 들었다. 찾던중 내게 딱 맞는 선반을 찾게 되었다. 

그런 바로 퍼니랙 조립식 철제 선반장이다.

https://smartstore.naver.com/furnirack/products/4690500770?NaPm=ct%3Dlfdfil05%7Cci%3Dcheckout%7Ctr%3Dppc%7Ctrx%3D%7Chk%3Dfe180c35125bc028c936e5000001e6ca113d4a96

우선 이 선반을 선택한 이유는 이렇다.
1. 철제 선반임에도 불구하고 디자인이 괜찮았다.(방안에 넣을것이었기 때문에 너무 투박한것은 안예쁘니깐..)
2. 높낮이 조절이 자유롭다. (하단에 선풍기를 넣어야 해서 높이 조절이 가능해야 했다.)
3. 악세사리가 다양하다. 선반이지만 나중에 필요에 따라서 옷장으로도 사용이 가능하고 서랍장도 넣을 수 있어서 활용도가 좋다.

상품은 목요일날 주문을 했는데 아쉽게도 도착을 월요일에 해서 조립해서 완성하는데에는 일주일 정도를 기다려야 했다.(아무래도 조립하면서 소리가 나서 평일 퇴근후 밤에 하기에는 무리였다.)

도착했을때 이렇게 두개로 포장을 해서 왔다. 하나는 기둥을 만드는 부품이고 다른 하나는 선반이다. 선반도 선반이지만 저 기둥을 만드는 프레임이 상당히 무겁다. 처음 들어보고 약간 놀랬다. ^^;;

기둥까지는 사진으로 찍지는 못했지만 포장도 꼼꼼히 잘 되어있고 조립을 위한 고무 망치도 포함되어있다. 설명서도 포함이 되어있긴 하지만 한번 읽어보면 설명서 없이도 조립하는데 어려움은 없었다. 

우선 먼저 기둥의 위, 아래에 상부캡, 하부캡, 조절발을 조립하고 가로 받침대를 넣어주면 바로 세울 수 있다. 이때 주의할 점은 설명서에도 나와있지만 타공 구멍의 상,하 방향을 잘 맞춰야 한다. 

타공구멍 방향이라는 것은 바로 이부분을 말한다. 저 구멍이 넓은쪽이 위로 가야 하고 좁은 쪽이 아래로 가도록 조립해야 한다. 

선반을 벽면에 넣은 모습이다. 고정을 위해서 벽뒤 쪽에 나사를 이용해서 고정이 가능 하지만 바닥에 높이 조절만으로도 충분히 고정이 가능해서 나사를 이용하지는 않았다. 그리고 하단에 선풍기를 넣고 선풍기 높이에 맞춰서 중간 받침대를 설치했다. 

나머지 선반들도 모두 설치한 모습이다. 원래 형태는 중간 선반을 기준으로 아래 하나 위에 하나가 들어가지만 우선 아래는 필요가 없어서 위에 두개를 넣었다. 이런 높낮이 조절이 마음대로 되니 활용도가 높은것 같다.

선반 맨 상단에는 스키 부츠와 헬멧을 넣고 왼쪽 빈 공간에는 스키 플레이트를 넣었다. 선반이 없을 때에는 선풍기 놓고 아무것도 놓을수가 없었는데 선반이 생기니 공간 활용도가 높아졌다. ^^

마지막으로 중간칸에는 우리집 꼬마 영어 책들을 넣었다. 저렇게 넣으니 참 많다 ㅡㅡ; 이미 다 읽은 책들, 그리고 지금 읽는 책들을 같이 놓으니 편하게 꺼내어서 읽을수 있어졌다. 기존에는 다른 책장 하단에 있어서 아무래도 높이가 안맞아 불편했는데 선반 덕분에 좋아졌다. 

나중에는 저 중간 부분에 책 치우고 철제 받침대와 옷걸이봉을 추가해서 간단한 옷걸이로 변경해서 써도 좋을것 같다. 

이렇게 조립식 선반 하나로 그동안 못썼던 공간을 잘 활용하게 되어서 만족스럽다. 현재 있는 오래된 책장들도 이 선반을 이용해서 붙여 넣으면 좋을것 같다는 생각도 들었다. 

• 함수의 앞 뒤 부가적인 기능을 넣어주고 싶을때 사용한다
• 클로저를 사용해서 구현한다.
• 데코레이터는 @를 함수위에 적용하여 사용한다

def logger(func):
  def wrapper():
    print("함수시작")
    func()
    print("함수종료")
  return wrapper

@logger
def print_hi():
  print("hi")

print_hi()


# OUTPUT
함수시작
hi
함수종료

• 매개변수 전달

@logger
def print_hi(name):
    print(name, 'hi')

print_hi("tom")

# OUTPUT
print_hi("tom")
TypeError: logger.<locals>.wrapper() takes 0 positional arguments but 1 was given

  위와 같이 함수에 매개변수를 추가하면 에러가 발생한다. logger 에서 전달 받은 함수를 매개변수 없이 호출을 하려고 해서 발생하는 에러이다. 따라서 데코레이터는 전달받은 함수가 어떤 매개변수를 사용할지 알수 없기 때문에 매개변수와 상관없이 동작을 해야 한다. 그래서 다음과 같이 정의를 해준다. 

def logger(func):
    def wrapper(*args, **kwargs):  # *args, **kwargs 는 전달받은 매개변수
        print("함수시작")
        func(*args, **kwargs)      # *args, **kwargs 전달받은 매개변수로 함수 실행
        print("함수 종료")
    return wrapper

  참고로 *args 는 튜플형태, **kwargs 는 딕셔너리 형태로 매개변수를 변환해서 처리한다. 정확히는 일반 변수는 튜플로, key=value 형태는 딕셔너리로 변환한다.

• 이터러블 객체
  • 순서가 있는 자료형
  • 문자열, 리스트, 튜플, 딕셔너리, range 객체
  • __iter__(), __next__() 메소드가 정의되어있다.
• 제너레이터 함수
  • 이터레이터를 만드는 함수이다.
  • yield 사용한다
  • 제너레이터 표현식을 사용해서 만들 수 있다.
  • 메모리 사용이 효율적이다.
    • List 같은 경우 결과 값을 메모리에 저장한다.
    • 제너레이터의 경우 식만 저장할뿐 값을 저장 하지 않는다. __next__ 함수가 호출 될 때에 결과값을 만든다

# yield 사용
def gen_func(*args):
  for arg in args:
    yield arg

month = gen_func('1월', '2월', '3월', '4월')

print(month.__next__())   # 1월
print(month.__next__())   # 2월
print(month.__next__())   # 3월
print(month.__next__())   # 4월


# 제너레이터 표현식 -> () 를 사용한다.
double_generator = (i * 2 for i in range(1,10))

for i in double_generator:
  print(i)


# 메모리 차이
import sys

list_data = [i * 3 for i in range(1, 10000+1)]
generator_data = (i * 3 for i in range(1, 10000+1))

print(sys.getsizeof(list_data))       # 85176
print(sys.getsizeof(generator_data))  # 208

• 내부함수
  • 함수 안에서 정의 되는 함수
• 클로저(closure)
  • 함수가 종료되어도 자원을 사용할 수 있는 함수
  • 클로저 조건
    • 내부함수
    • 외부함수 변수를 참조해야 한다.
    • 외부함수가 내부함수를 반환 해야 한다.

def outer(name):			# 외부함수
  def inner():				# 내부함수
    print(name, "하이")			# 외부함수 변수 참조
  return inner				# 내부함수 반환
  
callfunc = outer("tom")  
callfunc()  

# OUTPUT
tom 하이

• 클로저 살펴보기

print(dir(callfunc))
# ['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
print(type(callfunc.__closure__))
# <class 'tuple'>
print(callfunc.__closure__[0])
# <cell at 0x00000233CBE8A6E0: str object at 0x00000233CBE93B30>
print(dir(callfunc.__closure__[0]))
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'cell_contents']
print(callfunc.__closure__[0].cell_contents)
# tom

• 라인 1: dir 로 callfunc 를 살표보면 __closure__ 가 존재하는것을 볼수 있다.
• 라인 3: __closure__ 의 타입은 tuple 이다.
• 라인 5: __closure__[0] 번째 항목을 출력한 결과이다.
• 라인 7:__closure__[0] 을 dir 로 살펴보면 cell_contents 가 존재하는 것을 볼수 있다.
• 라인 9: cell_contents 를 출력해보면 외부함수 변수의 값인 tom 이 있는것을 확인 할 수 있다.
• 위 코드에서 callfunc = outer("tom") 호출 시점에 외부함수는 종료가 된다. 하지만 종료가 된 후에도 callfunc() 가 외부함수 변수 값인 "tom" 을 출력할 수 있는 이유는 클로저 공간에 변수의 값을 저장하고 있기 때문이다.

• 인스턴스 메소드
  • 인스턴스 속성에 접근하는 메소드
  • self 를 파라미터로 받는다.
• 클래스 메소드
  • 클래스 속성에 접근하는 메소드
  • 클래스를 의미하는 cls 를 파라미터로 받는다
  • @classmethod 를 붙인다

class Unit:
  count = 0
  def __init__(self, name, weight, height, hidden):
    self.name=name
    self.weight=weight
    self.height=height
    self.__hidden=hidden
    Unit.count +=1
    print(f"{self.name} Unit 생성")
  
  def __str__(self):
    return f"name={self.name} weight={self.weight} height={self.height}"
  
  # 인스턴스 메소드
  # 인스턴스 속성에 접근하는 메소드
  def loseWeight(self, value):
    self.weight = self.weight - value
    print(f"무게가 {value} 만큼 줄었습니다. 현재는 {self.weight} 입니다.")

  # 클래스 메서드
  # 클래스 속성에 접근하는 메소드
  # cls를 파라미터로 받는다
  @classmethod
  def print_count(cls):
    print(f"생성된 Unit 개수 = {cls.count}")
    
unit1 = Unit("Unit1", 20, 30, "magic")
print(unit1)
print(unit1.loseWeight(10))
Unit.print_count()

# OUTPUT
Unit1 Unit 생성
name=Unit1 weight=20 height=30
무게가 10 만큼 줄었습니다. 현재는 10 입니다.
생성된 Unit 개수 = 2

• 정적 메소드
  • 인스턴스를 만들 필요가 없다.
  • self 를 받지 않는다.
  • @staticmethod 를 붙인다

class Math:
  @staticmethod
  def add(x,y):
    return x+y

print(Math.add(3,5))

• 매직 메소드
  • __이름__ 형태로 되어있다.
  • __init__ : 객체가 생성될때 실행되는 메소드
  • __str__ :  객체를 출력하는 메소드

• 인스턴스 속성
  • 객체마다 다르게 갖고 있는 속성
  • 코드에서 self 로 표기된 속성들이 인스턴스 속성이다.
• 클래스 속성
  • 모든 객체가 공유하는 속성
  • count 가 클래스 속성
  • 접근시에는 클래스이름.속성 으로 접근 (ex : Unit.count)
• 비공개 속성
  • 클래스 안에서만 접근 가능한 속성
  • __hidden 이 비공개 속성이다.
  • 외부에서 변경시 Unit.__hidden 으로는 접근이 불가능 하다
  • 네이밍 맹글링에 의해서 접근은 가능하다 (unit1._Unit__hidden)

class Unit:
  count = 0
  def __init__(self, name, weight, height, hidden):
    self.name=name
    self.weight=weight
    self.height=height
    self.__hidden=hidden
    Unit.count +=1
    print(f"{self.name} Unit 생성")
  
  def __str__(self):
    return f"name={self.name} weight={self.weight} height={self.height}"


unit1 = Unit("Unit1", 20, 30, "magic")
unit2 = Unit("Unit2", 100, 200, "power")

print(unit1)
print(unit2)
print(Unit.count)
print(unit1._Unit__hidden)

# OUTPUT
Unit1 Unit 생성
Unit2 Unit 생성
name=Unit1 weight=20 height=30
name=Unit2 weight=100 height=200
2
magic

• map 함수
  • map(함수, 순서가 있는 자료형)
  • map 의 결과는 map object 이기 때문에 사용하기 편한 list 형태로 변환한다.

def remove_blank(x):
  return x.strip()

items=[' mouse', ' monitor ']

items=list(map(remove_blank, items))

print(items)

# output
# ['mouse', 'monitor']

# 람다함수로 표기할 경우
items=list(map(lambda x:x.strip(), items))

• filter 함수
  • filter(함수, 순서가 있는 자료형)

def func(x):
  return x < 0

print(list(filter(func, [-3, 0, 2, 7, -7])))

# output
# [-3, -7]

# 람다함수로 표현
print(list(filter(lambda x:x<0, [-3, 0, 2, 7, -7])))

• 람다함수를 사용하면 코드가 간결해진다
• 메모리 사용이 효율적이다.

# 람다함수 선언 방법
lambda a : a-1

# 호출방법 1 : 그대로 호출
print ((lambda a:a-1)(10))

# 호출방법 2 : 변수에 담아서 호출
minus_ten = lambda a : a-10
print (minus_ten(100))

# 람다함수 if 문 사용
def is_positive_num(a):
  if a > 0:
    return True
  else:
    return False

lambda a : True if a > 0 else False

개인적으로 함수 자체를 호출하는 방법보다는 변수에 담아서 호출하는게 가독성에는 더 좋아보인다.

• kwargs 는 keyword arguments
• 매개변수 앞에 ** 가 붙는다
• 딕셔너리 로 인식한다.

def comment_info(**kwargs):
  print(kwargs)
  for key,value in kwargs.items():
    print(f'{key}:{value}')

comment_info(name='test1', age=10)

output
{'name': 'test1', 'age': 10}
name:test1
age:10

추가 사항 : 추가적으로 *args 는 임의의 개수의 argument 를 의미한다. kwargs 와는 달리 tuple 로 인식한다.