Python 3주차 - 1

 

함수 (function)

1. 함수 기본

 

함수 : 특별한 기능을 위한 코드들의 집합

 

함수 용어

• 함수 호출(function call) : 함수의 사용
• 매개변수(parameter variable) : 함수 실행을 위해 인자(전달되는 값)를 저장하는 변수
• 인자 또는 인수(arguments) : 함수 호출 시 전달하는 입력값
• 리턴값(return value) : 함수 호출 시 최종적으로 나오는 결과 값. return 사용

함수 형식

def 함수이름(<매개변수, 매개변수, ...>):
	실행문
    실행문
   	...
    <return <값 or 수식 or 변수>>
    
# 함수 호출
함수이름(<필요한 입력값>)

# 함수 형식 예제

def plus(v1,v2):
	result = 0
    result = v1 + v2
    return result
    
hap = plus(100,200)
print(hap)

함수 종류

• 내장함수 : 파이썬에서 이미 작성되어 사용자에게 제공되는 함수
• 사용자 정의 함수 : 사용자가 필요한 기능을 만들어 사용하는 함수. def 사용
• 메서드(method) : 클래스(class) 내부에 선언된 함수

2. 지역변수, 전역변수

def func1():
	a = 10	# 지역변수
    print("local var of func1 :", a)
    
def func2():
	print("global var :", a)
    
 a = 30		# 전역변수
 func1()	# 10
 func2()	# 30

def sub():
	global s	# global : 함수 안에서 사용되는 변수를 전역변수로 사용하고 싶은 경우
    print(s)
    s = "안녕하세요"
    print(s)
    
s = "Hello"
sub()
print(s)

3. 네임스페이스 (namespace)

 

이름(변수이름, 함수이름, 클래스이름, 모듈이름 등)이 묶여 있는 영역

이름과 바인딩된 객체의 모임으로 구성된 사전

지역, 전역, 내장의 네임스페이스 사전 객체가 존재

• 지역(local) : 함수 또는 클래스의 인스턴스가 생성될 때 그 내부에서 이름과 객체의 묶임으로 생성. locals()로 확인
• 전역(global) : 각 모듈이 시작될 때 생성되는 최상위 네임스페이스, 모듈 전체에서 사용 가능. globals()로 확인
• 내장(built-in) : 파이썬 인터프리터가 시작될 때 생성, 끝날때 까지 유지됨. dir(__builtins__)로 확인

유효범위 규칙에 따라 네임을 찾아감 : 지역 -> 전역 -> 내장 순

 

유효범위 규칙 확인 코드 - global

def test_Scope():
	global x
    print(f'global x: {x}')
    x = 100
    print(f' test_scope x: {x}')
    print(f'{locals()}')
    return

유효범위 규칙 확인 코드 - nonlocal (비 지역변수를 참조할 때 사용)

• nonlocal로 선언된 변수는 해당 함수의 지역변수에 표시
• 그 함수의 부모함수에 같은 이름을 가진 지역변수를 참조
• 따라서 부모함수에 반드시 nonlocal로 선언된 이름의 변수가 존재해야 함

def name_f1():
	i = 10
    def name_f2():
    	nonlocal i	# nonlocal : name_f2 에서 name_f1의 변수 i를 참조하고 싶을 때
        print(f'name_f2 i : {i}')
        i = 20
        print(f'name_f2 i : {i}')
        print(f'name_f2 local: {locals()}')
        
        print('*'*40)
        
	name_f2()
    print(f'name_f1 i : {i}')
    print(f'name_f1 local: {locals()}')
    
i = 30
name_f1()
print(f'global i : {i}')
       

4. return

 

함수의 종결자

return 다음에 오는 값을 함수를 호출시킨 위치로 반환

def sub(1):
	return
    a = a * 10
    print("a * 10 = ", a)
 
a = int(input("enter number>> "))
sub(a)
print("program end")	# 함수 시작 부분에 return이 있으므로 program end만 출력됨

5. 매개변수 사용

 

1) 가변 매개변수

• 매개변수를 원하는 만큼 받을 수 있는 함수
• 가변 매개변수 뒤에는 일반 매개변수가 위치할 수 없음
• <*변수이름> 형식 사용
• 가변 매개변수는 tuple형식으로 처리

def print_n_times(n, *values):	
	for i in range(n):
    	for value in values:	# values는 튜플처럼 사용
        	print(value, end='')
        print()
        
print_n_times(4, '안녕하세요','즐거운','수업시간입니다')
print_n_times(4, '건강한','하루')

2) 가변 매개변수 ** 인 경우

• 딕셔너리 형태로 전달
• 함수 호출 시 인자값의 형태는 키(key)=값(value)로 작성
• 함수에서 위치는 항상 마지막에 와야 함

def dic_func(**para):
	for k in para.keys():
    		print("%s --> %d 입니다" % (k,para[k]))

dic_func(트와이스=9, 소녀시대=7, 방탄소년단=7, 블랙핑크=4)

3) 키워드 매개변수 함수

• 매개변수에 초기값이 부여된 경우
• 키워드 매개변수 뒤에는 일반 매개변수 위치 불가
• def function name(매개변수1, 매개변수2, 매개변수3=초기값)

def print_n_times(value, n=2):	# n=2 초기값
	for i in range(n):
    	print(value)

print_n_times("안녕하세요", 3)	# n값을 지정하지 않으면 초기값 2 적용

4) 키워드 매개변수/가변 매개변수 함께 사용 시

• 가변 매개변수 앞에 일반 또는 키워드 매개변수가 정의된 경우
• 키워드 매개변수를 이용하여 호출 불가

def sample(n, *test):
	print("sample")

sample(3,1,2,3)	# sample(n=3, 1,2,3) : 오류 -> 키워드 매개변수를 이용하여 호출할 수 없음

• 가변 매개변수 뒤에 일반 또는 키워드 매개변수가 정의된 경우
• 반드시 키워드 매개변수를 이용하여 호출

def sample(*test, n):
	print("sample")

sample(1,2,3, n=4)	# sample(1,2,3,4) : 오류

# 예제 - 매개변수 사용 

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

def testF(*var):
    x,y,*z = var	# * : unpacking 연산자, z가 리스트로 변함
    print("%d, %d, %s" % (x,y,z))

change(1,2,3,4,5,6)
testF(1,2,3,4,5,6)

6. 재귀함수 (Recursive Function)

 

self 호출 하는 함수. 자기 자신을 호출하는 코드가 존재하는 함수

반복문으로 대체할 수 있는 재귀함수는 반복문으로 작성함

def A(<매개변수>):
	<변수> = <초기값>
    <실행문>
    A(<값>)

def recur_f(num):
	if num == 0:
    	return 0
    else:
    	return num + recur_f(num-1)		# 재귀함수 -> 반복문 역할을 함

value = int(imput("Enter number>> "))
result = recur_f(value)
print("sum of %d :: %d" % (value, result))

# 예제 - 재귀함수를 사용한 계승문제(누적의 곱) factorial

def fact(n):
	if n < 0 or n != int(n):
    	print("wrong input")
        return
    elif n == 0 or n == 1:
    	return 1
    else:
    	return n*fact(n-1)

n = int(input("factorial number >> "))
result = fact(n)
print(f'{n}! == {result}')

# 참고: 반복문으로 작성
def factorial(num):
	fact = 1
    for i in range(1,num+1):
    	fact *= i
    return fact

value = int(input("Enter number >> "))
result = factorial(value)
print("factorial of %d :: %d" % (value,result))

# 예제 - 재귀함수를 이용한 피보나치 수열

def fibo(n):
	if n<0:
    	print("range out number")
        return
    elif 0<=n<=1:
    	return n
    else:
    	return fibo(n-1) + fibo(n-2)
        
fibo_n = int(input("fibonacci number >> "))
print(fibo(fibo_n))

# 피보나치 수열 - 메모이제이션 사용

fibo_dict = {	# 딕셔너리를 이용한 메모화 기능 사용
	1:1,
    2:1
}
def fibo(n):
	if n in fibo_dict:
    	return fibo_dict[n]
    output = fibo(n-1) + fibo(n-2)
    fibo_dict[n] = output
    return output

7. 람다 (Lambda)

 

함수의 기능을 매개변수로 전달하는 코드에서 사용

함수의 형태가 간단한 경우

런타임에 생성해서 사용할 수 있는 익명의 함수

Lambda <매개변수> : <리턴값>

power = lambda x: x*x
n_power = lambda x,y: x**y
print(power(3))
print(n_power(2,5))
print((lambda x,y: x+y)(3,4))

8. map 함수

 

map(함수이름, 리스트 또는 리스트 변수이름)

두번째 인자인 리스트값을 순차적으로 첫번째 인자인 함수에 대입해주는 함수

ex) map(str, [1,2,3]) 를  str(1), str(2), str(3)로, 결과는 '1', '2', '3'

# 예제 - 리스트에 +10을 하는 함수 호출

myList = [1,2,3,4,5]
def add10(num):
	return num+10

result10 = map(add10, myList)
print(result10)
print(list(result10))

# lambda를 사용한 map 함수

myList = [1,2,3,4,5]

result10 = map(lambda num:num+10, myList)
print(result10)
print(list(result10))

9. filter 함수

 

filter(<함수>,<리스트>)

리스트의 용소를 함수에 입력하고, 리턴된 값이 True인 것으로 새로운 리스트를 생성하는 함수

필요없는 데이터를 걸러내기 위하여 사용하는 함수

list_a = [1,2,3,4,5]
output = list(filter(lambda x:x<3, list_a))
print(output)

# map, filter 함수 컴프리핸션

seq = [1,2,3,4,5]
f = lambda x:x**2
print(list(map(f,seq))		# print([x**2 for x in seq])

seq = [1,2,3,4,5]
f = lamabda x,y:x+y
print(list(map(f,seq,seq)))	# print([x+y for x,y in ziq(seq,seq)])

10. reduce 함수

 

map과 형제같은 함수로, 리스트와 같은 시퀀스 자료형에 차례대로 함수를 적용 후, 모든 값을 통합하는 함수

from functools import reduce

f = reduce(lambda x,y:x+y, [1,2,3,4,5])
print(f)	# 결과 : 15

11. 제너레이터(Generator)

 

성능 및 효율적 코드 작성을 위한 패턴

- 메모리와 CPU 효율이 높음 : 생성된 데이터는 임시저장, 1회 사용 후 메모리에서 삭제되므로 재사용 불가

- 코드의 간결성이 높음

파이썬의 시퀀스를 생성하는 객체

제너레이터는 이터레이터임

제너레이터의 형태 - 제너레이터 함수(function), 제너레이터 표현(expressions)

 

1) 제너레이터 표현

변수이름 = (수식 또는 항목 for 항목 in range() <if 조건식>)

-> 튜플형식, class는 generator

튜플은 컴프리핸션이 없음

-> 튜플 형식을 사용한 컴프리핸션 표현은 제너레이터

gen = (i for i in range(10) if i%2 == 0)
print(type(gen))
print(gen)

2) 제너레이터 함수

def 함수이름(<인자1, 인자2, ...>):
	실행문
    실행문
    ...
	yield 변수 or 수식 or 값

return 대신 yield를 사용하여 값을 반환

return과는 달리 yield는 값을 반환하고 다시 함수로 되돌아와 남은 실행문을 실행함

대표적인 제너레이터 함수 range() -> range는 iterable이며, range()는 제너레이터이자 이터레이터

# 제너레이터 함수 예제 - 0~4 사이의 정수값 발생하고 리스트로 저장

def gen():
	for i in range(5):
    	yield i
        
me = list(gen())
print(me)

12. 모듈 (module)

 

함수, 전역변수, 클래스 등의 집합체로 .py로 작성되는 파이썬 파일

코드를 분리하고 공유하기 편한 형태로 만들기 위한 목적

모듈 종류 : 표준모듈, 사용자정의모듈, 서드파티

 

모듈 사용하기

• 모듈 전체 기능 사용 : import <모듈이름>
• 모듈 특정 기능 사용 : from <모듈이름> import <특정기능1>, <특정기능2>, ...
• 모듈 또는 특정 기능을 다른 이름으로 사용 : from <모듈이름> import <특정기능1> as <식별자>
•                                                          import <모듈이름> as <식별자>

import math
print("trigonometric ratio of sin(1): ", math.sin(1))

import math as m
print("trigonometric ratio of sin(1): ", m.sin(1))

from math import sin, cos
print("trigonometric ratio of sin(1): ", sin(1))

__name__, "__main__" 모듈

• 어떤 py파일이 프로그램이 시작되는 진입 파일(엔트리 포인트)인지 구분
• 메인파일(엔트리 포인트 파일) 내부에서의 __name__ 변수값은 "__main__"
• py 파일 내에서 print(__name__)을 실행 시 __main__이 출력되면 그 파일이 엔트리 포인트 파일. 그 외 파일은 자신의 모듈이름이 출력됨

# 예제 - test_module.py 파일

PI - 3.141592

def number_input():
	output = input("Enter your number :: ")
    return float(output)
    
def get_circumference(radius):
	return 2*PI*readius
    
def get_circle_area(radius):
	return PI*radius**2
    
if __name__ == "__main__":		# test_module.py가 엔트리 포인트 파일이면 이 부분만 실행시킴
	print(get_circumference(10))
    print(get_circle_area(10))

13. Package

 

모듈이 모여서 구조를 이룬 것

pip (python package index) : 패키지 또는 모듈을 설치할 때 사용하는 명령어. package management system임

__init__.py

• 패키지를 import 할 때 어떤 처리를 수행하거나, 패키지 내부의 모듈을 모두 import하고 싶을 때 처리하는 파일
• package를 초기화 하는 역할
• 패키지 호출 시 자동 실행