Step_09_Method_and_Class

Step_09_Method_and_Class¶

프로그램을 개발하다 보면, Python에서 제공하는 연관된 데이터와 함수들을 묶어서 사용하면 좋겠다는 생각을 하게 됩니다.
모듈처럼 단순하게 하나의 화일에 물리적으로 모아 놓는 개념을 넘어서서, 데이터 값과 함수가 상호 의미적으로 연관되어 있는 의미있는 묶음을 의미합니다.
이런 경우 본 수업에서 설명하는 Class를 사용하게 됩니다.
본 수업에서는 일단 Class와 이에 속한 Methods의 개념을 이해하고, 이미 Python에서 제공하는 기능들을 사용해 봅니다.
나중에 우리는 스스로 본인만의 Class를 만들고 사용하게 될 것입니다.

Method와 Class 개념 이해하기¶

앞서의 수업에서 우리는 함수에 대해서 배웠으며, 다양한 형태의 함수가 있는 것을 알게 되었습니다.

(a) Built-in functions: Python 언어에서 기본 제공하는 함수
(b) Functions inside modules: 모듈에 포함되어 모듈을 import 한후 사용하는 함수 (예: 모듈명.함수명())
(c) Programmer defined functions: 프로그래머가 본인의 프로그램안에서 직접 만들어서 사용하는 함수

하지만 우리는 이미 다른 형태의 함수를 사용한 적이 있습니다.
바로 Step.7 Conditional Statement (조건문)에서 다음의 예제를 사용한 것이 있습니다.

sentence = 'Mary had a little lamb'
sentence.count('a')

해당 코드를 살펴보면, 문자열인 sentence의 뒤에 점(.)을 찍은후 count() 함수를 호출하는 것을 보았습니다.
이런 함수는 위의 (a)~(c)안에 포함이 되지 않는데, 이건 뭘까요?

이런 함수를 Python에서는 method라고 부르는데, metohd는 특정 타입에 포함된 함수로서, 특정 모듈에 포함된 함수와 비슷하지만 다릅니다.
특정 모듈에 함수가 포함된다는 것은, Step.8 모듈(Module)에서 수업한 것처럼, 특정 모듈의 화일에 함수를 만들어 넣은 것을 의미합니다.
이와 다르게 "특정 타입"이라는 것은, 점차 설명을 하겠지만, 관련성이 있는 "데이터와 함수"을 묶은 개념이라고 볼수 있습니다.

즉 위의 sentence는 문자열(string) 타입 임을 우리는 알고 있습니다.
위의 예제에서, 이 문자열 타입인 sentence 안에는 Mary had a little lamb'라는 데이터가 있으며,
본인의 데이터 안에 글자를 세는 count()와 같은 함수도 묶여 있는 것입니다.
이런 데이터와 함수가 묶여있는 타입을 Python에서는 Class라고 칭하며, Class안의 함수들을 Method라고 부릅니다.
또한 문자열 Class 타입에서 만들어진 sentence를 객체(object)라고 합니다.

특별히 Class로 부터 만들어지는 객체들의 데이터와 함수는 멤버 데이터와 멤버 Method라고 하여, 특정 타입에 소속된 것임을 강조합니다.

결국 위의 문장을 다시 설명한다면 다음과 같습니다.

(1) String 타입의 Class를 기반으로 sentence 객체를 생성함
(2) sentence 객체의 멤버 데이터로 'Mary had a little lamb'를 저장함
(3) String 타입의 Class면 사용할 수 있는 멤버 method인 count()를 사용하여, 데이터 안에서 글자 'a'의 갯수를 카운트 함

설명한 String Class의 멤버 Method에 대해서 더 알고 싶다면, help(str) 구문을 아래 입력창에서 실행하여,
String Class의 멤버 method를 살펴보고, 특별히 문자열의 글자를 모두 대문자로 바꾸는 upper() 함수를 다음 입력창에서 실행해 봅니다.

In [1]:

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__(self, format_spec, /)
 |      Return a formatted version of the string 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.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __sizeof__(self, /)
 |      Return the size of the string in memory, in bytes.
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  capitalize(self, /)
 |      Return a capitalized version of the string.
 |      
 |      More specifically, make the first character have upper case and the rest lower
 |      case.
 |  
 |  casefold(self, /)
 |      Return a version of the string suitable for caseless comparisons.
 |  
 |  center(self, width, fillchar=' ', /)
 |      Return a centered 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(self, /, encoding='utf-8', errors='strict')
 |      Encode the string using the codec registered for encoding.
 |      
 |      encoding
 |        The encoding in which to encode the string.
 |      errors
 |        The error handling scheme to use for encoding errors.
 |        The 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(self, /, tabsize=8)
 |      Return a copy 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
 |      
 |      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.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  isalnum(self, /)
 |      Return True if the string is an alpha-numeric string, False otherwise.
 |      
 |      A string is alpha-numeric if all characters in the string are alpha-numeric and
 |      there is at least one character in the string.
 |  
 |  isalpha(self, /)
 |      Return True if the string is an alphabetic string, False otherwise.
 |      
 |      A string is alphabetic if all characters in the string are alphabetic and there
 |      is at least one character in the string.
 |  
 |  isascii(self, /)
 |      Return True if all characters in the string are ASCII, False otherwise.
 |      
 |      ASCII characters have code points in the range U+0000-U+007F.
 |      Empty string is ASCII too.
 |  
 |  isdecimal(self, /)
 |      Return True if the string is a decimal string, False otherwise.
 |      
 |      A string is a decimal string if all characters in the string are decimal and
 |      there is at least one character in the string.
 |  
 |  isdigit(self, /)
 |      Return True if the string is a digit string, False otherwise.
 |      
 |      A string is a digit string if all characters in the string are digits and there
 |      is at least one character in the string.
 |  
 |  isidentifier(self, /)
 |      Return True if the string is a valid Python identifier, False otherwise.
 |      
 |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
 |      such as "def" or "class".
 |  
 |  islower(self, /)
 |      Return True if the string is a lowercase string, False otherwise.
 |      
 |      A string is lowercase if all cased characters in the string are lowercase and
 |      there is at least one cased character in the string.
 |  
 |  isnumeric(self, /)
 |      Return True if the string is a numeric string, False otherwise.
 |      
 |      A string is numeric if all characters in the string are numeric and there is at
 |      least one character in the string.
 |  
 |  isprintable(self, /)
 |      Return True if the string is printable, False otherwise.
 |      
 |      A string is printable if all of its characters are considered printable in
 |      repr() or if it is empty.
 |  
 |  isspace(self, /)
 |      Return True if the string is a whitespace string, False otherwise.
 |      
 |      A string is whitespace if all characters in the string are whitespace and there
 |      is at least one character in the string.
 |  
 |  istitle(self, /)
 |      Return True if the string is a title-cased string, False otherwise.
 |      
 |      In a title-cased string, upper- and title-case characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |  
 |  isupper(self, /)
 |      Return True if the string is an uppercase string, False otherwise.
 |      
 |      A string is uppercase if all cased characters in the string are uppercase and
 |      there is at least one cased character in the string.
 |  
 |  join(self, iterable, /)
 |      Concatenate any number of strings.
 |      
 |      The string whose method is called is inserted in between each given string.
 |      The result is returned as a new string.
 |      
 |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
 |  
 |  ljust(self, width, fillchar=' ', /)
 |      Return a left-justified string of length width.
 |      
 |      Padding is done using the specified fill character (default is a space).
 |  
 |  lower(self, /)
 |      Return a copy of the string converted to lowercase.
 |  
 |  lstrip(self, chars=None, /)
 |      Return a copy of the string with leading whitespace removed.
 |      
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  partition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |      
 |      This will search for the separator in the string.  If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing the original string
 |      and two empty strings.
 |  
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |      
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |      
 |      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
 |      
 |      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.
 |      
 |      Raises ValueError when the substring is not found.
 |  
 |  rjust(self, width, fillchar=' ', /)
 |      Return a right-justified string of length width.
 |      
 |      Padding is done using the specified fill character (default is a space).
 |  
 |  rpartition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |      
 |      This will search for the separator in the string, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |      
 |      If the separator is not found, returns a 3-tuple containing two empty strings
 |      and the original string.
 |  
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the words in the string, using sep as the delimiter string.
 |      
 |        sep
 |          The delimiter according which to split the string.
 |          None (the default value) means split according to any whitespace,
 |          and discard empty strings from the result.
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |      
 |      Splits are done starting at the end of the string and working to the front.
 |  
 |  rstrip(self, chars=None, /)
 |      Return a copy of the string with trailing whitespace removed.
 |      
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the words in the string, using sep as the delimiter string.
 |      
 |      sep
 |        The delimiter according which to split the string.
 |        None (the default value) means split according to any whitespace,
 |        and discard empty strings from the result.
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |  
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the string, 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(self, chars=None, /)
 |      Return a copy of the string with leading and trailing whitespace removed.
 |      
 |      If chars is given and not None, remove characters in chars instead.
 |  
 |  swapcase(self, /)
 |      Convert uppercase characters to lowercase and lowercase characters to uppercase.
 |  
 |  title(self, /)
 |      Return a version of the string where each word is titlecased.
 |      
 |      More specifically, words start with uppercased characters and all remaining
 |      cased characters have lower case.
 |  
 |  translate(self, table, /)
 |      Replace each character in the string using the given translation table.
 |      
 |        table
 |          Translation table, which must be a mapping of Unicode ordinals to
 |          Unicode ordinals, strings, or None.
 |      
 |      The table must implement lookup/indexing via __getitem__, for instance a
 |      dictionary or list.  If this operation raises LookupError, the character is
 |      left untouched.  Characters mapped to None are deleted.
 |  
 |  upper(self, /)
 |      Return a copy of the string converted to uppercase.
 |  
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |      
 |      The string is never truncated.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  maketrans(...)
 |      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 [2]:

sentence="Mary had a little lamb"
print(sentence.upper())

MARY HAD A LITTLE LAMB

Python의 기본 Class 이해하기¶

앞서의 설명에서 우리는 Class를 일종의 타입이라고 하였으며, 데이터와 함수(method)의 묶음이라고 정의했습니다.
이미 익숙하게 사용하는 정수, 실수도 문자열과 마찬가지로 Class이며, 각각 int와 float 타입 입니다.

아래의 입력창에 다음의 구문을 실행해서 직접 익숙한 데이터 타입의 Class가 어떤 것인지를 확인해 봅니다.

print(type(17))
print(type(17.0))
print(type("17"))

In [3]:

print(type(17))
print(type(17.0))
print(type("17"))

<class 'int'>
<class 'float'>
<class 'str'>

알아두면 요긴한 문자열 Class의 멤버 Method를 좀 더 실행해 보도록 합니다.
각각의 method에 대한 설명은 아래의 참조사이트에서 해당 method를 찾아 이해하기 바랍니다.
[참조문헌]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str

아래의 입력창에 다음의 구문을 실행해서 문자열 Class의 멤버 method가 어떤 기능을 하는지를 확인해 봅니다.

tempString = "Mr.Suhyun"
print(tempString.capitalize())
print(tempString.upper())
print(tempString.lower())
print(tempString.center(20))
print(tempString.count('.'))

In [6]:

tempString = "Mr.Suhyun"
print(tempString.capitalize())
print(tempString.upper())
print(tempString.lower())
print(tempString.center(20))
print(tempString.count('.'))

Mr.suhyun
MR.SUHYUN
mr.suhyun
     Mr.Suhyun      
1

멤버 method를 실행하는 방법으로, 조금 이상할지 모르지만, 다음과 같이 정수/실수/문자열의 값에 바로 .을 찍어서 method를 실행하기도 합니다.

나중을 위해서, 아래의 입력창에 다음의 구문을 실행해보기 바랍니다.

"Mr.Suhyun".capitalize()
"Mr.Suhyun".upper()
"Mr.Suhyun".lower()
"Mr.Suhyun".center(20)
"Mr.Suhyun".count('.')

In [8]:

print("Mr.Suhyun".capitalize())
print("Mr.Suhyun".upper())
print("Mr.Suhyun".lower())
print("Mr.Suhyun".center(20))
print("Mr.Suhyun".count('.'))

Mr.suhyun
MR.SUHYUN
mr.suhyun
     Mr.Suhyun      
1

문자열 Class Methods 알아두기¶

문자열 Class는 실제 문제 해결을 위하여 매우 많이 자주 사용되므로, 다음 Python 사이트의 String methods 부분을 꼭 읽어 보기 권합니다.
[참조문헌]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str

특별히 format()은 결과값의 형태를 규격화하기 위한 유용한 method 로서, 다음의 코드를 수행하고 이해하는 것을 반드시 스스로 해보도록 합니다.

print('{0} ate {1} apples {2}'.format('I', '3', 'yesterday'))
print('{0} ate {1} apples {2}'.format('You', '5', 'at 2 pm'))
print('{1} ate {0} apples {2}'.format('5', 'You', 'at 2 pm'))
print('{} ate {} apples {}'.format('I', '3', 'yesterday'))

import math
myPi = math.pi
print('Pi rounded to {0} decimal places is {1:.2f}.'.format(2, myPi))
print('Pi rounded to {0} decimal places is {1:.3f}.'.format(3, myPi))
print('Pi rounded to {0} decimal places is {1:.4f}.'.format(4, myPi))

mySentence = "Pi rounded to {0} decimal places is {1:.4f}."
print(mySentence.format(4, myPi))

In [9]:

print('{0} ate {1} apples {2}'.format('I', '3', 'yesterday'))
print('{0} ate {1} apples {2}'.format('You', '5', 'at 2 pm'))
print('{1} ate {0} apples {2}'.format('5', 'You', 'at 2 pm'))
print('{} ate {} apples {}'.format('I', '3', 'yesterday'))

import math
myPi = math.pi
print('Pi rounded to {0} decimal places is {1:.2f}.'.format(2, myPi))
print('Pi rounded to {0} decimal places is {1:.3f}.'.format(3, myPi))
print('Pi rounded to {0} decimal places is {1:.4f}.'.format(4, myPi))

mySentence = "Pi rounded to {0} decimal places is {1:.4f}."
print(mySentence.format(4, myPi))

I ate 3 apples yesterday
You ate 5 apples at 2 pm
You ate 5 apples at 2 pm
I ate 3 apples yesterday
Pi rounded to 2 decimal places is 3.14.
Pi rounded to 3 decimal places is 3.142.
Pi rounded to 4 decimal places is 3.1416.
Pi rounded to 4 decimal places is 3.1416.

실습 (LAB)¶

문자열 Methods 활용하기 (1)¶

다음의 기능을 위에서 아래로 차례대로 실행하면서, 결과를 화면에 출력하는 프로그램을 아래 입력창에서 만들고 실행해서 결과를 확인합니다.

(1) name 이라는 변수를 생성하여 본인의 이름을 소문자 string 값으로 지정합니다.
(2) string method 중 하나를 사용하여 name의 첫번째 문자만 대문자로 바꾸어 화면에 출력합니다.
(3) string method 중 하나를 사용하여 name의 모든 문자를 대문자로 바꾸어 화면에 출력합니다.
(4) len() 함수를 사용하여 name의 문자 개수를 출력합니다.
(5) string method 중 하나를 사용하여 name에 포함된 'g'의 개수를 출력합니다.

In [16]:

name = 'suhyun'
print(name[0].upper())
print(name.upper())
print(len(name))
print(name.count('g'))

S
SUHYUN
6
0

문자열 Methods 활용하기 (2)¶

다음의 기능을 위에서 아래로 차례대로 실행하면서, 결과를 화면에 출력하는 프로그램을 아래 입력창에서 만들고 실행해서 결과를 확인합니다.

(1) string method인 find()를 사용하여 'tomato'단어 안에 첫번째 'o' 의 위치(인덱스)를 찾아내어 출력하시오.
(2) string method인 find()를 사용하여 'tomato'단어 안에 두번째 'o' 의 위치(인덱스)를 찾아내어 출력하시오.

In [20]:

string = 'tomato'
print(string.find('o'))
first_index = string.find('o')
print(string[first_index+1:].find('o')+first_index+1)

1
5

문자열 Methods를 이용한 크리스마스 트리 만들기¶

사용자로부터 나무를 그리는데 사용할 문자 하나, 그리고 받침을 그리는데 사용할 문자 하나를 입력 받습니다.
다음은 실행 예제로서, 아래와 같은 결과가 화면에 나타날 수 있도록, 문자열 Methods를 충분히 활용하여 프로그램을 만들고 실행합니다.

Enter your code for tree: *
Enter your code for floor: #

In [22]:

          *          
         ***         
        *****        
       *******       
      *********    
     ***********     
    *************   
         ###         
         ###         
         ### 

In [25]:

input_tree = input(prompt="Enter your code for tree : ")
input_floor = input(prompt="Enter your code for floor : ")

print((input_tree*1).center(15))
print((input_tree*3).center(15))
print((input_tree*5).center(15))
print((input_tree*7).center(15))
print((input_tree*9).center(15))
print((input_tree*11).center(15))
print((input_tree*13).center(15))
print((input_floor*3).center(15))
print((input_floor*3).center(15))
print((input_floor*3).center(15))

Enter your code for tree : *
Enter your code for floor : -
       *       
      ***      
     *****     
    *******    
   *********   
  ***********  
 ************* 
      ---