3일차 - 영상 데이터 처리를 위한 객체지향 프로그래밍

Python

Python에서는 모든 것이 객체다

함수도 객체 파일도 객체 가능한 모든 것들이 객체

Object (type)의 내부 정보를 알고 싶을 때

1. type 2. dir 3. id 4. vars

이름/식별자를 불렀을 때 내부적으로 작동하는 것들

1. REPR 2. STR

class A:
  def __repr__(self):
    return 'REPR'

  def __str__(self):
    return 'STR'
a = A()
a # 이름을 부르면 __repr__가 호출된다 
# REPR

print(a) # 이름을 print하면 __str__이 호출된다 / escape를 처리해준다 
# STR

※ self를 붙이는 이유

class A: 
  def __init__(this):  # self 대신 다른 것 사용 가능 그러나 pep8에서 self 사용 권장 
    print('a') 
  def __call__(self):  # 객체 지향에서 self는 인스턴스(object)를 뜻한다  
    print('call')
  def aa(self):
    print('aa')

# python 내부에서 c기반으로 작동하기 때문에 (c는 method 개념이 없다) 이와 같이 만들어 졌다 
a = A()
A.aa(a) # 어떤 인스턴스에 대해서 사용할 것인가 인자가 필요 / version 1 / 주체가 class A 
a.aa(a) # 인스턴스가 주체이고 싶을 때 / argument가 중복되기 때문에 a 생략하게 만들었다 
a.aa()

 import itertools 
 dir(itertools) #__package__ / dir은 객체의 모든 attribute를 조회 함수이다 
 ['__doc__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 '_grouper',
 '_tee',
 '_tee_dataobject',
 'accumulate',
 'chain',
 'combinations',
 'combinations_with_replacement',
 'compress',
 'count',
 'cycle',
 'dropwhile',
 'filterfalse',
 'groupby',
 'islice',
 'permutations',
 'product',
 'repeat',
 'starmap',
 'takewhile',
 'tee',
 'zip_longest']

type(itertools) # module이라는 데이터 타입 
# module

id(itertools)
# 140663255600208

dir(int) # 클래스도 객체 이다 
['__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']

객체 지향

[객체지향의 4가지 특성]

1. 캡슐화

- 실제 구현내용을 감추는 것

- 재활용 가능

- 파이썬에서는 기본적으로 외부에서 클래스 접근 가능

- descriptor로 클래스 접근을 막을 수도 있다

2. 추상화

- 필요로 하는 속성이나 행동을 추출하는 작업

- 구체적인것과 추상적인 것을 분리시킨다

- 특징을 뽑아 객체로 구현

3. 상속

- 추상화의 반대

- 추상화한 클래스를 물려받아 구체적으로 원하는 대로 바꾸어 사용 가능

4. 다형성

- 다양한 결과를 낼 수 있다

Subclass(Inheritance)

'장점'

- 부모 클래스의 기능을 재사용

-부모의 기능을 그대로 사용한다

- 부모의 기능을 일부만 사용한다

- 부모에게 없는 기능을 추가 가능하다

'단점'

- 부모가 바뀌면 같이 바뀐다

# composition 방식으로 inheritance 방식 대체 가능하다

※ duck typing, composition으로 사용해도 상속받은 것과 유사하게 사용 가능하다

 

class A:
  a = 1

class B(A): # Delegat(위임/대리자)
  pass 
  
id(A.a) == id(B.a)
# True

A.a is B.a # B에 없으면 부모의 것을 불러오기 때문에 같아진다 
# True

Python의 모든 객체는 object로 부터 상속 받는다

class A(object, metaclass=type):
  pass
  
dir(A)
['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__']

dir(A.__class__)
['__abstractmethods__',
 '__base__',
 '__bases__',
 '__basicsize__',
 '__call__',
 '__class__',
 '__delattr__',
 '__dict__',
 '__dictoffset__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__flags__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__instancecheck__',
 '__itemsize__',
 '__le__',
 '__lt__',
 '__module__',
 '__mro__',
 '__name__',
 '__ne__',
 '__new__',
 '__prepare__',
 '__qualname__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasscheck__',
 '__subclasses__',
 '__subclasshook__',
 '__text_signature__',
 '__weakrefoffset__',
 'mro']

다중 상속

다중 상속이란 2개 이상 클래스를 상속하는 것을 말한다

python은 다중 상속을 지원하는 언어이다

다중 상속은 편한 기능이지만 다이아몬드 문제가 발생할 수 있다

단일 상속인 프로그래밍 언어들이 많음(Java)

class A:
  x = 1

class B:
  x = 2 

class C(A,B):
  pass

# method resolution order (python2.2 부터 지원)

C.mro()
# [__main__.C, __main__.A, __main__.B, object]

C.__mro__
# (__main__.C, __main__.A, __main__.B, object)

C.x # C에 없어서 그 다음 우선순위인 A에서 찾는다 
# 1

다이아몬드 문제

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(A, B):
    pass

# 이런 경우 메소드의 실행순서를 정할 수 없다 
# TypeError: Cannot create a consistent method resolution order (MRO) for bases A, B

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass
    
D.mro() # linearization / tail recursion elimination => linearization
# [__main__.D, __main__.B, __main__.C, __main__.A, object]

dir(D) # metaclass 
['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__']

MRO (Method Resolution Order)

메소드 실행 순서를 확인하는 클래스 메소드(인스턴스로 사용 불가)

class A:
    def __init__(self):
        print('A')

class B(A):
    def __init__(self):   #overriding (parent와 가능한 parameter 일치)
        A.__init__(self) 
        print('B')

class C(A):
    def __init__(self):
        A.__init__(self)
        print('C')

class D(B, C):
    def __init__(self):
        B.__init__(self)   # __init__ 함수 
        C.__init__(self)
        print('D')

d = D()  # A가 중복해서 실행되는 문제가 발생한다 
# A
# B
# A
# C
# D

D.mro()
# [__main__.D, __main__.B, __main__.C, __main__.A, object]

import tensorflow as tf 

model = tf.keras.models.Sequential()

model.__class__.mro()
[keras.engine.sequential.Sequential,
 keras.engine.functional.Functional,
 keras.engine.training.Model,
 keras.engine.base_layer.Layer,
 tensorflow.python.module.module.Module,
 tensorflow.python.training.tracking.tracking.AutoTrackable,
 tensorflow.python.training.tracking.base.Trackable,
 keras.utils.version_utils.LayerVersionSelector,
 keras.utils.version_utils.ModelVersionSelector,
 object]

Super - 중복 실행을 방지하는 방법

super는 상속을 전부 실행하지 않는다

class A:
    def __init__(self):
        print('A')

class B(A):
    def __init__(self):     
        super().__init__()  #super()는 부모의 인스턴스다 / python3 방식이다 
        print('B')

class C(A):
    def __init__(self):  
        super(C, self).__init__()        # __init__은 메소드 이다 / python2, python3 방식이다 
        print('C')

class D(B, C):
    def __init__(self):
        super().__init__()
        print('D')
        
d = D()
# A
# C
# B
# D

D.mro()
# [__main__.D, __main__.B, __main__.C, __main__.A, object]

실행 순서는 D -> B -> C -> A 인데 출력 결과는 왜 반대일까? 그 이유는 바로 super사용시 stack에 들어가기 때문이다

※ Stackoverflow

def fib(n):
  return fib(n-1) + fib(n-2) if n>2 else 1  # 재귀적으로 계산되는 중간 과정은 stack영역에 저장된다 => 중간 과정에서 중복되는 연산이 많이 쌓인다 => stack에 많이 쌓여 넘치는 것을 stackoverflow 
                                            # 그러나 python에서는 overflow가 없다 
fib(10) 
# 55

import sys
sys.maxsize
# 9223372036854775807

sys.maxsize + 1 # 정수형은 stackoverflow가 없는 대신에 내부적으로 현재 남아있는 만큼의 가용 메모리를 모두 수 표현에 끌어다 쓴다. 따라서 정수형 연산은 속도(성능)가 매우 느리다 
# 9223372036854775808

sys.float_info
# sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

0.1 + 0.1 + 0.1 
# 0.30000000000000004

1.7976931348623157e+308  == 1.7976931348623157e+308 + 1 # 근사적으로 계산하기 때문에 속도가 빠르다 
# True

a == a + 1 # infinity

 

Duck Typing

미운오리새끼 이야기에서 유래가 되어 오리가 아닌데 오리처럼 행동을 하면 오리라고 간주한다는 개념이다

타입을 미리 정하지 않고 실행되었을 때 해당 Method들을 확인하여 타입을 정한다

 

'장점'

- 타입에 대해 자유롭다

- 상속을 하지 않아도 상속을 한것처럼 클래스의 메소드 사용이 가능하다

'단점'

- 원치 않는 타입이 들어 갈 경우 오류가 발생할 수 있다

- 오류 발생시 원인을 찾기 어려울수 있다

- 호환성 떨어짐 => 추상 클래스로 대체

- 코딩 많이 해야 함

Composition

상속을 하지 않고 클래스내에 객체를 불러와 다른 클래스의 일부 기능을 사용하는 방법.

상속의 위험부담을 줄일 수 있다

class SecurityDoor:
    locked = True

    def __init__(self, number, status):
        self.door = Door(number, status) # Door의 객체를 갖게 한다

    def open(self):
        if self.locked:
            return
        self.door.open()

    def __getattr__(self, attr):        # try except와 비슷
        return getattr(self.door, attr) # Door의 attr를 가져와라 (상속을 비슷하게 사용)


class ComposedDoor:
    def __init__(self, number, status):
        self.door = Door(number, status)

    def __getattr__(self, attr): # 없으면 가져와라
        return getattr(self.door, attr) # 바꾸지 않고 불러와서 사용할 때

Meta class

type => 모든 클래스의 행동을 결정해준다 클래스의 행동을 바꾸고자 할때 사용하는 클래스

 

type('int2', (int,), {}) # __main__ 메소드가 있다면 현재 내 작업 공간에서 만든 것이라는 의미이다 
# __main__.int2

a = type('int2', (int,), {})
type(a)
# type

class A:  # attribute(클래스안에 정의된 모든 것) vs property (descriptor)
  pass

%whos # 현재 작업 공간에 어떤 객체가 있는가 확인  할때 사용 
#
Variable    Type      Data/Info
-------------------------------
A           type      <class '__main__.A'>
a           type      <class '__main__.int2'>
drive       module    <module 'google.colab.dri<...>s/google/colab/drive.py'>
itertools   module    <module 'itertools' (built-in)>

%who_ls
['A', 'a', 'drive', 'itertools']

%lsmagic
Available line magics:
%alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cat  %cd  %clear  %colors  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %pip  %popd  %pprint  %precision  %profile  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %rep  %rerun  %reset  %reset_selective  %rm  %rmdir  %run  %save  %sc  %set_env  %shell  %store  %sx  %system  %tb  %tensorflow_version  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode

Available cell magics:
%%!  %%HTML  %%SVG  %%bash  %%bigquery  %%capture  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%shell  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile

Automagic is ON, % prefix IS NOT needed for line magics.

A # REPR(Representation / 이름을 부르면 표현해 주세요) => 메모리에 저장되어 있는 것 부른다 
# __main__.A

※ Error

1. NameError : 이름이 없을 때

2. AttributeError : attribute가 없을 때, 기능 자체가 없을 때

import tensorflow as tf 
model = tf.keras.models.Sequential()

model.summary() # 실행하는 시점에 따라서 인스턴스 변수가 다르게 갖기 때문에 / 값이 없기 때문에 valueError 
# ValueError: This model has not yet been built. Build the model first by calling `build()` or calling `fit()` with some data, or specify an `input_shape` argument in the first layer(s) for automatic build.

model(tf.constant([[1,2]]))
# <tf.Tensor: shape=(1, 2), dtype=int32, numpy=array([[1, 2]], dtype=int32)>

model.summary()
#
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
Total params: 0
Trainable params: 0
Non-trainable params: 0
_________________________________________________________________

layer = tf.keras.layers.Dense(1) 
layer.summary()
# AttributeError: 'Dense' object has no attribute 'summary'

class A:
  t = 1
  def tt(self):
    print('t')
getattr(A, 't') # A에서 t접근 해주세요 
# 1
a = A()
getattr(A, 'tt')(a)
# 1

변수와 상수가 구분이 있는 언어라면 상수는 재할당 할 수 없다

python은 변수와 상수를 구분하지 않는다

따라서 tensorflow에서는 이를 구분하기 위해 constant와 variable을 추가적으로 만들었다

cc = tf.constant([1,2,3]) # 상수
dd = tf.Variable([1,2,3]) # 변수 
dd.assign_add([2,3,4])
# <tf.Variable 'UnreadVariable' shape=(3,) dtype=int32, numpy=array([3, 5, 7], dtype=int32)>

import numpy as np
x = np.array([1,2,3])
x 
# array([1, 2, 3])

print(x)
# [1 2 3]

Python의 *

1. number *, **

- 3*3 # 곱하기

- 3**3 # 제곱

2. sequence *

3. assignment (binding) : unpacking

- x,y,*z = 1,2,3,4 # unpacking에서 나머지

4. parameter *name

- def x(*b): # 인자의 갯수 제한을 두지 않는다 return b

5. parameter *

- def name(*,a,b): # keyword only *다음엔 keyword를 사용해야 한다

       return a + b # positional 방식 다음에 keyword 방식을 써야 한다

6. parameter **

- def y(**b): # Variable Keyword return b 7. argument *

- def a(*b):

      return b x = [1,2,3,4] a(*x) # argument unpacking

8. argument **

- def aa(**b):

       return b y = {'a': 1, 'b' : 2} aa(**)

9. import에서 모두

- import *

※ def t(a, *b)이런 형태를 자주 쓰는 이유

def t(*a, **b):

     print(a)

     print(b)

# parameter, argument를 정확히 맞출 필요가 없음, 인터페이스의 유연성을 위해

 

def aa(**b):
  return b

y= {'a':1,'b':2}
z= {'c':2,'a':3}
{**y, **z}
# {'a': 3, 'b': 2, 'c': 2}