def oz():
for i in range(5):
print('oz코딩스쿨')
oz() # 함수의 이름을 적어주면 바로 함수의 내용이 출력
def oz(message, n):
for i in range(n):
print(message)
oz('oz코딩스쿨', 5) # 'oz코딩스쿨', 5 : 인자
- 매개변수(parameter)
- 함수 정의 def oz(message, n): 안에서 외부에서 값을 받을 자리를 의미합니다.
- message, n 은 oz 함수가 호출될 때 값을 받아서 내부에서 변수처럼 사용
- 함수 정의 def oz(message, n): 안에서 외부에서 값을 받을 자리를 의미합니다.
- 식별자(identifier)
- 파이썬에서 변수, 함수, 클래스 이름 등 무언가를 구분하기 위해 붙인 이름을 통틀어 식별자
- message,n은 식별자의 이름
- 파이썬에서 변수, 함수, 클래스 이름 등 무언가를 구분하기 위해 붙인 이름을 통틀어 식별자
- 인자(argument)
- 함수를 실제로 호출할 때 전달하는 실제 값을 인자라고 합니다.
def oz(message, n):
for i in range(n):
print(message)
oz('oz코딩스쿨') # 정상적으로 호출
oz('oz코딩스쿨') # 매개변수의 개수가 2개인데 입력된 매개변수가 1개여서 호출 X
oz('oz코딩스쿨',5,3) # 3개가 입력되어 호출 X
- 매개변수의 개수와 호출시 입력되는 매개변수의 개수는 동일해야 한다.
def oz(n, *values): # 매개변수 ,* 가변 매개변수
for i in range(n):
for value in values:
print(value)
print() # 한줄 띄어쓰기
oz(3, "이렇게", "저렇게", "가변 매개변수는 요렇게", "신기하죠")
# 3은 n 매개변수에 들어가고 나머지는 가변 매개변수에 들어간다.- 가변 매개변수(*함수 이름) : 함수가 받을 수 있는 인자의 개수가 고정되어 있지 않을 경우 사용
- 가변 매개변수 뒤에는 일반 매개 변수가 올 수 없습니다.(*values , n)불가
- 함수의 호출 시 전달된 값에서 가변 매개변수의 끝을 판단할 수 없기 때문
- 가변 매개변수는 하나만 사용 가능합니다.
- 가변 매개변수 뒤에는 일반 매개 변수가 올 수 없습니다.(*values , n)불가
def oz(value, n=2): # (매개변수, 기본 매개변수)
for i in range(n):
print(value)
oz("일반 매개변수 다음에 기본 매개변수를 배치해야 합니다.")
# 매개변수 값을 지정하지 않아서 기본값으로 대체
oz("일반 매개변수 다음에 기본 매개변수를 배치해야 합니다.", n=10)
# 기본값이 존재하지만 매개변수 값을 지정하면 지정한 값으로 호출
- 기본 매개변수 : 매개변수를 입력하지 않으면 함수 호출시 설정해 놓은 기본값으로 대체
- 기본 매개변수 뒤에는 일반 매개변수가 올 수 없다. (기본 매개변수, 매개변수)불가
def oz(n=3, *values): #(기본 매개변수, 가변 매개변수)
for i in range(n):
for value in values:
print(value)
print()
oz("기본 매개변수 다음에", "가변 매개변수를", "넣을 수 있을까요?")
- 기본 매개변수가 가변 매개변수보다 앞에 존재하게 될 경우
- 기본 매개변수 자리에는 range(n)에 의해 숫자형 데이터가 들어가야 하는데 문자형 데이터가 들어가 오류가 발생 해서 출력이 불가
- 기본 매개변수에서 오류가 발생하여 뒤에있는 가변 매개변수는 의미가 없어짐
#(가변 매개변수, 기본 매개변수)
def oz(*values, n=3):
for i in range(n):
for value in values:
print(value)
print()
oz("기본 매개변수 다음에", "가변 매개변수를", "넣을 수 있을까요?", 10)
- 입력된 모든 매개변수가 가변 매개변수로 인식
- 입력된 매개변수인 10이 아닌 기본 매개변수인 3이 작동
- for문은 출력시에 자동으로 한줄씩 띄어쓰는 end=\n이 작동
- 한줄씩 띄어쓰기 하는것을 없애기 위하여
키워드 매개변수 end=""를 사용하면 한줄에 모두 출력
- 한줄씩 띄어쓰기 하는것을 없애기 위하여
키워드 매개변수
#직육면체를 부피를 구하는 코드를 작성해보자 : 가로 : x, 세로 : y, 높이 : h
def oz(x, y=20, h=10):
print(x * y * h)
#x식별자에 매개변수 10을 넣은 경우
oz(10) = 2000
#x식별자에 10을 넣고 y=10이라는 키워드 매개변수를 이용한 경우
oz(10, y=10) = 1000
#모든 매개변수를 키워드 매개변수로 넣은 경우
oz(x=5, y=5, h=5) = 125
return
- 함수를 호출하면 함수안에 있는 코드가 하나씩 실행되다가 return을 만나면 함수를 호출한 자리로 돌아간다.
def oz_return():
return "파이썬 재미있엉" # 값과 함께 리턴하는 경우
result = oz_return()
print(result)
값과 함께 리턴하는 경우
- 돌려받은 return 값을 result 변수에 저장
- 변수에 저장된 리턴값은 다른 곳에서도 사용이 가능하다.
def oz_return():
# return # 리턴값이 없는 경우
result = oz_return()
print(result) = None
리턴값이 없는 경우
- 돌려받을 값이 없기때문에 None 출력 (bool 에서는 False로 출력)
함수의 종료(조기 리턴)
- 코드의 스타일을 좋아보이게 만들 수 있다.
1. return을 사용하는 이유와 역할에 대해 설명해보세요
- return으로 돌려받은 값은 변수로 활용 할 수 있어서 다른 위치에서도 사용이 가능해서?
2. return으로 값을 반환하기 위한 문법에 대해 설명해주세요
- range(stop) / range(start,stop) / range(start,stop,step)
- start : 시작 값 (기본 : 0)
- stop : 끝 값 (이전까지만 반복 , 5일경우 4까지만)
- step : 증가값 (기본 : 1, 음수일 경우 역순이 가능하다)
def oz(start, end, multiple): # 기본 매개변수 이용가능
for i in range(start, end, multiple):
print(i, " ", end="")
print()
oz(1, 10, 3) # 매개변수 입력 =1 4 7 10
oz(start=1, end=50, multiple=5) # 키워드 매개변수 이용
oz(start=10, end=100, multiple=10)
- 매개변수를 입력, 키워드 매개변수를 이용 , 기본 매개변수 이용 전부 가능
재귀함수 : 함수 안에 자신의 함수를 다시 호출하는 함수
# 반복문을 이용한 팩토리얼 구현 코드
def oz_factorial(n):
output = 1
for i in range(1, n+1):
output *= i # 곱하기 연산에서 output의 초기값은 1
return output
n = int(input("구하고자하는 팩토리얼의 수를 입력해주세요"))
print(f'{n}의 결과는 {oz_factorial(n)}입니다.')
- n : 입력값을 저장하는 변수
- oz_factorial(n) : 함수 호출
- 함수 안에서 n값이 인자로 들어가고 return output를 통해 리턴값을 반환
- print()안에서 바로 사용했기 때문에 별도의 변수가 필요하지 않다.
- 리턴값을 변수에 담기 위해서는 : result = oz_factorial(n)
- print(f'{n}의 결과는 {result}입니다.') 이런 방법도 있다
- print()안에서 바로 사용했기 때문에 별도의 변수가 필요하지 않다.
- 함수 안에서 n값이 인자로 들어가고 return output를 통해 리턴값을 반환
#재귀함수를 이용한 팩토리얼 구현 코드
def oz_factorial(n):
if n == 0:
return 1 # 0! = 1
else:
return n * oz_factorial(n-1)
n = int(input("구하고자하는 팩토리얼의 수를 입력해주세요"))
print(f'{n}의 결과는 {oz_factorial(n)}입니다.')
count = 0
def oz_fibo(n):
print(f'피보나치 수열 {n}을 구하는 중입니다.')
global count
count += 1
if n == 1:
return 1
if n == 2:
return 1
else:
return oz_fibo(n-1) + oz_fibo(n-2)
n = int(input("구하고자하는 피보나치의 수열의 수를 입력해주세요"))
oz_fibo(n)
print(f'피보나치 수열 {n}을 구하기 위해 계산된 횟수는 {count}입니다')
메모리제이션 (memo)
- 이전에 계산한 값을 메모리에 저장하여 중복적인 계산을 반복적으로 해야할때, 이전의 계산값을 메모리에 저장하여 중복적인 계산을 제거하여 전체적 속도를 빠르게 해주는 기법.
튜플()
- 튜플의 값은 변경 불가
- ()없이도 값을 할당 할 수 있다.
oz_tuple = (1,2,3)
print(oz_tuple) = (1,2,3)
print(oz_tuple[0]) = 1
print(oz_tuple[1]) = 2
print(oz_tuple[2]) = 3
#튜플에 데이터를 변경을 불가하므로 아래 코드 실행 시 오률가 발생합니다.
oz_tuple[2] = 5
- 값의 교환은 가능
x, y = 1, 2
print("x: ", x) =1
print("y: ", y) =2
print() # 한줄 띄어쓰기
x, y = y, x # 값의 교환
print("x: ", x) =2
print("y: ", y) =1
튜플을 이용한 값의 리턴
- 여러개의 값을 리턴할 수 있음
def oz_tuple():
return (1, 2)
x, y = oz_tuple()
print("x:", x)
print("y:", y)
- enumerate()
- 반복문(for)에서 인덱스(번호)와 값을 동시에 꺼낼 수 있게 해주는 내장 함수
fruits = ["사과", "바나나", "체리"]
for index, value in enumerate(fruits):
print(index, value)
출력 = 0 사과
1 바나나
2 체리
for index, value in enumerate(fruits, start=1): # 시작 번호 변경
print(index, value)
출력 = 1 사과
2 바나나
3 체리
divmod(a,b)
- 두 숫자를 나눌 때 몫과 나머지를 한꺼번에 구해주는 내장 함수
- a : 나누어 지는 수 , b : 나누는 수 = (몫, 나머지) 형태의 튜플로 반환
- divmod(10,3) = (3,1)
- a : 나누어 지는 수 , b : 나누는 수 = (몫, 나머지) 형태의 튜플로 반환
a, b = 7, 3 # 괄호 없이 여러개의 값을 할당 가능한 이유 : 튜플형태이기 때문
x, y = divmod(a, b)
print("몫:", x) = 몫 : 2
print("나머지:", y) = 나머지 : 1
람다
- 함수 자체를 매개변수로 사용하기 쉽도록 도움
- 함수의 매개변수로 사용되는 함수 : 콜백 함수
- 콜백 함수를 호출할때는 이름만 입력한다.()제외
- 함수의 매개변수로 사용되는 함수 : 콜백 함수
def oz_call(function):
for i in range(5):
function()
def talk():
print("콜백 함수는 무엇인가..")
oz_call(talk) # talk : 콜백 함수
map()/filter()
- 리스트의 요소를 함수에 넣고 리턴된 값으로 새로운 리스트를 구성해 줌
- 리스트의 요소를 함수에 넣고 리턴된 값이 True인 값만을 새로운 리스트를 구성해 줌
#자기 자신을 곱합 결과를 새로운 list를 만들어주는 map() 함수 코드
def square(i):
return i * i
numbers_list = [1,2,3,4,5,6,7,8,9,10]
result = map(square, numbers_list)
# list값을 square에 매개변수로 넣고 리턴
print("map 결과:", result)
print("map 결과의 list 형변환:", list(result))
-------------------------------------------------------------------------
#조건에 맞는 값만을 이용해 새로운 list를 만들어주는 filter()함수 코드
def under(i):
return i < 5
numbers_list = [1,2,3,4,5,6,7,8,9,10]
result = filter(under, numbers_list)
print("map 결과:", result)
print("map 결과의 list 형변환:", list(result))
lambda
- 간단히 함수를 쉽게 선언하는 방법으로 이름이 없는 익명함수를 만들 수 있습니다.
- lambda 매개변수 : 리턴값
- lambda 함수는 결과를 바로 리턴
square = lambda i : i * i # def square(i) return i*i 와 동일
numbers_list = [1,2,3,4,5,6,7,8,9,10]
result = map(square, numbers_list)
print("map 결과:", result)
print("map 결과의 list 형변환:", list(result))
-------------------------------------------------------------------------
numbers_list = [1,2,3,4,5,6,7,8,9,10]
result = map(lambda i : i * i, numbers_list)
print("map 결과 :", result)
print("map 결과의 list 형변환:", list(result))
-------------------------------------------------------------------------
under = lambda i : i < 5 # def under(i) return i < 5 와 동일
numbers_list = [1,2,3,4,5,6,7,8,9,10]
result = filter(under, numbers_list)
print("map 결과:", result)
print("map 결과의 list 형변환:", list(result))
-------------------------------------------------------------------------
numbers_list = [1,2,3,4,5,6,7,8,9,10]
result = filter(lambda i : i < 5, numbers_list)
print("map 결과:", result)
print("map 결과의 list 형변환:", list(result))
제너레이터(yield)
- 이터레이터를 생성하는 객체
- 이터레이터 : 순서대로 다음 값을 리턴할 수 있는 객체로 자체적으로 내장하고 있는 next 메서드를 통해 다음 값을 가져올 수 있습니다.
- 제너레이터 함수가 적용 되면 호출해도 함수 내부의 코드가 작동하지 않습니다.
def test():
print("제너레이터 실습 코드입니다.")
yield "test"
print("첫번째 출력")
test()
print("두번째 출력")
test()
print(test()) = <generator object test at 0x103ec7400> 출력
- test함수 안에 yield코드가 있기 때문에 제너레이터함수가 되었고 그로 인해 함수를 호출해도 함수 내부의 코드가 실행되지 않는다.
def test():
print("첫번째 출력") = 2.출력
yield 1 = 3. "1" 출력
print("두번째 출력") = 5.출력
yield 2 =6. "2" 출력
print("세번째 출력") = 8.출력 다음 yield 3 없어서 오류 발생
output = test()
print("네번째 출력") = 1.출력
x = next(output) # next를 만나면 yield있는 위치까지 출력
print(x)
print("다섯번째 출력") = 4.출력
y = next(output)
print(y)
print("여섯번째 출력") = 7.출력
z = next(output)
print(z)
타입 어노테이션
- 타입 어노테이션은 잘못된 내용이어도 어떠한 오류나 경고가 발생하지 않는다.
- 다른 개발자와의 협업시 읽기 수월하도록 하는 도구
def oz(x: int, y: int, h: int) -> int: # 타입 어노테이션
return x * y * h
oz(10,10,10)
1. 변수 타입 어노테이션
- 변수 이름 뒤에 콜론을 붙이고 타입을 명시한다.
my_dog : str = "hunt"
my_dog_age : int = 7
dogs: list[str] = ["딕스훈트", "시바견", "웰시코기", "이탈리안그레이하운드"]
dogs: dict[str, int] = {
"닥스훈트" : 7,
"시바견" : 5,
"웰시코기" : 6,
"이탈리안그레이하운드" : 3,
}
print(my_dog)
2. 함수 타입 어노테이션
- 함수에 타입 헌팅을 적용할 때는 인자 타입과 반환 타입 두곳에 추가할 수 있습니다.
- 인자에 타입 어노테이션을 추가할 때는 변수와 동일한 문법을 사용
- 반환값에 대한 타입을 추가할 때는 화살표를 사용합니다.
def hunt(name: str) -> str:
return name[0]
def hunt_info(name: str, age: int = 7) -> str:
return name + str(age)
def hunt_happy_time(name: str) -> None:
print("간식줄께" + name)
def hunt_bow(message: str, times: int = 10) -> list[str]: # 리스트에 문자열 들어갈것임
return [message] * times
안녕하세요.