[DAY 8] parameter와 argument, lambda, list comprehension

함수
- 반복적으로 사용되는 코드를 묶어서 사용
- 관련 용어 : def, return, parameter, argument, docstring, scope, lambda
- 코드가 간결해지고 유지보수가 쉬워진다는 장점
- 사용법 : 함수 선언(코드 작성) -> 함수 호출(코드 실행)
return
- 함수 호출을 통해 결과 데이터를 변수에 저장
- 함수 실행을 중단
- 함수에서 return은 필수는 아니다

# return 없는 함수
def plus1(n1, n2):
    print(n1 + n2)  # 덧셈 결과를 출력
    
# return 있는 함수
def plus2(n1, n2):
    return n1 + n2  # 덧셈 결과를 반환

 

# 리턴이 있는 함수 예시: str.upper()
data = 'python'
result = data.upper()
print(data, result)

# 실행 결과
python PYTHON

data.upper()로 'PYTHON'이 result에 return 되었고 원래 data 값은 바뀌지 않았다.

# 리턴이 없는 함수 예시 : list.sort()
data = [1, 3, 2]
result = data.sort()
print(data, result)

# 실행 결과
[1, 2, 3] None

data.sort()로 data list는 정렬되었고 result에는 아무 값도 return 되지 않았다.

 

여러 개의 데이터를 한 번에 return : 파이썬의 장점

# 데이터 list를 return
def calc(n1, n2):
    result = [n1 + n2, n1 - n2]
    return result
result = calc(3, 1)
print(result)

# 실행 결과
[4, 2]

 

# 두 변수가 return 값을 받는 경우
def calc(n1, n2):
    return n1 + n2, n1 - n2
plus, minus = calc(3, 1)  # unpacking
print(plus, minus)

# 실행 결과
4 2

 

def calc(n1, n2):
    return n1 + n2, n1 - n2
plus, _ = calc(3, 1)   # 일부 데이터를 활용하지 않는 경우 _ 사용 가능
print(plus)

# 실행 결과
4

 

docstring 과 help() 함수
- docstring : 함수 선언을 할 때 함수에 대한 설명을 작성
- 함수 선언 코드 바로 아래에 멀티라인 문자열로 작성
- help() 함수로 docstring을 출력, 확인할 수 있다

plus 함수를 선언하고 docstring을 작성한 후 help() 함수로 docstring을 확인하였다.

 

파이썬 내장함수 print에는 sep, end 등의 파라미터가 있는 것을 확인할 수 있다.

 

*args, **kwargs 사용 코드

# type과 값을 출력하는 함수 작성
def echo(*args, **kwargs): # 파라미터에 컬렉션 데이터 타입을 받아줌 : 식별자1개, 데이터n개
    print(type(args), args)
    print(type(kwargs), kwargs)
    
# 키워드 아규먼트는 키워드가 없는 아규먼트 뒤에 사용
# 디폴트 파라미터는 디폴트 값이 없는 파라미터 뒤에 사용
echo(1, 2, 3, 4, 5, n1=10, n2=30) # 여러개의 아규먼트

# 실행 결과
<class 'tuple'> (1, 2, 3, 4, 5)
<class 'dict'> {'n1': 10, 'n2': 30}

 

# 내장함수 print의 argument에 활용
data = [1, 2, 3]
print(*data)

#실행 결과
1, 2, 3   # [1, 2, 3] 이 아님

 

def echo(*args, **kwargs):
    print(type(args), args)
    print(type(kwargs), kwargs)
    
data1 = [1, 2, 3]
echo(data1)  # echo([1, 2, 3]) > 아규먼트 : 1개, 데이터타입 : 리스트
echo(*data1) # echo(1, 2, 3) > 아규먼트 : 3개, 데이터타입 : 정수

print()

data2 = {'num1': 10, 'num2': 20}
echo(data2)   # echo({'num1': 10, 'num2': 20}) > 아규먼트 1개, 데이터타입 : 딕셔너리
echo(**data2) # echo(num1=10, num2=20) > 키워드 아규먼트 2개, 데이터타입 : 정수

# 실행 결과
<class 'tuple'> ([1, 2, 3],)
<class 'dict'> {}
<class 'tuple'> (1, 2, 3)
<class 'dict'> {}

<class 'tuple'> ({'num1': 10, 'num2': 20},)
<class 'dict'> {}
<class 'tuple'> ()
<class 'dict'> {'num1': 10, 'num2': 20}

 

*args, **kwargs 정리
parameter
   - 여러개의 아규먼트 > 하나의 컬렉션 데이터타입(tuple, dictionary)으로 묶어서 받아준다
  - *args : 키워드가 없는 여러개의 아규먼트를 받는다 : tuple
  - **kwargs : 키워드가 있는 여러개의 아규먼트를 받는다 : dict
argument
  - 묶여있는 컬렉션 데이터타입(list,tuple,dict) > 여러 개의 아규먼트로 풀어서 함수 호출
  - *args : list, tuple 데이터타입의 데이터를 여러 개의 아규먼트로 풀어준다
  - **kwargs : dictionary 데이터타입의 데이터를 여러 개의 키워드 아규먼트로 풀어준다

scope : global scope(전역 범위)와 local scope(지역 범위)의 이해
실수 유의 코드부터 확인

# 실수 유의 코드
data = 10
def change():
    data = 20
change()
print(data)

# 실행 결과
10		# 20이 아닌 10이 출력

local scope에서 global 변수를 사용하는 방법
- global 키워드 사용

data = 10
def change():
    global data
    data = 20
change()
print(data)

# 실행 결과
20

사용되는 변수가 local scope에 없으면, 전역 변수를 가져와서 사용한다.

data = 10
def change():
    print('local', data)
change()
print('global', data)

# 실행 결과
local 10
global 10

 하지만 global 키워드 사용을 권장한다.

lambda 함수 : 일회성 함수로 간단한 함수를 선언 없이 사용 가능
- 메모리 절약, 가독성 증대 효과
사용 형태 :    lambda (파라미터) : (결과)

# lambda 함수 사용 전 - 플러스, 마이너스 계산 : 함수 3개로 저장 공간 3칸 사용
def plus(n1, n2):
    return n1 + n2
def minus(n1, n2):
    return n1 - n2
def calc(func, n1, n2):
    return func(n1, n2)
print(calc(plus, 1, 2), calc(minus, 1, 2))

# 실행 결과
3 -1

 

# lambda함수 사용 후 - calc 함수만 선언하므로 저장 공간 1칸 사용
def calc(func, n1, n2):
    return func(n1, n2)
    
calc(lambda n1, n2: n1 + n2, 1, 2), calc(lambda n1, n2: n1 - n2, 1, 2)

# 실행 결과
3 -1

같은 연산을 하지만 간결하며 메모리도 절약되었다.

list comprehension
- 간단한 반복문, 조건문을 사용해서 리스트 데이터를 만들 때 사용하는 문법
- 주로 리스트 데이터를 필터링하거나 데이터를 변경할 때 사용

# 0 ~ 9 까지의 데이터에서 홀수만 뽑아서 제곱한 결과를 리스트로 출력
result = []
for number in range(10):
    if number % 2:
        result.append(number ** 2)
print(result)

# 실행 결과
[1, 9, 25, 49, 81]

위의 코드를 list comprehension을 사용하여 바꿔보자

# list comprehension 사용 - 속도 증대
result = [number ** 2 for number in range(10) if number % 2]
print(result)

# 실행 결과
[1, 9, 25, 49, 81]

list comprehension의 활용 : 데이터 전처리를 할 때 원하는 데이터만 얻기 위해 유용하게 사용될 수 있다.

활용 1. 보고서 목록에서 2020년도의 보고서만 년도를 제외하고 출력

# list comprehension 활용 1
reports = ['사업보고서(2020)', '감사보고서(2021)', '[기재정정]사업보고서(2020)']

reports_2020 = [report[:-6] for report in reports if report[-5:-1] == '2020']

print(reports_2020)

# 실행 결과
['사업보고서', '[기재정정]사업보고서']

list comprehension과 string slicing을 활용하였다.
2021년도의 감사보고서는 제외된 결과를 얻었다.

활용 2. 김씨 성을 가진 사람만 나이를 연령대로 바꾼 후 출력

# list comprehension 활용 2
names = ['kim python(23)', 'lee notebook(32)', 'kim macbook(47)']

def ages(data):
    return data[:-3] + str(int(data[-3:-1]) // 10 * 10) + ')'
    
names_kim = [
    ages(name)
    for name in names 
    if name.split(' ')[0] == 'kim'
]
print(names_kim)

# 실행 결과
['kim python(20)', 'kim macbook(40)']

list comprehension, string slicing과 함수를 활용하였다.
이 씨 성을 가진 사람은 제외되었고 나이도 연령대로 잘 바뀌었다.

map() 함수 : iterable 데이터의 모든 value에 특정 함수를 적용한 결과를 얻는 경우 사용
map 함수 사용 예시

# 나이를 연령대로 바꿔서 리스트로 출력
names = ['kim python(28)', 'lee java(45)', 'choi c(57)']

def ages(data):
    return data[:-3] + str(int(data[-3:-1]) // 10 * 10) + ')'
    
print(list(map(ages, names))) 

# 출력 결과
 ['kim python(20)', 'lee java(40)', 'choi c(50)']

map 함수를 사용하여 names 데이터의 모든 value에 ages 함수를 적용한 결과를 얻었다.

 

이후 네이버의 파파고 API를 사용해서 한국어 텍스트를 서버에 전송하고 번역된 영어 텍스트를 받는 실습을 했다.

2023.01.04  Papago API