2021년 2학기 00분반 기출 풀이

이찬·2023년 7월 26일

Web/Python Programming From KHU

목록 보기

6/10

# [ANSWER START]
class MyInteger:

  def __init__ (self, givenValue):
    if type(givenValue) == type (1):
      self.storage = givenValue
    elif type(givenValue) == type (1.0):
      self.storage = int(givenValue)
    elif type(givenValue) == type ('1'):
      self.storage = int(givenValue)
    else:
      self.storage = 0

  def __str__(self):
    return str(self.storage)

  def __add__(self, givenValue):
    convertedGivenValue = MyInteger(givenValue)
    result = MyInteger(self.storage + convertedGivenValue.storage)
    return result

  def _get_MyInteger(self):
    return MyInteger(self.storage)

  def __eq__(self, Value):
    return self.storage == Value

class MyDerivedInteger(MyInteger):

  def __init__ (self, givenValue):
    if type(givenValue) == type (1):
      self.storage = givenValue
    elif type(givenValue) == type (2.0):
      self.storage = int(givenValue)
    elif type(givenValue) == type ('3'):
      self.storage = int(givenValue)
    else:
      self.storage = 0
    self.origin = givenValue

  def __str__(self):
    sent = '<{}:{},{}:{}>'.format(self.storage, type(self.storage),self.origin,type(self.origin))
    return sent

  def __add__(self, givenValue):
    convertedGivenValue = MyInteger(givenValue)
    resul = MyDerivedInteger(self.storage + convertedGivenValue.storage)
    return resul

  def _get_MyInteger(self):
    return MyDerivedInteger(self.storage)

  def _get_Original(self):
    return self.origin

  def __eq__(self, Valu):
    return self.origin == Valu

# 시험 문제
#
# 답안은 위의 [ANSWER START]와 [ANSWER END] 사이에 작성함
# 아래의 STEP.1~7을 수행하여 RESULTS의 결과를 출력하는 MyInteger 클래스와 MyDerivedInteger 클래스를 개발함
# MyDerivedInteger 클래스는 MyInteger 클래스를 base 클래스로 함
# 수행 결과는 아래 RESULTS와 동일해야 함 (결과값, 대소문자, 철자, 빈공간 등 모든 정보가 동일해야 함)
#

''' STEP.1
'''

variable_01 = MyInteger(1)
print('#01: {} ==>> {}'.format(variable_01, type(variable_01)))

variable_02 = MyInteger(2.0)
print('#02: {} ==>> {}'.format(variable_02, type(variable_02)))

variable_03 = MyInteger('3')
print('#03: {} ==>> {}'.format(variable_03, type(variable_03)))

variable_04 = MyInteger([4,5,6])
print('#04: {} ==>> {}'.format(variable_04, type(variable_04)))

''' STEP.2
'''
variable_05 = variable_01 + '10'
print('#05: {} ==>> {}'.format(variable_05, type(variable_05)))

variable_06 = variable_05 + 100
print('#06: {} ==>> {}'.format(variable_06, type(variable_06)))

variable_07 = variable_06 + 1000.0
print('#07: {} ==>> {}'.format(variable_07, type(variable_07)))

variable_08 = variable_07 + [10000, 100000]
print('#08: {} ==>> {}'.format(variable_08, type(variable_08)))

''' STEP.3
'''

variable_09 = variable_08._get_MyInteger()
print('#09: {} ==>> {}'.format(variable_09, type(variable_09)))

''' STEP.4
'''

variable_10 = MyDerivedInteger(1)
print('#10: {} ==>> {}'.format(variable_10, type(variable_10)))

variable_11 = MyDerivedInteger(2.0)
print('#11: {} ==>> {}'.format(variable_11, type(variable_11)))

variable_12 = MyDerivedInteger('3')
print('#12: {} ==>> {}'.format(variable_12, type(variable_12)))

variable_13 = MyDerivedInteger([4,5,6])
print('#13: {} ==>> {}'.format(variable_13, type(variable_13)))

''' STEP.5
'''

variable_14 = variable_12 + '10'
print('#14: {} ==>> {}'.format(variable_14, type(variable_14)))

variable_15 = variable_14 + 100.0
print('#15: {} ==>> {}'.format(variable_15, type(variable_15)))

variable_16 = variable_15 + 1000
print('#16: {} ==>> {}'.format(variable_16, type(variable_16)))

variable_17 = variable_16 + [10000, 100000]
print('#17: {} ==>> {}'.format(variable_17, type(variable_17)))

variable_18 = variable_17 + MyInteger('10000')
print('#18: {} ==>> {}'.format(variable_18, type(variable_18)))


''' STEP.6
'''

variable_19 = variable_18._get_MyInteger()
print('#19: {} ==>> {}'.format(variable_19, type(variable_19)))

''' STEP.7
'''

variable_20 = variable_12._get_Original()
print('#20: {} ==>> {}'.format(variable_20, type(variable_20)))

print('#21: {} {} {}'.format(variable_01 == 1, variable_02 == 2, variable_03 == 3))
print('#22: {} {} {}'.format(variable_10 == 1, variable_11 == 2, variable_12 == 3))
print('#23: {} {} {}'.format(variable_10 == 1, variable_11 == 2.0, variable_12 == '3'))

#21: True True True
#22: True True False
#23: True True True

''' RESULTS

#01: 1 ==>> <class '__main__.MyInteger'>
#02: 2 ==>> <class '__main__.MyInteger'>
#03: 3 ==>> <class '__main__.MyInteger'>
#04: 0 ==>> <class '__main__.MyInteger'>
#05: 11 ==>> <class '__main__.MyInteger'>
#06: 111 ==>> <class '__main__.MyInteger'>
#07: 1111 ==>> <class '__main__.MyInteger'>
#08: 1111 ==>> <class '__main__.MyInteger'>
#09: 1111 ==>> <class '__main__.MyInteger'>
#10: <1:<class 'int'>,1:<class 'int'>> ==>> <class '__main__.MyDerivedInteger'>
#11: <2:<class 'int'>,2.0:<class 'float'>> ==>> <class '__main__.MyDerivedInteger'>
#12: <3:<class 'int'>,3:<class 'str'>> ==>> <class '__main__.MyDerivedInteger'>
#13: <0:<class 'int'>,[4, 5, 6]:<class 'list'>> ==>> <class '__main__.MyDerivedInteger'>
#14: <13:<class 'int'>,13:<class 'int'>> ==>> <class '__main__.MyDerivedInteger'>
#15: <113:<class 'int'>,113:<class 'int'>> ==>> <class '__main__.MyDerivedInteger'>
#16: <1113:<class 'int'>,1113:<class 'int'>> ==>> <class '__main__.MyDerivedInteger'>
#17: <1113:<class 'int'>,1113:<class 'int'>> ==>> <class '__main__.MyDerivedInteger'>
#18: <11113:<class 'int'>,11113:<class 'int'>> ==>> <class '__main__.MyDerivedInteger'>
#19: <11113:<class 'int'>,11113:<class 'int'>> ==>> <class '__main__.MyDerivedInteger'>
#20: 3 ==>> <class 'str'>
#21: True True True
#22: True True False
#23: True True True
'''

STEP 7 해설

print(2  == 2.0) #True
print(0o177 == 127) #True

숫자와 문자 끼리의 비교 ==> False
정수와 실수 끼리의 비교 ==> 값이 같으면 True

class

클래스 속성(클래스 내부 속성(= 변수) ex. count)은 클래스가 정의된 메모리에서 각 인스턴스가 참조합니다.

인스턴스의 count 는 모두 클래스 count를 참조하고 있음을 알 수 있습니다. 즉, Person.count 의 숫자를 바꾸면 모든 인스턴스의 count 또한 바뀌게 됩니다.
만약 인스턴스의 count 의 값을 바꾸게 되면, 나머지 값들은 변화하지 않고 인스턴스 속성의 값만 변함.
self 라는 항목이 붙은 것은 각 객체 안에서만 통용되는 인스턴스 속성라고 생각하시면 됩니다. 즉, 한 객체에서 self.age를 바꾸어도 다른 객체에서는 영향을 받지 않습니다.

class 상속

물려주는 클래스를 Parent Class 또는 Super Class
물려받는 클래스를 Child Class 또는 Sub Class
부모 클래스의 속성(데이터)과 메소드(함수)를 상속받게 되면, 자식 클래스는 따로 정의하지 않더라도 부모 클래스의 클래스속성과 메소드를 사용할 수 있게 됩니다.
만약 자식노드에서 어떠한 속성을 변화시킨다면, 자식노드의 메소드는 변경된 속성을 반영합니다.

부모 클래스가 class 속성이 아닌, instance 속성을 가질 경우엔 어떻게 될까요?

부모 클래스의 인스턴스 속성은 자식 클래스에 상속되지 않습니다.

이때 필요한 것이 super()!!

super().init()

"class 클래스 이름(부모 클래스이름)" 의 역할은 부모 클래스의 메소드와 클래스 속성을 상속받기 위함 입니다. super()의 역할과 다릅니다.
super().init()이라는 코드가 다른 클래스의 속성 및 메소드를 자동으로 불러와 해당 클래스에서도 사용이 가능하도록 해줍니다.

class Parent:
    def __init__(self, p1, p2):
    	'''super()를 사용하지 않으면 overriding 됩니다.'''
        self.p1 = p1
        self.p2 = p2
        
class Child(Parent):
    def __init__(self, c1, **kwargs):
        super(Child, self).__init__(**kwargs)
        self.c1 = c1
        self.c2 = "This is Child's c2"
        self.c3 = "This is Child's c3"

child = Child(p1="This is Parent's p1", 
	      p2="This is Parent's p1", 
              c1="This is Child's c1")

print(child.p1)
print(child.p2)
print(child.c1)
print(child.c2)
print(child.c3)

#This is Parent's p1
#This is Parent's p1
#This is Child's c1
#This is Child's c2
#This is Child's c3

Parent 클래스와 Child 클래스는 모두 init()이라는 메소드를 가지고 있다. 따라서 super()를 사용하지 않으면, 부모 클래스의 init()는 자식 클래스의 init()에 의해 overriding(덮어쓰기) 됩니다.

Child 클래스의 init() 메소드에 Parent 클래스의 init() 메소드의 변수를 가지고 오고 싶기에, Child 클래스의 init() 메소드내에서 super().init()을 입력하여 Parent 클래스의 init()에 있는 클래스 변수들을 가지고 온다
super()는 상속받은 부모 클래스를 의미
Parent 클래스의 _init() 메소드에 argument가 있다면 Child 클래스는 _init()에 kwargs를 반드시 입력해 주어야 합니다. 또한 super().init()에도 반드시 kwargs를 인자로 전달해 주어야 합니다. 이를 하지 않으면 init() missing required positional arguments 에러가 발생합니다.

이찬

Kyunghee univ. IE 21

이전 포스트

2020년 1학기 기출 풀이

다음 포스트