국민대, 파이썬, 데이터

W06


Table of Contents

  1. Package와 Module
  2. Scope
  3. Object-Oriented Programming

In [1]:
from IPython.display import Image

1. Package와 Module

1.1 Module

Module은 확장자가 py인 파일 하나를 의미합니다.

1.2 Package

Package는 Module이 있는 디렉토리를 의미합니다. 이 때 디렉토리에는 Package initailization file이 필요합니다. 아무런 내용이 없는 __init__.py을 만들어 이 디렉토리가 Python에서 사용하는 Package임을 나타낼 수 있습니다.


In [62]:
!ls source/package/


package1

In [14]:
!dir -r source\package\


 C 드라이브의 볼륨에는 이름이 없습니다.
 볼륨 일련 번호: D68D-E2A9

 C:\GitHub\kookmin-1 디렉터리


 C:\GitHub\kookmin-1\source\package 디렉터리

2016-04-10  오전 12:33    <DIR>          .
2016-04-10  오전 12:33    <DIR>          ..
2016-04-10  오전 12:33    <DIR>          package1
               0개 파일                   0 바이트
               3개 디렉터리  253,857,869,824 바이트 남음
파일을 찾을 수 없습니다.

In [61]:
!tree source/package/


source/package/
└── package1
    ├── __init__.py
    ├── module1.py
    └── package2
        ├── __init__.py
        └── module2.py

2 directories, 4 files

위 트리 구조를 보면 디렉토리 안에 __init__.py가 있음을 알 수 있습니다.

1.3 How to use

from dir1 import mod1
from mod1 import function
from mod1 import Class
from mod1 import *
import dir1.dir2.mod1

위와 같은 형식으로 Package와 Module 그리고 Module 안의 객체를 문서 안으로 가져와서 사용할 수 있습니다. 다만 import * 에서 별표(*)는 되도록 사용하지 않고 필요한 객체를 정확히 써주는게 좋습니다.


In [15]:
from source.package.package1 import module1

In [16]:
dir(module1)


Out[16]:
['__author__',
 '__builtins__',
 '__cached__',
 '__doc__',
 '__file__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 'author']

In [17]:
module1.author()


Out[17]:
'kwangyoun.jung'

In [18]:
module1.__author__ = 'abcd'

In [19]:
module1.author()


Out[19]:
'abcd'

2. Scope


In [3]:
Image(filename='images/scope.png')


Out[3]:
  • Scope 혹은 Namespace
    • 객체가 사용할 수 있는 지역(Area) 혹은 구역을 말합니다.
    • Python에서는 위 그림과 같은 규칙을 따릅니다. 혹자는 이를 LEGB Rule이라고 부릅니다.
    • 위 그림에 있는 것처럼 네모칸 안에서 선언한 것은 해당 네모칸에서만 사용가능합니다.

2.1 Built-in

  • 빌트인? 대개 우리는 이 단어는 풀옵션 원룸 같은 곳에서 빌트인 되어있는 책장, 침대 등을 통해 익숙할 것입니다.
  • Python을 실행하자마자 따로 사용하겠다고 선언하지 않았는데도 어디서나 실행가능 한 객체입니다. 어떤 것들이 있는지 살펴보겠습니다.

builtins


In [20]:
import builtins

In [21]:
dir(builtins)


Out[21]:
['ArithmeticError',
 'AssertionError',
 'AttributeError',
 'BaseException',
 'BlockingIOError',
 'BrokenPipeError',
 'BufferError',
 'BytesWarning',
 'ChildProcessError',
 'ConnectionAbortedError',
 'ConnectionError',
 'ConnectionRefusedError',
 'ConnectionResetError',
 'DeprecationWarning',
 'EOFError',
 'Ellipsis',
 'EnvironmentError',
 'Exception',
 'False',
 'FileExistsError',
 'FileNotFoundError',
 'FloatingPointError',
 'FutureWarning',
 'GeneratorExit',
 'IOError',
 'ImportError',
 'ImportWarning',
 'IndentationError',
 'IndexError',
 'InterruptedError',
 'IsADirectoryError',
 'KeyError',
 'KeyboardInterrupt',
 'LookupError',
 'MemoryError',
 'NameError',
 'None',
 'NotADirectoryError',
 'NotImplemented',
 'NotImplementedError',
 'OSError',
 'OverflowError',
 'PendingDeprecationWarning',
 'PermissionError',
 'ProcessLookupError',
 'RecursionError',
 'ReferenceError',
 'ResourceWarning',
 'RuntimeError',
 'RuntimeWarning',
 'StopAsyncIteration',
 'StopIteration',
 'SyntaxError',
 'SyntaxWarning',
 'SystemError',
 'SystemExit',
 'TabError',
 'TimeoutError',
 'True',
 'TypeError',
 'UnboundLocalError',
 'UnicodeDecodeError',
 'UnicodeEncodeError',
 'UnicodeError',
 'UnicodeTranslateError',
 'UnicodeWarning',
 'UserWarning',
 'ValueError',
 'Warning',
 'WindowsError',
 'ZeroDivisionError',
 '__IPYTHON__',
 '__IPYTHON__active',
 '__build_class__',
 '__debug__',
 '__doc__',
 '__import__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 'abs',
 'all',
 'any',
 'ascii',
 'bin',
 'bool',
 'bytearray',
 'bytes',
 'callable',
 'chr',
 'classmethod',
 'compile',
 'complex',
 'copyright',
 'credits',
 'delattr',
 'dict',
 'dir',
 'divmod',
 'dreload',
 'enumerate',
 'eval',
 'exec',
 'filter',
 'float',
 'format',
 'frozenset',
 'get_ipython',
 'getattr',
 'globals',
 'hasattr',
 'hash',
 'help',
 'hex',
 'id',
 'input',
 'int',
 'isinstance',
 'issubclass',
 'iter',
 'len',
 'license',
 'list',
 'locals',
 'map',
 'max',
 'memoryview',
 'min',
 'next',
 'object',
 'oct',
 'open',
 'ord',
 'pow',
 'print',
 'property',
 'range',
 'repr',
 'reversed',
 'round',
 'set',
 'setattr',
 'slice',
 'sorted',
 'staticmethod',
 'str',
 'sum',
 'super',
 'tuple',
 'type',
 'vars',
 'zip']

In [22]:
len("abcd")


Out[22]:
4

In [23]:
sum([1, 2]) / len([1, 2])


Out[23]:
1.5

In [24]:
builtins


Out[24]:
<module 'builtins' (built-in)>

In [25]:
builtins.dir('a')


Out[25]:
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmod__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'capitalize',
 'casefold',
 'center',
 'count',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'format_map',
 'index',
 'isalnum',
 'isalpha',
 'isdecimal',
 'isdigit',
 'isidentifier',
 'islower',
 'isnumeric',
 'isprintable',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'maketrans',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill']

위와 같이 Built in function 객체를 볼 수 있습니다. 다만 built in function에는 무엇이 있는지 보기위해 builtins라는 모듈을 가져와서(import) 그 모듈안에 있는 함수가 무엇이 있는지 dir이라는 built in function으로 살펴본 것입니다.

2.2 Global(module)과 Local


In [3]:
NUM1 = 100  # Global Variable

def foo(NUM2):
    print("NUM1 + NUM2 = %d" % (NUM1 + NUM2))

foo(1)


NUM1 + NUM2 = 101

위의 예제처럼 파일(모듈) 안에 있다면 어디서든 쓸 수 있는 변수를 Global Variable 혹은 전역 변수라고 합니다.


In [26]:
NUM1 = 100  # Global Variable

def foo(NUM2):
    NUM1 = NUM2  # Local Variable
    print("Local NUM1 = %d" % NUM1)  # Local Variable

foo(1)
print("Global NUM1 = {0}".format(NUM1))  # {0} 는 format 함수의 첫번째 argument


Local NUM1 = 1
Global NUM1 = 100

위에서 보듯 Local은 Function 안에서만 사용할 수 있는 객체입니다. 따라서 위 예제와 같이 Global이나 Local에서 똑같은 이름의 객체라 할지라도 Scope가 다르기 때문에 다른 값을 가지고 있는 것입니다. 즉 function 안의 NUM1과 function 밖의 NUM1은 엄연히 다른 것입니다.

Function안에서 Global Variable인 NUM1 값을 바꾸는 방법은 없을까요!?


In [41]:
NUM1 = 100  # Global Variable

def foo(NUM2):
    global NUM1
    NUM1 = NUM2
    print("Global NUM1 = %d" % NUM1)  # Global Variable

foo(1)
print("Global NUM1 = {0}".format(NUM1))  # Global Variable


Global NUM1 = 1
Global NUM1 = 1

2.3 Enclosing function locals

  • 함수 안에 함수를 만들 수 있습니다.
  • 이 때 함수에 선언했던 특정 변수를 함수 안의 함수 안에서 사용할 수 있습니다.

In [56]:
X = 99

def f1():
    X = 88
    def f2():
        print(X)
    f2()

f1()


88

3. Object-Oriented Programming

3.1 객체 정의


In [20]:
Image(filename='images/class.png')


Out[20]:
  • 객체는 아래와 같은 특징을 갖고 있는 것을 말합니다.
    • Variables(State): 변수(상태값)
    • Methods: 메소드(행동)

함수 VS. 메소드

위 둘은 같은 기능을 합니다. 똑같다고 보면 됩니다. 하지만 관점에 따라 다르게 부르는 차이가 있을 뿐입니다. 클래스 안에서 만들었다면 Method, 클래스 밖에서 즉, 클래스 안이 아닌 문서 내 어디에서나 만든 것을 함수라고 부릅니다.

3.2 객체 지향 프로그래밍

  • 컴퓨터 프로그램을 독립된 단위인 객체들의 모임으로 바라보는 소프트웨어 개발 방법론이다.
  • 유연하고 변경이 용이하다는 특징을 가지고 있다.

3.2.1 절차지향 VS. 객체지향


In [23]:
Image(filename='images/class_comparison1.png')


Out[23]:

In [24]:
Image(filename='images/class_comparison2.png')


Out[24]:

3.2.2 Real World의 Abstraction(추상화)

  • 그렇다면 실제 세계에 존재하는 것들을 객체 지향적 관점으로 Abstraction(추상화) 혹은 모델링을 해보겠습니다.
  • 자전거를 예로 들어보겠습니다.
  • 자전거
    • Methods(Behavior)
      • 기어 바꾸기
      • 브레이크
      • 방향 바꾸기
    • Attributes/Fields(State)
      • mph 속도
      • rpm 속도
      • 기어

In [22]:
Image(filename='images/class_state_methods.png')


Out[22]:

3.2.3 다양한 자전거 종류의 표현

  • 그런데 자전거는 종류가 많습니다.
  • 자전거
    • MTB
    • Road Bike
    • Tandem Bike(이인승 자전거)
    • Fixie Bike
  • 기본적인 자전거의 형태를 통해 다양한 자전거를 만들어낼 수 있습니다.

In [21]:
Image(filename='images/class_bicycle.png')


Out[21]:

3.2.4 자전거 외

  • 위에서는 자전거로 예를 들어보았지만, 다른 것도 많겠지요 어떤 것이 있을까요!?

In [25]:
Image(filename='images/class_examples.png')


Out[25]:
  • 객체의 특징을 이용한다면 사람이라는 틀을 만들어 속성을 다르게 하여 아프리카인, 아시아인 등의 객체를 만들 수 있습니다.
  • 붕어빵도 마찬가지겠죠, 붕어빵 틀을 이용해 속에 들어가는 속성을 바꿔 여러 객체를 생성할 수 있습니다.

3.3 Python에서의 객체

  • Python은 객체 지향 프로그래밍 언어입니다.
  • Python의 모든 것은 객체입니다. 심지어 숫자와 문자까지 다 객체입니다.

Python의 모든 것이 객체이다

문자일뿐인데


In [27]:
"a"


Out[27]:
'a'

숫자일뿐인데


In [28]:
1


Out[28]:
1

문자와 숫자도 객체이므로 객체의 특징이 있습니다. Python이 문자와 숫자에 미리 사용할 수 있는 함수와 변수를 만들어 놨기 때문입니다.


In [29]:
dir("a")


Out[29]:
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmod__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'capitalize',
 'casefold',
 'center',
 'count',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'format_map',
 'index',
 'isalnum',
 'isalpha',
 'isdecimal',
 'isdigit',
 'isidentifier',
 'islower',
 'isnumeric',
 'isprintable',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'maketrans',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill']

In [30]:
dir(1)


Out[30]:
['__abs__',
 '__add__',
 '__and__',
 '__bool__',
 '__ceil__',
 '__class__',
 '__delattr__',
 '__dir__',
 '__divmod__',
 '__doc__',
 '__eq__',
 '__float__',
 '__floor__',
 '__floordiv__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__index__',
 '__init__',
 '__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']

문자와 숫자가 진짜 객체인지 확인해봅시다.


In [15]:
type("a")


Out[15]:
str

In [9]:
type(1)


Out[9]:
int

In [10]:
isinstance("a", str)


Out[10]:
True

In [11]:
isinstance(1, int)


Out[11]:
True

In [12]:
isinstance(1, str)


Out[12]:
False

In [31]:
help(str)


Help on class str in module builtins:

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |  
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __format__(...)
 |      S.__format__(format_spec) -> str
 |      
 |      Return a formatted version of S as described by format_spec.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __getnewargs__(...)
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __hash__(self, /)
 |      Return hash(self).
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __sizeof__(...)
 |      S.__sizeof__() -> size of S in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(...)
 |      S.capitalize() -> str
 |      
 |      Return a capitalized version of S, i.e. make the first character
 |      have upper case and the rest lower case.
 |  
 |  casefold(...)
 |      S.casefold() -> str
 |      
 |      Return a version of S suitable for caseless comparisons.
 |  
 |  center(...)
 |      S.center(width[, fillchar]) -> str
 |      
 |      Return S centered in a string of length width. Padding is
 |      done using the specified fill character (default is a space)
 |  
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |      
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |  
 |  encode(...)
 |      S.encode(encoding='utf-8', errors='strict') -> bytes
 |      
 |      Encode S using the codec registered for encoding. Default encoding
 |      is 'utf-8'. errors may be given to set a different error
 |      handling scheme. Default is 'strict' meaning that encoding errors raise
 |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
 |      'xmlcharrefreplace' as well as any other name registered with
 |      codecs.register_error that can handle UnicodeEncodeErrors.
 |  
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |      
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |  
 |  expandtabs(...)
 |      S.expandtabs(tabsize=8) -> str
 |      
 |      Return a copy of S where all tab characters are expanded using spaces.
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |  
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |      
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |      
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |      
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |  
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |      
 |      Like S.find() but raise ValueError when the substring is not found.
 |  
 |  isalnum(...)
 |      S.isalnum() -> bool
 |      
 |      Return True if all characters in S are alphanumeric
 |      and there is at least one character in S, False otherwise.
 |  
 |  isalpha(...)
 |      S.isalpha() -> bool
 |      
 |      Return True if all characters in S are alphabetic
 |      and there is at least one character in S, False otherwise.
 |  
 |  isdecimal(...)
 |      S.isdecimal() -> bool
 |      
 |      Return True if there are only decimal characters in S,
 |      False otherwise.
 |  
 |  isdigit(...)
 |      S.isdigit() -> bool
 |      
 |      Return True if all characters in S are digits
 |      and there is at least one character in S, False otherwise.
 |  
 |  isidentifier(...)
 |      S.isidentifier() -> bool
 |      
 |      Return True if S is a valid identifier according
 |      to the language definition.
 |      
 |      Use keyword.iskeyword() to test for reserved identifiers
 |      such as "def" and "class".
 |  
 |  islower(...)
 |      S.islower() -> bool
 |      
 |      Return True if all cased characters in S are lowercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  isnumeric(...)
 |      S.isnumeric() -> bool
 |      
 |      Return True if there are only numeric characters in S,
 |      False otherwise.
 |  
 |  isprintable(...)
 |      S.isprintable() -> bool
 |      
 |      Return True if all characters in S are considered
 |      printable in repr() or S is empty, False otherwise.
 |  
 |  isspace(...)
 |      S.isspace() -> bool
 |      
 |      Return True if all characters in S are whitespace
 |      and there is at least one character in S, False otherwise.
 |  
 |  istitle(...)
 |      S.istitle() -> bool
 |      
 |      Return True if S is a titlecased string and there is at least one
 |      character in S, i.e. upper- and titlecase characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |      Return False otherwise.
 |  
 |  isupper(...)
 |      S.isupper() -> bool
 |      
 |      Return True if all cased characters in S are uppercase and there is
 |      at least one cased character in S, False otherwise.
 |  
 |  join(...)
 |      S.join(iterable) -> str
 |      
 |      Return a string which is the concatenation of the strings in the
 |      iterable.  The separator between elements is S.
 |  
 |  ljust(...)
 |      S.ljust(width[, fillchar]) -> str
 |      
 |      Return S left-justified in a Unicode string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  lower(...)
 |      S.lower() -> str
 |      
 |      Return a copy of the string S converted to lowercase.
 |  
 |  lstrip(...)
 |      S.lstrip([chars]) -> str
 |      
 |      Return a copy of the string S with leading whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  partition(...)
 |      S.partition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, and return the part before it,
 |      the separator itself, and the part after it.  If the separator is not
 |      found, return S and two empty strings.
 |  
 |  replace(...)
 |      S.replace(old, new[, count]) -> str
 |      
 |      Return a copy of S with all occurrences of substring
 |      old replaced by new.  If the optional argument count is
 |      given, only the first count occurrences are replaced.
 |  
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |      
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |      
 |      Return -1 on failure.
 |  
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |      
 |      Like S.rfind() but raise ValueError when the substring is not found.
 |  
 |  rjust(...)
 |      S.rjust(width[, fillchar]) -> str
 |      
 |      Return S right-justified in a string of length width. Padding is
 |      done using the specified fill character (default is a space).
 |  
 |  rpartition(...)
 |      S.rpartition(sep) -> (head, sep, tail)
 |      
 |      Search for the separator sep in S, starting at the end of S, and return
 |      the part before it, the separator itself, and the part after it.  If the
 |      separator is not found, return two empty strings and S.
 |  
 |  rsplit(...)
 |      S.rsplit(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string, starting at the end of the string and
 |      working to the front.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified, any whitespace string
 |      is a separator.
 |  
 |  rstrip(...)
 |      S.rstrip([chars]) -> str
 |      
 |      Return a copy of the string S with trailing whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  split(...)
 |      S.split(sep=None, maxsplit=-1) -> list of strings
 |      
 |      Return a list of the words in S, using sep as the
 |      delimiter string.  If maxsplit is given, at most maxsplit
 |      splits are done. If sep is not specified or is None, any
 |      whitespace string is a separator and empty strings are
 |      removed from the result.
 |  
 |  splitlines(...)
 |      S.splitlines([keepends]) -> list of strings
 |      
 |      Return a list of the lines in S, breaking at line boundaries.
 |      Line breaks are not included in the resulting list unless keepends
 |      is given and true.
 |  
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |      
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |  
 |  strip(...)
 |      S.strip([chars]) -> str
 |      
 |      Return a copy of the string S with leading and trailing
 |      whitespace removed.
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  swapcase(...)
 |      S.swapcase() -> str
 |      
 |      Return a copy of S with uppercase characters converted to lowercase
 |      and vice versa.
 |  
 |  title(...)
 |      S.title() -> str
 |      
 |      Return a titlecased version of S, i.e. words start with title case
 |      characters, all remaining cased characters have lower case.
 |  
 |  translate(...)
 |      S.translate(table) -> str
 |      
 |      Return a copy of the string S in which each character has been mapped
 |      through the given translation table. The table must implement
 |      lookup/indexing via __getitem__, for instance a dictionary or list,
 |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If
 |      this operation raises LookupError, the character is left untouched.
 |      Characters mapped to None are deleted.
 |  
 |  upper(...)
 |      S.upper() -> str
 |      
 |      Return a copy of S converted to uppercase.
 |  
 |  zfill(...)
 |      S.zfill(width) -> str
 |      
 |      Pad a numeric string S with zeros on the left, to fill a field
 |      of the specified width. The string S is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  maketrans(x, y=None, z=None, /)
 |      Return a translation table usable for str.translate().
 |      
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.


In [16]:
help(object)


Help on class object in module builtins:

class object
 |  The most base type


In [17]:
isinstance("a", object)


Out[17]:
True

3.1 Class

  • 객체 지향 프로그래밍을 구현하기 위해서는 클래스(Class)라는 것을 선언하여 사용합니다.
  • Class는 새로운 객체를 생성하는 데 사용되는 매커니즘인 것입니다.
  • 이 Class라는 것은 마치 붕어빵 틀처럼 여러 붕어빵을 만들 수 있습니다.
  • 그리고 이 붕어빵의 속성은 속이 팥, 크림이라는 것과 반죽은 밀가루라는 것 등이 있으며, 재밌게도 말을 할 수 있다는 행위적인 기능이 있다고 생각해보겠습니다.
  • 정리해보면 Class를 통해 객체 지향 매커니즘을 구현할 수 있습니다.
  • 이 Class를 통해 여러 객체 또는 인스턴스를 만들 수 있습니다.

3.2 Class 특징 - 상속(Inheritance)

  • 클래스는 클래스 간 상속을 받을 수 있습니다.
  • 상속을 받기 때문에 부모와 자식 관계라고도 합니다.
  • 부모 클래스로부터 변수와 메소드를 사용할 수 있습니다.
  • 클래스에는 상속 외에 Encapsulation, Abstration, Polymorphism 같은 특징이 있지만 여기서는 데이터 분석에 초점을 두고 흔히 사용되는 상속개념만 보고 넘어가도록 하겠습니다.

3.3 Class 정의하기

class Bicycle(상속받을 부모 클래스):
    COLOR = "BLACK"
    def pedaling(self):
        # Statements
  • Python에서는 클래스를 대문자로 시작합니다. 의무는 아니지만 지키는 것이 다른 개발자와 Cowork하기에 좋을 것 같습니다.
  • 괄호 안에는 상속받을 부모 클래스를 입력합니다.
  • 클래스 안에는 지금껏 공부했던 속성과 메소드를 작성할 수 있습니다.

3.4 Class로부터 인스턴스(Instance) 만들기

  • 응? 인스턴스는 무엇일까요!?
  • 우리가 위에서 계속해서 언급했던 단어가 객체입니다. 인스턴스는 객체와 똑같은 말입니다.
  • 다만, 관점이 달라서 특정 클래스로부터 만든 객체를 나타날 때는 특히 인스턴스라는 말을 많이 합니다.

In [30]:
class Bicycle():
    COLOR = "BLACK"
    def pedaling(self, speed):
        print("%d 속도로 달립니다!" % speed)

In [32]:
my_bicycle = Bicycle()
my_bicycle.COLOR


Out[32]:
'BLACK'

In [33]:
my_bicycle.pedaling(40)


40 속도로 달립니다!

In [25]:
Bicycle.pedaling('a', 30)


30 속도로 달립니다!

3.4.1 하나의 클래스로부터 다수의 인스턴스 생성


In [39]:
my_bicycle = Bicycle()
a = Bicycle()
b = Bicycle()
c = Bicycle()
d = Bicycle()

print(my_bicycle.COLOR)
print(d.COLOR)


BLACK
BLACK

3.4.2 부모 클래스로부터 상속받은 변수의 값을 인스턴스에서 변경


In [40]:
d.COLOR = "RED"
d.COLOR


Out[40]:
'RED'

3.4.3 인스턴스를 통해 함수 실행


In [42]:
d.pedaling(30)


30 속도로 달립니다!

3.5 클래스에서 정의할 수 있는 메서드

  • 그런데 위에 예제를 보면 pedaling 메소드의 인자값에 self라는 낮선 것이 있습니다.
  • 클래스 안에서 생성할 수 있는 메소드의 종류에는 아래와 같습니다.
  • 여기서는 대략적으로만 보도록 하겠습니다.
  • 데이터 분석할 때의 사용하는 메소드는 제한적이기 때문에 깊이 들어가지는 않겠습니다.
  1. Special Method
      • Constructor(생성자): __init__(self)
    • 일반적으로 위와 같이 특수하게 작동하는 메소드를 말합니다. 생성자는 인스턴스가 만들어질 때 최초로 실행하는 메소드를 말합니다.
  2. Instance Method
    • 위에 pedaling 메소드는 인스턴스 메소드입니다. 인스턴스를 통해서만 접근할 수 있는 메소드입니다.
    • 여기서 self라는 것은 항상 첫 번째 인자값으로 존재합니다.
    • self는 만들어진 인스턴스 자신을 인자로 받겠다는 것을 말합니다.
  3. Static Method
    • 클래스 안에서만 쓰이는 메소드입니다.
  4. Class Method
    • 인스턴스 메소드가 인스턴스를 통해서 접근 가능한 메소드인 반면 클래스 메소드는 인스턴스를 생성하지 않고 클래스를 통해 바로 접근 가능한 메소드를 말합니다.
    • 인스턴스 메소드의 첫 번째 인자값이 self이었지만 클래스 메소드의 첫 번째 인자값은 cls로 씁니다.