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

이찬·2023년 7월 30일

Web/Python Programming From KHU

목록 보기

7/10

# [ANSWER START]
class MyQueue:
  def __init__(self):
    self.originalList = []
    self.filteredList = []

  def __add__(self, plus):
    result = MyQueue()
    for i in self.originalList:
      result.originalList.append(i)
    for k in self.filteredList:
      result.filteredList.append(k)
    for a in plus.originalList:
      result.originalList.append(a)
    for b in plus.filteredList:
      result.filteredList.append(b)
    result.filteredList = dict.fromkeys(result.filteredList)
    result.filteredList = list(result.filteredList)
    return result

  def push(self,givenValue):
    if givenValue not in self.originalList:
        self.originalList.append(givenValue)
    else:
      return 'error@duplicated'
    self.givenValue = givenValue
    if type(self.givenValue) == type(1):
      k = int(self.givenValue)
      self.filteredList.append(k)
      return k
    elif (type(self.givenValue) == type('2')):
      k = ''
      for i in self.givenValue:
        if i.isdecimal():
          k = k + i
      k = int(k)
      self.filteredList.append(k)
      return k
    elif type(self.givenValue) == type(3.2):
      k = int(self.givenValue)
      self.filteredList.append(k)
      return k
    elif type(self.givenValue) == type([4,5,6]):
      k = 0
      self.filteredList.append(k)
      return k

  def get_original(self):
    return self.originalList

  def get_filtered(self):
    return self.filteredList

  def get_filtered_sorted(self):
    return sorted(self.filteredList)

  def get_filtered_reversed(self):
    return self.filteredList[::-1]

  def get_dictionary(self):
    dictionaryE = dict()
    for i in self.filteredList:
      for k in self.originalList:
        if self.forpop(k) == i:
          dictionaryE[i] = k
    return dictionaryE

  def forpop(self, giv):
    self.giv = giv
    if type(self.giv) == type(1):
      k = int(self.giv)
      return k
    elif (type(self.giv) == type('2')):
      k = ''
      for i in self.giv:
        if i.isdecimal():
          k = k + i
      k = int(k)
      return k
    elif type(self.giv) == type(3.2):
      k = int(self.giv)
      return k
    elif type(self.giv) == type([4,5,6]):
      k = 0
      return k

  def pop(self,delValue = None):
    if delValue:
      diction = dict()
      self.delValue = delValue
      self.filteredList.remove(delValue)
      for wor in self.originalList:
        if self.forpop(wor) == delValue:
          diction[wor]= delValue
      return diction
    else:
      delValue = self.filteredList[-1]
      diction = dict()
      self.delValue = delValue
      self.filteredList.remove(delValue)
      for wor in self.originalList:
        if self.forpop(wor) == delValue:
          diction[wor]= delValue
      return diction

# [ANSWER END]

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

''' STEP.A
'''

myQ = MyQueue()

variable_A01 = myQ.push(1)
print('#A.1:({})==>>({})'.format(variable_A01, type(variable_A01)))

variable_A02 = myQ.push('2')
print('#A.2:({})==>>({})'.format(variable_A02, type(variable_A02)))

variable_A03 = myQ.push(3.2)
print('#A.3:({})==>>({})'.format(variable_A03, type(variable_A03)))

variable_A04 = myQ.push([4,5,6])
print('#A.4:({})==>>({})'.format(variable_A04, type(variable_A04)))

variable_A05 = myQ.push('1abc2def3xyx')
print('#A.5:({})==>>({})'.format(variable_A05, type(variable_A05)))

''' STEP.B
'''

variable_B01 = myQ.get_original()
print('#B.1:({})==>>({})'.format(variable_B01, type(variable_B01)))

variable_B02 = myQ.get_filtered()
print('#B.2:({})==>>({})'.format(variable_B02, type(variable_B02)))

variable_B03 = myQ.get_filtered_sorted()
print('#B.3:({})==>>({})'.format(variable_B03, type(variable_B03)))

variable_B04 = myQ.get_filtered()
print('#B.4:({})==>>({})'.format(variable_B04, type(variable_B04)))

variable_B05 = myQ.get_filtered_reversed()
print('#B.5:({})==>>({})'.format(variable_B05, type(variable_B05)))

variable_B06 = myQ.get_filtered()
print('#B.6:({})==>>({})'.format(variable_B06, type(variable_B06)))

''' STEP.C
'''

variable_C01 = myQ.pop()
print('#C.1:({})==>>({})'.format(variable_C01, type(variable_C01)))

variable_C02 = myQ.get_filtered()
print('#C.2:({})==>>({})'.format(variable_C02, type(variable_C02)))

variable_C03 = myQ.pop(2)
print('#C.3:({})==>>({})'.format(variable_C03, type(variable_C03)))

variable_C04 = myQ.get_filtered()
print('#C.4:({})==>>({})'.format(variable_C04, type(variable_C04)))

''' STEP.D
'''

variable_D01 = myQ.get_dictionary()
print('#D.1:({})==>>({})'.format(variable_D01, type(variable_D01)))

variable_D02 = myQ.get_filtered()
print('#D.2:({})==>>({})'.format(variable_D02, type(variable_D02)))

''' STEP.E
'''

variable_E01 = myQ.push(1)
print('#E.1:({})==>>({})'.format(variable_E01, type(variable_E01)))

variable_E02 = myQ.get_filtered()
print('#E.2:({})==>>({})'.format(variable_E02, type(variable_E02)))

variable_E03 = myQ.push('999')
print('#E.3:({})==>>({})'.format(variable_E03, type(variable_E03)))

variable_E04 = myQ.get_filtered()
print('#E.4:({})==>>({})'.format(variable_E04, type(variable_E04)))

''' STEP.F
'''

varQ1 = MyQueue()
varQ1.push('1')
varQ1.push(10)
varQ1.push(2)

varQ2 = MyQueue()
varQ2.push(22)
varQ2.push(999)
varQ2.push(44)

variable_F01 = myQ + varQ1 + varQ2
print('#F.1:({})'.format(type(variable_F01)))

variable_F02 = variable_F01.get_filtered()
print('#F.2:({})==>>({})'.format(variable_F02, type(variable_F02)))

variable_F03 = myQ.get_filtered()
print('#F.3:({})==>>({})'.format(variable_F03, type(variable_F03)))

variable_F04 = varQ1.get_filtered()
print('#F.4:({})==>>({})'.format(variable_F04, type(variable_F04)))

variable_F05 = varQ2.get_filtered()
print('#F.5:({})==>>({})'.format(variable_F05, type(variable_F05)))

''' RESULTS

#A.1:(1)==>>(<class 'int'>)
#A.2:(2)==>>(<class 'int'>)
#A.3:(3)==>>(<class 'int'>)
#A.4:(0)==>>(<class 'int'>)
#A.5:(123)==>>(<class 'int'>)
#B.1:([1, '2', 3.2, [4, 5, 6], '1abc2def3xyx'])==>>(<class 'list'>)
#B.2:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#B.3:([0, 1, 2, 3, 123])==>>(<class 'list'>)
#B.4:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#B.5:([123, 0, 3, 2, 1])==>>(<class 'list'>)
#B.6:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#C.1:({'1abc2def3xyx': 123})==>>(<class 'dict'>)
#C.2:([1, 2, 3, 0])==>>(<class 'list'>)
#C.3:({'2': 2})==>>(<class 'dict'>)
#C.4:([1, 3, 0])==>>(<class 'list'>)
#D.1:({1: 1, 3: 3.2, 0: [4, 5, 6]})==>>(<class 'dict'>)
#D.2:([1, 3, 0])==>>(<class 'list'>)
#E.1:(error@duplicated)==>>(<class 'str'>)
#E.2:([1, 3, 0])==>>(<class 'list'>)
#E.3:(999)==>>(<class 'int'>)
#E.4:([1, 3, 0, 999])==>>(<class 'list'>)
#F.1:(<class '__main__.MyQueue'>)
#F.2:([1, 3, 0, 999, 10, 2, 22, 44])==>>(<class 'list'>)
#F.3:([1, 3, 0, 999])==>>(<class 'list'>)
#F.4:([1, 10, 2])==>>(<class 'list'>)
#F.5:([22, 999, 44])==>>(<class 'list'>)
'''

STEP A - 문자열에서 숫자만을 추출

STEP B

List 순서 뒤집기

슬라이싱 사용하기

reverse() 메서드 사용하기

내장함수 reversed() 사용하기

슬라이싱

close[::-1]은 순서가 뒤집어진 close 리스트가 됩니다.
하지만 원본 리스트 close는 바뀌지 않습니다.

reverse() 메서드

파이썬 리스트의 메서드 중 하나인 reverse()는 해당 리스트의 순서를 뒤집습니다. 원본 리스트 close의 순서가 바뀝니다.

reversed()

reverse() 내장함수는 주어진 시퀀스 (리스트, 튜플 등)에 대해 순서가 뒤집어진 iterator 객체의 형태로 반환하기 때문에 내장함수 list()를 이용해서 리스트 자료형으로 변환해줍니다.
원본 리스트 close의 순서는 바뀌지 않습니다.

STEP C - None

0과 False는 같은 값

None과는 모두 다른 값

Python의 if가 (여타 언어들과 마찬가지로) '빈 객체'를 받았을 때에 False와 같이 취급
zero = 0
false = False
none = None
print(zero == false)  # True
print(false == none)  # False
print(zero == none)  # False
# print nothing
if ['a']:
   print('[]')  # []
if []:
   print('[]')  # X
if '':
   print('')   # X

STEP F - add

입력 파라미터의 값(객체 본연의 값)을 바꾸지는 않고, 기존의 수에 입력 파라미터를 더해준 값을 반환해줌을 명시하자!

STEP F - 중복 제거

파이썬 리스트 중복 제거 방법 3가지

set 이용한 리스트 중복 제거

for 반복문을 이용한 리스트 중복 제거

dictionary를 이용한 리스트 중복 제거

1. 파이썬 리스트 중복제거 - set을 이용한 방법
set 자료구조의 특징은 중복이 없다는 것입니다.
이 "중복이 불가능하다"라는 성질을 이용해서 리스트에서 중복을 제거할 수 있습니다. 리스트 자료형을 set(리스트)를 통해서 set 타입으로 변경하면서 중복을 제거합니다. 그 후에 list(set(리스트)) 다시 리스트로 감싸주어서 리스트 타입으로 데이터를 변경합니다.

arr = [6, 5, 6, 4, 4, 1, 1, 2, 3, 9, 8, 7, 9, 8, 7]

result1 = set(arr)
print(f"set(arr)      : {result1}")

result2 = list(result1)  # list(set(arr))
print(f"list(set(arr) : {result2}")

첫 번째 결과를 보면 리스트를 set(arr) 하게 되어 리스트가 set 타입이 되어서 {} 괄호로 묶여있는 것을 볼 수 있습니다.
여기서 주의 깊게 보아야 할 것은 중복이 제거되었다는 점과 자동으로 순서가 변경되었다는 점입니다.

왜 set으로 집합을 제거하지 않고, 딕셔너리의 dict.fromkeys(iterable) 메서드로 바꾸었을까? => Error : TypeError: unhashable type: 'list'

list를 set으로 바꿀 때 발생하는 에러

set에 들어있는 값들은 해쉬 가능해야합니다.

그래서 문자열, 숫자, 튜플만 set에 넣으면 중복 제거가 가능

set(집합) 내부 원소는 다양한 값을 함께 가질 수 있지만, mutable한 값은 가질수 없다.

mutable한 값은 변경 가능한 객체로 리스트와 딕셔너리가 있다.

같은 이유로, list를 딕셔너리의 키로 사용할 수 없다.
이럴 경우, 리스트를 튜플(tuple)로 변환하면 키로 사용할 수 있다.
set이나 딕셔너리의 키의 원소는 해시할 수 있는 "변형이 불가능한" (immutable) 값이어야 한다. 리스트와 튜플의 차이는 리스트는 리스트에 원소를 더하거나 빼거나 할 수 있는 변형이 가능한 타입이다. 튜플은, 반면, 한번 정의되면 변형이 불가능한 타입이다.

2. 파이썬 for 반복문을 이용해서 리스트 중복 제거

중복 제거된 값들이 들어갈 result 리스트를 하나 더 만들고
for 반복문에서 원래 리스트를 하나씩 돌면서
result 리스트에 값을 넣습니다. 이때 값을 넣으면서 result 리스트에 이미 있는 값인지 확인을 하는 작업을 거칩니다.

arr = [6, 5, 6, 4, 4, 1, 1, 2, 3, 9, 8, 7, 9, 8, 7]
result = [] # 중복 제거된 값들이 들어갈 리스트

for value in arr:
    if value not in result:
        result.append(value)

print(result)
# [6,5,4,1,2,3,9,8,7]

결과를 보면 for 반복문을 이용해서 중복을 제거하는 경우에 원래 arr 리스트에서 중복이 제거되었으며, 순서가 그대로 유지되는 것을 볼 수 있습니다.

3. 파이썬 dictionary를 이용해서 리스트 중복 제거 방법

딕셔너리 자료구조도 set 자료구조처럼 중복이 불가능한 규칙이 있습니다.
딕셔너리는 key, value로 데이터를 이루게 되는데 이 key 값이 중복 불가의 성질이 있습니다. 이 성질을 이용해서 list에서 중복을 제거할 수 있습니다.
딕셔너리의 메서드 중에서 dict.fromkeys( iterable)이라는 것이 있는데 인자로 들어온 iterable 데이터를 key 값으로 해서 딕셔너리 자료형을 만들어 주는 작업을 하는 메서드입니다. 이 메서드를 이용해서 리스트의 값들을 딕셔너리의 key 값들로 만들면, 중복이 제거됩니다. 그 중복이 제거된 key 값들을 다시 리스트로 변환하면 됩니다.

arr = [6, 5, 6, 4, 4, 1, 1, 2, 3, 9, 8, 7, 9, 8, 7]
result1 = dict.fromkeys(arr) # 리스트 값들을 key 로 변경
print(result1)
result2 = list(result1) # list(dict.fromkeys(arr))
dict.fromkeys(리스트 자료형)을 이용해서 중복이 제거된 키 값들로 변환된 것을 볼 수 있습니다.

list(dict.fromkeys(리스트 자료형)을 이용해서 키 값으로 변환된 것들을 다시 리스트로 변환하는 것을 볼 수 있습니다.

이방법 또한 순서가 유지되는 것을 볼 수 있습니다.

# 1줄씩 채점하는 코드
answer = """
#A.1:(1)==>>(<class 'int'>)
#A.2:(2)==>>(<class 'int'>)
#A.3:(3)==>>(<class 'int'>)
#A.4:(0)==>>(<class 'int'>)
#A.5:(123)==>>(<class 'int'>)
#B.1:([1, '2', 3.2, [4, 5, 6], '1abc2def3xyx'])==>>(<class 'list'>)
#B.2:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#B.3:([0, 1, 2, 3, 123])==>>(<class 'list'>)
#B.4:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#B.5:([123, 0, 3, 2, 1])==>>(<class 'list'>)
#B.6:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#C.1:({'1abc2def3xyx': 123})==>>(<class 'dict'>)
#C.2:([1, 2, 3, 0])==>>(<class 'list'>)
#C.3:({'2': 2})==>>(<class 'dict'>)
#C.4:([1, 3, 0])==>>(<class 'list'>)
#D.1:({1: 1, 3: 3.2, 0: [4, 5, 6]})==>>(<class 'dict'>)
#D.2:([1, 3, 0])==>>(<class 'list'>)
#E.1:(error@duplicated)==>>(<class 'str'>)
#E.2:([1, 3, 0])==>>(<class 'list'>)
#E.3:(999)==>>(<class 'int'>)
#E.4:([1, 3, 0, 999])==>>(<class 'list'>)
#F.1:(<class '__main__.MyQueue'>)
#F.2:([1, 3, 0, 999, 10, 2, 22, 44])==>>(<class 'list'>)
#F.3:([1, 3, 0, 999])==>>(<class 'list'>)
#F.4:([1, 10, 2])==>>(<class 'list'>)
#F.5:([22, 999, 44])==>>(<class 'list'>)
"""
my = """
#A.1:(1)==>>(<class 'int'>)
#A.2:(2)==>>(<class 'int'>)
#A.3:(3)==>>(<class 'int'>)
#A.4:(0)==>>(<class 'int'>)
#A.5:(123)==>>(<class 'int'>)
#B.1:([1, '2', 3.2, [4, 5, 6], '1abc2def3xyx'])==>>(<class 'list'>)
#B.2:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#B.3:([0, 1, 2, 3, 123])==>>(<class 'list'>)
#B.4:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#B.5:([123, 0, 3, 2, 1])==>>(<class 'list'>)
#B.6:([1, 2, 3, 0, 123])==>>(<class 'list'>)
#C.1:({'1abc2def3xyx': 123})==>>(<class 'dict'>)
#C.2:([1, 2, 3, 0])==>>(<class 'list'>)
#C.3:({'2': 2})==>>(<class 'dict'>)
#C.4:([1, 3, 0])==>>(<class 'list'>)
#D.1:({1: 1, 3: 3.2, 0: [4, 5, 6]})==>>(<class 'dict'>)
#D.2:([1, 3, 0])==>>(<class 'list'>)
#E.1:(error@duplicated)==>>(<class 'str'>)
#E.2:([1, 3, 0])==>>(<class 'list'>)
#E.3:(999)==>>(<class 'int'>)
#E.4:([1, 3, 0, 999])==>>(<class 'list'>)
#F.1:(<class '__main__.MyQueue'>)
#F.2:([1, 3, 0, 999, 10, 2, 22, 44])==>>(<class 'list'>)
#F.3:([1, 3, 0, 999])==>>(<class 'list'>)
#F.4:([1, 10, 2])==>>(<class 'list'>)
#F.5:([22, 999, 44])==>>(<class 'list'>)
"""
# 전체 T/F
print(my == answer, end = ' Everything is correct. good!\n')
#1줄별 T/F
a = my.split('\n')
b = answer.split('\n')
for i in range(len(a)):
 print(a[i] == b[i])

실수

__add__ 메서드 생성을 하면서 " _ "을 하나 놓쳤었다. 조금 더 신중하게 코드를 짜야겠다.

채점 프로그램 만들기

문자열.split()

문자열.split('구분자')

문자열.split('구분자', 분할횟수)

문자열.split(sep='구분자', maxsplit=분할횟수)

sep 파라미터
해당 파라미터의 기본값은 none이며, 이때 동작은 띄어쓰기, 엔터를 구분자로 하여 문자열을 자릅니다.
문자열.split(sep=',') 이라 한다면 문자열에서 "," 를 기준으로 자르게 됩니다.
sep은 생략하고 문자열.split(',')으로 사용해도 무방합니다.
maxsplit 파라미터
해당 파라미터의 기본값은 -1 이며, 이때 동작은 제한없이 자를 수 있을 때 까지 문자열 전체를 자릅니다.
문자열.split(maxsplit=1) 이라 하면, 문자열을 1번만 자르게 됩니다.
역시 maxsplit 를 생략이 가능하지만 앞에 sep 파라미터가 있어야지만 가능합니다.
문자열.split(1) 불가능
문자열.split(',', 1) 가능
문자열.split(maxsplit=1) 가능

모범 답안 코드 해석

# 모범답안
class MyQueue:

  def __init__(self):
    self.storage_original = []
    self.storage_sorted = []

  # STEP A & E
  def push(self, givenValue):
    if type(givenValue) == type(1):
      value = givenValue
    elif type(givenValue) == type(1.0):
      value = int(givenValue)
    elif type(givenValue) == type('1'):
      str_length = len(givenValue)
      temp = 1
      conv_number = 0
      int_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
      for index in range(str_length):
        if givenValue[str_length - (1+index)] in int_list:
          conv_number += temp * int (givenValue[str_length - (1+ index)])
          temp *= 10
      value = conv_number
    else:
      value = 0

    if value in self.storage_sorted:
      return 'error@duplicated'
    else:
      self.storage_original.append(givenValue)
      self.storage_sorted.append(value)
      return self.storage_sorted[len(self.storage_sorted)-1]

  # STEP B
  def get_original(self):
    return self.storage_original

  def get_filtered(self):
    return self.storage_sorted

  def get_filtered_sorted(self):
    return sorted(self.storage_sorted)

  def get_filtered_reversed(self):
    return list(reversed(self.storage_sorted))

# STEP C
  def pop(self, givenValue = -1):
    if givenValue == -1:
      idx_original = self.storage_original[len(self.storage_original) - 1]
      idx_sorted = self.storage_sorted[len(self.storage_sorted) - 1]
      self.storage_original.pop()
      self.storage_sorted.pop()
    else:
      index = self.storage_sorted.index(givenValue)
      idx_original = self.storage_original[index]
      idx_sorted = self.storage_sorted[index]
      self.storage_original.remove(idx_original)
      self.storage_sorted.remove(idx_sorted)
    result = {}
    result[idx_original] = idx_sorted
    return result
# STEP D
  def get_dictionary(self):
    result = {}
    for index in range(len(self.storage_sorted)):
      result[self.storage_sorted[index]] = self.storage_original[index]
    return result

# STEP F
  def __add__(self,givenValue):
    result = MyQueue()
    for index in range(len(self.storage_sorted)):
      result.storage_sorted.append(self.storage_sorted[index])
      result.storage_original.append(self.storage_original[index])
    for index in range (len(givenValue.storage_sorted)):
      if (givenValue.storage_sorted[index] in self.storage_sorted) == False:
        result.storage_sorted.append(givenValue.storage_sorted[index])
        result.storage_original.append(givenValue.storage_original[index])
    return result

이찬

Kyunghee univ. IE 21

이전 포스트

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

다음 포스트

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

Web/Python Programming From KHU

STEP A - 문자열에서 숫자만을 추출

STEP B

STEP C - None

STEP F - add

STEP F - 중복 제거

왜 set으로 집합을 제거하지 않고, 딕셔너리의 dict.fromkeys(iterable) 메서드로 바꾸었을까? => Error : TypeError: unhashable type: 'list'

실수

채점 프로그램 만들기

모범 답안 코드 해석

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

2021년 2학기 01분반 기출 모범 답안 풀이

0개의 댓글

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

Web/Python Programming From KHU

STEP A - 문자열에서 숫자만을 추출

STEP B

STEP C - None

STEP F - __add__

STEP F - 중복 제거

왜 set으로 집합을 제거하지 않고, 딕셔너리의 dict.fromkeys(iterable) 메서드로 바꾸었을까? => Error : TypeError: unhashable type: 'list'

실수

채점 프로그램 만들기

모범 답안 코드 해석

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

2021년 2학기 01분반 기출 모범 답안 풀이

0개의 댓글

STEP F - add