PARKYONGROK

python 내장 함수 중 max()라는 함수가 있다.

이 max() 함수를 이용하여 list 를 받아 최대값을 return 해주는 함수를 작성해 보았다.

def max_list(list):
    return max(list)

위의 함수를 for loop을 이용하여 다음과 같이 구현해 보았다.

def max_forloop(list):
    max = 0
    for i in range(len(list)):
        if list[i] > max:
            max = list[i]    
    return max

.

두 함수의 성능을 비교해 보자.

같은 리스트를 사용하여 비교하기 위해

매 테스트마다 새로운 리스트를 작성하여

두 함수의 속도를 측정해 보자.

코드는 아래와 같이 작성하였다.

random 함수를 이용하여 10,000,000 개의 정수로 이루어진 list를 만들어서 각각 전달해 주었다.

총 10번씩 반복하며 각각의 실행 시간과 평균 실행 시간을 출력해 주었다.

import time
import random

def make_list(count):
    arr = []
    for i in range(count):
        arr.append(int(random.random()*10000%1000))
    return arr

def max_forloop(list):
    max = 0
    for i in range(len(list)):
        if list[i] > max:
            max = list[i]    
    return max

def max_list(list):
    return max(list)


time_list_forloop = []
time_list_list = []

for i in range(10):
    test_list = make_list(10000000)

    time_begin = time.perf_counter()
    max_forloop(test_list)
    time_end = time.perf_counter()

    time_list_forloop.append(time_end - time_begin)
    print(f"{i+1}번째 for 실행시간 : {time_end-time_begin}")

    time_begin = time.perf_counter()
    max_list(test_list)
    time_end = time.perf_counter()

    time_list_list.append(time_end - time_begin)
    print(f"{i+1}번째 max 실행시간 : {time_end-time_begin}")


print(f">>> for   평균 실행시간 : {sum(time_list_forloop)/len(time_list_forloop)}")
print(f">>> max() 평균 실행시간 : {sum(time_list_list)/len(time_list_list)}")

출력 결과는 다음과 같다.

built-in function 의 사용이 속도면에서 유리하다는 점을 배웠다. 

백준 2739번 구구단

[파이썬/Python] 백준 2739번 구구단

문제

N을 입력받은 뒤, 구구단 N단을 출력하는 프로그램을 작성하시오. 출력 형식에 맞춰서 출력하면 된다.

입력

첫째 줄에 N이 주어진다. N은 1보다 크거나 같고, 9보다 작거나 같다.

출력

출력형식과 같게 N*1부터 N*9까지 출력한다.

기존 풀이는 다음과 같다.

N = int(input())

for i in range(1,10):
    print(f"{N} * {i} = {N*i}")

위 문제를 다음과 같이 함수화 하였다

# 백준 2739번 구구단
def show_multiple_table(num):
    for i in range(1,10):
        print(f"{num} * {i} = {num*i}")
        
N = int(input())
show_multiple_table(N)

백준 10950번 A+B - 3

[파이썬/Python] 백준 10950번 A+B - 3

문제

두 정수 A와 B를 입력받은 다음, A+B를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다.

각 테스트 케이스는 한 줄로 이루어져 있으며, 각 줄에 A와 B가 주어진다. (0 < A, B < 10)

출력

각 테스트 케이스마다 A+B를 출력한다.

기존 풀이는 다음과 같다

T = int(input())

test_case = []

for i in range(T):
    test_case.append(list(map(int,input().split())))

for x in range(T):
    print(test_case[x][0]+test_case[x][1])

위의 문제를 다음과 같이 함수화 하였다.

함수 내에서 한 줄씩 프린트하고 끝낼 수도 있지만,

함수화하는 의미를 부여하기 위해 결과값들을 list 형태로 return해 주는 방식으로 코드를 작성해 보았다.

# 백준 10950번 A+B - 3
def AplusB3():
    test_case = []
    result_list = []
    
    count = int(input())
    
    for i in range(count):
        test_case.append(list(map(int,input().split())))
    for x in range(count):
        result_list.append(test_case[x][0]+test_case[x][1])
    
    return result_list

print(AplusB3())

백준 8393번 합

[파이썬/Python] 백준 8393번 합

문제

n이 주어졌을 때, 1부터 n까지 합을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 n (1 ≤ n ≤ 10,000)이 주어진다.

출력

1부터 n까지 합을 출력한다.

기존 풀이는 다음과 같다.

n = int(input())

total = 0 

for i in range(1,n+1):
    total += i

print(total)

위의 문제를 다음과 같이 함수화 하였다.

재귀 함수를 사용하여 작성해 보았다.

# 백준 8393번 합
def addtil1(num):
    if num == 1:
        return 1
    else:
        return num + addtil1(num-1)

n = int(input())
print(addtil1(n))

재귀 함수를 사용하다 보니 재귀와 for loop의 성능 차이에 대해 궁금해져서 확인해 보기 위해 코드를 작성해 보았다.

import time

def addtil1_resursion(num):
    if num == 1:
        return 1
    else:
        return num + addtil1_resursion(num-1)

def addtil1_for(num):
    total = 0
    for i in range(num+1):
        total += i
    return total

n = int(input())

start = time.time()
print(addtil1_resursion(n))
end = time.time()
print(f"resursion : {end-start}")

start = time.time()
print(addtil1_for(n))
end = time.time()
print(f"for-loop : {end-start}")

결과를 확인하기 위해 10,000이상의 큰 수를 넣어보니 Recursion Error 가 발생하였다.

RecursionError: maximum recursion depth exceeded in comparison

python에서는 recursion limit을 기본적으로 1,000으로 둔다는 것을 배웠다.

결과를 확인하기 위해 900 으로 비교해 보았다.

결과값은 동일하였으며 속도 측면에서는 역시 재귀함수보다 for loop 이 빠름을 알 수 있었다.

백준 25304번 영수증

[파이썬/Python] 백준 25304번 영수증

문제

준원이는 저번 주에 살면서 처음으로 코스트코를 가 봤다. 정말 멋졌다. 그런데, 몇 개 담지도 않았는데 수상하게 높은 금액이 나오는 것이다! 준원이는 영수증을 보면서 정확하게 계산된 것이 맞는지 확인해보려 한다.

영수증에 적힌,

• 구매한 각 물건의 가격과 개수
• 구매한 물건들의 총 금액

을 보고, 구매한 물건의 가격과 개수로 계산한 총 금액이 영수증에 적힌 총 금액과 일치하는지 검사해보자.

입력

첫째 줄에는 영수증에 적힌 총 금액 X가 주어진다.

둘째 줄에는 영수증에 적힌 구매한 물건의 종류의 수 N이 주어진다.

이후 N개의 줄에는 각 물건의 가격 a와 개수 b가 공백을 사이에 두고 주어진다.

출력

구매한 물건의 가격과 개수로 계산한 총 금액이 영수증에 적힌 총 금액과 일치하면 Yes를 출력한다.

일치하지 않는다면 No를 출력한다.

기존 풀이는 다음과 같다.

X = int(input()) # total price
N = int(input()) # total number of types of objects
product_list = []
total_price = 0

for i in range(N): # total number 만큼 단가와 수량 입력받기
    product_list.append(list(map(int,input().split())))

for j in range(N): # 물건값 총 합계 계산
    total_price += product_list[j][0] * product_list[j][1]

if X == total_price: # 합계 비교 
    print('Yes')
else:
    print('No')

위의 풀이를 다음과 같이 함수화 하였다.

# 백준 25304번 영수증
def checking_receipt(total_price, total_type):
    product_list = []
    add_price = 0
    
    for i in range(total_type):
        product_list.append(list(map(int,input().split())))
    
    for j in range(total_type):
        add_price += product_list[j][0] * product_list[j][1]
    
    if total_price == add_price:
        return True
    else:
        return False
    
X = int(input())
N = int(input())
print(checking_receipt(X, N))

백준 25314번 코딩은 체육과목 입니다

[파이썬/Python] 백준 25314번 코딩은 체육과목 입니다

문제

오늘은 혜아의 면접 날이다. 면접 준비를 열심히 해서 앞선 질문들을 잘 대답한 혜아는 이제 마지막으로 칠판에 직접 코딩하는 문제를 받았다. 혜아가 받은 문제는 두 수를 더하는 문제였다. C++ 책을 열심히 읽었던 혜아는 간단히 두 수를 더하는 코드를 칠판에 적었다. 코드를 본 면접관은 다음 질문을 했다. “만약, 입출력이 N바이트 크기의 정수라면 프로그램을 어떻게 구현해야 할까요?”

혜아는 책에 있는 정수 자료형과 관련된 내용을 기억해 냈다. 책에는 long int는 4바이트 정수까지 저장할 수 있는 정수 자료형이고 long long int는 8바이트 정수까지 저장할 수 있는 정수 자료형이라고 적혀 있었다. 혜아는 이런 생각이 들었다. “int 앞에 long을 하나씩 더 붙일 때마다 4바이트씩 저장할 수 있는 공간이 늘어나는 걸까? 분명 long long long int는 12바이트, long long long long int는 16바이트까지 저장할 수 있는 정수 자료형일 거야!” 그렇게 혜아는 당황하는 면접관의 얼굴을 뒤로한 채 칠판에 정수 자료형을 써 내려가기 시작했다.

혜아가 𝑁바이트 정수까지 저장할 수 있다고 생각해서 칠판에 쓴 정수 자료형의 이름은 무엇일까?

입력

첫 번째 줄에는 문제의 정수 𝑁이 주어진다. (4≤𝑁≤1000; 𝑁은 4의 배수)

출력

혜아가 𝑁바이트 정수까지 저장할 수 있다고 생각하는 정수 자료형의 이름을 출력하여라.

기존 풀이는 다음과 같습니다

N = int(input())
result_string = []

number_long = N // 4

for i in range(number_long):
    result_string.append("long")

result_string.append('int')

print(f'{" ".join(result_string)}')

위의 풀이를 다음과 같이 함수화 하였습니다

# 백준 25314번 코딩은 체육과목 입니다
def decide_datatype(byte):
    result_string = []
    number_long = N // 4
    for i in range(number_long):
        result_string.append("long")
    result_string.append('int')
    
    return " ".join(result_string)
    
N = int(input())
print(decide_datatype(N))

백준 15552번 빠른 A+B

[파이썬/Python] 백준 15552번 빠른 A+B

기존 풀이는 다음과 같습니다.

import sys

T = int(input())

test_case = []

for i in range(T):
    test_case.append(list(map(int,sys.stdin.readline().split())))

for x in range(T):
    print(test_case[x][0]+test_case[x][1])

위의 풀이를 다음과 같이 함수화 하였습니다

# 백준 15552번 빠른 A+B
import sys

def fastAplusB():
    test_case = []
    result_case = []
    
    count = int(input())
    for i in range(count):
        test_case.append(list(map(int,sys.stdin.readline().split())))
    for j in range(count):
        result_case.append(test_case[j][0]+test_case[j][1])
        
    return result_case

print(fastAplusB())

백준 11021번 A+B - 7

[파이썬/Python] 백준 11021번 A+B - 7

기존 풀이는 다음과 같습니다

T = int(input())

test_case = []

for i in range(T):
    test_case.append(list(map(int,input().split())))

for x in range(T):
    print(f"Case #{x+1}: {test_case[x][0]+test_case[x][1]}")

위의 풀이를 다음과 같이 함수화 하였습니다

# 백준 11021번 A+B - 7
def AplusB7():
    T = int(input())
    test_case = []
    
    for i in range(T):
        test_case.append(list(map(int,input().split())))
    
    for x in range(T):
        print(f"Case #{x+1}: {test_case[x][0]+test_case[x][1]}")

AplusB7()

백준 11022번 A+B - 8

[파이썬/Python] 백준 11022번 A+B - 8

기존 풀이는 다음과 같습니다

T = int(input())

test_case = []

for i in range(T):
    test_case.append(list(map(int,input().split())))

for x in range(T):
    print(f"Case #{x+1}: {test_case[x][0]} + {test_case[x][1]} = {test_case[x][0]+test_case[x][1]}")

위의 풀이를 다음과 같이 함수화 하였습니다

# 백준 11022번 A+B - 8
def AplusB8():
    T = int(input())
    test_case = []
    
    for i in range(T):
        test_case.append(list(map(int,input().split())))
    
    for x in range(T):
        print(f"Case #{x+1}: {test_case[x][0]} + {test_case[x][1]} = {test_case[x][0]+test_case[x][1]}")

AplusB8()

백준 2438번 별 찍기 - 1

[파이썬/Python] 백준 2438번 별 찍기 - 1

기존 풀이는 다음과 같습니다

N = int(input())

for i in range(1,N+1):
    print("*"*i)

위의 풀이를 다음과 같이 함수화 하였습니다.

# 백준 2438번 별 찍기 - 1
def print_stars1(num):
    for i in range(1,num+1):
        print("*"*i)

N = int(input())
print_stars1(N)

백준 2439번 별 찍기 - 2

[파이썬/Python] 백준 2439번 별 찍기 - 2

기존 풀이는 다음과 같습니다

N = int(input())

for i in range(1,N+1):
    print(" "*(N-i)+"*"*i)

위의 풀이를 다음과 같이 함수화 하였습니다

# 백준 2439번 별 찍기 - 2
def print_stars2(num):
    for i in range(1,num+1):
        print(" "*(N-i)+"*"*i)

N = int(input())
print_stars2(N)

백준 10952번 A+B - 5

[파이썬/Python] 백준 10952번 A+B - 5

기존 풀이는 다음과 같습니다

test_case = []

while True:
    temp_arr=[]
    a, b = map(int,input().split())
    if a==0 and b==0:
        break
    else:
        temp_arr.append(a)
        temp_arr.append(b)
        test_case.append(temp_arr)

for i in range(len(test_case)):
    print(test_case[i][0] + test_case[i][1])

위의 풀이를 다음과 같이 함수화 하였습니다

# 백준 10952번 A+B - 5
def AplusB5():
    test_case = []
    while True:
        temp_arr=[]
        a, b = map(int,input().split())
        if a==0 and b==0:
            break
        else:
            temp_arr.append(a)
            temp_arr.append(b)
            test_case.append(temp_arr)

    for i in range(len(test_case)):
        print(test_case[i][0] + test_case[i][1])

AplusB5()

백준 10951번 A+B - 4

[파이썬/Python] 백준 10951번 A+B - 4

기존 풀이는 다음과 같습니다

test_case = []

while True:
    temp_arr=[]
    try:
        a, b = map(int,input().split())
        temp_arr.append(a)
        temp_arr.append(b)
        test_case.append(temp_arr)
    except:
        break

for i in range(len(test_case)):
    print(test_case[i][0] + test_case[i][1])

위의 풀이를 다음과 같이 함수화 하였습니다

# 백준 10951번 A+B - 4
def AplusB4():
    test_case = []

    while True:
        temp_arr=[]
        try:
            a, b = map(int,input().split())
            temp_arr.append(a)
            temp_arr.append(b)
            test_case.append(temp_arr)
        except:
            break

    for i in range(len(test_case)):
        print(test_case[i][0] + test_case[i][1])
    
AplusB4()

백준 1330번 두수 비교하기

[파이썬/Python] 백준 1330번 두 수 비교하기

기존 문제 풀이는 다음과 같다.

a, b = map(int,input().split())

if a > b:
    print('>')
elif a < b:
    print('<')
else:
    print('==')

위의 문제를 다음과 같이 함수화 하였다

# 백준 1330번 두 수 비교하기
def compare_two_number(first_num, second_num):
    if first_num > second_num:
        return ">"
    elif first_num < second_num:
        return "<"
    else:
        return '=='
    
a, b = map(int,input().split())
print(compare_two_number(a,b))

백준 9498번 시험성적

[파이썬/Python] 백준 9498번 시험성적

기존 풀이는 다음과 같다

score = int(input())

if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
else:
    grade = 'F'
    
print(grade)

위의 문제를 다음과 같이 함수화하였다.

# 백준 9498번 시험성적
def return_test_grade(score):
    if score >= 90:
        return 'A'
    elif score >= 80:
        return 'B'
    elif score >= 70:
        return 'C'
    elif score >= 60:
        return'D'
    else:
        return 'F'
    
score = int(input())
print(return_test_grade(score))

백준 2753번 윤년

[파이썬/Python] 백준 2753번 윤년

기존 풀이는 다음과 같다.

year = int(input())

if year%400==0:
  print(1)
elif year%4==0 and not year%100==0:
  print(1)
else:
  print(0)

위의 문제를 다음과 같이 함수화 하였다.

# 백준 2753번 윤년
def is_leapyear(year):
    if year%400==0:
        return True
    elif year%4==0 and not year%100==0:
        return True
    else:
        return False
    
year = int(input())
print(is_leapyear(year))

백준 14681번 사분면 고르기

[파이썬/Python] 백준 14681번 사분면 고르기

기존 풀이는 다음과 같다.

x = int(input())
y = int(input())

if x > 0 :
  if y > 0 :
    print(1)
  else:
    print(4)
else:
  if y > 0:
    print(2)
  else:
    print(3)

위의 문제를 다음과 같이 함수화 하였다.

# 백준 14681번 사분면 고르기
def return_quadrant(x, y):
    if x > 0 :
        if y > 0 :
            return 1
        else:
            return 4
    else:
        if y > 0:
            return 2
        else:
            return 3

x = int(input())
y = int(input())
print(return_quadrant(x,y))

백준 2884번 알람 시계

[파이썬/Python] 백준 2884번 알람 시계

기존 풀이는 다음과 같다.

H, M = map(int, input().split())

if M-45 < 0:
    H = (H-1)%24
    M = (M-45)%60
else:
    M = (M-45)%60

print(H,M)

위의 문제를 다음과 같이 함수화 하였다.

# 백준 2884번 알람 시계
def set_alarmclock(H,M):
    if M-45 < 0:
        H = (H-1)%24
        M = (M-45)%60
    else:
        M = (M-45)%60
    return H, M

Hour, Minute = map(int, input().split())
print(set_alarmclock(Hour, Minute))

백준 2525번 오븐 시계

[파이썬/Python] 백준 2525번 오븐 시계

기존 풀이는 다음과 같다.

A, B = map(int,input().split())
C = int(input())

B += C
A = A + (B//60)

A = A % 24
B = B % 60

print(A,B)

위의 문제를 다음과 같이 함수화 하였다

# 백준 2525번 오븐 시계
def set_ovenclock(Hour, Minute, cooking_time):
    Minute += cooking_time
    Hour = Hour + (Minute//60)

    return Hour % 24, Minute % 60

A, B = map(int,input().split())
C = int(input())
print(set_ovenclock(A, B, C))

백준 2480번 주사위

[파이썬/Python] 백준 2480번 주사위

기존 풀이는 다음과 같다.

a, b, c = map(int,input().split())

if a == b == c :
  print(10000+(a*1000))
elif a==b or b==c or a==c:
  if a==b:
    print(1000+(a*100))
  elif b==c:
    print(1000+(b*100))
  else:
    print(1000+(c*100))
else:
  print(max(a,b,c)*100)

위 풀이를 다음과 같이 함수화 하였다

# 백준 2480번 주사위

def prize_dice(a ,b ,c):
    if a == b == c :
      return 10000+(a*1000)
    elif a==b or b==c or a==c:
       if a==b:
          return 1000+(a*100)
       elif b==c:
          return 1000+(b*100)
       else:
          return 1000+(c*100)
    else:
       return max(a,b,c)*100
    
a, b, c = map(int,input().split())
print(prize_dice(a,b,c))

풀이

리스트와 내장함수를 이용하여 풀이 가능하며, 리스트 사용 없이 입력받는 즉시 비교하여 최대값과 위치(몇 번재 수인지)를 업데이틑 하는 방법이 가능하다.

>>> 리스트 사용 없이 입력받는 즉시 비교하여 최대값과 위치(몇 번재 수인지)를 업데이틑 하는 방법

max = 0
max = 0

for i in range(9):
    num = int(input())
    
    if num > max:
        max = num
        max_i = i
    
print(max)
print(max_i+1)

>>> 리스트와 내장함수를 사용하는 방법

arr = []

for i in range(9):
    arr.append(int(input()))
    
print(max(arr))
print(arr.index(max(arr))+1)

>>> 결과

가장 처음에 제출하여 36ms 걸린 풀이는 리스트 사용 없이 입력받는 즉시 비교하여 최대값과 위치(몇 번재 수인지)를 업데이틑 하는 방법이다.

두 번째 제출은 중간에 오타가 있어서 틀렸다;;;

마지막에 제출하여 32ms 걸린 풀이는 리스트와 내장함수를 사용하는 방법이다.

결론

이번에는 리스트를 사용하지 않는 방식이 조금이나마 빠를 것으로 예상하였지만, 리스트와 내장 함수를 사용하는 방법이 조금이나마 빠른 결과를 낳았다.

이는 매 입력시 값을 비교하는 과정이 시간 소요가 된다는 점을 시사한다.

최대한 빠르게 입력받아 내장 함수를 사용하여 최대값을 찾는 방법이 빠르다는 것을 배웠다.

풀이

이번 문제는 python 내장 함수인 min(), max()를 사용하여 풀면 간단하나, 내장함수를 사용하고 for loop 을 사용하여 푸는 방법에 대해서도 같이 고민해 보았다. 

두 방법을 제출하여 사용 메모리와 처리시간에 차이가 있는지도 확인해 보고 싶었다.

>>> 내장 함수를 사용하여 풀이한 방법:

N = int(input())
arr = list(map(int, input().split()))

print(min(arr),max(arr))

>>> for loop을 이용하여 전체를 다 비교하는 방법

N = int(input())
arr = list(map(int, input().split()))

min = arr[0]
max = arr[0]

for i in range(1, N):
    if arr[i] > max:
        max = arr[i]
    elif arr[i] < min:
        min = arr[i]
        
print(min, max)

>>> 백준 사이트 내 결과

제일 아래쪽(시간: 364ms)이 내장함수를 사용하여 제출한 풀이이며, 제일 위는 for loop을 이용하여 제출한 풀이의 결과이다.

리뷰

우선 내장 함수를 이용하는 것이 코드도 간단하고 더욱 빠르게 해결되는 점을 확인할 수 있다.

아무래도 for loop를 이요하여 전체를 다 비교하는 방식보다는 내장함수에서 그보다 빠르게 수행 가능한 binary search같은 방식을 채택하고 있는 듯하다. 

그럼 python에서 같이 제공하는 method에는 어떤 차이가 있는지 궁금하여 테스트 해보기로 하였다.

sort()를 이용하여 정렬한 후, list의 최초의 값과 마지막 값을 출력하는 것은 어떤지 확인해 보자.

코드는 다음과 같다.

N = int(input())
arr = list(map(int, input().split()))

arr.sort()

print(arr[0],arr[N-1])

결과는 다음과 같다. 

>>> 예상은 했지만 역시 sorting 하는데 시간이 꽤 많이 걸리는 점을 확인할 수 있었다.

결론

python의 장점을 살리기 위해선 지금 내가 필요한 작업에 적합한 내장함수를 최대한 활용하여 코드길이도 줄이고 가독성도 높이면 성능도 좋아질 가능성이 높다.

풀이

N, X = map(int, input().split())
A = list(map(int, input().split()))

for i in range(N):
    if A[i] < X:
        print(A[i], end=" ")

결과값들을 다른 배열에 저장하여 처리하고 싶었지만, 출력만 나오면 되는 문제이기에 print()함수의 end 를 이용하여 문제에서 요구하는 출력에 맞추도록 집중하였다.

풀이

N = int(input())
arr = list(map(int, input().split()))
v = int(input())

print(arr.count(v))

주요 강의내용

• Python 변수와 자료형
  • 파이썬 메모리 사용과 자료형
  • 리스트(List)
  • 집합(Set)
  • 튜플(Tuple)
  • Strings
• Python 반복문과 조건문 그리고 함수
  • 조건문
  • 반복문

인상 깊었던 세부 내용

• python에서도 메모리 단에서 코드를 작성할 수 있다는 점이 신기했으며, 그간 혼자 공부하며 나도 모르게 제한된 정보에서 공부하고 있었다는 생각이 들었다.
  • C에서는 당연하게 메모리, 비트 단위로 코드를 짜보는 일이 있었지만, 틈틈히 python 을 독학하는 과정에서는 이런 레벨보다는 좀 더 일상적이고 쉬운 접근만 있었다.

import sys
a = [1,2,3]
b=a
print(id(a))
print(id(b))
del a # MEMORY 삭제
sys.getrefcount(b) #참조 카운팅

• 리스트(list)와 딕셔너리(dict) 의 자료형에 copy() method
  • 혼자 공부할 때는 왜, 어디에 써야 하는지 궁금했던 method였는데 강사님께서 원본 Data를 유지한 채 작업할 때 필요하며 ai 현업에서 은근 많이 쓰인다고 해서 인상 깊었다.
  • Excel 작업 시, Backdata 남겨 두는 것처럼 필요할 것 같다고 생각한다.
• 집합(set) 
  • 중복이 허용되지 않기 때문에 순수하게 value값에 대한 계산이 필요할 때 유용하게 쓰일 수 있을 것 같다.
  • method : remove() vs discard()
    • error 발생의 유무가 상황에 맞춰서 유용하게 쓰일 수 있다는 생각을 했다.

풀이

> EOF 처리에 대해 알아야 한다

> try: & except: 사용법에 대한 이해가 필요하다.

test_case = []

while True:
    temp_arr=[]
    try:
        a, b = map(int,input().split())
        temp_arr.append(a)
        temp_arr.append(b)
        test_case.append(temp_arr)
    except:
        break

for i in range(len(test_case)):
    print(test_case[i][0] + test_case[i][1])

풀이

test_case = []

while True:
    temp_arr=[]
    a, b = map(int,input().split())
    if a==0 and b==0:
        break
    else:
        temp_arr.append(a)
        temp_arr.append(b)
        test_case.append(temp_arr)

for i in range(len(test_case)):
    print(test_case[i][0] + test_case[i][1])