Polpid's Pensieve

• 내부함수
  • 함수 안에서 정의 되는 함수
• 클로저(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 로 인식한다.

• 튜플은 () 로 정의된다
• 튜플은 값을 바꿀수 없다.

t1 = ()
t2 = (1,)
t3 = (1,2,3)
t4 = 1,2,3
t5 = ('a', 'b', ('ab', 'cd'))

• 1개의 요소만 가질때에는 콤마(,) 를 붙여야 한다.
• 괄호가 생략 가능하다
• 개수가 정해지지 않은 매개 변수로 사용된다. (* 가 매개변수 앞에 붙는다.) = 위치가변 매개변수

def print_fruits(*args):
  print(args)
  for arg in args:
    print(arg)

print_fruits('apple', 'banana', 'melon')

output
('apple', 'banana', 'melon')
apple
banana
melon

최근에 타입스크립트에 관심이 생겨서 공부를 해보려고 했었는데 마침 나는 리뷰어다 책 목록에 "러닝 타입스크립트" 신간이 있어서 읽게 되었다. O'Reilly 책 표지에 밝은 색깔이 들어가 있는것은 정말 오랜만에 본것 같다. 

책은 생각보다 쉽게 읽혀진다. 설명과 코드로 이루어진 책이긴 하지만 따라하기도 쉽고 이해하기 쉽게 설명이 되어있다. 

특히 코드 부부은 주석과 오류에 대한 내용이 컬러로 표기되어있어서 눈에 더 잘 들어왔다. 소스코드도 다 제공이 되긴 하지만 간단한 코드들이니 직접 해보는것이 좋다. 

저자가 책 서문에 말한대로 이책은 한번 가볍게 1독을 한 후에 레퍼런스 처럼 활용하는게 가장 좋은 활용법인것 같다. 간단한 문법과 설명들이지만 다 외울수 있는 양은 아니다. 보다보면 내용이 생각이 안나는 경우도 생기기 때문에 우선 한번 끝까지 읽어보고 실제 타입 스크립트를 사용할때 모르는 부분을 찾아보는 형식으로 활용하면 큰 도움이 될것 같다. 

아직 천천히 공부중이라서 다 읽지는 못했지만 다 읽고 나면 타입 스크립트에 대한 기본적인 이해와 사용 방법에 대해서는 익숙해 질수 있을 것 같다.

 "한빛미디어 <나는 리뷰어다> 활동을 위해서 책을 제공받아 작성된 서평입니다."

Union : 값이 허용된 타입을 두개 이상의 가능한 타입으로 확장하는 것

let physicist = Math.random() > 0.5 ? "TEST" : 100;

실제 위와 같은 코드에서는 아래와 같이 판단한다.

Narrowing : 값이 허용된 타입이 하나 이상의 가능한 타입이 되지 않도록 좁히는것

let animal: number | string;
animal = 'tiger';

number 와 string 으로 선언했지만 값 할당을 통해서 string 타입으로 확인되었기 때문에 string 관련 메소드만 사용 가능 하다.

아래와 같이 조건문을 통해서도 타입이 결정될수 있다.

let physicist = Math.random() > 0.5 ? "TEST" : 100;

typeof physicist === "string" ? physicist.toUpperCase() : physicist.toFixed();