함수(Function)
1. 함수 선언
- 입력을 받아 특정 기능을 수행한 후 그 결과를 반환
- 반복 사용되는 코드를 미리 정의하여 필요할 때 사용 및 수정이 용이할 수 있도록 모듈화
- 입력(Input) : 매개변수(기본 매개변수, 가변 매개변수, 키워드 매개변수)
- 출력(Output) : 입력값인 매개변수를 받아 코드 처리한 결과
1.1 기본 표현
- def(definition) : 함수를 선언하기 위한 키워드
- 함수명 : 내장 함수명과 동일하지 않은 함수명으로 선언
- 콜론(:) : 코드 블록의 시작을 의미하며 이후 실행문 입력
- 들여쓰기(indent) : 코드 블록 안에서 실행문 입력을 구분하기 위해 사용
- 실행문 : 함수 처리가 필요한 코드 입력
# 함수 선언 : 처리하는 함수
def greet():
print("Hello!")
print("Nice to meet you:)")
# 함수 사용
greet() # Hello!
# Nice to meet you:)
# 함수 선언 : 반환하는 함수
def greet():
return "Hello!"
# 함수 사용
a = greet()
print(a) # Hello!
1.2 입력
- 기본 매개변수 : 기본값으로 사용되는 매개변수
- 가변 매개변수 : 원하는 만큼 정하여 사용할 수 있는 매개변수, '*가변 매개변수'
- 키워드 매개변수 : 이름을 지정하여 사용하는 매개변수, '키워드 매개변수 = 값'
# 함수 선언 - 기본 매개변수
def greet(name):
print(f"Hello, {name}!")
# 함수 사용
# greet() # greet() missing 1 required positional argument: 'name'
greet("Lee") # Hello, Lee!
# 함수 선언 - 가변 매개변수
def greet(*args):
for i in args:
print(f"Hello, {i}!", end = " ")
# 함수 사용
greet() #
greet("Lee") # Hello, Lee!
greet("Lee", "Kim", "Park") # Hello, Lee! Hello, Kim! Hello, Park!
# 함수 선언 - 키워드 매개변수
def greet(name = "Lee"):
print(f"Hello, {name}!")
# 함수 사용
greet() # Hello, Lee!
greet("Kim") # Hello, Kim!
1.3 출력
- return : 함수 안에서 결과값을 반환하여 함수 실행했던 위치로 돌아감
- 여러개 결과값 반환 가능
- 반환값이 없는 함수의 결과값을 받으면 None 출력
# 함수 선언 - 반환값 있음
def calc(a, b):
return a + b
# 함수 사용
c = calc(5, 10)
print(c) # 15
calc(5, 5) # 10
# 함수 선언 - 여러개 변환값
def calc2(a, b):
return a + b, a * b
# 함수 사용
c, d = calc2(5, 10)
print(c) # 15
print(d) # 50
calc2(5, 5) # (10, 25)
# 함수 선언 - 반환값 없음
def calc3(a, b):
print(a + b)
# 함수 사용
c = calc3(5, 10) # 15
print(c) # None
calc3(5, 5) # 10
# 함수 선언 - 반환값 없음
def calc4(a, b):
return
# 함수 사용
c = calc4(5, 10)
print(c) # None
calc4(5, 5) #
2. 변수
2.1 매개변수
- 일반 매개 변수 뒤에 가변 매개변수 사용 가능
- 가변 매개변수 뒤에 일반 매개변수 사용 불가능
- 가변 매개변수는 하나만 사용 가능
- 가변 매개변수 뒤에 키워드 매개변수 사용 가능
# 함수 선언 - 일반 매개 변수 뒤에 가변 매개변수 사용 가능
def greet(n, *args):
for a in args:
print(f"Hello, {n}{a}!")
# 함수 사용
greet("Mr.", "Lee", "Kim", "Park") # Hello, Mr.Lee!
# Hello, Mr.Kim!
# Hello, Mr.Park!
# 함수 선언 - 가변 매개변수 뒤에 일반 매개변수 사용 불가능
def greet(*args, n):
for a in args:
print(f"Hello, {n}{a}!")
# 함수 사용
greet("Mr.", "Lee", "Kim", "Park") # greet() missing 1 required keyword-only argument: 'n'
# 함수 선언 - 가변 매개변수는 하나만 사용 가능
def greet(n, *arg, *args):
for a in args:
print(f"Hello, {n}{a}!")
# 함수 사용
greet("Mr.", "Lee", "Kim", "Park") # * argument may appear only once
# 함수 선언 - 가변 매개변수 뒤에 키워드 매개변수 사용 가능
def greet(*args, n):
for a in args:
print(f"Hello, {n}{a}!")
# 함수 사용
greet("Lee", "Kim", "Park", n = "Mr.") # Hello, Mr.Lee!
# Hello, Mr.Kim!
# Hello, Mr.Park!
추가)
# *은 낱개씩 처리하라는 의미
print("ABCDEFG") # ABCDEFG
print(*"ABCDEFG") # A B C D E F G
print("A", "B", "C", "D", "E", "F", "G") # A B C D E F G
a = [1, 2, 3, 4, 5]
print(*a) # 1 2 3 4 5
print(a[0], a[1], a[2], a[3], a[4]) # 1 2 3 4 5
2.2 지역변수 & 전역변수
- 변수 우선 순위 : L→E→G
- L(Local variable) : 함수 안에서 선언되고 유효 지역변수
- E(Enclosing varibale) : 안쪽 함수 입장에서 바깥 함수가 선언한 변수
- G(Global variable) : 함수 안과 밖에서 모두 사용 가능한 전역변수, global 키워드 사용
# L(Local variable)
# 함수 선언
def fun():
lv = 10 # Local variable
print(lv)
# 함수 확인
fun() # 10
# E(Enclosing variable)
# 함수 선언
def outer_fun():
ev = 10 # Enclosing variable
def inner_fun():
print(ev)
inner_fun()
# 함수 확인
outer_fun() # 10
# G(Global variable)
# 함수 선언
gv = 10
def fun():
global gv # Global variable
print(gv)
gv = 15
print(gv)
# 함수 확인
fun() # 10
# 15
추가)
x = 10 # Global variable
def outer_fun():
x = 20 # Enclosing variable
def inner_fun():
x = 30 # Local variable
print(x) # Local variable is used
inner_fun()
print(x) # Enclosing variable is used
outer_fun() # 30 # Local variable
# 20 # Enclosing variable
print(x) # 10 # Global variable
3. 내장 함수
3.1 숫자형 관련 함수
- int(x) : 정수로 변환한 x 값 반환
- abs(x) : 절대값 x 반환
- min(x) : x 값 중 최소값 반환
- max(x) : x 값 중 최대값 반환
- sum(x) : x 값을 모두 더한 결과값 반환
- pow(x, y) : x를 y번 제곱한 결과값 반환
- divmod(x, y) : x를 y로 나눈 몫과 나머지를 튜플 형태로 반환
# int(x)
x = 123.45
int(x) # 123
# abs(x)
x = -123.45
abs(x) # 123.45
# min(x)
x = [1, 2, 3, 4, 5]
min(x) # 1
# max(x)
x = [1, 2, 3, 4, 5]
max(x) # 5
# sum(x)
x = [1, 2, 3, 4, 5]
sum(x) # 15
# pow(x, y)
x = 5
y = 3
pow(x, y) # 125 = 5 * 5 * 5
# divmod(x, y)
x = 17
y = 5
divmod(x, y) # (3, 2)
3.2 논리형 관련 함수
- all(x) : 매개변수 x 모두가 참일 경우 True 반환
- any(x) : 매개변수 x 중 하나라도 참일 경우 True 반환
# all(x)
x = [1, 2, 3, 4, 5]
all(x) # True
x = [0, 1, 2, 3, 4]
all(x) # False
# any(x)
x = [0, 1, 2, 3, 4]
any(x) # True
참고) 숫자0, 숫자 0.0, 빈 문자열, 빈 리스트, 빈 튜플, 빈 딕셔너리, None은 False로 변환
3.3 문자형 관련 함수
- str(x) : x를 문자열로 변환
- chr(x) : 아스키코드(ASCII) 값 x에 대응하는 문자 반환
- ord(x) : 문자 x의 아스키코드(ASCII) 값 반환
# str(x) : x를 문자열로 변환하여 반환
x = 123.45
y = "Number : " + str(x)
print(y) # Number : 123.45
print(type(y)) # <class 'str'>
# chr(x)
x = 65
chr(x) # 'A'
# ord(x)
x = "A"
ord(x) # 65
3.4 리스트&튜플&집합 관련 함수
- list(x) : x를 리스트로 변환
- tuple(x) : x를 튜플로 변환
- set(x) : x를 집합으로 변환
- len(x) : 매개변수 개수를 반환
- enumerate(x) : 문자열, 리스트, 튜플, 집합, 딕셔너리를 입력받아 순번과 요소를 반환
- zip(x, y) : x와 y 매개변수를 쌍으로 묶어서 반환
# list(x)
x = "12345"
list(x) # ['1', '2', '3', '4', '5']
# tuple(x)
x = "12345"
tuple(x) # ('1', '2', '3', '4', '5')
# set(x)
x = "12345"
set(x) # {'1', '2', '3', '4', '5'}
# len(x)
x = [1, 2, 3, 4, 5]
len(x) # 5
# enumerate(x)
x = "ABCDE"
for i, a in enumerate(x):
print(i, ":", a) # 0 : A
# 1 : B
# 2 : C
# 3 : D
# 4 : E
# zip(x, y)
x = [1, 2, 3, 4, 5]
y = "ABCDE"
list(zip(x, y)) # [(1, 'A'), (2, 'B'), (3, 'C'), (4, 'D'), (5, 'E')]
3.5 함수와 함께 사용하는 함수
- filter(f, x) : 함수 f에 x를 매개변수로 전달하여 True인 결과를 리스트로 반환
- map(f, x) : 함수 f에 매개변수 x를 하나씩 전달해 얻은 결과를 리스트로 반환
- lambda x: y : 매개변수 x를 받아 y를 반환
# filter(f, x)
def func(s):
return s == s.upper()
x = "Dream Comes True"
list(filter(func, x)) # ['D', ' ', 'C', ' ', 'T']
# map(f, x)
x = [1, 2, 3, 4, 5]
list(map(lambda li : li * li, x)) # [1, 4, 9, 16, 25]
# lambda x: y
add = lambda x, y: x + y
print(add(3, 5)) # 8
3.6 실행관련 함수
- eval(x) : 실행 가능한 문자열을 받아 문자열을 실행한 결과를 반환
- input() : 사용자로부터 입력을 받음, 입력받은 값은 언제나 문자열
# eval(x)
x = "10 + 5"
eval(x) # 15
# input()
x = input().split(" ") # 1 2 3 4 5
print(x) # ['1', '2', '3', '4', '5']
3.7 객체 정보 및 메타 데이터 관련 함수
- id(x) : x의 고유 주소값을 반환
- isinstnace(x, y) : x가 y의 인스턴스인지 여부를 True, False로 반환
- dir(x) : x가 가지고 있는 변수나 메소드 목록 반환
# id(x)
x = [1, 2, 3, 4, 5]
id(x) # 3024298901248
# isinstnace(x, y)
x = [1, 2, 3, 4, 5]
isinstance(x, tuple) # False
isinstance(x, list) # True
# dir(x)
x = [1, 2, 3, 4, 5]
dir(x) # ['__add__',
# '__class__',
# '__class_getitem__',
# '__contains__',
# '__delattr__',
# '__delitem__',
# '__dir__',
# '__doc__',
# '__eq__',
# '__format__',
# '__ge__',
# '__getattribute__',
# '__getitem__',
# '__getstate__',
# '__gt__',
# '__hash__',
# '__iadd__',
# '__imul__',
# '__init__',
# '__init_subclass__',
# '__iter__',
# '__le__',
# '__len__',
# '__lt__',
# '__mul__',
# '__ne__',
# '__new__',
# '__reduce__',
# '__reduce_ex__',
# '__repr__',
# '__reversed__',
# '__rmul__',
# '__setattr__',
# '__setitem__',
# '__sizeof__',
# '__str__',
# '__subclasshook__',
# 'append',
# 'clear',
# 'copy',
# 'count',
# 'extend',
# 'index',
# 'insert',
# 'pop',
# 'remove',
# 'reverse',
# 'sort']
3.8 기타
- range(x, y, z) : x부터 y-1까지 z씩 증가하는 객체를 반환
- sorted(x) : x 요소를 정렬하여 반환
# range(x, y, z)
a = range(1, 11, 2)
print(list(a)) # [1, 3, 5, 7, 9]
# sorted(x)
x = [3, 2, 5, 1, 4]
sorted(x) # [1, 2, 3, 4, 5]
'STUDY > PYTHON' 카테고리의 다른 글
| [Python] 6. 조건문 & 반복문 (3) | 2024.11.11 |
|---|---|
| [Python] 5. 딕셔너리 (0) | 2024.11.10 |
| [Python] 4. 튜플 & 집합 (3) | 2024.11.09 |
| [Python] 3. 리스트 (0) | 2024.11.08 |
| [Python] 2. 문자형 (0) | 2024.09.21 |
