이번 포스팅에서는 turtle 모듈을 활용하여 키를 입력하면 아이콘이 움직이게 만들어 보겠습니다.


turtle 모듈 import 하기

from turtle import Turtle, Screen

먼저 위와 같이 작성해 줍니다. turtle은 turtle 이라는 모듈의 이름입니다.

우리는 아이콘을 만들고 스크린창을 띄워야 하니 Turtle(아이콘), Screen(스크린) 클래스를 import 할 것입니다.

여기서, turtle과 Turtle의 차이가 무엇인가 의문이 들 수 있습니다.

turtle은 모듈 이름이며, Turtle은 클래스 이름입니다. 어떤 것이 모듈이고, 클래스인지 구분하기 위해서 모듈은 소문자로, 클래스는 앞글자를 대문자로 명명하기로 규칙을 정하였습니다. 이것은 전 세계의 개발자들 사이에서 통용되는 규칙 입니다.


from turtle import Turtle, Screen

timmy = Turtle()
timmy.shape("turtle")
screen = Screen()

screen.exitonclick()

먼저 timmy라는 이름으로 아이콘(Turtle())을 만들었습니다. 그리고 shape 함수를 이용하여 모양을 거북이로 설정하였습니다.

여담으로 여기서 해당 모듈의 이름이 turtle인 이유를 추측할 수 있습니다. 기본 아이콘 모양이 거북이 이기 때문입니다.

다시 본론으로 돌아가서, 이제 스크린창을 만들어야 합니다. 그래서 screen이라는 이름으로 스크린(Screen())을 만들었습니다.

마지막으로 exitonclick 함수를 작성하여 스크린창이 화면에 계속 유지되도록 해줍니다.

함수를 실행하면 위와 같이 스크린창과 거북이 모양의 아이콘이 뜰 것입니다.


onkey 함수로 아이콘을 움직이게 만들기

파이썬에는 다양한 모듈이 존재하며 각 모듈들의 사용법을 설명해놓은 웹페이지가 있습니다.

turtle 모듈은 아래의 링크에서 사용법을 볼 수 있습니다.

(https://docs.python.org/3/library/turtle.html)


위의 링크에 들어가 살펴보면 listen과 onkey 함수의 기능에 대해 자세히 알아볼 수 있습니다.

onkey 함수는 onkey(key = X, fun = X)의 형태로 되어 있으며, key를 설정하면 function이 실행되는 구조입니다.

listen 함수는 onkey 함수를 실행하기 위해 따라오는 함수입니다.


만약 f 키를 눌렀을때 아이콘이 앞으로 움직이게 하고 싶다면 아래와 같이 코드를 작성하면 됩니다.

from turtle import Turtle, Screen

timmy = Turtle()
timmy.shape("turtle")
screen = Screen()

def move_fd():
timmy.forward(100)

screen.onkey(key="f", fun = move_fd)
screen.listen()
screen.exitonclick()

코드를 실행하고 f키를 누르면 위의 스크린샷처럼 아이콘이 앞으로 움직임을 확인할 수 있습니다.

이런 방식으로 뒤로가기, 시계방향으로 움직이기, reset하기 등 다양하게 응용할 수 있습니다.

블로그 이미지

방구석 세계인

관심분야 : 외국어 학습, 프로그래밍, 책 리뷰 등...

,

함수(function)를 매개변수(parameter)로 사용하는 경우

def add(n1, n2):
return n1 + n2
def subtract(n1, n2):
return n1 - n2
def multiply(n1, n2):
return n1 * n2
def divide(n1, n2):
return n1 / n2

파이썬에서 기본 사칙연산 (더하기, 빼기, 곱하기, 나누기)을 수행하는 함수를 만들어 보았습니다.

총 4개의 함수가 만들어졌습니다. 

위의 함수를 이용하여 4+5를 계산해보고 싶다면 add(4, 5)를 작성하고 실행해주면 될 것입니다.


Example

5+9 = add(5, 9)

9-7 = subtract(9, 7)

8*12 = multiply(8, 12)

90/21 = divide(90, 21)


그런데 함수를 하나만 더 작성한다면 좀 더 편리하게 만들 수 있습니다.


def add(n1, n2):
return n1 + n2
def subtract(n1, n2):
return n1 - n2
def multiply(n1, n2):
return n1 * n2
def divide(n1, n2):
return n1 / n2

def calculator(n1, n2, func):
return func(n1, n2)

print(calculator(2,3,subtract))

그래서 calculator라는 함수를 하나 더 만들어 보았습니다. 그리고 calculator의 매개변수로 func을 추가했습니다. 이제 매개변수 func의 자리에 필요한 함수를 넣는다면 원하는대로 계산을 해줄 것입니다.


Example

5+9 = calculator(5, 9, add)

9-7 = calculator(9, 7, subtract)

8*12 = calculator(8, 12, multiply)

90/21 = calculator(90, 21, divide)



블로그 이미지

방구석 세계인

관심분야 : 외국어 학습, 프로그래밍, 책 리뷰 등...

,

튜플 (tuple)

튜플은 다른 프로그래밍 언어에는 없고, 파이썬에만 있는 특별한 기능 중 하나입니다.

튜플은 리스트 (list)와 같은 자료형으로, 생긴것도 리스트와 비슷하게 생겼습니다.


list_example = [1, 2, 3, 4, 5]
tuple_example = (1, 2, 3, 4, 5)

리스트, 튜플을 각각 하나씩 선언해보았습니다. 리스트는 []로 감싸지며, 튜플은 ()로 감싸진다는 차이점을 알 수 있습니다.


그럼 리스트, 튜플 사이의 기능적 차이점은 어떻게 될까요?


리스트

list_example = [1, 2, 3, 4, 5]
print(list_example)

list_example[0] = 10
print(list_example)


튜플

tuple_example = (1, 2, 3, 4, 5)
print(tuple_example)

tuple_example[0] = 10
print(tuple_example)

리스트는 이미 선언된 요소를 중간에 자유롭게 바꿀 수 있습니다.

그래서 처음에 [1, 2, 3, 4, 5]로 선언된 것을 [10, 2, 3, 4, 5]로 바꿀 수 있었습니다.

하지만 튜플은 한번 선언된 요소를 중간에 바꿀 수 없습니다.

그래서 [1, 2, 3, 4, 5]로 선언된 것을 [10, 2, 3, 4, 5]로 바꾸려하자 에러가 발생했습니다.



프로그램을 작성하다보면 리스트 내부의 요소를 변경해서는 안되는 일이 생길 수 있습니다.

그럼 해당 리스트에 주석을 달아놓던지하여 요소를 변경해서는 안된다고 표시해줄 수 있을 것입니다. 하지만 프로그램은 한 번 만들면 끝이 아니라 이후 계속 유지, 보수를 해줘야 합니다. 그러나 시간의 흐름에 따라 해당 리스트 내부의 요소를 변경해서는 안된다는 사실을 잊어버릴 수도 있습니다.

그럴때 아예 튜플로 선언해버리면 해당 문제를 사전에 예방할 수 있을 것입니다.

 


튜플 (tuple) 선언 할 때 tip

1. 튜플 내 요소를 하나만 생성하고 싶을 때

tuple_example = (1,) O
tuple_example = (1) X

요소가 하나뿐이더라도 튜플을 생성할 때에는 요소 뒤에 항상 comma(,)를 붙여야 합니다.


2. 괄호 생략

#둘 다 가능함
tuple_example = (1, 2, 3, 4, 5)

tuple_example = 1, 2, 3, 4, 5

튜플을 생성할 때, 괄호를 쓰지 않아도 아무 문제 없이 정상적으로 생성됩니다.

블로그 이미지

방구석 세계인

관심분야 : 외국어 학습, 프로그래밍, 책 리뷰 등...

,


부울대수 (Boolean Algebra) 란?


부울대수는 현존하는 모든 컴퓨터 동작의 원리가 된다고 한다. 왜일까?


대수학 (Algebra)이란 일련의 공리들을 만족하는 수학적 구조들의 일반적인 성질을 연구하는 수학의 한 분야이다.

그 중, 부울대수 (Boolean Algebra)는 참(True), 거짓(False)라는 논리로만 이루어진 대수학이라 할 수 있다. 


다들 이미 알다시피 컴퓨터는 0,1 이라는 두개의 숫자만으로 모든 것을 표현한다. True, False라는 논리를 0과 1이라는 두 숫자로 나타낼 수 있기 때문에 부울대수가 컴퓨팅의 기반이 되는 것이다.


논리연산자 - NOT, AND, OR

부울대수를 연산하는 연산자에는 3가지 - NOT, AND, OR - 가 있다. 하나 하나 살펴보도록 하자.



NOT(논리부정)

영어 not의 뜻을 생각하면 연산자 NOT을 쉽게 이해할 수 있다. 알다시피 영어에서 not은 ~가 아니다의 뜻을 가진다.

표현방법 :


이것을 게이트(gate)로 표현하면 아래와 같다.

(*게이트란 부울대수 연산을 시각적으로 보기 쉽게 만든 것이다. ex. 변수 A를 게이트에 넣으면 결과값 Q가 나온다.)

A를 NOT 게이트에 넣었을 때 나오는 결과값 Q는 A'가 될 것이다.


AND(논리곱)

영어 and는 그리고 라는 뜻이다. 그러므로 A AND B는 A 그리고 B라는 뜻이 될 것이다. 만약 A AND B의 결과가 True가 되려면 A, B 둘다 True가 되야 할 것이다. 둘 중 하나라도 False라면 True라는 결과가 나올 수 없을 것이다.

표현방법 : Q = A⋅ B ( ⋅ 는 생략가능)
INPUTOUTPUT
ABQ
000
010
100
111

게이트로는 아래와 같이 표현된다.



OR(논리합)

영어 or의 뜻은 또는 이다. 그러므로 A OR B는 A 또는 B라는 뜻이 될 것이다. 만약 A OR B의 결과가 True가 되려면 A, B 둘 중 하나만 True가 되어도 True가 될 것이다.

표현방법 : Q = A+ B
INPUTOUTPUT
ABQ
000
011
101
111

게이트로는 아래와 같이 표현된다.


부울대수의 주요 법칙

1. 기본 공리

A⋅A=A, A+A=A, A⋅0=0, A+0=A, A⋅1=A, A+1=1

2. 부정법칙

A⋅A'=0, A+A'=1, A''=A

3. 교환법칙

A⋅B=B⋅A, A+B=B+A

4. 결합법칙

A⋅(B⋅C)=(A⋅B)⋅C, A+(B+C)=(A+B)+C

5. 분배법칙

A⋅(B+C)=A⋅B+A⋅C, A+(B⋅C)=A+B⋅A+C

6. 흡수법칙

A⋅(A+B)=A, A+(A⋅B)=A


이것을 그냥 외우려하면 당연히 잘 안될 것이다.

이럴땐 게이트를 이용하여 직접 계산해보면 왜 이러한 법칙이 성립하는지 이해할 수 있게 된다.


예를 하나 들어보겠다.

A+A'=1

#case1

#case2


다른 법칙도 이런 식으로 직접 연산해보면 왜 그러한 법칙이 성립되는지 이해할 수 있을 것이다.

블로그 이미지

방구석 세계인

관심분야 : 외국어 학습, 프로그래밍, 책 리뷰 등...

,

커피 자판기 만들기 (실습)

이번에는 커피 자판기 프로그램을 만들어 보려고 합니다. (물론 실제로 커피를 만들어주는 프로그램이 아니라 가상의 커피 자판기를 만드려는 것입니다)

espresso, latte, cappuccino 이렇게 3가지의 메뉴를 뽑을 수 있고, report를 입력했을 땐 남은 재료 현황, off를 입력했을땐 자판기 작동이 멈추도록 프로그램을 짜려고 합니다.

먼저 아래의 코드를 복사, 붙여넣기 한 후 몇 번 동작시켜서 자판기의 구조를 파악해보시길 바랍니다.


# current resources status
water = 1000
milk = 600
coffee = 300
money = 0

# coins setting / quarters : 0.25, dimes : 0.10, nickles : 0.05, pennies : 0.01
quarter = 0.25
dime = 0.10
nickle = 0.05
penny = 0.01

def running() :
"""coffee machine running"""
global water, milk, coffee, money
# is resources sufficient? (if not, print current status)
switch = True
while switch:
# prompt user by asking "what would you like?? (espresso/latte/cappuccino) : "
question = input("What would you like? espresso(1.5$) / latte(2.5$) / cappuccino(3.0$) : ")

# report function (shows current resources up. hidden function for maintainers)
if question == "report":
print(f"Current stock \n water : {water}ml \n milk : {milk}ml \n coffee : {coffee}g \n money : {money}$")
continue
elif question == "off":
switch = False

# coin insert question and make progress
input_quarter = float(input("How many quarters?(0.25$) : "))
input_dime = float(input("How many dimes(0.10$) : "))
input_nickle = float(input("How many nickles(0.05$) : "))
input_penny = float(input("How many pennies(0.01$) : "))

def coin_calculation(coin, input_coin) :
"""calculate inputted coins"""
coin *= input_coin
return coin

inputted_money = float(coin_calculation(quarter, input_quarter))

+ float(coin_calculation(dime, input_dime)) + float(coin_calculation(nickle, input_nickle))

+ float(coin_calculation(penny, input_penny))

# check inserted coins are enough or not / stock check / money check
if question == "espresso" and inputted_money > 1.5:
if water >= 50 and coffee >= 18:
print(f"Here is espresso and ${round(inputted_money - 1.5, 2)} in change")
money += 1.5
water -= 50
coffee -= 18
else:
if water < 50:
print("Sorry, there is no water enough.")
if coffee < 18:
print("Sorry, there is no coffee enough.")
elif question == "latte" and inputted_money > 2.5:
if water >= 200 and milk >= 150 and coffee >= 24:
print(f"Here is latte and ${round(inputted_money - 2.5, 2)} in change")
money += 2.5
water -= 200
milk -= 150
coffee -= 24
else:
if water < 200:
print("Sorry, water is not enough.")
if milk < 150:
print("Sorry, milk is not enough.")
if coffee < 24:
print("Sorry, coffee is not enough.")
elif question == "cappuccino" and inputted_money > 3.0:
if water >= 250 and milk >= 100 and coffee >= 24:
print(f"Here is cappuccino and ${round(inputted_money - 3.0, 2)} in change")
money += 3.0
water -= 250
milk -= 100
coffee -= 24
else:
if water < 250:
print("Sorry, there is no water enough.")
if milk < 100:
print("Sorry, there is no milk enough.")
if coffee < 24:
print("Sorry, there is no coffee enough.")
else:
print("You inserted not enough money or chose wrong menu.")


running()

몇번 작동 시킨 후, 다시 작성된 코드를 봅니다. 위의 코드는 작동하는데에는 문제가 없습니다. 하지만 자판기에 메뉴를 추가한다던지, 재료 사용량을 바꾼다던지, 가격을 바꾼다던지 등등.. 프로그램을 수정할 일이 생기면 어떨까요? 위의 코드는 수정하기에 조금 불편할 것입니다.

프로그램은 한 번 완성하면 끝나는 것이 아닙니다. 버그를 찾아 수정해야하고, 버전을 업데이트해야하는 경우도 많습니다. 그렇기 때문에 코드를 읽기 쉽게, 그리고 나중에 수정하기 쉽게 작성할 필요가 있습니다. 이번 포스팅에서는 그 중, 수정하기 쉽게 작성하기에 포커스를 맞춰볼 것입니다.



dictionary를 이용해 코드 간소화

#1
MENU = {
"espresso": {
"ingredients": {
"water": 50,
"coffee": 18,
},
"cost": 1.5,
},
"latte": {
"ingredients": {
"water": 200,
"milk": 150,
"coffee": 24,
},
"cost": 2.5,
},
"cappuccino": {
"ingredients": {
"water": 250,
"milk": 100,
"coffee": 24,
},
"cost": 3.0,
}
}
resources = {
"water": 1000,
"milk": 600,
"coffee": 300,
}
profit = 0
#4
def is_ingredient_sufficient(order_ingredients):
"""return True if ingredients are enough, return False if ingredients are not enough"""
for item in order_ingredients:
if order_ingredients[item]>resources[item]:
print(f"sorry. {item} is not enough.")
return False
return True

#6
def coin_process():
"""insert coins and sum up how much is it"""
print("please insert coins")
total = float(input("How many quarters?(0.25$) : ")) * 0.25
total += float(input("How many dimes?(0.10$) : ")) * 0.10

total += float(input("How many nickles?(0.05$) : ")) * 0.05

total += float(input("How many pennies?(0.01$) : ")) * 0.01

return total

#8
def is_transaction_successful(money_inputted, beverage_cost):
"""Return True if money is enough. return False if money is not enough"""
if money_inputted >= beverage_cost:
charge = round(money_inputted - beverage_cost, 2)
print(f"${charge} in charge.")
global profit
profit += beverage_cost
return True
else :
print("Sorry. That is not enough money.")
return False

#10
def make_coffee(ordered_ingredients, beverage_name):
"""Deduct the required ingredients from the resources"""
for item in ordered_ingredients:
resources[item] -= ordered_ingredients[item]
print(f"Here is your {beverage_name}.")

#2
is_on = True
while is_on:
#3
choice = input("What would you like? espresso(1.5$) / latte(2.5$) / cappuccino(3.0$) : ")
if choice == "off":
is_on = False
elif choice == "report":
print("Current stock")
print(f"water : {resources['water']}ml")
print(f"milk : {resources['milk']}ml")
print(f"coffee : {resources['coffee']}g")
print(f"money : ${profit}")
else:
#5
drink = MENU[choice]
if is_ingredient_sufficient(drink['ingredients']):
#7
payment = coin_process()
#9
if is_transaction_successful(payment, drink['cost']):
#11
make_coffee(drink['ingredients'], choice)

이번에는 각 메뉴에 들어가는 재료, 비용을 딕셔너리로 만든 후 다시 코드를 작성하였습니다.

이제 메뉴, 재료, 가격 등을 수정하려면 딕셔너리 내부 위주로하여 쉽게 수정하실 수 있을 것입니다.


그리고 코드를 작성한 순서를 매겨보았습니다. 

while 반복문 안에 커피를 뽑는 과정을 작성하면서 필요한 함수들이 생기면 추가하는 방식으로 작성하였습니다.




*이 글은 Udemy 강좌 100 Days of Code - The Complete Python Pro Bootcamp for 2021의 Day 15 (intermediate) - Local Development Environment Setup & Coffee Machine Project 내용을 바탕으로 작성하였습니다.

(URL : https://www.udemy.com/course/100-days-of-code/)


블로그 이미지

방구석 세계인

관심분야 : 외국어 학습, 프로그래밍, 책 리뷰 등...

,

While 반복문

While 반복문은 특정 조건을 만족하면 반복문 안의 내용이 무한히 반복되도록 만드는 구문입니다.


#while loop

while True:
question = input("Do you like fruit? type Y or N : ")

위의 코드를 보겠습니다. True라는 조건에 맞으면, "Do you like fruit? type Y or N : "라는 질문이 계속 반복되는 구조입니다.


그럼 N을 입력했을 때 질문을 멈추게 하려면 어떻게 해야할까요?


break

#break

while True:
question = input("Do you like fruit? type Y or N : ")
if question == "N":
break

위의 코드처럼 break를 추가하면 반복문을 멈추게 할 수 있습니다. 이제 N을 입력하면 더 이상 질문이 반복되지 않고 종료될 것입니다.


continue

#continue

while True:
question = input("Do you like fruit? type Y or N : ")
if question == "N":
break
elif question == "Y" :
question2 = input("Do you like apple? type Y or N : ")

이번엔 Y를 입력했을 때 "Do you like apple? type Y or N : " 라는 질문이 이어지도록 코드를 추가하였습니다. 두번째 질문에서 N를 입력했을 때, 프로그램을 끝내지 않고 다시 첫번째 질문으로 돌아가려면 어떻게 해야할까요?


#continue

while True:
question = input("Do you like fruit? type Y or N : ")
if question == "N":
break
elif question == "Y" :
question2 = input("Do you like apple? type Y or N : ")
if question2 == "N":
continue
else :
print("I'll give you an apple.")
break

그렇다면 continue를 추가하면 됩니다. 이제 두번째 질문에서 N으로 답하면 프로그램이 끝나지 않고 다시 첫번째 질문으로 돌아가게 될 것입니다.


블로그 이미지

방구석 세계인

관심분야 : 외국어 학습, 프로그래밍, 책 리뷰 등...

,

* 저도 프로그래밍을 처음 공부 하는 것이기 때문에 틀린 설명이 있을 수도 있습니다. 그런 부분을 발견했을 때 따끔한 피드백을 주시면 감사하겠습니다!


if 조건문만 활용하여 경우의 수 만들기

1~100사이의 숫자를 랜덤으로 2개를 뽑아 변수 a, b를 만들고, a, b 중 누가 더 큰지 맞추는 간단한 프로그램을 만들어 보겠습니다.


import random

numbers = range(1,100+1)

a = random.choice(numbers)
b = random.choice(numbers)

guess = input("Which one is bigger? type a, b, or match : ")

변수 a, b를 설정하였고, 프로그램을 실행했을 때 a, b 중 하나를 선택할 수 있도록 input 함수까지 작성하였습니다.

그 다음으로, 답을 선택 했을 때 나올만한 경우의 수를 생각해보도록 하겠습니다.
아래의 표 처럼 총 9가지 경우의 수가 나올 것입니다.


 a>b and guess = "a" 

 (right)

a<b and guess = "a" 

 (wrong) 

a=b and guess = "a" 

 (wrong) 

 a>b and guess = "b" 

(wrong)

a<b and guess = "b" 

(right) 

 a=b and guess = "b" 

(wrong) 

 a>b and guess = "match" (wrong)

 a<b and guess = "match" (wrong)

 a=b and guess = "match" (right)



그럼 if 조건문을 활용하여 9가지의 경우의 수와 그에 따른 결과를 입력해보겠습니다.


#if 조건문만 활용

import random

numbers = range(1,100+1)

a = random.choice(numbers)
b = random.choice(numbers)

guess = input("Which one is bigger? type a, b, or match : ")

if a>b and guess == "a" :
    print(f"right. result : a = {a}, b = {b}")
elif a>b and guess == "b" :
    print(f"wrong. result : a = {a}, b = {b}")
elif a>b and guess == "match" :
    print(f"wrong. result : a = {a}, b = {b}")  
elif a<b and guess == "a" :
    print(f"wrong. result : a = {a}, b = {b}")
elif a<b and guess == "b" :
    print(f"right. result : a = {a}, b = {b}")
elif a<b and guess == "match" :
    print(f"wrong. result : a = {a}, b = {b}")
elif a==b and guess == "a" :
    print(f"wrong. result : a = {a}, b = {b}")
elif a==b and guess == "b" :
    print(f"wrong. result : a = {a}, b = {b}")
elif a==b and guess == "match" :
    print(f"right. result : a = {a}, b = {b}")


표의 내용을 참고하여 위와 같이 입력하면 될 것입니다.

하지만 왠지 경우의 수가 너무 많아 복잡해보입니다.. 경우의 수가 이것보다 더 많다면, 일일히 if 조건문으로 모든 경우의 수를 입력하기 힘들 것입니다. 그리고 경우의 수를 일일히 입력하다보면 실수로 코드를 잘못 입력할 가능성도 그만큼 올라갈 것입니다. 게다가 오류가 발생한다면, 어디서 오류가 났는지 찾는 것도 번거로울 것입니다.

이럴 때는 return과 boolean을 활용하여 경우의 수를 줄이는 것이 더 효과적일 것입니다.



return과 boolean을 활용한 조건문 간소화

#return과 boolean 활용

import random

numbers = range(1,100+1)

a = random.choice(numbers)
b = random.choice(numbers)

guess = input("Which one is bigger? type a or b, or match : ")
def check(guessab) :
    if a == b :
        return guess == "match" 
    elif a > b :
        return guess == "a"
    elif a < b :
        return guess == "b"

result = check(guess, a, b)

if result == True :
    print(f"right. result : a = {a}, b = {b}")
else : 
    print(f"wrong. result : a = {a}, b = {b}")


먼저 check라는 함수를 만들었습니다. 우리가 답으로 선택할 수 있는 경우의 수는 a, b, match 이렇게 3가지가 있을 것입니다. 이것을 if 조건문과 return 기능을 통해, a = b이면 guess는 match, a > b이면 guess는 a, a < b이면 guess는 b가 되도록 설정하였습니다.

그 다음으로는 result = check(guess, a, b)라고 변수를 선언하였습니다.

마지막으로 boolean을 활용하여 유저가 직접 입력한 답과 check 함수에서 만든 조건과 일치하면 정답, 일치하지 않으면 오답이라고 출력되도록 만들었습니다.






프로그램을 실행해보면 위의 스크린샷 처럼 잘 작동되고 있음을 확인할 수 있습니다.


이렇게 return과 boolean을 활용하면 경우의 수가 줄어들기 때문에 써야하는 if 구문의 숫자도 줄일 수 있다는 장점이 있습니다. 

블로그 이미지

방구석 세계인

관심분야 : 외국어 학습, 프로그래밍, 책 리뷰 등...

,

* 저도 프로그래밍을 처음 공부 하는 것이기 때문에 틀린 설명이 있을 수도 있습니다. 그런 부분을 발견했을 때 따끔한 피드백을 주시면 감사하겠습니다!



global scope(전역 범위) vs local scope(지역 범위)

number = 5

def number_function() :
    number = 6
    print(f"number inside function : {number}")
    
number_function()
print(f"number outside function : {number}")


먼저 위와 같이 코드를 입력합니다. 

저는 number = 5 라는 variable(변수)를 선언하였고, 다시 number_function() 이라는 function(함수)를 선언하었습니다. 함수의 내용은 변수 number를 6으로 바꾼다는 내용입니다.

어떤 결과가 나올지 먼저 추측해보시고 스크롤을 내려 결과를 확인해보시길 바랍니다.









number_function() 의 결과값은 6으로 출력되었고, 마지막줄은 결과값이 5로 출렸되었습니다.

똑같은 이름의 변수인데도 값이 달라지는 이상한 현상이 발생한 것입니다.



이 현상을 이해시켜주는 개념이 바로 global scope(전역 범위) 와 local scope(지역 범위) 입니다.

global scope(전역 범위) 와 local scope(지역 범위)의 뜻을 살펴보면,


global scope : 해당 file 전체에 걸쳐서 영향력을 행사함

local scope : 부분(ex. 함수 내부)에서만 영향력을 행사함. (함수) 밖에는 아무 영향도 끼치지 않음


이라고 할 수 있겠습니다.


따라서 함수 number_function()에서 선언한 변수 number = 6는 함수 밖에서는 적용되지 않았던 것입니다. 그리고 마지막 줄은 원래 선언되어있던 변수 number = 5로 결과값이 출력되었습니다.


* global scope(전역 범위) 와 local scope(지역 범위)를 변수의 입장에서 말한다면, global variable(전역 변수) 와 local variable(지역 변수) 라고 부릅니다.



global keyword(글로벌 키워드)

number = 5

def number_function() :
    global number
    number = 6
    print(f"number inside function : {number}")
    
number_function()
print(f"number outside function : {number}")


이번엔 함수 number_function()에 global number 라는 내용을 추가해보았습니다. 

이번에도 어떤 결과가 나올지 먼저 추측해보시고 스크롤을 내려 결과를 확인해보시길 바랍니다.









아까와는 달리 이번에는 모두 6이라고 출력되었네요. global number 라는 내용을 추가로 입력했더니 결과값이 같아졌습니다. 변수 number = 6는 원래 함수 number_function() 안에서만 유효했지만, global keyword(글로벌 키워드)를 통해 파일 전체에서 유효하도록 바꾸었기 때문입니다.


global keyword(글로벌 키워드)의 형태를 살펴보면,


global + 변수이름 (ex. global number)

(의미 : 지역 변수를 전역 변수로 바꾸어줌)


이라고 할 수 있습니다.


다시 위의 작성한 코드로 돌아가보겠습니다. 

global keyword(글로벌 키워드) 덕분에 함수 number_function()의 변수 number는 파일 전역에 걸쳐 영향을 끼치는 전역 변수로 바뀌었습니다. 그래서 첫줄에 선언된 변수 number는 함수 number_function()의 영향을 받아 6으로 바뀌었고, 마지막 줄에서는 바뀐대로 6으로 출력된 것입니다.







*보너스 퀴즈

number = 5

def number_function() :
    global number
    number = 6
    print(f"number inside function : {number}")

print(f"number outside function : {number}")    
number_function()


위의 코드를 출력하면 어떤 결과값이 나올까요?

어떤 결과가 나올지 먼저 추측해보시고 스크롤을 내려 결과를 확인해보시길 바랍니다.









글로벌 키워드를 사용했음에도 서로 다른 결과값이 출력됨을 확인할 수 있습니다.

그 이유는 파이썬은 먼저 입력한 코드 순으로 결과를 출력하기 때문입니다.


def number_function() :
    global number
    number = 6
    print(f"number inside function : {number}")

이 부분은 함수의 내용이 어떤 것인지 설정하는 코드일 뿐이라서 실제로는 출력되지 않습니다.


따라서 실제 출력되는 순서는 아래와 같습니다.

1. print(f"number outside function : {number}")    
2. number_function()


변수 number가 6으로 바뀌는 것은 함수 number_function() 안에서 일어나는 일이기 때문에,

print(f"number outside function : {number}") 에서 먼저 5로 출력되고, 그 다음 작성되어있는 함수 number_function()에서 6으로 출력되는 것입니다.

블로그 이미지

방구석 세계인

관심분야 : 외국어 학습, 프로그래밍, 책 리뷰 등...

,