05. 함수 / Git

컴퓨터 키면
0. git pull

커밋
1. git status - 현재 저장소 상태를 확인

• 빨간색 파일명/디렉토리명 -> add 할 대상이 있다.
• 초록색 파일명/디렉토리명 -> commit 할 대상이 있다.

2. git add 파일명

• git add .
  - staging/indexing
  • commit에 포함시킬 파일들을 추가

3. git commit -m "커밋 메세지"

4. git pull

5. git push

   • 로컬의 커밋을 원격과 동기화.(로컬 -> 원격)

• 파일추가 -> status -> add -> status -> -m "수정내용" -> push

• git clone url
  - 원격 저장소를 로컬에 복제해서 로컬저장소 생성
  • 참고) git init : 로컬저장소를 생성

내 블로그(?) -> code -> 주소 복사 or download zip -> git clone 주소

---

함수

가. 처리하기 위한 사용자 정의 연산자
	1. input 받아서 output하는 과정을 정의
나. 정의된 함수를 사용하는 것을 호출한다 라고 한다.
다. 함수 구현
	1. 선언부(Header) 
    2. 구현부(Body)
    3. 함수 선언 마지막에는 ":"를 넣어 구현부와 구분한다.
    

def 함수이름( [변수, 변수, ]) : #선언부(header)
	#구현부(Body)
    실행구문 1
    실행구문 2
    실행구문 3
    
    [return [결과값]]

# 함수 정의

# input(입력)값이 없는 함수(변수가 선언되있지 않음)
# output(출력)값이 없는 함수(처리결과를 호출한 곳으로 반환하지 않는다)
def greet():
    print("안녕하세요.")
    print("반갑습니다.")

# 함수 호출
greet()
print("-----------")
greet()
greet()

---

# 입력값을 받는 함수
# 변수선언 -> parameter(매개변수)

def greet2(name): # 이름을 받는 변수 - 파라미터
    print(f"{name}님 안녕하세요.")
    print("환영합니다.")
greet2("이순신") # 파라미터에 전달할 값(argument, 전달인자)을 반드시 넘겨줘야함.

---

def greet3(name, age, address):
    print(f"{address}에 사는 {age}세의 {name}님 환영합니다.")
greet3("이순신", 30, "독산동")

함수 parameter와 return value

가. parameter : 함수가 호출하는 곳으로 부터 입력받는 값 저장
	1. arugument : 호출할 때 파라미터에 전달하는 값
나. return value : 함수의 처리 결과로 호출하는 곳에 전달하는 값
	1. return
    	- 함수가 정상적으로 끝났고, 호출한 곳으로 돌아간다.
        - 반환값이 없을 경우 None을 반환한다.

def greet4(name):
    return f"{name}님 안녕하세요. 환영합니다."
  	result = greet4("이순신") #return값 받을 변수 = 함수호출print("인사말:", result)
print(result + "aaa")
print("종료")

def greet5():
    print("안녕")
    # return None
v = greet5()
print("종료", v)

def divide (num1, num2):
    if num2 == 0:
        print("num2는 0일 수 없습니다.")
        return #none을 반환
    return num1 / num2
result = divide(10, 5)
print(result)

result = divide(10, 0)
if result:
    print(result)
else:
    print("계산 안됨")

#리턴값이 여러개인 경우
#리턴값은 한개만 가능 - 자료구조로 묶어서 반환한다.
def calculate(num1, num2):
    r1 = num1 + num2
    r2 = num1 - num2
    r3 = num1 * num2
    r4 = num1 / num2
    return r1, r2, r3, r4 #튜플

result = calculate(10, 2)

# r1, r2, r3, r4 = calculate(10, 2)
# print(r1, r2, r3, r4)

print(result)

Parameter(매개변수)

가. 기본값 없는 매개변수를 선언하고 그 다음 기본값 있는 변수 선언
	- 틀린 ex) def print_info3(id~~=None~~, pwd, name, age=None, tall=None):

# id, pwd, name은 호출하는 곳에서 반드시 넘겨받아야한다, age, tall은 안받을 수도 있다.
def print_info3(id, pwd, name, age=None, tall=None):
    print(id ,pwd, name, age, tall)

print_info3("id-1", "1111", "홍길동")
print_info3("id-1", "1111", "홍길동", 30)
print_info3("id-1", "1111", "홍길동", 30, 170)

def print_info5(id, pwd, name, age=None, tall=None): #parameter
    print(id ,pwd, name, age, tall)

print_info5("id-1111", "pwd-1111", "이순신", 20, 182)
print_info5(182, "이순신", 30, "id-1111", "pwd-1111") #argument

#파라미터 = 전달할 값 형식으로 호출 -> keyword argument
print_info5(id="my-id", pwd="my_pwd", name="홍길동", age = 50, tall = 190)

#키워드 아큐먼트 보다 포지션 아큐먼트가 먼저 와야함
def print_info5(id=None, pwd=None, name=None, age=None, tall=None):
    print(id ,pwd, name, age, tall)
print_info5("my-id", pwd="my_pwd")

가변인자

가. 함수 정의 시 argument의 개수를 미리 지정하지 않고, 호출할 때 그 개수를 정해서 인자를 전달할 수 있도록 하는 방법

나. 가변인자의 종류
	- 위치 가변 인자(*args)
    - 키워드 가변 인자(**kwargs)
    

def test3(**kwargs):
    print(type(kwargs))
    print(kwargs)

test3(id="my-id", name="홍길동", age=30, address="서울")
test3()
test3(name="이순신")

def test4(*args, **kwargs):
    print(args)
    print(kwargs)
test4(1,2,3,4,a=10,b=20,c=30)

변수의 유효범위

가. 지역변수
	1. 함수 안에 선언 된 변수
나. 전역변수
	1. 함수 밖에 선언 된 변수
    2. 전역변수에 값을 대입하기 위해서 global 키워드를 이용해 미리 선언

name = "이순신" # name 변수를 정의
print(name)
name = "홍길동"

def fun1(loc="서울"):
    age_local = 30
    print("fun1()", name) # 전역변수 name의 값
    print("fun1()의 지역변수:", loc, age_local) #loc, age_local: 함수 안에서 정의된 변수

def fun2():
    loc = "인천"
    age_local = 100
    print("fun2()", name)
    print(loc, age_local)

def fun3():
    name = "유관순" # fun3() 함수의 지역변수를 정의
    print("fun3()", name)

def fun4():
    #global 변수 name의 값을 변경
    #변수 name은 global 변수임을 선언
    global name
    name = "유관순" 

fun1()
fun2()
fun3()
print("함수 밖에서 출력:", name)
fun4()
print("함수 밖에서 출력:", name)

함수는 일급시민

가. 일급시민
	1. 변수에 대입할 수 있다.
	2. argument로 사용할 수 있다.
	3. 함수나 메소드의 반환값으로 사용 할 수 있다.
나. 함수는 일반 값으로 취급

a = 10.5 #정수
def f(x):
    return 10.5

f(10.5)

----------------------
def greet():
    print("안녕하세요")

greet() # 함수 호출
greet   # 함수 자체를 의미
hello = greet # greet함수를 hello로 호출할 수 있다.
hello()

----------------------
def calc(num1,num2, func):
    print("받은 값:",num1, num2) # 1번째 할 일
    result = func(num1, num2) # 2번째 할 일 - 계산
    print("계산 결과:", result) #3번째 할 일 - 계산 결과

# 1, 3번은 고정적인 작업
# 2번째 작업 -> 호출하는 쪽이 원하는 연산을 처리 
# 처리할 값 : num1, num2
# 처리할 함수: func
def minu(n1,n2):
    return n1 - n2

calc(100,200,minu)
def plus(n1,n2):
    return n1 + n2
calc(100,200,plus)


------------------------
l = ["가", "안녕", "반가워", "배고파", "나", "내가"]
l.sort() #오름/내림차순 정렬
print(l)
# 글자수 정렬
l.sort(key=len) #, reverse=True 글자수 많은 순
print(l)


------------------------
def outer():

    def inner():
        print("outer() 안에 정의된 inner() 함수")

    inner()
    inner()
    inner()

    return inner

f = outer()
print("------------")
print(f)
f()

람다식

가. 함수를 표현식으로 정의
나. 구문
	1. lambda 매개변수 [, 매개변수, ] : 명령문(구문)

def plus(num1, num2):  #하나의 리턴값이 있을때? 사용??
    return num1 + num2

## 람다식으로 표현
f = lambda num1, num2 : num1 + num2
f(100, 200)

--------------
f2 = lambda x : len(x)*100 #구문을 한개밖에 못널음
f2("aaaa")
--------------

def calc(num1,num2, func):
    print("받은 값:",num1, num2) # 1번째 할 일
    result = func(num1, num2) # 2번째 할 일 - 계산
    print("계산 결과:", result) #3번째 할 일 - 계산 결과

calc(10,20, lambda num1, num2 : num1 + num2)
calc(10,20, lambda num1, num2 : num1 * num2)

---------------

f = lambda x, y : len(x) > len(y)
f("aaaaa", "bbbb")

docstring

가. 함수 안에 메뉴얼을 만듦?
나. 함수에 대한 설명
	# 함수에 대한 설명
	# 파라미터에 대한 설명
	# 반환값에 대한 설명
	# 발생 가능성 있는 예외(에러)에 대한 설명
    # 사용 예제
다. 설명을 달아주는거..
	1. # help(함수) -> 함수설명
    	help(print)

# 함수에 대한 설명
# 파라미터에 대한 설명
# 반환값에 대한 설명
# 발생 가능성 있는 예외(에러)에 대한 설명
# 사용 예제
def calc(num1,num2, func):
    """다양한 계산을 하는 함수        # 함수설명
    
    Atrgs:    #파라미터 설명
        num1 (int|float): 피연산자 1 # 변수명(타입): 피라미터 설명
        num2 (int|float): 피연산자 2
        func (callable) : 두 피연산자를 처리할 함수
    Returns : #리턴값
        int | float : 계산 결과      # 리턴값의 타입: 설명

    Raise:    #발생 가능성 있는 예외(에러)
        ValueError: 발생 이유        # 에러이름(타입): 발생 이유

    """
    print("받은 값:",num1, num2) # 1번째 할 일
    result = func(num1, num2) # 2번째 할 일 - 계산
    print("계산 결과:", result) #3번째 할 일 - 계산 결과
    return result

help(calc)