파일명 : day05.txt
학습 목표 :
1. 함수의 종류와 개념을 파악할 수 있다.
2. 사용자 정의함수를 이용해서 프로그램을 작성할 수 있다.
##########
## 함수
##########
함수란 1개 이상의 실행문을 하나로 묶은 것이며 프로그램에서 재사용 하기 위해서 만든다.
함수는 코드의 중복을 제거하고 다시 사용하는 재사용성의 의미를 가지고 있다.
함수 종류
라이브러리 함수: 파이썬을 설치하면 제공되는 함수 (print, input)
패키지 함수: 추가적인 패키지를 설치하면 제공되는 함수
사용자 정의 함수: 사용자가 직접 만들어서 사용하는 함수
입력값은 함수를 호출할 때 함수에 전달하는 값을 말한다.
입력값 : 인수, 인자, 아규먼트, 파라미터, 매개변수
출력값은 함수가 종료하면 호출된 쪽으로 값을 전달하는 것을 말한다.
출력값 : 리턴값
인수, 인자, argument :
- 함수로 전달되는 값을 말한다.
- 함수 호출 부분에 있다. e.g.) max(1,2), print('Hello')
매개변수, parameter :
- 함수 내부에서 함수로 전달된 값을 저장한 변수를 말한다.
- 함수 정의 부분에 있다.
e.g.)
def max(i, j):
:
:
함수의 종료 시점
- 함수안에 실행문들이 끝난 경우
- 함수에서 리턴문을 만난 경우
함수는 정의가 먼저 나오고 호출이 나중에 나온다.
함수 호출이 먼저 나오고 함수 정의가 뒤에 오면 에러가 발생된다.
~~PEP란 무엇인가 ?~~
~~https://jeongukjae.github.io/posts/pep1/~~
PEP 1번 문서
https://www.python.org/dev/peps/pep-0001/
함수 어노테이션
파이썬 3부터 추가된 기능으로 PEP 484로 정의되어 있다.
인수로 전달받은 매개변수의 자료형의 Hint를 추가하는 방법이다.
형식 :
어노테이션이 없는 경우 : def function(i, j):
어노테이션이 있는 경우 : def function(i:자료형, j:자료형) -> 리턴값의 자료형:
def function(i:int, j:int) -> int :
-- exFunction1.py --
"""
파일명 : exFunction1.py
프로그램 설명 : 함수 예제
작성자: 리눅스마스터넷
"""
# myfunction 함수를 만들어 보기
# myfunction 함수의 기능은 문자열 출력하는 것이다.
# 함수를 정의할 때 주의할 점은 이미 존재하는 함수나 클래스를 만들면 안된다.
# 순서: 함수 정의 -> 함수 호출 O
# 순서: 함수 호출 -> 함수 정의 X
# 1. 함수 정의 (함수 만들기)
def myfunction():
"""처음 만드는 함수"""
print('함수 실행!')
print('Hello function!')
# 2. 함수 호출 (함수 실행하기)
myfunction()
# 메모리 주소 확인하기
# 함수명은 메모리 주소다.
print(myfunction)
print(id(myfunction))
print(hex(id(myfunction)))
# 함수 호출
# 함수 호출은 메모리에 만들어진 함수로 점프해서 함수 안에 있는 실행문들을 실행하는 것이다.
myfunction()
myfunction() # 함수 재사용(재활용)
myfunction() # 함수 재사용(재활용)
print('프로그램 종료')
-- exFunction1.py --
-- 함수2.py --
"""
파일명 : 함수2.py
프로그램 설명 : 함수 예제
"""
# myfor 함수 정의
# 함수명 : myfor
# 매개변수 : 없음
# 리턴값 : 없음
# 함수 기능 : 1 ~ 5까지 출력
# 함수 정의
# def myfor():
# """myfor 함수입니다.""" # docstring
# listData = [1,2,3,4,5]
# for i in listData:
# print(i)
# else:
# print("for문 종료")
# # 함수 호출
# myfor()
# gugudan 함수 정의
# 함수명 : gugudan
# 매개변수 : 없음
# 리턴값 : 없음
# 함수 기능 : 구구단 2단 출력
# 함수 정의
def gugudan():
"""
매개변수 : 없음
리턴값 : 없음
함수 내용 : 구구단 2단 출력
"""
dan = 2
for i in range(1,10):
print(f"{dan}x{i}={dan*i} ", end='')
else:
print()
# 함수 호출
gugudan()
-- 함수2.py --
-- 함수3.py --
"""
파일명 : 함수3.py
프로그램 설명 : 함수 예제
"""
# 함수를 사용하지 않은 경우
# i = 1
# print(i)
# 함수를 사용한 경우
# function 함수 정의
# 함수명 : function
# 매개변수 : 없음
# 리턴값 : 없음
# 함수 기능 : i 변수에 1을 저장하고 출력한다.
# 함수 정의
def function():
i = 1
print(i)
# 함수 호출
function()
# 함수를 사용한 경우
# function 함수 정의
# 함수명 : function
# 매개변수 : i
# 리턴값 : 없음
# 함수 기능 : 매개변수 i 에 값을 받아서 저장하고 출력한다.
# 함수 정의
def function(i): # i = ?
print(i)
# 함수 호출
function(1) # i = 1
function(2) # i = 2
function(3) # i = 3
# 함수명 : f
# 매개변수 : x
# 리턴값 : y
# 기능 : x 에 5를 더해서 y 저장하고 이 값을
# 호출한 쪽으로 리턴(되돌려준다)한다.
# 1. 함수 정의
def f(x):
y = x + 5
return y
print(f(3)) # 8
print(f(10)) # 15
# 실습 : 아래 제시한 조건을 이용해서 함수를 작성하시오.
# 함수명 : gugudan
# 매개변수 : dan
# 리턴값 : 없음
# 기능 : dan으로 넘어온 값을 이용해서 구구단을 출력한다.
# 함수로 구현하면 2단 ~ 9단까지를 중첩 for문을 이용하지 않고 사용할 수 있다.
# 1. 함수 정의
def gugudan(dan):
for i in range(1,10):
print(f'{dan}x{i}={dan*i:<2} ', end='')
print()
# 2. 함수 호출
gugudan(2) # 2단 출력 : 2x1=2 2x2=4 ... 2x9=18
gugudan(3) # 3단 출력 : 3x1=3 3x2=6 ... 3x9=27
# 2단 ~ 9단까지 출력
for i in range(2,10):
gugudan(i)
print("프로그램 종료")
-- 함수3.py --
-- 함수4.py --
"""
파일명 : 함수4.py
프로그램 설명 : 4가지 유형의 함수 만들기 예제
"""
# 첫 번째 유형의 함수
# 첫 번째 유형의 함수명 : f1
# 매개변수 : 1개 있음
# - 매개변수명 : x
# 리턴값 : 있음
# - 리턴값 : y
# 기능 : 매개변수에 5를 더해서 호출한 쪽으로 돌려준다.
def f1(x):
y = x + 5
return y
# 함수 호출
# 리턴값이 있는 함수는
# 1. 변수로 받을 수 있다.
# 2. 함수로 받을 수 있다.
number = f1(3)
print(number) # 8
print(f1(3)) # 8
print(max(f1(3),2)) # 8
# 두 번째 유형의 함수
# 두 번째 유형의 함수명 : f2
# 매개변수 : 없음
# 리턴값 : 없음
# - 리턴값 : None을 리턴한다.
# 기능 : 화면에 8을 출력한다.
def f2():
print(8)
# 함수 호출
# 리턴값이 없는 함수는
# 1. 변수로 받으면 안된다. (받을 수도 있다.)
# 2. 함수로 받으면 안된다. (받을 수도 있다.)
# retValue = f2()
# print(retValue, type(retValue)) # None
f2()
# 세 번째 유형의 함수
# 세 번째 유형의 함수명 : f3
# 매개변수 : 1개 있음
# - 매개변수명 : x
# 리턴값 : 없음
# - 리턴값 : None을 리턴한다.
# 기능 : 매개변수에 5를 더해서 화면에 y를 출력한다.
def f3(x):
y = x + 5
print(y)
# 함수 호출
# 리턴값이 없는 함수는
# 1. 변수로 받으면 안된다.
# 2. 함수로 받으면 안된다.
f3(3) # 8
f3(10) # 15
# 네 번째 유형의 함수
# 네 번째 유형의 함수명 : f4
# 매개변수 : 없음
# 리턴값 : 있음
# - 리턴값 : y
# 기능 : y에 8을 저장한 후 y를 호출한 쪽으로 돌려준다.
def f4():
y = 3 + 5
return y
# 함수 호출
# 매개변수가 없는 함수는
# 함수 호출 시 값을 넘겨줄 수 없다.
# 리턴값이 있는 함수는
# 1. 변수로 받을 수 있다.
# 2. 함수로 받을 수 있다.
retValue = f4()
print(retValue) # 8
print(f4()) # 8
print(max(f4(), 3)) # 8
-- 함수4.py --
-- 함수5.py --
"""
파일명 : 함수5.py
프로그램 설명 : 함수 예제
"""
# 값을 더해주는 함수
# 인수 : 인수가 O
# 리턴값 : 리턴값 O
print(sum([1,2,3,4,5])) # 15
# 최대값을 구하는 함수
# 인수 : 인수가 O
# 리턴값 : 리턴값 O
print(max(1,5)) # 5
# 최소값을 구하는 함수
# 인수 : 인수가 O
# 리턴값 : 리턴값 O
print(min(1,5)) # 1
# 문자열의 개수를 출력하는 함수
# 인수 : 인수가 O
# 리턴값 : 리턴값 O
print(len("Hello python!")) # 13
# 화면에 출력하는 함수
# 인수 : 인수가 O
# 리턴값 : 리턴값 X
print(print("Hello")) # None
# 함수 구현하기
# 최대값을 구하는 사용자 함수
# 함수명 : mymax
# 매개변수 : 있음
# - i : 첫 번째 인수를 저장할 매개변수
# - j : 두 번째 인수를 저장할 매개변수
# 리턴값 : 있음
# - 가장 큰수를 리턴한다.
# 함수 기능 : 매개변수로 들어온 두 수를 비교해서 가장 큰 수를 리턴한다.
# 함수 호출 :
# print(mymax(1,5)) # 5
# print(mymax(10,5)) # 10
def mymax(i, j):
"""최대값을 구하는 함수"""
if i > j:
return i
else:
return j
print(mymax(1,5)) # 5
print(mymax(10,5)) # 10
# 최소값을 구하는 사용자 함수
# 함수명 : mymin
# 매개변수 : 있음
# - i : 첫 번째 인수를 저장할 매개변수
# - j : 두 번째 인수를 저장할 매개변수
# 리턴값 : 있음
# - 가장 작은수를 리턴한다.
# 함수 기능 : 매개변수로 들어온 두 수를 비교해서 가장 작은 수를 리턴한다.
# 함수 호출 :
# print(mymin(10,5)) # 5
# print(mymin(1,5)) # 1
def mymin(i, j):
"""최소값을 구하는 함수"""
# if i > j:
# return j
# else:
# return i
# if i > j:
# result = j
# else:
# result = i
# result = j if i > j else i
# return result
return j if i > j else i
print(mymin(10,5)) # 5
print(mymin(1,5)) # 1
# 문자열의 길이를 구하는 사용자 함수
# 함수명 : mylen
# 매개변수 : 있음
# - a : 첫 번째 인수를 저장할 매개변수
# 리턴값 : 있음
# - 인수로 들어온 문자열의 길이를 리턴한다.
# 함수 기능 : 인수로 들어온 문자열의 값의 길이를 구해서 리턴한다.
# 조건 : mylen 함수 안에서 len()함수는 사용하지 않고 직접 구현한다.
# 함수 호출 :
# print(mylen("Hello python!")) # 13
# print(mylen("Hello")) # 5
def mylen(a):
"""문자열의 개수를 구하는 함수"""
count = 0
for c in a: # 문자열을 반복해서
count += 1 # 개수를 구한다.
return count # 개수를 구한 값을 리턴한다.
print(mylen("Hello python!")) # 13
print(mylen("Hello")) # 5
# 함수명 : mysum
# 매개변수 : 있음
# - a : 첫 번째 인수를 저장할 매개변수
# 리턴값 : 있음
# - 매개변수로 들어온 숫자의 합을 리턴한다.
# 함수 기능 : 매개변수로 들어온 숫자를 모두 더해서 리턴한다.
# 함수 호출 : print(mysum([1,2,3,4,5])) # 15
# 함수 호출 : print(mysum([1,2,3,4,5,6,7,8,9,10])) # 55
# 함수 호출 : print(mysum(range(1,11))) # 55
def mysum(a):
"""숫자의 총합계를 구하는 함수"""
# for 문을 이용해서 값을 모두 누적시키고 그 결과값을 돌려준다.
# print(a, type(a))
hap = 0
for i in a: # 리스트 a의 원소를 하나씩 i변수에 저장한다.
hap += i # hap = hap + i hap 변수에 누적시킨다.
return hap # 총합계를 호출한 쪽으로 되돌려준다.
print(mysum([1,2,3,4,5])) # 15
print(mysum([i for i in range(1,11)])) # 55
print(mysum(range(1,11))) # 55
-- 함수5.py --
-- 함수6.py --
"""
파일명 : 함수6.py
프로그램 설명 : 함수 예제
"""
# 함수 정의
# 함수명 : jumsu
# 매개변수 : 없음
# 리턴값 : 없음
# 함수 내용 : 점수를 입력받아서 출력한다.
"""
파일명 : jumsu1.py
프로그램 설명 : 성적처리 프로그램 예제 1 (정수 자료형을 이용한 형태)
"""
# 1. 점수 입력
print("점수를 입력하세요.")
kor = input("국어 점수 : ")
eng = input("영어 점수 : ")
math = input("수학 점수 : ")
# 2. 점수 체크
kor = int(kor) if kor.isdigit() else 0
eng = int(eng) if eng.isdigit() else 0
math = int(math) if math.isdigit() else 0
# 3. 점수 계산
#total = kor + eng + math # 총점
total = sum([kor, eng, math]) # 총점
average = total / 3 # 평균
# 4. 점수 출력
print("\n===== 점수의 결과 =====\n"
f"국어 점수 : {kor}\n"
f"영어 점수 : {eng}\n"
f"수학 점수 : {math}\n"
f"총점 : {total}\n"
f"평균 : {average:.2f}\n"
"===== 점수의 결과 =====")
-- 함수6.py --
함수로 변환한 프로그램은 아래와 같다.
-- 함수6.py --
"""
파일명 : 함수6.py
프로그램 설명 : 함수로 구현한 성적처리 프로그램
"""
# 함수 정의
def jumsu():
"""
함수명 : jumsu
매개변수 : 없음
리턴값 : 없음
함수 내용 : 점수를 입력받아서 출력한다.
"""
# 1. 점수 입력
print("점수를 입력하세요.")
kor = input("국어 점수 : ")
eng = input("영어 점수 : ")
math = input("수학 점수 : ")
# 2. 점수 체크
kor = int(kor) if kor.isdigit() else 0
eng = int(eng) if eng.isdigit() else 0
math = int(math) if math.isdigit() else 0
# 3. 점수 계산
#total = kor + eng + math # 총점
total = sum([kor, eng, math]) # 총점
average = total / 3 # 평균
# 4. 점수 출력
print("\n===== 점수의 결과 =====\n"
f"국어 점수 : {kor}\n"
f"영어 점수 : {eng}\n"
f"수학 점수 : {math}\n"
f"총점 : {total}\n"
f"평균 : {average:.2f}\n"
"===== 점수의 결과 =====")
# 함수 호출
# jumsu()
count = input('학생수 : ')
count = int(count) if count.isdigit() else 1
for i in range(1, count+1):
print(f'{i} 번째 학생 점수 :')
jumsu() # 함수 재사용
print()
print("프로그램 종료")
-- 함수6.py --
PEP 1번 문서
참고 : https://www.python.org/dev/peps/pep-0001/
함수 어노테이션 (29-Sep-2014)
파이썬 3.5부터 추가된 기능으로 PEP 484로 정의되어 있다.
인수로 전달받은 매개변수의 자료형의 Hint를 추가하는 방법이다.
형식 :
어노테이션이 없는 경우 : def function(i, j):
어노테이션이 있는 경우 : def function(i:자료형, j:자료형) -> 리턴값의 자료형:
def function(i:int, j:int) -> int :
-- 함수7.py --
"""
파일명 : 함수7.py
프로그램 설명 : 함수 예제
"""
# 함수 호출 시 매개변수로 받고 자료형을 확인한다.
# 함수가 끝나면 받은 자료를 리턴하고 자료형을 확인한다.
# 결론 : 파이썬에서는 자료를 주고(입력값) 받는(출력값) 것이 자유롭다.
# 함수 어노테이션
# 파이썬 3부터 추가된 기능으로 PEP 484로 정의되어 있다.
# 인수로 전달받은 매개변수의 자료형의 Hint를 추가하는 방법이다.
# 형식 :
# 어노테이션이 없는 경우 : def function(i, j):
# 어노테이션이 있는 경우 : def function(i:자료형, j:자료형) -> 리턴값의 자료형:
# def function(i:int, j:int) -> int :
# 정수
# def func1(a):
def func1(a:int) -> int:
"""정수 """
print(a, type(a)) # 1 <class 'int'>
return a
print(func1(1)) # 1
# 실수
# def func2(a):
def func2(a:float) -> float:
"""실수 """
print(a, type(a)) # 3.14 <class 'float'>
return a
print(func2(3.14)) # 3.14
# 문자열
# def func3(a):
def func3(a:str) -> str:
"""문자열 """
print(a, type(a)) # Hello Python! <class 'str'>
return a
print(func3("Hello Python!")) # Hello Python!
# 리스트
# def func4(a):
def func4(a:list) -> list:
"""리스트 """
print(a, type(a)) # [1, 2, 3, 4, 5] <class 'list'>
return a
print(func4([1,2,3,4,5])) # [1, 2, 3, 4, 5]
# 튜플
# def func5(a):
def func5(a:tuple) -> tuple:
"""튜플 """
print(a, type(a)) # (10, 20, 30) <class 'tuple'>
return a
print(func5((10,20,30))) # (10, 20, 30)
# 딕셔너리
# def func6(a):
def func6(a:dict) -> dict:
"""딕셔너리 """
print(a, type(a)) # {'a': 1, 'b': 2} <class 'dict'>
return a
print(func6({'a':1, 'b':2})) # {'a': 1, 'b': 2}
# 셋
# def func7(a):
def func7(a:set) -> set:
"""셋"""
print(a, type(a)) # {1, 2, 3} <class 'set'>
return a
print(func7({1,2,3})) # {1, 2, 3}
# 불리언
# def func8(a):
def func8(a:bool) -> bool:
"""불리언"""
print(a, type(a)) # True <class 'bool'>
return a
print(func8(True)) # True
-- 함수7.py --
-- 함수8.py --
"""
파일명 : 함수8.py
프로그램 설명 : 함수에서 다양한 리턴값을 전달하는 방법 예제
"""
# 사용자 함수 정의
# 형식 :
# def 함수명(매개변수):
# 실행문
# :
# return 리턴값
#
# 사용자 함수 호출
# 형식 :
# 변수 = 함수명(인수)
# 함수(함수명(인수))
# 함수 정의
def function():
return True # True <class 'bool'>
return {'a':1, 'b':2, 'c':3, 'd':4, 'e':5} # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5} <class 'dict'>
return {1,2,3,4,5} # {1, 2, 3, 4, 5} <class 'set'>
return (1,2,3,4,5) # (1, 2, 3, 4, 5) <class 'tuple'>
return [1,2,3,4,5] # [1, 2, 3, 4, 5] <class 'list'>
return 3.14 # 3.14 <class 'float'>
return 1 # 1 <class 'int'>
# 함수 호출
# 리턴값을 변수로 받은 경우
# 다른 곳에서 retValue 변수에 저장값을 다시 활용하고자 할 경우에 사용한다.
retValue = function()
print(retValue, type(retValue))
# 리턴값을 함수로 받은 경우
# 다른 곳에서 retValue 변수에 저장값을 활용하지 않을 때 사용한다.
# print(function(), type(function()))
-- 함수8.py --
-- 함수8.py --
"""
파일명 : 함수8.py
프로그램 설명 : 다양한 리턴값을 전달하는 방법에 대한 예제
"""
# 사용자 함수 정의
# 형식 :
# def 함수명(매개변수):
# 실행문
# :
# return 리턴값
#
# 사용자 함수 호출
# 형식 :
# 함수명(인수)
# 함수 정의
def functionTest1():
"""정수 자료형을 리턴하는 경우"""
return 1
def functionTest2():
"""실수 자료형을 리턴하는 경우"""
return 3.14
def functionTest3():
"""리스트 자료형을 리턴하는 경우"""
return [1,2,3,4,5]
def functionTest4():
"""튜플 자료형을 리턴하는 경우"""
return (1,2,3,4,5)
# return 1,2,3,4,5
def functionTest5():
"""딕셔너리 자료형을 리턴하는 경우"""
return {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
def functionTest6():
"""셋 자료형을 리턴하는 경우"""
return {1, 2, 3, 4, 5}
def functionTest7():
"""불리언 자료형을 리턴하는 경우"""
return True
# 함수 호출
# 리턴값을 변수로 받은 경우
# 다른 곳에서 a 변수에 저장값을 다시 활용하고자 할 경우에 사용한다.
a = functionTest1() # 정수 자료형을 리턴받는 경우
print(a, type(a)) # 1 <class 'int'>
# 리턴값을 함수로 받은 경우
# 다른 곳에서 a 변수에 저장값을 활용하지 않을 때 사용한다.
print(functionTest1(), type(functionTest1()))
a = functionTest2() # 실수 자료형을 리턴받는 경우
print(a, type(a)) # 3.14 <class 'float'>
a = functionTest3() # 리스트 자료형을 리턴받는 경우
print(a, type(a)) # [1, 2, 3, 4, 5] <class 'list'>
a = functionTest4() # 튜플 자료형을 리턴받는 경우
print(a, type(a)) # (1, 2, 3, 4, 5) <class 'tuple'>
a = functionTest5() # 딕셔너리 자료형을 리턴받는 경우
print(a, type(a)) # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5} <class 'dict'>
a = functionTest6() # 셋 자료형을 리턴받는 경우
print(a, type(a)) # {1, 2, 3, 4, 5} <class 'set'>
a = functionTest7() # 불리언 자료형을 리턴받는 경우
print(a, type(a)) # True <class 'bool'>
-- 함수8.py --
-- 함수9.py --
"""
파일명 : 함수9.py
프로그램 설명 : 여러 개의 인수가 있는 함수 예제
"""
# 여러 개의 인수가 있는 경우
# 관례상 매개변수명은 arguments의 약자인 *args로 받는다.
# 형식 :
# 함수 정의 부분 : def functionArgs(*args):
# 함수 호출 부분 : functionArgs(1,2,3,4,5)
# 함수 호출 부분 : functionArgs(1,2,3)
# 함수 호출 부분 : functionArgs("Hello",1,2,3)
# 함수 정의
def functionArgs(*args):
"""args는 들어온 인수를 묶어서 받는 매개변수"""
print(args, type(args))
# 함수 호출
functionArgs(1,2,3,4,5) # (1, 2, 3, 4, 5) <class 'tuple'>
functionArgs(1,2,3) # (1, 2, 3) <class 'tuple'>
functionArgs("Hello",1.2,2,3) # ('Hello', 1.2, 2, 3) <class 'tuple'>
print()
# 여러 개의 리턴값이 있는 경우
def functionReturn1(*args):
return args[0], args[1], args[2]
# 함수 호출
# 변수 하나로 받으면 튜플 자료형으로 받는다.
a1 = functionReturn1(1,2,3)
print(a1, type(a1)) # (1, 2, 3) <class 'tuple'>
# 변수를 여러 개 풀어서 받으면 각각의 자료형으로 받는다.
a1, a2, a3 = functionReturn1(1,2,3)
print(a1, a2, a3) # 1 2 3
print(type(a1), type(a2), type(a3)) # <class 'int'> <class 'int'> <class 'int'>
# 리턴 개수와 다르게 받는 방법으로 전달 받는다.
# a1, a2 = functionReturn1(1,2,3) 에러
a1, *a2 = functionReturn1(1,2,3)
print(a1) # 1
print(a2) # [2, 3]
*a1, a2 = functionReturn1(1,2,3)
print(a1) # [1, 2]
print(a2) # 3
-- 함수9.py --
-- 함수10.py --
"""
파일명 : 함수10.py
프로그램 설명 : 함수에서 여러 개의 리턴을 하는 방법
"""
# 함수 정의
# 여러 개의 리턴값이 있는 경우
def f():
return 1, 2, 3 # (1, 2, 3) <class 'tuple'>
# 함수 호출
# 리턴값을 변수 하나로 받는 경우
a1 = f()
print(a1, type(a1)) # (1, 2, 3) <class 'tuple'>
# 리턴값을 변수 여러 개로 받는 경우
# 변수의 개수와 동일하게 맞추면 각각의 자료형으로 받는다.
a1, a2, a3 = f()
print(a1, a2, a3) # 1 2 3
print(type(a1), type(a2), type(a3)) # <class 'int'> <class 'int'> <class 'int'>
# 리턴 개수와 다르게 받는 방법은 *변수명으로 받는다.
# *변수명 으로 받으면 자료형은 리스트가 된다.
# a1, a2 = f() # 에러
a1, *a2 = f()
print(f'a1 : {a1}, a2 : {a2}') # a1 : 1, a2 : [2, 3]
*a1, a2 = f()
print(f'a1 : {a1}, a2 : {a2}') # a1 : [1, 2], a2 : 3
-- 함수10.py --
-- 함수11.py --
"""
파일명 : 함수11.py
프로그램 설명 : 함수에서 여러 개의 인수가 있는 방법 2
"""
# * (별 한개)가 오면 매개변수의 자료형은 튜플이 된다.
# def function(*args):
# print(args, type(args))
# function(1,2,3,4,5)
# tupleData = (1,2,3,4,5)
# function(*tupleData)
# function([1,2,3,4,5]) # ([1, 2, 3, 4, 5],) <class 'tuple'>
# ** (별 두개)가 오면 매개변수의 자료형은 딕셔너리가 된다.
# 별 두개로 받을 경우는 변수명은 관례상 keyword arguments의 약자인 kwargs로 사용한다.
# 함수 정의 형식 : def 함수명(**kwargs):
# 함수 호출 형식 1 : 함수명(키=값) *** 키에는 따옴표가 없어야 한다. ***
# 함수 호출 형식 2 : 함수명(**변수명)
def function(**kwargs):
print(kwargs, type(kwargs))
# function(1,2,3,4,5) 에러
function(a=1) # {'a': 1} <class 'dict'>
# {'name': '홍길동', 'age': 30, 'phone': '010-1111-2222'} <class 'dict'>
function(name='홍길동',age=30, phone='010-1111-2222')
student = {'name':'홍길동','age':30,'phone':'010-2222-3333'}
function(**student)
# 패킹(packing), 언패킹(unpacking)
# 패킹은 싸다라는 의미를 가지고 있다.
# 언패킹 풀다라는 의미를 가지고 있다.
# * 시퀀스 패킹/언패킹 연산자
# 패킹 예
# packing : 함수를 호출할 때 여러 개의 인수 값을 한번에 묶어서 받는다.
# 함수의 매개변수에 *을 붙히면 패킹이 발생되며
# 매개변수 args에 값 1,2,3,4,5 가 묶어서 저장된다.
def myPacking(*args):
print(args, type(args)) # (1, 2, 3, 4, 5) <class 'tuple'>
for a in args:
print(a)
myPacking(1,2,3,4,5)
# 언패킹 예
# unpacking : 함수를 호출할 때 인수에 *을 붙히면 언패킹이 발생된다.
# 인수를 풀어서 함수로 넘기므로 함수의 매개변수
# a와 b에 각각의 값 1, 2가 저장된다.
def myUnPacking(a, b):
print(a, b, type(a), type(b))
# myUnPacking([1,2]) # 에러
myUnPacking(*[1,2]) # 1 2 <class 'int'> <class 'int'>
-- 함수11.py --
-- 함수12.py --
"""
파일명 : 함수12.py
프로그램 설명 : 함수의 디폴트 인수 예제
"""
# 디폴트 값 (default argument)
# 기본 값은 함수를 호출할 때 인수를 전달하지 않으면
# 함수에서 인수가 없을 때 기본값으로 설정된 값을 세팅한다.
# 조건 : 기본값은 오른쪽에서 왼쪽으로 설정한다.
# 기본값의 오른쪽의 변수가 설정되지 않으면 왼쪽의 변수를 설정할 수 없다.
# 함수 호출 시 인수를 전달하지 않으면 변수의 값은
# 기본값으로 초기화된다.
# def f(a=3, b=10, c=20): # o
# def f(a, b=10, c): # x
# def f(a=3, b, c=20): # x
# def f(a, b=10, c=20): # o
def f(a=3, b=10, c=20): # o
print(a,b,c)
f() # 3 10 20
f(1) # 1 10 20
f(1, 2) # 1 2 20
f(1, 2, 3) # 1 2 3
def function(a = 10, b = 20, c = 30):
print(a,b,c)
function(3) # ?
function(c = 3) # ?
# positional arguments :
# 함수를 호출할 때 인수값을 순서대로 전달하는 방식
f(1, 2, 3) # 1 2 3
# keyword arguments :
# 함수를 호출할 때 인수값을 순서대로 저장하는 방식이 아니라
# 변수의 이름으로 값을 전달하는 방식
# 조건은 변수명이 동일해야 한다.
# 형식 : 함수명(변수명=값)
# def f(a=3, b=10, c=20): # o
# def f(**kwargs): # o
# print(kwargs)
def f(a,b,c): # o
print(a,b,c)
# 순서에 상관이 없다.
f(c=3, a=1, b=2) # 1 2 3
f(a=1, b=2, c=3) # 1 2 3
f(b=2, a=1, c=3) # 1 2 3
f(b=2, c=3, a=1) # 1 2 3
# positional 과 keyword arguments를 섞어서 사용하는 경우의
# 대표적인 함수는 print() 함수이다.
# 주의할 점은 keyword arguments가 먼저오면 에러가 발생한다.
# https://docs.python.org/3/library/functions.html#print
def f(*args, a=1,b=2,c=3): # o
print(args, a, b, c)
f(10,20,30) # (10, 20, 30) 1 2 3
# f(10,20,30, a=1, b=2, c=3)
# f(10,20,30, a=11, c=31, b=21) # (10, 20, 30) 11 21 31
# f(a=1, 10,20,30, b=2, c=3) # 에러 x
print(1,2,3,sep='-------') # o
# print(sep='-------',1,2,3) # 에러 x
-- 함수12.py --
전역 변수 & 지역 변수
전역 변수 : 모든 함수에서 사용할 수 있는 변수
지역 변수 : 함수 내에서만 사용하는 변수
전역 변수 지역 변수
함수 안에서 읽기 O O
함수 안에서 쓰기 X (global 키워드를 이용하면 O) O
함수 밖에서 읽기 O X
함수 밖에서 쓰기 O X
a = 1
def func1():
global b
a = 30
b = 20
print(a)
func1() # 30
print(a) # 1
print(b) # 20
함수 내부에서
변수를 선언하고 값을 저장하면 지역변수로 만들어진다.
외부의 전역변수를 참조할(읽을) 수 있다.
외부의 전역변수의 값을 변경할 수 없다.
외부의 전역변수의 값을 변경하기 위해서는 global 키워드를 사용하면 가능하다.
외부의 전역변수의 값을 생성할 수 있다. (global 키워드를 사용하면 __main__ 영역에 없는 변수를 만든다.)
지역 변수는 함수가 시작되면 생성되고 함수가 종료하면 모두 사라진다. (지역변수는 메모리의 스택에 저장되어 있다. )
-- 함수13.py --
"""
파일명 : 함수13.py
프로그램 설명 : 함수 예제
"""
value = 1
print(value, id(value))
# 함수 내부에서 전역변수 읽기 테스트
# def printValue():
# # 함수 내부에서 전역변수 value에 접근할 수 있다.
# # r(읽기) 가능하다.
# print(value, id(value)) # 1
# printValue()
# 함수 내부에서 쓰기 테스트 (global x)
# def changeValue1():
# value = 10
# print(value, id(value))
# changeValue1()
# 함수 내부에서 쓰기 테스트 (global o)
# def changeValue2():
# global value # 전역 변수를 쓸 수 있게 설정한다.
# print(value, id(value))
# value += 100
# print(value, id(value))
# # 함수 내부에서 전역변수 value에 접근해서 값을 수정한다.
# changeValue2()
# print(value) # 101
# 함수 외부에 변수 생성 테스트
# def func1():
# global value2 # 전역 변수 value2를 생성한다.
# value2 = 200
# print(value2, id(value2))
# func1()
# print(value2) # 200
# 함수 외부에서 함수 내부의 변수 접근 테스트
# def func2():
# value3 = 300 # 지역 변수 value3
# print(value3, id(value3))
# func2()
# NameError: name 'value3' is not defined
# print(value3)
# print(__name__)
def func3():
print(__name__)
func3()
print('프로그램 종료')
-- 함수13.py --
-- 함수14.py --
"""
파일명 : 함수14.py
프로그램 설명 : 함수 예제
"""
# 전역 변수 지역 변수
# 함수 안에서 읽기 O O
# 함수 안에서 쓰기 X (global 키워드를 이용하면 O) O
# 함수 밖에서 읽기 O X
# 함수 밖에서 쓰기 O X
a = 1 # 전역 변수
b = 2 # 전역 변수
# f1() 함수 정의
def f1():
a = 2 # 지역변수
print(a) # 지역변수 a를 출력하므로 2가 출력된다.
# f1()
# f2() 함수 정의
def f2():
# a += 3 # 에러, 전역변수 a를 그냥 수정할 수 없다.
print(a + 3)
# f2()
# f3() 함수 정의
def f3():
# 함수 내부에 변수 a가 없으므로 밖에 있는 변수인
# 전역변수를 참고한다.
# 전역변수는 읽기가 가능하므로 1이 출력된다.
print(a)
# f3()
# f4() 함수 정의
def f4():
# 전역변수 a를 함수 내부에서 수정한다는 의미
global a
a += 5 # a = a + 5
print(a)
print(a) # 1
f4() # 6
print(a) # 6
# f5() 함수 정의
def f5():
global a # 전역변수 a를 수정할 수 있게 설정한다.
global c # 전역변수 c를 생성한다.
c = 10 # 10
a += 1 # 7
f5()
print(a, c) # 7 10
# f6() 함수 정의
def f6():
# __main__ <class 'str'>
print(__name__, type(__name__))
if __name__ == '__main__':
f6()
-- 함수14.py --
-- 함수15.py --
"""
파일명 : 함수15.py
프로그램 설명 : 함수 안에 저장된 지역변수를 함수 밖에서 인식하기 위한 방법
"""
# 두 가지가 존재한다.
# 첫 번째 방법 : 변수를 리턴한다. (추천o)
# 두 번째 방법 : global을 이용한다. (추천x)
# 첫 번째 방법
def function():
a = 1
b = 2
# 리턴 : 지역변수의 값을 global 영역으로 빼내기 위한 방법
return a,b
a,b = function()
print(a, b)
# 두 번째 방법
def function2():
# global : 지역변수의 값을 global 영역으로 빼내기 위한 방법
global c,d
c = 3
d = 4
function2()
print(c, d)
-- 함수15.py --
함수 안에 함수 넣기
-- 함수16.py --
"""
파일명 : 함수16.py
프로그램 설명 : 함수 안에 함수 넣기 예제
"""
# 1. 함수 정의
def funcOut():
print("funcOut() 함수 실행")
# 3. 함수 정의
def funcIn1():
print("funcIn1() 함수 실행")
def funcIn2():
print("funcIn2() 함수 실행")
# 4. 함수 호출
funcIn1() # funcOut() 함수 안에서 호출해야 한다.
funcIn2()
# 2. 함수 호출
funcOut()
# 함수 안에 있는 함수는 함수 밖에서 직접 호출은 안된다.
# funcIn2() # funcOut() 함수 안에서 호출해야 한다.
-- 함수16.py --
-- 함수17.py --
"""
파일명 : 함수17.py
프로그램 설명 : 람다 함수
"""
# 람다 함수는 함수의 이름이 없는 익명함수이다.
# 간단히 사용할 때 사용하는 함수다.
# 형식 :
# lambda 인수리스트 : 표현식
# 함수를 정의한 것
def lambdaTest(x):
return x * 2
print(lambdaTest(2)) # 4
# lambda 인수리스트 : 표현식
# 1. lambdaTest() 함수를 한 줄로 연결한다.
# 2. retrun을 삭제한다.
# 3. 괄호를 삭제한다.
# 4. def lambdaTest 함수명을 삭제하고 함수명을 lambda로 수정한다.
# 5. 변수에 저장한다.
# 함수를 간략히 표현한 것( 람다 함수, 람다 표현식)
lambdaTest = lambda x : x * 2
print(lambdaTest(2)) # 4
print(lambdaTest(10)) # 20
# a = []
# for i in [1,2,3,4,5]:
# a.append(i)
# for문을 간략히 표현한 것(리스트 컴프리헨션)
# a = [i for i in [1,2,3,4,5]]
# number = input("숫자 : ")
# if number.isdigit():
# number = int(number)
# else:
# number = 0
# if ~ else문을 간단히 표현한 표현식 (삼항 연산자)
# number = int(number) if number.isdigit() else 0
-- 함수17.py --
def lambdaTest():
return 1
>>> lambda:1
<function <lambda> at 0x0000012EB603E9D0>
>>> f1 = lambda:1
>>> f1
<function <lambda> at 0x0000012EB603E940>
>>> f1()
1
def lambdaTest(a):
return a + 1
인수 1개를 받아서 1을 더해서 리턴해주는 람다 함수
>>> lambda a: a + 1
<function <lambda> at 0x0000012EB5B5E040>
>>> f2 = lambda a: a + 1
>>> f2
<function <lambda> at 0x0000012EB603E9D0>
>>> f2(1)
2
>>> print(f2(1))
2
>>> print(max(f2(1), 1))
2
def lambdaTest(a,b):
return a + b
인수 2개를 받아서 두 개의 매개변수를 더해서 리턴해주는 람다 함수
>>> lambda a,b: a + b
<function <lambda> at 0x0000012EB5B5E040>
>>> f3 = lambda a,b: a + b
>>> f3
<function <lambda> at 0x0000012EB603E550>
>>> f3(10,20)
30
>>> f3(100,200)
300
>>> print(f3(10,20))
30
>>> print(min(f3(10,20), 5))
5
인수 여러 개를 받아서 받은 값 전체를 리턴해주는 람다 함수
함수명 : f4
ex) f4(1,2,3,4,5), f4(1,2,3)
>>> lambda *args: args
<function <lambda> at 0x0000012EB5B5E040>
>>> f4 = lambda *args: args
>>> f4
<function <lambda> at 0x0000012EB603E790>
>>> f4(1,2,3,4,5)
(1, 2, 3, 4, 5)
>>> f4(1,2,3)
(1, 2, 3)
람다 함수는 리스트에도 저장할 수 있다.
참고로 리스트 안에는 람다함수만 넣을 수 있고 일반 함수는 넣을 수 없다.
>>> f5 = [lambda a,b:a+b, lambda a,b:a-b]
>>> f5
[<function <lambda> at 0x0000012EB5B5E040>, <function <lambda> at 0x0000012EB603E670>]
>>> f5[0]
<function <lambda> at 0x0000012EB5B5E040>
>>> f5[0](20,10)
30
>>> f5[1](20,10)
10
-- 함수18.py --
"""
파일명 : 함수18.py
프로그램 설명 : 람다 함수
"""
# 람다 함수는 함수의 이름이 없는 익명함수이다.
# 간단히 사용할 때 사용하는 함수다.
# 형식 :
# lambda 인수리스트 : 표현식
# 함수 정의
# def function(x):
# return x * 2
# 함수 호출
# print(function(2)) # 4
# print(function(10)) # 20
# lambda 인수리스트 : 표현식
# 1. function() 함수를 한 줄로 연결한다.
# 2. retrun을 삭제한다.
# 3. 괄호를 삭제한다.
# 4. function 함수명을 삭제하고 함수명을 lambda로 수정한다.
# 5. def 를 삭제한다.
# 6. 변수에 저장한다.
# 함수 정의
# def function(x):
# return x * 2
# function = lambda x: x * 2
# 함수 호출
# print(function(2)) # 4
# print(function(10)) # 20
# 함수를 간략히 표현한 것(람다 함수, 람다 표현식)
# 인수 2개를 받아서 두 개의 매개변수를 더해서
# 리턴해주는 람다 함수
# def function(a,b):
# return a + b
# function = lambda a,b: a + b
# print(function(3,5))
# 인수 여러 개를 받아서 받은 값 전체를 리턴해주는 람다 함수
# def function(*args):
# return args
# function = lambda *args : args
# print(function(1,2,3,4,5))
# 람다 함수는 리스트에도 저장할 수 있다.
# 참고로 리스트 안에는 람다 함수만 넣을 수 있고
# 일반 함수는 넣을 수 없다.
# def plus(a,b): return a + b
# listFunction = [def plus(a,b): return a + b] # 에러
# def minus(a,b): return a - b
minus = lambda a,b: a - b
print(minus(10,5)) # 5
listFunction = [lambda a,b: a + b, lambda a,b: a - b]
print(listFunction[0](1,2)) # 3
print(listFunction[0](10,20)) # 30
print(listFunction[1](10,5)) # 5
-- 함수18.py --
-- 이전함수18.py --
"""
파일명 : 함수18.py
프로그램 설명 : 람다 함수
"""
# 인수가 없고 1을 리턴하는 람다 함수
f1 = lambda:1
print(f1) # <function <lambda> at 0x000001D5FA09B550>
print(f1()) # 1
# 인수 1개를 받아서 1을 더해서 리턴해주는 람다 함수
f2 = lambda a: a + 1
print(f2) # <function <lambda> at 0x0000020D5FC0B670>
print(f2(1)) # 2
# 인수 2개를 받아서 두 개의 매개변수를 더해서 리턴해주는 람다 함수
f3 = lambda a,b: a + b
print(f3) # <function <lambda> at 0x000001EE941BB700>
print(f3(10,20)) # 30
# 인수 여러 개를 받아서 받은 값 전체를 리턴해주는 람다 함수
# 함수명 : f4
# ex) f4(1,2,3,4,5), f4(1,2,3)
f4 = lambda *args: args
print(f4) # <function <lambda> at 0x000002775A0AB790>
print(f4(1,2,3,4,5)) # (1, 2, 3, 4, 5)
print(f4(1,2,3)) # (1, 2, 3)
# 람다 함수를 리스트 저장할 수 있다.
f5 = [lambda a,b:a+b, lambda a,b:a-b]
print(f5[0]) # <function <lambda> at 0x000002027D27B820>
print(f5[1]) # <function <lambda> at 0x000002027D27B8B0>
print(f5[0](20,10)) # 30
print(f5[1](20,10)) # 10
-- 이전함수18.py --
-- mymax.py --
"""
파일명 : mymax.py
프로그램 설명 : max 함수 구현하기 2
"""
# max 함수 구현하기
# 함수명 : mymax
# 매개변수 : 있음
# - 매개변수명 : args
# 리턴값 : 있음
# - 가장 큰 수를 리턴한다.
# 기능 : 매개변수로 들어온 전체 수를 비교해서 가장 큰 수를 리턴한다.
# 함수 호출
# print(mymax(1,5,3)) # 5
# print(mymax(1,5,3,4,15)) # 15
# print(mymax(1,10,9,8,300,6,20)) # 300
def mymax(*args):
"""최대값을 구하는 함수"""
retValue = 0
for i in args: # (1,5,3)
if i > retValue:
retValue = i
return retValue
print(mymax(1,5,3)) # 5
print(mymax(1,5,3,4,15)) # 15
print(mymax(1,10,9,8,300,6,20)) # 300
-- mymax.py --
문자열 관련 함수
파이썬 문자열 변환(변경)
upper() - 대문자로 변경
lower() - 소문자로 변경
swapcase() - 대문자는 소문자로, 소문자는 대문자로 변경
capitalize() - 첫 문자를 대문자로 변경
title() - 각 단어의 첫 글자를 대문자로 변경
strip() - 문자열 양쪽 끝을 자른다. 제거할 문자를 인자로 전달 (디폴트는 공백)
lstrip() - 문자열 왼쪽을 자름
rstrip() - 문자열 오른쪽을 자름
replace() - 문자열 특정 부분을 변경 (대체)
format() - 틀(포맷)을 만들어 놓고 문자열을 생성
join() - 리스트 같은 iterable 인자를 전달하여 문자열로 연결
파이썬 문자열 정렬
center() - 문자열 가운데 정렬. (인자로 넓이를 지정, 채울 문자 선택 가능)
ljust() - 문자열 왼쪽 정렬
rjust() - 문자열 오늘쪽 정렬
파이썬 문자열 분리(나누기)
partition() - 전달한 문자로 문자열을 나눔(분리), 결과는 튜플(구분자도 포함)
rpartition() - 뒤에서 부터 전달한 인자로 문자열을 나눔
split() - 전달한 문자로 문자열을 나눔, 결과는 리스트(구분자 포함 안됨)
rsplit() - 뒤에서 부터 전달한 문자로 문자열을 나눔
splitlines() - 라인 단위로 문자열을 나눔
문자열 판단
is로 시작하는 메소드(함수)의 결과는 bool(True, False)이다.
isdecimal, isdigit, isnumeric 메소드로 숫자인지 평가할 수 있다. (거의 비슷함)
isalnum() - 알파벳 또는 숫자인가?
isalpha() - 알파벳인가?
isdecimal() - 숫자(decimal, 10진수)인가?
isdigit() - 숫자(digit, 10진수)인가?
isidentifier() - 식별자로 사용 가능한가?
islower() - 소문자인가?
isnumeric() - 숫자인가?
isspace() - 공백인가?
istitle() - title 형식인가? (단어마다 첫 글자가 대문자인가?)
isupper() - 대문자인가?
문자열 메소드(함수) 형식 :
문자열.메소드명()
변수명.메소드명()
>>> "123".isalnum()
True
>>> "@@@".isalnum()
False
>>> "Hello".isalnum()
True
>>> "Hello".isalpha()
True
>>> "123".isalpha()
False
>>> "한글".isalpha()
True
>>> "HELLO".islower()
False
>>> "hello".islower()
True
>>> "hello".isupper()
False
문자열 확인
count() - 특정 단어(문자열)의 수를 구함 (없으면 0을 반환)
(문자열의 글자수는 len함수를 사용하여 구한다.)
startswith() - 특정 단어로 시작하는지 확인
endswith() - 특정 단어로 끝나는지 확인
find() - 특정 단어를 찾아 인덱스를 리턴 (없으면 -1을 리턴)
rfind() - 뒤에서부터 특정 단어를 찾아 인덱스를 리턴
in, not in을 사용하면특정 단어가 있는지 없는지 확인 가능 (True, False)
index() - find와 동일하지만 없을 때 예외를 발생시킴
rindex() - rfind와 동일하지만 없을 때 예외를 발생시킴
>>> str1 = "I like programming"
>>> str1.count('like')
1
>>> str1 = "I like like like programming"
>>> str1.count('like')
3
>>> str1.count('i')
4
>>> str1 = "I like programming"
>>> str1
'I like programming'
>>> str1.find('like')
2
>>> str1.find('pro')
7
>>> str1.find('programming')
7
>>> str1[str1.find('programming'):]
'programming'
슬라이싱 : 문자열을 추출할 때 사용한다.
형식 : 변수명[시작숫자:끝숫자]
시작숫자와 끝숫자는 생략이 가능하다.
>>> str1 = "I like programming"
>>> str1[10:]
'gramming'
>>> str1[10:15]
'gramm'
>>> str1[-11:-8]
'pro'
>>> str1[7:] # 슬라이싱 (문자열 자르기)
'programming'
>>> str1.index('pro')
7
>>> str1[str1.find('pro'):]
'programming'
>>> str[7:]
'programming'
>>> str1.index('pro')
7
>>> str1.index('abc')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
!!! 문자열을 찾지 못했을 경우는 -1을 리턴한다. !!!
>>> str1
'I like programming'
>>> str1.find('abc')
-1
문자열에 관련된 도움말 출력한다.
>>> del str
>>> help(str)
사용자 정의함수를 통해서 배운 내용을 가지고 파이썬에서 제공되는
다양한 함수들을 익혀나가야 한다.
그리고 그 함수들의 사용법과 아래 3가지의 내용을 익혀나가야
어떤 문제가 주어질 때 그 문제를 풀 수 있다.
함수의 기능, 인수값, 리턴값
※ 참고 : https://www.exploit-db.com/exploits/51005
https://www.exploit-db.com/exploits/50973
정보보안 전문가