Python (연습문제, 반복문, 반복문-for, break, 내장함수)

1. 연습문제

# 1
score = int(input("점수를 입력하세요 >>>"))
if (score <= 100 and score >= 90):
    print(f"점수는 {score}점이고, 학점은 A 학점입니다.")
elif (score >= 80 and score <90):
    print(f"점수는 {score}점이고, 학점은 B 학점입니다.")
elif (score >= 70 and score < 80):
    print(f"점수는 {score}점이고, 학점은 C 학점입니다.")
elif (score >= 60 and score < 70):
    print(f"점수는 {score}점이고, 학점은 D 학점입니다.")
else:
    print(f"점수는 {score}점이고, 학점은 F 학점입니다.")

# 2
number = int(input("정수를 입력하세요 >>> "))
if (number % 3 == 0):
    print(f'{number}는 3의 배수입니다.')
else:
    print(f'{number}는 3의 배수가 아닙니다.')

# 3
num1 = int(input('정수를 입력하세요 >>> '))
num2 = int(input('정수를 입력하세요 >>> '))
num3 = int(input('정수를 입력하세요 >>> '))
if (num1 > num2 and num1 > num3):
    print(f'가장 큰 수는 {num1}입니다.')
elif (num2 > num1 and num2 ):
    print(f'가장 큰 수는 {num2}입니다.')
elif (num3 > num1 and num3 > num2):
    print(f'가장 큰 수는 {num3}입니다.')

# max_num = num1
# if num2 > max_num:
#     max_num = num2
# if num3 > max_num:
#     max_num = num3
# print(f'가장 큰 수는 {max_num}입니다.')
#
# print(f'가장 큰 수는 {max([num1, num2, num3])}입니다.')

 

2. 반복문

 - do while 문 없음

 - while은 간단. 자바와 유사

 - for문은 삼항을 이용하는 for문은 없는 대신, 자바에 비해 새로운 기능이 있음

 - 개선된 for문은 2000년대 이후에 만들어졌거나, 성능이 개선된 언어의 공통된 특징.

# while 문
# 특정 조건을 만족하는 동안 반복해서 수행해야 하는 코드를 작성할 때 사용
# while 조건식 :
#   반복실행문

n = 1
while n <= 10:
    print(n)
    n += 1 # n = n+1
print(n)

# 1부터 10사이의 모든 정수를 역순으로 출력
n = 10
while n >= 1:
    print(n)
    n -= 1

# 100 부터 50사이의 짝수를 출력
n = 100
while n >= 50:
    if n % 2 == 0:
        print(n)
    n -= 1

n = 100
while n >= 50:
    print(n)
    n -= 2

# 사용자로 부터 임의의 정수를 입력받아 모두 리스트에 보관
# 단 사용자가 0을 입력하면 프로그램을 종료. 이 때 입력받은 0은 리스트에 보관하지 않음

my_list = [] # 빈 리스트 생성
n = int(input("정수를 입력하세요 (종료 : 0) >>> ")) # 한 번만 실행

while n != 0:
    my_list.append(n)
    n = int(input('정수를 입력하세요 (종료 : 0) >>> '))

print(my_list)

# 구구단 2단 부터 9단 까지 출력
# 단 앞에 제목, 마지막에 구분선을 넣어볼 것
# 8 * 9 = 72
# =================
# 9 단
# 9 * 1 = 9

dan = 2 # 구구단의 단을 의미
while dan <= 9:
    n = 1
    print(f'{dan}단')
    while n <= 9:
        print(f'{dan} * {n} = {dan * n}')
        n += 1
    print("=============")
    dan += 1

# 정수를 입력받아서 그 횟수만큼 'Hello'를 출력하는 프로그램 구현하세요
# 0이하의 값이 입력되면 '잘못된 입력입니다'를 출력

greetingNum = int(input("정수를 입력하세요 >>> "))
if greetingNum < 0:
    print("잘못된 입력입니다.")
elif (greetingNum >= 0):
    num = 1
    while (greetingNum >= num):
        print(f"{num}번째 Hello")
        num += 1

# 3. 커피 1잔을 300원에 판매하는 커피자판기가 있습니다.
# 이 커피자판기에 돈을 넣으면 자판기에서 뽑을 수 있는 커피가 몇 잔이며 잔돈은 얼마인지를 함께 출력하는 프로그램을 구현하세요.

money = int(input("자판기에 얼마를 넣을까요? >>>"))
while (money > 300):
    coffee = 1
    money -= 300
    print(f'커피 {coffee}잔, 잔돈 {money}원')

# 4. 사용자에게 0부터 9사이의 정수를 입력받습니다.
# 이 때 입력된 정수가 5개가 될 때까지 입력받는 프로그램을 구현하세요.
# 이 때 중복된 값이 입력되면 해당 입력은 무시하세요.

number = set()
while len(number) < 5: # numbers에 저장된 요소의 개수
    n = int(input("0 ~ 9 사이 정수를 입력하세요 >>> "))
    number.add(n)
print('모두 입력되었습니다.')
print(f'입력된 값은 {number}입니다.')

 

3. 반복문 - for 문

# for 문
# 값의 범위나 횟수가 정해져 있을 때 사용하면 편리한 반복문
# 1) 특정 횟수 반복
# 2) 데이터 순회

# 기본 구조
# for 변수 in 반복가능객체 :
#   반복실행문

for n in [2, 4, 6]:
    print(n)

# 반복가능객체
# 1. 시퀀스 sequence 자료형 : 순서를 가지고 있는 자료형
#    문자열, 리스트, 튜플, range
# 2. 비시퀀스 non-sequence 자료형 : 순서를 가지고 있지 않은 자료형
#    세트, 딕셔너리

# 1. 문자열
# for 문자 in 문자열:
#     반복실행문

for ch in "Hello": # 문자열 내부의 문자를 하나씩 꺼내서 사용할 수 있음
    print(ch)

# 2. 리스트
# for 요소 in [리스트]:
#     반복실행문

for item in ['가위', '바위', '보']:
    print(item)

# 인덱스 번호 사용  enumerate() 사용.
li = ['가위', '바위', '보']
for i, v in enumerate(li): # i:index, v:요소의 값 value
    print(f'{i} {v}')

# 리스트 내포
# 리스트 생성할 때 for문을 유용하게 사용할 수 있음
# 기본 형식
# 리스트 = [표현식 for 변수 in 반복가능객체]
li = [n * 2 for n in [1,2,3]]
print(li) # [2, 4, 6]

# 조건에 맞는 데이터만 추출 가능
# 리스트 = [표현식 for 변수 in 반복가능객체 if 조건식]
li = [n * 2 for n in [1,2,3,4,5]]
print(li) # [2,4,6,8,10]

li = [n * 2 for n in [1,2,3,4,5] if n % 2 == 1]
print(li)

li2 = [1,2,3,4,5]
for n in li2:
    if (n % 2 == 1):
        li2.append(n * 2)
print(li2)

# 3. 튜플
# 기본 형식
# for 요소 in (튜플):
#   반복실행문

four_seasons = ('Spring', 'Summer', 'Autumn', 'Winter')
for season in four_seasons:
    print(season)

# 4. range() 함수
# '정수 범위'를 만들어 낼 때 유용한 함수. 일정 횟수 반복시에 많이 사용
# 기본 구조
# range(초깃값, 종료값, 증감값)

# 특징
# 1. 초깃값부터 종료값 전까지 숫자(n)들의 컬렉션을 만듬 (초기값 <= n < 종료값)
# 2. 초깃값을 생략하면 0부터 시작
# 3. 종료값은 생략할 수 없음
# 4. 증감값을 생략하면 1씩 증가

# 예
# range(5) : 0, 1, 2, 3, 4
# range(1, 11) : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
# range(1, 10, 2) : 1, 3, 5, 7, 9

print()
print(list(range(1, 6))) # [1, 2, 3, 4, 5]
print(tuple(range(1, 6))) # (1, 2, 3, 4, 5)

print()
for n in [1,2,3,4,5,6,7,8,9,10]:
    print(n)

# 아래와 같이 변경 가능
for n in range(1,11):
    print(n)

# range() 함수를 이용해 생성한 값을 사용하지 않는 경우
for n in range(10): # 10번 반복
    print("Hello")

# 문자열로 비밀번호를 입력 받아 숫자와 문자가 모두 포함이 되었는지 확인

pwd = input("비밀번호를 입력하세요 >>> ")

ch_conut = 0
num_count = 0

for ch in pwd:
    if ch.isalpha(): # ch가 문자인 경우 True 반환
        ch_conut += 1
    elif ch.isnumeric(): # ch가 숫자인 경우 True 반환
        num_count += 1

if ch_conut > 0 and num_count > 0:
    print("가능한 비밀번호입니다.")
else:
    print("불가능한 비밀번호입니다.")

출력하고자 하는 구구단을 입력받아 구구단을 출력
dan = int(input('출력할 구구단을 입력하세요 >>> '))
for n in range(1, dan):
    print()

dan = 2
while dan < 10:
    for n in range(1,10):
        print(f"{dan} * {n} = {dan*n}")
    dan += 1
    
    
# 1. 1부터 5사이에 존재하는 모든 정수를 역순으로 출력하는 프로그램을 구현하세요.
for n in range(5, 0, -1):
    print(n)

# 2. 사용자로부터 임의의 양의 정수를 하나 입력받은 뒤 1부터 입력받은 정수까지 모든 정수의 합계를 출력하는 프로그램을 구현하세요.
num = int(input("임의의 양수를 입력하세요 >>> "))
sum = 0
for n in range(1, num+1):
    sum += n
print(f"1부터 {num}사이 모든 정수의 합계는 {sum}입니다.")

# 3. 사용자로부터 임의의 양의 정수를 하나 입력 받은 뒤 그 숫자만큼 '과일 이름'을 입력받아 'basket' 리스트에
# 저장하는 프로그램을 구현하세요.
basket = []
fruNum = int(input("임의의 양수를 입력하세요 >>> "))
for n in range(1, fruNum+1):
    fru = input(f"{n}번째 과일을 입력하세요 >>> ")
    basket.append(fru)
print(f'입력받은 과일들은 {basket}입니다.')

# 1. 세트 set
# 비시퀀스 자료형이기 때문에 저장된 요소들 사이에 순서가 없음

# 기본 형식
# for 요소 in {세트} :
#    반복실행문

for item in {'가위', '바위', '보'}: # 순서가 지켜지지 않음
    print(item)


# 2. 딕셔너리
# key와 value의 조합이라 다른 자료형과 다른 방식으로 사용됨
# 키만 출력
print()
person = {'name' : "에일리", 'age': 20}
for item in person:
    print(item) # name age

# value 출력
for key, value in person.items():
    print(f'{key} = {value}')

for key in person:
    print(person[key]) # 에일리 20

for key in person: # get() 메소드를 이용해서 해당 key에 value를 가져옴
    print(person.get(key))

# 영어 사전을 딕셔너리 자료형으로 구현하고
# 영어 사전에 등록된 모든 단어와 그 단어의 의미를 출력
eng_dict = {
    'sun' : '태양',
    'moon': '달',
    'star': '별',
    'space': '우주'
}
for word in eng_dict:
    print(f'{word}의 뜻: {eng_dict[word]}')
    print(f'{word}의 뜻: {eng_dict.get(word)}')

 

4. break, continue 문

 - while문이나 for문과 같은 반복문을 강제로 종료하고자 할 때 사용하는 제어문

 - 반복문 내에 break문이 나타나면 곧바로 break문이 포함된 반복문은 종료

 

 - 반복문의 시작 지점으로 제어의 흐름을 옮기는 역할
 - 반복에서 제외하거나 생략하고 싶은 코드가 존재할 때 사용

 

# break문
# while문이나 for문과 같은 반복문을 강제로 종료하고자 할 때 사용하는 제어문
# 반복문 내에 break문이 나타나면 곧바로 break문이 포함된 반복문은 종료

n = 1
while True:
    print(n)
    if n == 10:
        break # if문에서 break문을 작성했지만 실제로 종료되는 것은 while문
    n += 1
print(n) # 10

while True: # 무한 루프
    city = input('대한민국의 수도는 어디인가요? >>>')
    city = city.strip() # 문자열의 양쪽끝에서 공백을 없앰
    if city == '서울' or city == 'seoul' or city == 'SEOUL': # 대소문자 모두 정답처리
        print('정답입니다.')
        break # 정답을 맞춰야 종료
    else:
        print("오답입니다. 다시 시도하세요.")

# 종료 조건이 2가지인 경우 : 5개까지 입력이 가능 혹은 그전에 그만두려면 q 입력

hobbies = [] # 빈 리스트 생성
while True: # 무한루프
    hobby = input('취미를 입력하세요(종료는 그냥 q) >>> ')
    if hobby == 'q':
        print('입력된 취미가 모두 저장되었습니다.')
        break
    else:
        hobbies.append(hobby)

    if len(hobbies) >= 5:
        print('5개 입력!')
        break
print(hobbies)

# continue 문
# 반복문의 시작 지점으로 제어의 흐름을 옮기는 역할
# 반복에서 제외하거나 생략하고 싶은 코드가 존재할 때 사용

# 1에서 100사이의 모든 정수를 합하는데 3의 배수는 제외
total = 0
for a in range(1, 101):
    if a % 3 == 0: # 3의 배수인지 검사
        continue
    total == 0
print(total)

fruites = ['사과', '감귤']
count = 3 # 입력 가능한 횟수

while count > 0:
    fruit = input('어떤 과일을 저장할까요? >>> ')

    if fruit in fruites: # fruites 리스트에 fruit 변수에 있는 값이 있다면
        print("동일한 과일이 있습니다.")
        continue # while문의 시작 지점으로 돌아가서 다시 과일 이름을 입력

    fruites.append(fruit) # 입력된 과일 이름을 리스트에 저장
    count -= 1 # 입력 가능 횟수가 줄어듬
    print(f'입력이 {count}번 남았습니다.')

print(f'5개 과일은 {fruites}입니다.')

 

5. 내장 함수

# eval() : 실행하고자 하는 표현식을 문자열로 전달하면 표현식의 결과값 반환
print(eval('100 + 200')) # 300


# format() : 전달받은 인수와 포맷 코드에 따라 형식을 갖춘 문자열을 반환

print()
print(format(10000)) # 10000 / str(10000)과 같음
print(format(10000, ',')) # 10,000 / 천단위 구분 기호로 쉼표(,)를 사용

# str() : 전달받은 인수를 문자열로 변환하여 반환


# 2. 숫자 내장함수

# abs() : 전달된 인수 (정수 혹은 실수)의 절대값을 반환
print(abs(10)) # 10
print(abs(-10)) # 10

# divmod() : 전달된 두 인수를 나누어 몫과 나머지를 한 쌍의 결과로 반환. 몫과 나머지는 하나의 튜플로 반환
print(divmod(10, 3)) # (3, 1)
print(type(divmod(10, 3))) # <class 'tuple'>

# float() : 전달된 인수(숫자 또는 문자열)를 실수로 만들어 반환. 전달된 인수가 없는 경우에는 0.0을 반환

# max() : 전달된 인수 중 가장 큰 값을 반환
print()
print(max(1,10)) # 10
li = [5, 4, 3, 2, 1]
print(max(li)) # 5

# min() : 전달된 인수 중 가장 작은 값을 반환

# pow() : 전달된 두 인수의 거듭제곱을 반환. 연산자 중에서 거듭 제곱 연산자 ** 와 같음
print()
print(pow(10, 2)) # 100
print(pow(10, 3)) # 1000

# round() : 전달된 인수를 이용해 반올림한 값을 반환
# 전달된 인수가 하나이면 정수로 반올림한 값을 반환하고, 전달된 인수가 2개이면 두 번째로 전달한 인수만큼 소수점을 남겨둠
print()
print(round(1.5)) # 2
print(round(1.4)) # 1
print(round(1.55, 1)) # 1.6
print(round(2.675, 2)) # 2.67 > 부동 소수점 에러로 인해 2.67 반환. 더 정확하게는 다른 함수 사용

# sum() : 전달된 리스트나 튜플과 같은 반복가능객체의 합계를 반환
# 숫자가 아닌 값을 전달하면 에러가 발생
print()
list1 = [1,2,3,4,5]
print(sum(list1)) # 15

# list2 = ['h', 'e', 'l', 'l', 'o']
# print(sum(list2) # 에러 발생

exam = []
print("점수를 입력하세요.")
print("더 이상 입력할 점수가 없으면 음수를 아무거나 입력하세요.")
while True:
    score = int(input("점수입력 >>> "))
    if (score < 0):
        print(f'평균 = {sum(exam)/len(exam)}, 최대 = {max(exam)}, 최소 = {min(exam)}')
        break
    else:
        exam.append(score)
        
        
# 3. 시퀀스 내장 함수

# enumerate() : 리스트에 저장된 요소와 해당 요소의 인덱스가 튜플 tuple 형태로 함게 추출
# for item in enumerate([리스트]) :
#   반복실행문

for item in enumerate(['가위', '바위', '보']) :
    print(item)
# (0, '가위')
# (1, '바위')
# (2, '보')

for idx, element in enumerate(['가위', '바위', '보']) :
    print(idx, ' / ', element)
# 0  /  가위
# 1  /  바위
# 2  /  보

# range() : 전달된 인수값에 따라 시퀀스 자료형의 데이터를 생성
# 1) range(stop) / 0부터 stop 사이의 모든 정수가 생성. 생성되는 정수를 n이라고 하면 n의 범위는 0 <= n < stop
# 2) range(start, stop) / start부터 stop 사이의 모든 정수가 생성. 생성되는 정수를 n이라고 하면 n의 범위는 start <= n < stop
# 3) range(start, stop, step) / start부터 stop 사이의 정수 중에서 step만큼의 차이를 가지고 있는 정수가 생성.

print()
print(list(range(10))) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1, 11))) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(range(0, 30, 5))) # [0, 5, 10, 15, 20, 25]
print(list(range(0, 10, 3))) # [0, 3, 6, 9]
print(list(range(0, -10, -1))) # [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
print(list(range(0))) # []
print(list(range(1, 0))) # []

# len() : 함수에 전달된 객체의 길이(항목 수)를 반환
print()
li = ['a', 'b', 'c', 'd']
print(len(li)) # 4

d = {'a' : 'apple', 'b' : 'banana'}
print(len(d)) # 2 / 딕셔너리는 '키:값'으로 구성된 한 쌍을 하나의 데이터로 봄

print(len(range(10))) # 10 / range() 함수로 생성되는 값은 0 ~ 9
print(len(range(1,10))) # 9 / range() 함수로 생성되는 값은 1 ~ 9

# range() 함수와 리스트의 길이를 구하는 len() 함수를 함께 사용하면 리스트의 인덱스를 생성가능
seasons = ['봄', '여름', '가을', '겨울']
seasons_eng = ['spring', 'summer', 'fall', 'winter']
for idx in range(len(seasons)):
    print(f'{seasons[idx]} / {seasons_eng[idx]}')

months_eng = ['January', 'February', 'March', 'April', 'May', 'June', 'July',
              'August', 'September','October', 'Novemer', 'December']
months = [31, 28, 31, 30, 31, 30, 31, 31, 30 ,31,30,31]

# 1. range 사용
for idx in range(len(months)):
    print(f'{months_eng[idx]} = {months[idx]}')

print()
# 2. enumerate() 사용
for i, v in enumerate(months):
    print(f'{v} = {months[i]}일')
print()

# sorted() : 전달된 반복가능객체의 오름차순 정렬 결과를 반환
# reverse=True 옵션을 추가할 경우 내림차순 정렬 결과를 반환
print()
my_list2 = ['b', 'c', 'a', 'd']
print(sorted(my_list2))  # ['a', 'b', 'c', 'd']
print(sorted(my_list2, reverse=True))  # ['d', 'c', 'b', 'a']

my_list = [6, 3, 1, 2, 5, 4]
print(sorted(my_list))  # [1, 2, 3, 4, 5, 6]
print(sorted(my_list, reverse=False))  # [1, 2, 3, 4, 5, 6]
print(sorted(my_list, reverse=True))  # [6, 5, 4, 3, 2, 1]

print()
print(sorted(my_list))  # [1, 2, 3, 4, 5, 6]
print(my_list)  # [6, 3, 1, 2, 5, 4] / 실제로 정렬이 된건 아님

print()
my_list = sorted(my_list)  # 오름차순 정렬 결과를 덮어쓰기
print(my_list)  # [1, 2, 3, 4, 5, 6]

# zip() : 전달된 여러 개의 반복가능객체의 각 요소를 튜플로 묶어서 반환
# 전달된 반복가능객체들의 길이가 서로 다르면 길이가 짧은 반복가능객체 기준으로 동작
print()
names = ['james', 'emily', 'amanda']
scores = [60, 70, 80]
for student in zip(names, scores):
    print(student)
# ('james', 60)
# ('emily', 70)
# ('amanda', 80)

# 튜플은 언패킹이 가능하므로 다음과 같은 모습으로 구성 가능
for name, score in zip(names, scores):
    print(f'{name}의 점수는 {score}입니다.')
# james의 점수는 60입니다.
# emily의 점수는 70입니다.
# amanda의 점수는 80입니다.

print()
for idx, name in enumerate(names):
    print(f'{name}의 점수는 {scores[idx]}입니다.')

print()
for idx in range(len(names)):
    print(f'{names[idx]}의 점수는 {scores[idx]}입니다.')