[3팀/김경은] 5차시 파이썬 스터디 - 함수

데이터 과학을 위한 파이썬 프로그래밍 교재를 사용하여 작성한 강의자료입니다.

5차시_함수_강의안.pdf

0.52MB

5차시_함수_과제.pdf

1.10MB

함수

어떤 일을 수행하는 코드의 덩어리, 또는 코드의 묶음

 

함수의 장점

 

1. 필요할 때마다 호출 가능 : 함수는 반복적으로 수행해야 하는 업무를 한번만 작성해 놓고 필요할때마다 호출하여 사용할 수 있다. 이렇게 하면 코드를 수정할 때 같은 작업을 여러 번 반복하지 않아도 된다.
2. 논리적인 단위로 분할 가능 : 함수는 코드를 논리적인 단위로 나눌 수 있다. 간단히 도형을 계산하는 프로그램을 작성하더라도 곱셈을 하는 코드, 덧셈을 하는 코드, 나눗셈을 하는 코드 등으로 나눌 수 있다.
3. 코드의 캡슐화 : 캡슐화는 함수의 인터페이스만 잘 정의하면 다른 사람이 자신의 코드를 쉽게 가져다 사용할 수 있는 특징이 있다.

함수의 선언

파이썬에서 함수를 선언하는 방법

def 함수 이름 ( 매개변수 #1 ...):
    명령문 1
    명령문 2
    return <반환값>

• def : ‘definition’의 줄임말로 함수의 정의를 시작한다는 의미
• 함수 이름 : 함수 이름은 개발자가 마음대로 지정할 수 있지만 파이썬에서는 다음과 같은 규칙 사용
  • 소문자로 입력
  • 띄어쓰기를 할 경우에는 기호를 사용 **ex) save_medel
  • 작업을 나타내기 위해 동사와 명사를 함께 사용하는 경우가 많음 ex) find_number
  • 외부에 공개하는 함수일 경우 줄임말을 사용하지 않고 짧고 명료한 이름으로 함
• 매개변수(parameter) : 매개 변수는 함수에서 입력값으로 사용하는 변수를 의미, 1개 이상의 값을 적을 수 있음
• 명령문 : 명령문은 반드시 들여쓰기한 후 코드를 입력해야 함, if 나 for문 등의 제어문을 사용할 수도 있고, 고급 프로그래밍 기법으로 함수 안에 함수를 사용하기도 함

함수 선언 작성 예시

def calculate_rectangle_area(x,y)
    return x*y

함수이름 : calculate_rectangle_area

매개변수 : x, y

return : 값을 반환한다는 뜻

→ x와 y를 곱한 값을 반환하는 함수

 

함수의 실행 순서

def calculate_rectangle_area(x,y):
    return x*y

rectangle_x = 10
rectangle_y = 20
print("사각형 x의 길이:", rectangle_x)
print("사각형 y의 길이:", rectangle_y)

#넓이를 구하는 함수 호출
print("사각형의 넓이:", claculate_rectangle_area(rectangle_x, rectangle_y))

#실행결과

사각형 x의 길이:10
사각형 y의 길이:20
사각형의 넓이: 200

1. 함수가 정의된 def는 정의만 하는것으로 함수만 파일에 저장하고 파이썬 명령으로 실행시켰을 때 별도의 출력이 일어나지 않음→ 만약 함수의 선언 부분을 코드의 맨 마지막에 입력한다면 해당 코드 호출에 오류가 발생 → 아무것도 실행되지 않는 것처럼 보이지만 실제로는 해당 코드를 메모리에 업로드하여 다른 코드를 호출해 사용할 수 있도록 준비 과정을 거침
2. rectangle_x = 10 rectangle_y = 20 → 2개의 변수에 값을 할당하고 그 값을 출력
3. claculate_rectangle_area(rectangle_x, rectangle_y) 출력,
4. 함수를 호출하고 rectangle_x 와 rectangle_y 변수에 할당된 값이 claculate_rectangle_area 함수에 입력값이 됨, return x*y 에 의해 반환값 200이 반환됨
5. claculate_rectangle_area(rectangle_x, rectangle_y) 는 200으로 치환되고 이 값이 화면에 출력

 

프로그래밍의 함수와 수학의 함수

f(x) = x + 1

다음의 문제를 프로그래밍에서 표현하기

💡 f(x) = 2x + 7, g(x) = x^2 이고, x = 2 일 때, f(x) + g(x) + f(g(x)) + g(f(x)) 의 값은 ? f(2) = 11, g(2) = 4, f(g(x)) =15, g(f(x)) = 121 → 11 +4 + 15 + 121 = 151

 

함수에 해당하는 f(x), g(x)

def f(x)
    return 2 * x + 7
def g(x)
    return x ** 2
x=2
print(f(x) + g(x) + f(g(x)) + g(f(x)))

#출력 결과

151

→ f(x), g(x), f(g(x)), g(f(x)) 가 각각 11, 4, 15, 121 로 치환되어 합이 출력됨

매개변수와 인수

함수의 입력값은 매개변수로 구분되어 사용

def f(x):
    return 2 * x + 7

print(f(2))

#출력결과

11

• ‘def f(x):’의 x를 매개변수라고 함매개변수는 함수의 인터페이스 정의에 있어 어떤 변수를 사용하는지 정의하는 것
• 함수의 입력값에 대한 정의를 함수 사용에 있어 인터페이스라고 정의
• 인수는 실제 매개변수에 대입되는 값
• f(2)에서 2가 인수에 해당

함수의 형태

함수는 매개변수와 반환값의 유무에 따라 네가지 형태로 구분

반환값 유무/매개변수 유무 |매개변수 없음                                   |매개변수 있음

반환값 없음	함수 내부 명령문만 수행	매개변수를 사용하여 명령문만 수행
반환값 있음	매개변수 없이 명령문을 수행한 후 결과값 반환	매개변수를 사용하여 명령문을 수행한 후 결과값 반환

def a_rectangle_area():      #매개변수 X, 반환값 X
    print(5*7)
def b_rectangle_area(x,y):   #매개변수 O, 반환값 X
    print(x*y)
def c_rectangle_area():      #매개변수 X, 반환값 O
    return(5*7)
def d_rectangle_area(x,y):   #매개변수 O, 반환값 O
    return(x*y)

a_rectangle_area()
b_rectangle_area(5,7)
print(c_rectangle_area())
print(d_rectangle_area(5,7))

#출력 결과

35
35
35
35

• a_rectangle_area() : 매개변수와 반환값이 모두 없는 경우a_rectangle_area()가 35로 치환되는 것이 아니고, 반환값이 없기 때문에 함수 자체는 none 값을 가짐
• 대신 내부 함수인 print()함수로 인해 35 출력
• 입력값과 반환값이 없지만 print(5*7)로 인해 35 출력
• b_rectangle_area() : 매개변수로 x,y를 넘겨받고, 그 값을 계산하여 화면에 출력하는 함수b_rectangle_area(5,7) 자체가 35로 치환되는 것은 아님
• 반환이 없으면 해당 함수는 none으로 치환
• 반환값이 없어 b_rectangle_area(5,7) 이라고 실행시켜야 35가 출력되는것
• c_rectangle_area(), d_rectangle_area() : 반환값이 있는 경우두 함수 모두 return 문으로 인해 35로 치환되는것
• return이 있는 경우, 즉 함수의 반환값이 있는 경우에는 그 함수를 호출하는 곳에서 함수의 반환값을 변수에 할당하여 사용하는 것이 가능
• 함수 안에서 print() 함수를 수행시키는 것이 아니라 함수를 호출할 때 print() 함수를 이용하는것

💡 → 모두 같은 값을 출력하지만 함수의 형태에 따라 사용하는 방법이 다르다.

 

 

함수 호출 방식

def f(x)
    y=x
    x=5
    return y*y

x = 3
print(f(x))
print(x)

#출력 결과

9
3

• 함수 밖에 있는 변수 x의 메모리 주소와 함수 안에 있는 변수 x의 메모리 주소가 같은지 다른지 확인할 필요가 있음

함수가 변수를 호출하는 방식

종류                                          설명

값에 의한 호출 (call by value)	- 함수에 인수를 넘길 때 값만 넘김 - 함수 내부의 인수값 변경 시 호출된 변수에 영향을 주지 않음
참조 호출 (call by reference)	- 함수에 이수를 넘길 때 메모리 주소를 넘김 - 함수 내부의 인수값 변경 시 호출된 변수값도 변경됨

• 메모리 주소 - 변수가 저장되는 공간, 공간 자체에 새로운 값을 할당하면 그 공간을 가리키고 있는 다른 변수에도 영향을 줌
• 객체 호출 방식 - 파이썬에서는 객체의 주소를 함수로 넘기기 때문에 전달된 객체의 값에 변경이 있을 경우, 즉 새로운 값을 할당하거나 해당 객체를 지울 때는 영향을 주지 않지만 단순히 해당 객체에 값을 추가할 때는 영향을 준다.

def spam(eggs):
    eggs.append(1)  #기존 객체의 주소값에 [1] 추가
    eggs = [2,3]    #새로운 객체 생성

ham = [0]
spam(ham)
print(ham)

#출력결과

[0,1]

1. ham 이라는 리스트를 만들고 함수 spam에 ham을 인수로 입력한다. 이때 함수 안에서는 이름이 ham에서 eggs로 바뀐다. ham과 eggs는 함수의 호출방식으로 객체를 호출하고 있으므로 같은 주소를 공유한다.
2. eggs.append(1)에 의해 해당 리스트에 1이 추가되면 ham과 eggs 모두 영향을 받는다.
3. eggs = [2,3]으로 새로운 리스트를 만들어준다. 그래서 더이상 ham과 eggs가 같은 메모리 주소를 가리키지 않고 eggs는 자기만의 메모리 주소를 가지게 된다.
4. 그리고 함수를 빠져나와 print(ham)이 실행되면 eggs.append(1)에 의해 추가된 [0,1] 이 화면에 출력된다.

이것이 객체 호출이라는 파이썬의 함수 내부 변수 호출 방식이다.

• 새로운 값을 할당하기 전까지는 기존에 넘어온 인수 객체의 주소값을 그대로 사용하는 방식

 

변수의 사용 범위

 

• 변수가 코드에서 사용되는 범위
• 함수 내부에서 사용할 것인지 프로그램 전체에서 사용할 것인지 그 범위를 결정하는 규칙

지역 변수 (local variable) : 함수 내부에서만 사용

전역 변수 (global variable) : 프로그램 전체에서 사용

def test(t)
    print(x)
    t = 20
    print("In Function:", t)

x = 10
test(x)
print("In Main:", x)
print("In Main:", t)

#출력 결과

10
In function : 20
In Main : 10
Traceback (most recent call last):
    File "scoping_rule.py", line 9, in <module>
        print ("In Main:", t)
NameError: name 't' is not defined

1. 프로그램이 가장 먼저 시작되는 지점은 x = 10 으로 x는 test(x) 함수의 인수로 넘어간다.
2. 그렇다면 print(x)의 x는 함수 내부에서 재정의되지 않았으므로 함수를 호출한 메인 프로그램에서 정의한 x = 10의 x를 뜻한다. 즉, 프로그램 전체에서 사용할 수 있는 전역 변수이다. 함수 내부에 있는 t는 test(x) 함수의 x를 t로 치환하여 사용한다. 즉, 함수 내부에서는 x를 따로 선언한 적은 없고, t 를 선언하여 사용한다.
3. 3행의 t = 20에 의해 t에 20이 할당되고, 실제로 4행 print(“In Function:", t)의 결과로 In Function: 20이 화면에 출력 되는 것으로 예상할 수 있다.
4. 하지만 함수가 종료되고 코드에 9행의 print("In Main:", t)가 실행되면 오류가 출력된다. t가 함수 내부에서만 사용할 수 있는 지역 변수이기 때문이다. 그래서 메인 함수에서 t 변수를 호출하는 것이 불가능하다. 이러한 차이를 이해하지 못하면 프로그래밍하는 데 어려움이 있을 것이다.

def f():
    s = "I love London!"
    print(s)

s = "I love Paris!"
f()
print(s)

#출력결과

I love London!
I love Paris!

1. 변수 s는 f( ) 함수의 내부에서도 사용되고 외부에서도 사용된다.
2. 프로그램이 시작되자마자 s에는 'I love Paris!' 라는 값이 할당된다.
3. 하지만 그 후 함수 내부로 코드의 실행이 옮겨가 다시 s에 ‘I love London!' 값이 저장되고, 그 값이 먼저 출력된다.
4. 함수 외부에 있는 변수 s의 값은 print(s)의 실행 결과로 'I love Paris!'이 출력되어 바뀌지 않았다는 것을 알 수 있다.

 💡 함수 내부와 외부에 있는 변수 s는 같은 이름을 가졌지만 사실 다른 메모리 주소를 갖고 있는 전혀 다른 변수다. 따라서 함수 내부의 s는 해당 함수가 실행되는 동안에만 메모리에 있다가 함수가 종료되는 순간 사라진다. 당연히 함수 외부의 s와는 메모리 주소가 달라 서로 영향을 주지 않는다.

함수 내부의 변수와 함수 외부의 변수가 같은 메모리 주소를 갖는 같은 변수를 사용하기 위한 방법

• global 키워드 사용

def f():
    global s
    s = "I love London!"
    print(s)

s = "I love Paris!"
f()
print(s)

#출력결과

I love London!
I love London!

• 기존 코드에서 변경된 것 → 함수 내부에서 global s 코드
• 기존의 s에는 ‘I love Paris!’가 저장되어 있는데 f() 함수 내부의 코드가 수행되는 순간 global s가 선언되어 함수 외부의 s, 즉 전역 변수 s의 메모리 주소를 사용한다.

💡 따라서 함수 내부와 외부에 있는 s는 같은 메모리 주소를 사용

함수 실습

직접 실행하지 않고 머릿속으로 실행한 뒤 결과값 맞추기

def calculate(x, y):
    total = x + y        # 새로운 값이 할당되어 함수 내부 total은 지역 변수가 됨
    print("In Function")
    print("a:", str(a), "b:", str(b), "a + b:", str(a + b), "total:", str(total))
    return total

a = 5                        # a와 b는 전역 변수
b = 7
total = 0                    # 전역 변수 total
print("In Program - 1")
print("a:", str(a), "b:", str(b), "a + b:", str(a + b))

sum = calculate (a, b)
print('After Calculation")
print(“Total:", str(total), " Sum:", str(sum))
# 지역 변수는 전역 변수에 영향을 주지않음

• 실행 결과 예상해보기

In Program - 1
a: 5 b: 7 a + b: 12
In Function
a: 5 b: 7 a + b: 12 total: 12
After Calculation
Total: 0 Sum: 12

재귀 함수 

• 자기 자신을 다시 호출하는 함수

• 팩토리얼 함수 : 정확히는 ‘n!’로 표시하고 n! = n x (n-1)! 로 선언할 수 있음
• 자신의 숫자에서 1씩 빼면서 곱하는 형식으로 점화식이라고 함

def factorial (n):
    if n == 1:
        return 1 
    else:
        return n * factorial (n - 1)

print(factorial(int(input ("Input Number for Factorial Calculation: "))))

#출력 결과

Input Number for Factorial Calculation: 5
120

• factorial() 함수는 n이라는 변수를 입력 매개변수로 넘겨받은 후 n==1 이 아닐때까지 입력된 n과 n-1을 입력값으로 다시 factorial() 함수를 호출하여 반환된 값과 곱한다.

사용자가 5를 입력한 경우

💡 5 * factorial(5 - 1)

= 5 * 4 * factorial (4 - 1)

= 5 * 4 * 3 * factorial (3 - 1)

= 5 * 4 * 3 * 2 * factorial (2 - 1)

=5 * 4 * 3 * 2 * 1

 

함수의 인수

 

파이썬에서 인수를 사용하는 방법

종류                             내용

키워드 인수	함수의 인터페이스에서 지정한 변수명을 사용하여 함수의 인수를 지정하는 방법
디폴트 인수	별도의 인수값이 입력되지 않을 때 인터페이스 선언에서 지정한 초깃값을 사용하는 방법
가변 인수	함수의 인터페이스에서 지정한 변수 이외의 추가 변수를 함수에 입력할 수 있도록 지원하는 방법
키워드 가변 인수	매개변수의 이름을 따로 지정하지 않고 입력하는 방법

키워드 인수

 

• 함수에 입력되는 매개변수의 변수명을 사용하여 함수의 인수를 지정하는 방법

def print _something (my name, your _name):
    print("Hello {0}, My name is {1}".format (your _name, my name))

print_something ("Sungchul", "TEAMLAB")
print_something(your _name = "TEAMLAB", my_name = "Sungchul")

#출력 결과

Hello TEAMLAB, My name is Sungchul
Hello TEAMLAB, My name is Sungchul

• print _something() 함수는 (my name, your _name)이라는 입력 인터페이스를 가짐
• print_something ("Sungchul", "TEAMLAB") 에서 "Sungchul"은 my name 에, "TEAMLAB"은 your _name에 할당
• print_something(your _name = "TEAMLAB", my_name = "Sungchul") → 함수의 인수에서 사용되는 각각의 변수명을 명시함으로써 해당 변수에 값이 할당될 수 있도록 처리
• 즉 입력되는 순서에 상관없이 "Sungchul"은 my name 에, "TEAMLAB"은 your _name에 할당되어 2가지 호출 코드의 실행 결과가 동일하게 출력

디폴트 인수

• 매개변수에 기본값을 지정하여 사용하고 아무런 값도 인수로 넘어가지 않을 때 지정된 기본값을 사용하는 방식

def print_something_2(my _name, your _name = "TEAMLAB"):
    print("Hello {0}, My name is {1}".format(your_name, my _name))

print something 2("Sungchul", "TEAMLAB")
print_something_2("Sungchul")

#출력 결과

Hello TEAMLAB, My name is Sungchul
Hello TEAMLAB, My name is Sungchul

• def print_something_2(my _name, your _name = "TEAMLAB") 에서 함수의 인터페이스 정의
• your_name 매개변수에는 기본값으로 "TEAMLAB” 지정 → your_name 매개변수에 별도의 값을 할당하지 않아도 함수 작동
• print_something_2("Sungchul") → 매개 변수가 2개인 데도 인수를 하나만 입력 → 입력한 값이 첫번째 매개변수 my_name에 할당되고 your_name에는 디폴트 인수로 지정된 "TEAMLAB"이 할당
• 결국 두 코드의 결과가 같음

 

가변인수

• 코드를 작성할 때 함수의 매개변수 개수를 정하지 않아야 하는 경우에 가변인수를 사용
  • 예를 들어 고객이 물건을 얼마나 구매할지 모르는 마트 계산기에서 합산을 수행하는 연산
• • (asterisk라고 부름)로 표현할 수 있는데, *는 파이썬에서 기본적으로 곱셈 또는 제곱 연산 외에도 변수를 묶어주는 가변 인수를 만들 때 사용

def asterisk_test(a, b, *args):
    return a + b + sum(args)

print(asterisk_test(1, 2, 3, 4, 5))

#출력 결과

15

• asterisk_test() 함수는 변수 a,b를 넘겨받고 나머지를 *args로 넘겨받는다.
• asterisk_test(1,2,3,4,5) → 1,2는 각각 a,b에 할당, 나머지 인수인 3,4,5가 모두 *args에 할당

def asterisk_test(a, b, *args):
    print(args)

print(asterisk_test(1, 2, 3, 4, 5))

#출력 결과

(3, 4, 5)
NONE

• 괄호로 출력되는 자료형을 튜플 자료형이라고 함 (리스트 자료형처럼 인덱스로 접근할 수 있는 자료형)
• 가변인수 *는 일반적인 키워드 인수에 대한 선언이 모두 끝난 후 마지막에 선언되어야 함
• 리스트와 비슷한 튜플 형태로 함수 안에서 사용되어 인덱스를 사용하여 args[0], args[1] 등의 형태로 변수에 접근 가능

def asterisk_test_2(*args):
    x， y, *z = args
    return x, y, z

print(asterisk_test_2(3, 4, 5))

#출력 결과

(3,4,[5])

• 입력받은 가변 인수의 개수를 안다면 x, y, z* = args 처럼 언패킹 가능
• *z 가 아닌 상태에서 asterisk_test_2(3,4,5,10,20)으로 변경하여 코드를 실행하면 오류 발생 → 언패킹의 개수가 지 않기 때문

언패킹 코드를 x, y, *z = args로 변경하여 보기

def asterisk_test_2(*args):
    x, y, *z = args
    return x,y,z

print(asterisk_test_2(3,4,5,10,20)) 

#출력 결과

(3,4,[5,10,20])

• *는 기능이 다양하여 언패킹할 때도 값을 가변 인수의 형태로 받을 수 있음

 

키워드 가변 인수

• 변수의 순서대로 튜플 형태로 저장
• 변수의 이름을 지정할 수 없다는 단점을 보완
• 매개변수의 이름을 따로 지정하지 않고 입력하는 방법으로 이전 가변 인수와는 달리 *를 2개를 사용하여 함수의 매개변수를 표현
• 입력된 값은 튜플 자료형이 아닌 딕셔너리 자료형으로 사용할 수 있음
• 반드시 모든 매개변수의 맨 마지막, 즉 가변 인수 다음에 선언되어야 함

def kwargs_test(**kwargs):
    print (kwargs)
    print("First value is {first}".format (**kwargs))
    print("Second value is {second}".format (**kwargs))
    print("Third value is {third}".format(**kwargs))

kwargs_test(first = 3, second = 4, third = 5)

#출력 결과

{'first': 3, 'second': 4, 'third': 5}
First value is 3
Second value is 4
Third value is 5

• kwargs_test(first = 3, second = 4, third = 5) 에서 3개의 키워드를 인수로 넘겼으므로 2행의 print() 함수에서 인수들이 {'first': 3, 'second': 4, 'third': 5}의 형태로 출력 → 딕셔너리 자료형
• 실행 결과 변수명과 값이 쌍으로 저장됨
• print("Second value is {second}".format (**kwargs)) 와 같이 변수명을 따로 불러내 사용할 수 있는데 print() 함수로 출력할 때 변수 kwargs에 있는 second 변수를 사용하고 있는것
• 이미 키워드 가변 인수를 사용하여 ‘first = 3, second = 4, third = 5’ 변수를 함수 안에 넣었기 때문에 second라는 변수 사용 가능
• 딕셔너리 자료형 변수에 *를 2개 붙이면 개별 변수로 풀리면서 함수에 들어갈 수 있음

인터프리터의 해석

»> kwargs = {'first': 3, 'second': 4, 'third': 5}
»> print("Second value is {second}".format (**kwargs))
Second Value is 4
» print("Second value is (second}".format(first = 3, second = 4, third = 5))
Second Value is 4

 

정리

• 매개변수, 가변 인수, 키워드 가변 인수를 모두 사용하면 매개변수, 가변 인수, 키워드 가변 인수 순으로 각 값을 적당한 위치의 변수에 할당

»> def kwargs_test (one, two, *args, **kwargs):
       print(one + two + sum(args))
       print(kwargs)

»> kwargs_test(3, 4, 5, 6, 7, 8, 9, first = 3, second =4, third = 5)
42
{'first': 3, 'second': 4, 'third': 5}

• 3,4는 각각 one,two에 할당되고, 나머지 5,6,7,8,9는 args에, first = 3, second = 4, third = 5는 딕셔너리형으로 kwargs에 할당

 

실습

사각형의 둘레를 구하는 함수 정의하고 호출하기

• 사각형의 세로는 3, 가로는 6
• 사각형의 가로 및 세로는 각각 side1,side2 로 할당할것
• 함수명은 circum으로 둘레는 squ 변수에 할당할것

정답

def circum(side1, side2):
    result = side1*2 + side2*2
    return result
squ = circum(3,6)
print(squ)

1. circum 함수를 정의하고 인수로 side1과 side2를 할당하여 준다.
2. result를 이용하여 사각형의 둘레를 계산하는 식을 할당하여 준다.
3. squ 변수에 circum 함수를 호출하고 side1은 3, side2는 6으로 할당하여 준다.
4. 함수 호출 결과 값이 squ에 할당되고 출력한다.

 

TV 음량의 현재 음량은 1이고, 증가시킬 만큼의 음량을 입력하면 음량이 증가하는 함수를 정의하고 호출하기

• volume 함수를 정의할것
• 현재 음량 → now_vol
• num에 증가시킬만큼의 음량을 입력받기
• 현재 음량은 3

정답

def volume(now_vol, num):
    now_vol = now_vol+num
    return now_vol

now_vol = 3
print("현재 음량은 3입니다.")
num = int(input("증가시킬만큼의 음량을 입력:"))
print("증가 후의 음량은", volume(now_vol,num),"입니다.")

1. volume 함수를 정의하고 현재 볼륨인 now_volume 과 증가 시킬 음량인 num을 입력받도록 한다.
2. 현재 음량에서 증가시킬 음량을 더해주어야 하므로 now_vol = now_vol+num 연산
3. now_vol 로 현재 음량을 전역변수로 할당하고 사용자에게 현재 음량을 알려준다.
4. num 변수를 새로 할당하여 증가시킬 만큼의 음량을 입력받는다.
5. volume 함수를 호출하여 증가 후의 음량을 출력한다.

 

함수의 출력 결과 예상해보기

def func1():
    a=10
    print("func1()에서 a 값:", a)

def func2():
    print("func2()에서 a 값:", a)

a=20
func1()
func2()

정답

#출력 결과

func1()에서 a 값 : 10
func2()에서 a 값 : 20

1. 함수 func1에서의 지역변수로 a=10이 할당되어 있으므로 print() 문을 실행하면 a가 10으로 나오게 된다.
2. 함수 func2 에서는 전역변수로 a= 20 이 할당되어 있으므로 print() 문을 실행하면 a가 20으로 나오게 된다.