[AI 부트캠프] DAY 8 - 파이썬 2

[오늘의 일지]

# 일지를 쓰기에 앞서 오늘 강의는 온라인 녹화 강의로 선택가 두 개가 있었는데 하나는 파이썬이 익숙하지 못한 사람들을 위한 것이었고 다른 하나는 파이썬이 익숙한 사람들이 선택할 수 있었습니다. 저는 당연히 초심자로서 첫 번째를 선택했는데 어제 들었던 강의의 강사님은 달랐지만 내용은 같은 부분을 다루고 있었습니다. 그래서 파이썬 기본 문법을 복습한다는 마인드로 임했습니다.

 

파이썬 익숙해지기 - 변수, 자료형, 조건문, 반복문, 함수

[상세 내용]

오늘 상세 내용의 방향성

- 오늘은 위에서 설명한 것과 같이 어제의 내용과 거의 똑같았는데 강사님만 달랐기 때문에 예시문을 실습하는 부분에서 다양하게 복습할 수 있었기에 상세 내용에는 오늘 들었던 강의에서 파이썬의 배경지식과 이론정리 부분은 생략하고 실습예시 위주로 일지를 작성해 보겠습니다. 파이썬의 배경지식과 이론에 대한 부분은 어제의 글을 보시면 자세하게 나와 있습니다. 링크 남기겠습니다.

[AI 부트캠프] DAY 7 - 파이썬 1

 

 

파이썬 익숙해지기

- 변수

# 변수 a에 10이라는 정수 데이터를 할당(assign)한다.
a = 10

# a라는 변수가 실제 메모리에서 저장되어 있는 위치.(메모리 주소)
id(a)

 

- 숫자 데이터 (Numeric Data Types) : 정수형 (Integer), 실수형 (Floating point)

- 정수형 (Integer)

# 기본적인 정수 연산
1+1
>>>2
# a에 10, b에 5를 할당하고, a와 b를 더한 결과를 출력합니다.
a = 10
b = 5
a + b
>>>15
a - b
>>>5
type(b)
>>>int

 

- 실수형 (Floating point)

# 기본적인 실수 할당
c = 3.14
c
>>>3.14
c + 3.14
>>>6.28
# d에 4를 할당하고 c에서 d를 뺀 값을 출력합니다.
d = 4
c - d # -0.86
>>>-0.8599999999999999 # 이렇게 나오는게 0과 1밖에 모르는 컴퓨터에게는 당연한 현상
# 1.34 x 10^6을 의미한다.
e = 1.34E6; e2 = 1.34e-3 # 1.34 x 10^(-3)
e, e2
>>>(1340000.0, 0.00134)

 

- 숫자형 데이터 타입이 제공하는 여러 연산자 : 사칙연산, 특수연산

- 사칙연산

# a에 10, b에 3을 할당하고 a와 b의 사칙연산 결과를 출력합니다. 이번에는 출력할때 print 함수를 사용합니다.
a = 10
b = 3
print(a + b)
print(a - b)
print(a * b)
print(a / b)
>>>
13
7
30
3.3333333333333335

 

- 특수연산

c = 5
d = 2
print(c ** d) # c를 d번 곱한 것. c^d
print(c // d) # c를 d로 나눈 몫.
print(c % d)  # c를 d로 나눈 나머지.
>>>
25
2
1

 

- 문자열(String)

- 문자열을 만드는 여러 가지 방법

# 기본적인 문자열 선언
s = 'Hello World'
s
>>> 'Hello World'
# 그냥 칸을 나누고 선언시 \n이 등장한다
s1 = """my name
is
smart."""
s1
>>> 'my name\nis\nsmart.'
# print()에 넣어주면 정상적으로 나온다
print(s1)
>>>my name
is
smart.
# 파이썬에서 ""와 ''를 모두 제공하는 이유 : 다음과 같은 예시에서 오류를 줄이기 위해
s2 = "I'm a boy."
s3 = 'She said, "Go away!"'
print(s3)
print(s4)
>>>
I'm a boy.
She said, "Go away!"

 

- 특수 문자 표현 (escape code) 익히기

# \n -> new line
print("Hello\n\n\n\n\nWorld")
>>>
Hello




World
# \t -> tab
print("Hello\t\t\t\t\t\tWorld")
>>>Hello						World

 

- 문자열 연산하기

# 문자열 더하기
s = "Hello"
s1 = "World"
# Q. 가운데 빈 칸을 넣고 싶을 땐 어떻게 해야할까?
s + ' ' + s1 # string concatenation
>>>Hello World
# 문자열 곱하기
s2 = "Hello"
s2 * 10
>>>HelloHelloHelloHelloHelloHelloHelloHelloHelloHello
# 문자열의 길이를 출력하는 함수 len() 을 통해 s3의 문자 갯수(문자열 길이)를 알아보자.
s3 = "Enjoy your life."
len(s3)
>>>16

 

- 문자열 Formatting

fruit = "파인애플"
count = 300
# 1) print formatting
print("%s는 %d개있다." % (fruit, count))
>>>파인애플는 300개있다.
# 2) str.format
print("{}는 {}개있다.".format(fruit, count))
>>>파인애플는 300개있다.
# 3) f-string
print(f"{fruit}는 {count}개있다.")
>>>파인애플는 300개있다.

 

- 문자열 관련 함수들

(영어) 대소문자 바꾸기 upper(), lower()

s = "hi"
s.upper()
>>>'HI'
s = "Hi"
s.lower()
>>>'hi'

 

- 문자 공백 지우기 strip()

# 문자 사이의 공백을 지우지 못하고 앞뒤 공백만 지운다
s = "         h        i     "
s.strip()
>>>'h        i'
# 문자 사이의 공백까지 지우는 방법
s.replace(" ", "")
>>>'hi'

 

- 문자열 삽입 join()

# 삽입 시키는 곳에는 웬만하면 어떠한 문자도 올수 있음
"?".join("mynameis")
>>>'m?y?n?a?m?e?i?s'

 

- 문자열 나누기 split()

s = "Life is too short."
s.split("too") # 괄호안에 아무것도 안쓰면 공백을 기준으로 잘라줍니다.
>>>['Life is ', ' short.']

 

- 문자열 바꾸기 replace()

s = "Life is too short."
# Life를 This pencil로 바꿔봅시다.
s.replace("Life", "This pencil")
>>>'This pencil is too short.'

 

- 연속형 데이터 (Sequential Data Types) : 리스트(List), 튜플(Tuple), 문자열(String) (문자열을 문자들의 나열로 인식하기 때문에, 연속형 데이터이다.)

- 리스트(List)

- 리스트를 만드는 방법

# 정수 1, 2, 3을 원소로 가지는 리스트를 만듭니다.
L = [1, 2, 3]
L, type(L)
>>>([1, 2, 3], list)
L1 = [] # 빈 리스트를 만드는 같은 방법1
type(L1)
>>>list
L2 = list() # 빈 리스트를 만드는 같은 방법2
type(L2)
>>>list
L3 = [1, "Hi", 3.14, [1, 2, 3]] # 리스트에는 다양한 타입의 원소를 다 포함할 수 있다. 심지어 리스트도.
L3
>>>[1, 'Hi', 3.14, [1, 2, 3]]
L4 = [[1, 2],
     [3, 4]] # 2x2 행렬 표현처럼 사용할 수 있다. 이를 2차원 리스트라고 한다.
L4 # 실제로는 2개의 리스트를 원소로 가지는 리스트이다
>>>[[1, 2], [3, 4]]

 

- Indexing

# 예시1
L = [1, 2, 3, 4, 5]
# L의 첫번째 원소
L[0]
>>>1
# L의 5번째 원소
L[4]
>>>5
# L에 없는 index는?
L[11]
>>>IndexError: list index out of range
# L의 마지막 원소
L[-1]
>>>5
# indexing을 이용한 연산. L의 첫번째, 두번째 원소를 가져다가 더해봅니다.
L[0] + L[1]
>>>3
# 예시2
L2 = [1, [2, 3], 5]
L2[1][0] # L2에서 2에 접근하기 위해 indexing을 해보자.
>>>2

 

- Slicing

L = [1, 2, 3, 4, 5]
# L의 첫번째부터 index2 까지 자르기
L[0:2] # L[0] L[1]

 

- 리스트 연산하기

- 리스트 더하기

L = [1, 2, 3]
L2 = [4, 5]
L + L2 # list concatenation
>>>[1, 2, 3, 4, 5]

 

- 리스트 곱하기

L = [1, 2, 3]
L * 3 # L + L + L
>>>
[1, 2, 3, 1, 2, 3, 1, 2, 3]

 

- 리스트 수정하기

L = [1, 2, 3]
L2 = [4, 5]
L2[0] = 144
L[2] = 7
print(L[1])
print(L2[1])
L[1] + L2[1] # 값이 바뀐게 적용이 됩니다.
>>>
2
5
7

 

- 리스트 관련 함수

- 리스트에 원소 추가하기 append() 

# 빈 리스트 L을 만들어서 3, 2, 1 순서대로 원소를 추가해봅니다.
L = []
L.append(3)
L.append(2)
L.append(1)
L
>>>[3, 2, 1]

 

- 리스트 원소 정렬하기 sort()

# sort()를 이용해 L을 "오름차순" 정렬합니다.
L = [4, 3, 16]
L.sort()
L
>>>
[3, 4, 16]
#L.sort(reverse=True) # reverse=True를 쓰면, "내림차순" 정렬이 됩니다.
L.sort(reverse=True)
L
>>>
[16, 4, 3]

 

- 리스트 뒤집기(정렬 X) reverse()

L = [4, 3, 16]
L.reverse()
L
>>>
[16, 3, 4]

 

 -리스트에서 원소 제거하기 pop()

L.pop()
# 다만 빈 리스트가 될 때까지 제거한 뒤로 에러가 난다.

 

- 튜플(Tuple) : tuple은 list과 거의 같다.(indexing, slicing 모두 동일하게 사용 가능하다. 원소들도 자유롭게 사용 가능하다.) 다만 변경은 불가능하다. 뿐만 아니라 정렬하기, 뒤집기도 안된다.

- 집합(Set)

# 1, 2, 3을 원소로 가지는 집합을 만들어 봅시다.
s = {1, 2, 3}
s, type(s)
>>>({1, 2, 3}, set)
#s1 = {} 이 형태는 사전(Dictionary) 자료형이 되므로 주의!!
s1 = set() # 반드시 이 형태로 공집합 생성
s1, type(s1)
>>>(set(), set)
s[1] # 2가 나올것 같지만... # indexing이 안됨.
>>>TypeError: 'set' object is not subscriptable

 

- 집합의 연산

- 교집합

s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
# s1과 s2의 교집합
s1 & s2 # 교집합의 연산 기호 &
>>>{3, 4, 5}
s1.intersection(s2) # s1과 s2의 자리를 바꿔서 당연히 같다.
s2.intersection(s1)
>>>{3, 4, 5}

 

- 합집합

s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
# s1과 s2의 합집합
s1 | s2
>>>{1, 2, 3, 4, 5, 6, 7}
s1 + s2 # 많이 혼동한다.
>>>TypeError: unsupported operand type(s) for +: 'set' and 'set'
s1.union(s2)
s2.union(s1)
{1, 2, 3, 4, 5, 6, 7}

 

- 차집합

s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
# s1과 s2의 차집합
s1 - s2
>>>{1, 2}
s2 - s1 # 당연히 다르다.
>>>{6, 7}

 

- 집합의 원소의 uniqueness를 활용하는 경우

# 리스트 L에 있는 서로 다른 원소의 개수는?
L = [1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 6, 1, 1, 5]
set(L), len(set(L)) # type conversion (번외로 list(), tuple(), int(), float() 등이 있다)
>>>({1, 2, 3, 4, 5, 6}, 6)

 

- 집합 관련 함수

- 집합에 원소 하나 추가하기 add()

s = set()
s.add(2)
s
>>>{2}

 

- 집합에 여러 원소 추가하기 update()

s = {1, 2, 3}
s.update({4, 5}) # sequence 가능.
s
>>>{1, 2, 3, 4, 5}

 

- 집합에서 원소 제거하기 remove()

s.remove(5) # 집합 내에 존재하는 수만 제거 가능
s
>>>{1, 2, 3, 4}
s.remove(13)
s
>>>KeyError: 13

 

- 사전(Dictionary) 

- 사전을 만드는 방법 : 파이썬에서 제공하는 사전 자료형은 key - value 방법을 통해 저장한다.

# 기본 적인 형태
D = {"hobby" : "game", "name" : "lee"}
D
>>>{'hobby': 'game', 'name': 'lee'}
# 테이블 예시를 사전으로 만들어봅니다.
D = {"John" : '0011', "Maria" : '1234'}
D
>>>{'John': '0011', 'Maria': '1234'}
# 사전 D에 key가 'a'이고 value가 3인 원소를 추가하자.
# 만약에 indexing하려는 key가 존재하지 않는 경우엔, assign을 하게되면 key-value pair가 추가됩니다.
# 아닌 경우에는 assign 하게되면 value가 업데이트 됩니다.
D['a'] = 5
D
{'John': '0011', 'Maria': '1234', 'a': 5}
D["a"] # key값이 이미 존재하는 경우에는 key값을 통한 indexing이 되며, key값이 존재하지 않을 때는 assignment를 사용하여 원소를 추가한다.
>>>5
D2 = {'a' : 1 , 'a' : 2, 'b': 3} # 무엇이 문제일까? 중복은 안되기 때문에 나중값이 선언된다
D2 # key가 될 수 있는 data type은 int, float, str, tuple

# TIP 사전을 만들 때 key는 중복이 있으면 절대 안된다.
# 사전에서 key가 될 수 있는 data type은 immutable이어야 한다.

 

- 사전 관련 함수

- 사전의 모든 key값들 보기 keys()

D = {'name': 'kim', 'phone': '01012345679', 'birth': '1234'}
D.keys()
>>>dict_keys(['name', 'phone', 'birth'])

 

- 사전의 모든 value들 보기 values()

D.values()
>>>dict_values(['kim', '01012345679', '1234'])

 

- 사전의 모든 key, value 쌍 보기 items()

D.items()
dict_items([('name', 'kim'), ('phone', '01012345679'), ('birth', '1234')])

 

- 사전의 원소 가져오기 get()

# D['name']과 같다.
D.get("surname", "Lee") # get 함수를 사용하면, default값을 지정할 수 있다.
>>>'Lee'

 

- Sequence에 해당 데이터가 존재하는지 확인하기 (in operator) : 사전의 경우에는 key값을 대상으로 하고, 리스트, 튜플, 집합, 문자열에 대해서는 해당 원소가 존재하는지 찾아서 True / False를 알려준다.

D = {'name': 'kim', 'phone': '01012345679', 'birth': '1234'}
"phone" in D
>>>True
"major" in D
>>>False
# 리스트, 튜플, 집합에서도 테스트
L = [1, 2, 3]
t = (4, 5, 7)
s = {1, 3.14, "kim"}
"kim" in s
>>>True

 

- Conditional Statement (IF)

- If statement (조건문)

# if문 사용하는 법
a = 5
# a가 5인데, a가 5와 같으면, True를 출력하고 싶다.
if a == 5:
  print("True")
  >>>True

 

- 조건문을 사용하기에 앞서 비교연산과 논리연산에 대해 알아보기

# 같다, 다르다, 크다, 작다, 크거나 같다, 작거나 같다
a == b
a != b
a > b
a < b
a >= b
a <= b
# A and B
# A = a > 4
# B = b < 6
A and B
# A or B
A or B
# not A
not A

 

- 자판기를 만들기

money = 500
# 돈이 500원인데, 돈이 500원이랑 같으면 coffee를 준다.
if money == 500:
  print("Coffee")
>>>Coffee

money = 200
# 돈이 200원 있다. 그러면 어떻게 해야할까?
if money < 500:
  print("거스름돈 %d원을 돌려줍니다." % money)
>>>거스름돈 200원을 돌려줍니다.

money = 1000
# 돈이 1000원이 있는 경우에는?
if money > 500:
  print("Coffee")
  print("거스름돈 %d원을 돌려줍니다." % (money-500))
>>>
Coffee
거스름돈 500원을 돌려줍니다.

 

- 자판기 코드 if-elif-else 사용해서 만들기

money = 1000
# 돈이 500원인데, 돈이 300원이랑 같으면 coffee를 준다.
if money == 500:
  print("Coffee")
elif money < 500:
  print("거스름돈 %d원을 돌려줍니다." % money)
else: # 나머지 케이스 == money > 500
  print("Coffee")
  print("거스름돈 %d원을 돌려줍니다." % (money-500))
>>>
Coffee
거스름돈 500원을 돌려줍니다.

 

- if-elif-else 말고 nested 구조를 이용해 작성해 보기

# nested if
money = 300
if money == 500:
  print("Coffee")
else:
  if money < 500:
    print("거스름돈 %d원을 돌려줍니다." % money)
  else:
    print("Coffee")
    print("거스름돈 %d원을 돌려줍니다." % (money-500))
>>>거스름돈 300원을 돌려줍니다.

 

- Iteration(while, For)

- while statement

# while문은 조건을 만족할 때 까지 반복한다.
while (조건): # 다음과 같은 형태로 만들 수 있다.
 <statement1>
 <statement2>
 <statement3>
# 조건이 만족하는 동안(while) statement1, 2, 3을 반복한다.

 

- 구구단을 통해 연습해 보기

# 2단을 while문으로 구현해봅시다.
number = 0
while  number < 9:
  print("2 x%d = %d"% (number+1,2*(number+1)))
  number = number + 1 
>>>
2 x1 = 2
2 x2 = 4
2 x3 = 6
2 x4 = 8
2 x5 = 10
2 x6 = 12
2 x7 = 14
2 x8 = 16
2 x9 = 18

 

- 커피가 다 떨어질 때까지 자판기 프로그램을 반복하면서 실행한 뒤, 돈을 입력받아서 커피를 주는 프로그램을 작성

# 자판기의 커피 수량
coffee = 5

# 커피가 남아있는 동안 작동!
while coffee > 0:

    # 실제로는 자판기를 통해서 넣은 금액.
    money = int(input("금액을 입력해주세요 : "))
    
    if money == 500:
        # 실제로 이 파트는 자판기에서 커피를 뽑는 명령으로 대체된다.
        print("coffee")
        # 이제 커피를 하나씩 줄인다.
        coffee = coffee - 1

    elif money < 500:
        # 실제로 이 파트는 돈을 반환한다.
        print("%d원을 돌려줍니다." % money)
        
     
    else: # or elif money > 500:
        # 커피를 뽑아주고
        print("coffee")
        # 이제 커피를 하나씩 줄인다.
        coffee = coffee - 1
        # 거스름돈을 돌려준다.
        print("%d원을 돌려줍니다." % (money- 500))
    # 커피가 다 떨어진 경우 알려야한다.
print("커피가 모두 소진되었으니, 관리자에게 문의해주세요.")
>>>
금액을 입력해주세요 : 100
100원을 돌려줍니다.
금액을 입력해주세요 : 500
coffee
금액을 입력해주세요 : 1000
coffee
500원을 돌려줍니다.
금액을 입력해주세요 : 1000
coffee
500원을 돌려줍니다.
금액을 입력해주세요 : 1200
coffee
700원을 돌려줍니다.
금액을 입력해주세요 : 1500
coffee
1000원을 돌려줍니다.
커피가 모두 소진되었으니, 관리자에게 문의해주세요.

 

- for statement

# while문은 조건이 만족하는 동안 반복을 수행했지만, for문은 지정 횟수동안 반복을 수행한다.
# 여기서 지정된 횟수라는 것은 반복 대상의 크기가 된다.
# 보통 iteratable object(반복 가능한 객체)를 대상으로 수행되며, 연속형 데이터 타입 변수들이 여기에 해당된다.
# List, Tuple, string, ...
for 변수 in 리스트(튜플, 문자열, iterator):
<statement1>
<statement2>
<statement3>
# 리스트(나 반복가능한 변수들)의 모든 원소를 (자동으로 끝까지) 반복한다.

 

- for 기본형 예시

# 원소가 1, 2, 3인 리스트의 원소를 하나하나 출력하는 반복문을 만든다.
L = [1, 2, 3]

for i in L:
  print(i)
>>>
1
2
3
# while statement
L = [1, 2, 3]
num = 0
while num < len(L) :
    print(L[num])
    num = num + 1
>>>
1
2
3

 

- 6개의 종류의 커피가 담긴 리스트가 있다. 카페에 있는 모든 커피를 출력해 보기

coffees = ['아메리카노', '카페라떼', '카페모카', '바닐라라떼', '핸드드립', '콜드브루']

for i in coffees :
  print(i)
>>>
아메리카노
카페라떼
카페모카
바닐라라떼
핸드드립
콜드브루

 

- for문의 단짝 range() 함수

# for문은 특정 횟수동안 반복을 하기 때문에, 횟수를 자동으로 만들어주는 기능이 있으면 좋다.
# 파이썬에서 기본적으로 제공하는 range 함수는 특정 숫자 범위내의 값들을 자동으로 생성해주는 함수이다.
# e.g. range(1, 5)는 1, 2, 3, 4를 차례대로 생성해준다.
# (5는 범위에서 제외된다. 즉,마지막 숫자는 제외된다. 1 <= x < 5)
for i in range(1,5):
  print(i)
>>>
1
2
3
4

 

- 6개의 종류의 커피와 가격이 담긴 리스트가 있다. 가지고 있는 돈이 5,000원일 때 먹을 수 있는 모든 음료를 찾아보기

coffees = ['아메리카노', '카페라떼', '카페모카', '바닐라라떼', '핸드드립', '콜드브루']
prices = [4100, 4600, 4600, 5100, 6000, 5000]

#for i in range(0, 6):
for i in range(6): # 0부터 시작.
  if prices[i] <= 5000:
    print(coffees[i])
>>>
아메리카노
카페라떼
카페모카
콜드브루

 

- 위에 예시랑 같은 내용으로 500원이 할인되었을 때 5,000원으로 먹을 수 있는 음료 찾기

coffees = ['아메리카노', '카페라떼', '카페모카', '바닐라라떼', '핸드드립', '콜드브루']
prices = [4100, 4600, 4600, 5100, 6000, 5000]

# 1. index를 사용하는 방법
for i in range(len(coffees)):
  if prices[i] - 500 <= 5000:
    print(coffees[i])

print()
# 2. enumerate를 사용하는 방법
for idx, price in enumerate(prices):
  if price - 500 <= 5000:
    print(coffees[idx])

print()
# 3. zip을 사용하는 방법
for coffee, price in zip(coffees, prices):
  if price - 500 <= 5000:
    print(coffee)
>>>
아메리카노
카페라떼
카페모카
바닐라라떼
콜드브루

아메리카노
카페라떼
카페모카
바닐라라떼
콜드브루

아메리카노
카페라떼
카페모카
바닐라라떼
콜드브루

 

- 반복문을 제어하는 break, continue

- break statement : 만약 반복문을 수행하다가 더 이상 반복이 필요 없는 경우에 사용

# 자판기의 커피 수량
coffee = 5

# 일단 작동!
while True: # 영원히 반복. (infinite loop)

    if coffee == 0:
        break
    # 실제로는 자판기를 통해서 넣은 금액.
    money = int(input("금액을 입력하세요."))

    
    if money == 300:
        # 실제로 이 파트는 자판기에서 커피를 뽑는 명령으로 대체된다.
        print("Coffee")
        # 이제 커피를 하나씩 줄인다.
        coffee = coffee - 1

    elif money < 300:
        # 실제로 이 파트는 돈을 반환한다.
        print("%d원을 반환합니다." % money)
     
    else: # or elif money > 300:
        print("Coffee")
        # 커피를 뽑아주고
        coffee = coffee - 1
        # 이제 커피를 하나씩 줄인다.
        print("%d원을 반환합니다." % (money-300))
        # 거스름돈을 돌려준다.
        
        
    # 커피가 다 떨어진 경우 알려야한다.
print("커피가 모두 소진되었으니, 관리자에게 문의해주세요.")
>>>
금액을 입력하세요.500
Coffee
200원을 반환합니다.
금액을 입력하세요.300
Coffee
금액을 입력하세요.500
Coffee
200원을 반환합니다.
금액을 입력하세요.700
Coffee
400원을 반환합니다.
금액을 입력하세요.1000
Coffee
700원을 반환합니다.
커피가 모두 소진되었으니, 관리자에게 문의해주세요.

 

- continue statement : 만약 반복문을 수행하다가 특정 조건에만 건너뛰고 싶은 경우에 사용

# 자판기의 커피 수량
coffee = 5
# 거스름돈 보관
change = 0

# 일단 작동!
while coffee > 0:

    # 실제로는 자판기를 통해서 넣은 금액.
    money = int(input("금액을 입력해주세요 : ")) # 150
    # 잔고와 합쳐서 체크.
    money = money + change

    
    if money == 300:
        # 실제로 이 파트는 자판기에서 커피를 뽑는 명령으로 대체된다.
        print("Coffee")
        # 이제 커피를 하나씩 줄인다.
        coffee = coffee - 1

    elif money < 300:
        # 돈을 더 받자.
        print("돈이 모자랍니다. 추가로 금액을 입력해주세요.")
        change = money # 잔고를 저장.
        continue # 정산을 하지 않고, skip.
        
    else: # or elif money > 300:
        print("Coffee")
        # 커피를 뽑아주고
        coffee = coffee - 1
        # 이제 커피를 하나씩 줄인다.
        print("%d원을 반환합니다." % (money-300))
        # 거스름돈을 돌려준다.

    # 정산
    change = 0
        
    # 커피가 다 떨어진 경우 알려야한다.
print("커피가 모두 소진되었으니, 관리자에게 문의해주세요.")
>>>
금액을 입력해주세요 : 300
Coffee
금액을 입력해주세요 : 500
Coffee
200원을 반환합니다.
금액을 입력해주세요 : 150
돈이 모자랍니다. 추가로 금액을 입력해주세요.
금액을 입력해주세요 : 200
Coffee
50원을 반환합니다.
금액을 입력해주세요 : 1500
Coffee
1200원을 반환합니다.
금액을 입력해주세요 : 100
돈이 모자랍니다. 추가로 금액을 입력해주세요.
금액을 입력해주세요 : 200
Coffee
커피가 모두 소진되었으니, 관리자에게 문의해주세요.

 

- 전설의 구구단 구현. nested loop를 연습해 보기

# nested loop를 이용하여 구구단을 구현합시다. 

for num1 in range(2,10):
  print("-"*10)
  for num2 in range(1,10):
    print("%d x %d = %d" % (num1,num2,num1*num2))
 >>>
 ----------
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
----------
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
3 x 6 = 18
3 x 7 = 21
3 x 8 = 24
3 x 9 = 27
----------
4 x 1 = 4
4 x 2 = 8
4 x 3 = 12
4 x 4 = 16
4 x 5 = 20
4 x 6 = 24
4 x 7 = 28
4 x 8 = 32
4 x 9 = 36
----------
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
----------
6 x 1 = 6
6 x 2 = 12
6 x 3 = 18
6 x 4 = 24
6 x 5 = 30
6 x 6 = 36
6 x 7 = 42
6 x 8 = 48
6 x 9 = 54
----------
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
----------
8 x 1 = 8
8 x 2 = 16
8 x 3 = 24
8 x 4 = 32
8 x 5 = 40
8 x 6 = 48
8 x 7 = 56
8 x 8 = 64
8 x 9 = 72
----------
9 x 1 = 9
9 x 2 = 18
9 x 3 = 27
9 x 4 = 36
9 x 5 = 45
9 x 6 = 54
9 x 7 = 63
9 x 8 = 72
9 x 9 = 81

 

- Function이란? 수학적인 의미의 함수와 개념은 비슷하지만 역할이 다르다. input이 들어와서 output이 정해진 규칙에 따라 나온다는 개념은 같지만, 프로그램에서의 하나의 함수는 하나의 기능을 나타낸다. 정확하게 함수는 특정 기능을 구현한 코드 묶음이다.

def 함수이름(param1, param2, ... ):
  <statement1>
  <statement2>
return
# 함수를 쓰는 이유는 재사용성 때문이다.

 

- Python Function Definition

# 기억해야 할 것은, input - (Function) -> output의 구조이며, 
# 이때 어떤 input parameter가 들어가서, 어떤 output parameter가 나오는지 주목해야 한다.
# Function Definition
def add(a, b):
    # 입력받은 a, b를 더한 값을 돌려주는 함수.
    result = a + b
    return result

# Function Call
add(3, 5)
>>>8

 

- 연습) 사칙연산을 모두 함수로 만들어보자

def sub(a, b):
  return a - b

def mul(a, b):
  return a * b

def div(a, b):
  if b == 0:
    return
  return a / b

n1, n2 = 2, 0
print(sub(n1, n2))
print(mul(n1, n2))
print(div(n1, n2))
>>>
2
0
None

 

- 함수 정의의 다양한 형태를 연습(여기서부터는 참고만)

- 가장 흔하게 사용되는 경우 -> 함수 parameter와 return이 모두 존재하는 경우

def set_name(name):
  name = name.upper()
  print(f"Set name as {name}.")
  return name

name = set_name("Kim")
>>>
Set name as KIM.
'KIM'

 

- 함수 parameter는 없고 return이 존재하는 경우

def save_file():
  save_flag = False
  with open("a.txt") as f:
    f.write(data)
    save_flag = True

  return save_flag

 

- 함수 parameter는 있는데 return이 없는 경우

def save_file(file_path):
  with open(file_path) as f:
    f.write(data)

 

- 함수 parameter도 없고 return도 없는 경우

def say_hi():
  print("Hi!")

say_hi()
>>>
Hi!

 

- Q) 만약에 함수의 입력 parameter의 개수를 모를 땐 어떻게 해야 할까?

def add_many(*args): # *(asterisk)를 앞에 붙이는 것으로 여러개의 parameter를 받아서 tuple로 변환하여 준다.   
  total = 0
  for arg in args:
    total += arg

  return total

print(add_many(1, 2, 3))
print(add_many(1, 2, 3, 4, 5))
print(add_many(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

def feed_forward(**kwargs): # kwargs -> dict
  pass
>>>
6
15
55

 

- Q) 만약에 parameter가 너무 많아서 몇 개만 입력 parameter로 넣고 싶을 땐 어떻게 해야 할까?

A) parameter가 너무 많아서, 다 외울 수도 없다. 이럴 땐 default parameter를 지정해 놓고,, 필요한 parameter만 입력받는다. 이렇게 정의되는 함수의 parameter를 keyword parameter라고 한다.

- Q) 코드를 작성할 때, 언제 이 부분은 함수로 구현해야겠다고 판단할 수 있을까?

A) 똑같은 코드가 2번 이상 반복될 때

- 파라미터에 대해 조금 더 알아보기

# 효력 범위 : scope
# 수명 : lifetime

# global variable
a = 10
name = "Kim"

def change_name(name): # code block
  #global name # make local variable to global.
  print("2. ", name)

  name = "Lee"
  #id(name)

  return name

print("1. " , name)
name2 = change_name()
print("3. ", name) # "Lee"가 아니고 "Kim" -> "Kim"이 아니고 "Lee"
print("4. ", name2)
>>>
1.  Kim
2.  Kim
3.  Lee
4.  Lee

 

- Lambda 함수를 사용해 보기

# Lambda Expression
# 굉장히 간단한 함수가 있는 경우, 한 줄짜리 함수로 간편하게 사용할 수 있다.
# 이런 함수를 Lambda 함수라고 하며, lambda 함수와 반복문을 통해 함수의 정의없이 다양한 프로그래밍이 가능하다.
# lambda 예시
def add(a, b):
    return a+b

# lambda 함수로 바꾸면?
f = lambda a, b : a + b
print(f(3, 5))
print(add(3, 5))
>>>
8
8
# Q. 아래 리스트의 원소들을 원소들의 길이에 따라 정렬하고 싶은 경우엔 어떻게 해야할까?
def get_length(s):
  return len(s)

strings = ['yoon', 'kim', 'jessica', 'jeong']
strings.sort(key=lambda s : len(s)) # alphatical order -> 글자 길이에 따른 정렬.
strings
>>>
['kim', 'yoon', 'jeong', 'jessica']

 

- 파이썬에 이미 정의되어 있는 함수들을 사용해 보기

import math
# 수학 계산을 해봅시다.
number = 3.14
# 절대값, 올림, 내림
print(abs(number))
print(math.ceil(number))
print(math.floor(number))
# sin, cos
print(math.sin(number))
print(math.cos(number))
>>>
3.14
4
3
0.0015926529164868282
-0.9999987317275395
# 복권 숫자를 만들어봅시다.(중복이 가능한 경우)
import random

random.randint(1, 45)
random.choices(list(range(1, 46)), k=6)
>>>
[35, 20, 34, 44, 45, 2]
# 다양한 사전들을 써봅시다.
import collections
from collections import defaultdict

#D = collections.defaultdict(int)
D = defaultdict(int)
D
#collections.OrderedDict() -> python 3.9 이상부터 default가 됨.
>>>
defaultdict(int, {})

 

[마무리]

 오늘은 확실히 어제 배운 내용을 바로 다음날 반복해서 하다 보니 뭔가 익숙해지는 느낌이 들었습니다. 그리고 공부라는 게 당연하겠지만 코딩이라는 것도 그냥 보면서 이해하는 것보다 내가 직접 타이핑을 하면서 연습하는 게 도움이 더 많이 된다는 것을 다시 한번 느꼈습니다. 파이썬 문법에 익숙해지기 위해 틈틈이 연습할 수 있는 것을 찾아봐야겠습니다.