1.  함수  function

🐰  함수는 fun으로 정의하고 반환값이 있는 함수는 내부에서 return으로 값을 반환
🐰  함수를 정의할 때 입력값을 기술한 것을 '파라미터'

    fun 함수이름 (파라미터 이름 : 타입) : 반환타입 {
        return 값
    }

  🥕  함수의 괄호 안에 입력되는 '파라미터 이름 : 타입'에 따라, 함수를 호출할 때 괄호 안에 값을 넣어서 전달하는데
        이 때 입력되는 값의 타입은 함수에 정의된 파라미터 타입과 동일하게 입력해야 함

1) 함수의 정의

 반환값과 입력값이 있는 함수의 정의

    ✏️  Int 타입의 x라는 입력 파라미터를 갖는 함수 square()를 정의

fun square(x: Int): Int {
    return x * x
}
// square() 함수가 호출되면 입력값을 제곱해서 호출한 측으로 반환하고 실행이 종류.

반환값이 없는 함수의 정의 

    ✏️  반환값 없이 입력값을 받아서 출력하는 함수 printSum() 함수를 정의. 함수가 호출되면 결과값을 출력하고 실행이 종료

fun printSum(x: Int, y: Int) {
    println("x + y = ${x + y}")
}

입력값 없이 반환값만 있는 함수의 정의

fun getPi(): Double {
    return 3.14
}

 2) 함수의 사용(호출)

🐰  함수의 사용은 이름 뒤에 괄호를 붙여서 명령어를 실행하는 형태

함수명(값)    

    🥕  괄호를 붙이지 않으면 함수의 코드가 실행되지 않고 마치 값처럼 인식

반환값과 입력값이 있는 함수의 호출

   ✏️  파라미터에 전달할 값을 입력하고 반환값은 대입 연산자(=)로 변수에 담은 후 사용

fun main() {
    var squareResult = square(30)
    println("30의 제곱은 ${squareResult}입니다.") // 30의 제곱은 900입니다.
    println("40의 제곱은 ${square(40)}입니다.") // 40의 제곱은 1600입니다.
}

반환값이 없는 함수의 호출

    ✏️  반환값이 없으면 대입 연산자(=)를 사용하지 않고 바로 호출해서 실행

fun main() {
    printSum(3, 5) // x + y = 8
}

입력값이 없는 함수의 호출

    ✏️  입력값이 없다면 괄호만으로 실행하고 결과값을 받을 수 있음

fun main() {

    val PI = getPi()
    println("지름이 10인 원의 둘레는 ${PI}입니다.") // 지름이 10인 원의 둘레는 3.14입니다.

}

 2.  함수 파라미터의 정의

🐰  함수에 입력되는 파라미터는 마치 변수를 정의하듯이 '이름 : 타입'의 형태로 정의
       ➡️  여러 개의 파라미터가 정의될 경우는 콤마로 구분
🐰  코틀린에서 함수 파라미터를 통해 입력되는 모든 값은 변하지 않는 immutable
🐰  코틀린에서의 함수 파라미터는 모두 읽기 전용 키워드 val이 생략된 형태

 fun 함수이름((val 생략) name1: String, name2: Int, name3: Double) {실행코드} 

1) 파라미터의 기본값 정의와 호출

    🥕  파라미터는 정의할 때 등호(=)를 사용해서 기본값을 설정할 수 있음

fun 함수이름 (name1: String, name2: Int = 157, name3: Double = 34.5) {실행코드}

fun newFun(name: String, age: Int = 29, weight: Double = 65.5) {
        // name = "tom"; // Val cannot be reassigned
        println("name의 값은 ${name}입니다.")
        println("age의 값은 ${age}입니다.")
        println("weight의 값은 ${weight}입니다.")
}

// 정의된 newFun() 함수를 호출할 때 기본값이 없는 첫 번째 파라미터에만 값을 입력하면
// 두 번째와 세 번째 파라미터에는 설정한 기본값이 자동으로 입력.
    
    newFun("Hello")
    /*
    name의 값은 Hello입니다.
    age의 값은 29입니다.
    weight의 값은 65.5입니다.
     */

2)  파라미터 이름으로 값을 입력하기

    🥕  함수에 정의된 파라미터가 많을 경우 입력하는 값의 의미가 명확하지 않을 때가 있음
    🥕  이럴 경우 순서와 상관 없이 정의된 파라미터 이름을 지정해서 직접 값을 입력할 수 있음

fun main() {

    newFun("Michael", weight=67.5)
    /*
     name의 값은 Michael입니다.
     age의 값은 29입니다.
     weight의 값은 67.5입니다.
     */

}

응용 예제

   📍 login() 메서드와 logout() 메서드를 선언
        login() 메서드를 호출할 때는 매개값으로 id와 passwd를 제공하고, logout() 메서드는 id만 매개값으로 제공

       1) login() 메서드는 매개값 id가 "admin", 매개값 password가 "1234"일 경우에만 true 로 리턴하고

           그외의 값일 경우에는 false를 리턴
       2) logout() 메서드는 "admin 아이디가 로그아웃 되었습니다"가 출력

fun main() {

    print("아이디를 입력해주세요. >> ")
    val id = readln()
    print("비밀번호를 입력해주세요. >> ")
    val password = readln()

    val result = login(id = id, password = password)
    if (result) {
        println("로그인 되었습니다.")
        logout(id)
    } else {
        println("id 또는 password가 올바르지 않습니다.")
    }

}

fun login(id:String, password: String): Boolean {
    return id == "admin" && password == "1234"
}

fun logout(id: String) {
    println("$id 아이디가 로그아웃 되었습니다.")
}

  📍  배열을 전달 받아 짝수만 출력하는 메서드 작업 

fun main() {
   
    val numbers = IntArray(10)
    for (i in numbers.indices) {
        numbers[i] = i + 1
    }
    print("main() : ")
    for (i in numbers.indices) {
        print(numbers[i])
        if (i < numbers.size - 1) {
            print(", ")
        }
    } // main() : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

    println()
    printOdd(numbers) // printOdd() : 2, 4, 6, 8, 10
}

fun printOdd(numbers: IntArray) {
    print("printOdd() : ")
    for (i in numbers.indices) {
        if (numbers[i] % 2 == 0) {
            print(numbers[i])
            if ( i < numbers.size - 1) {
                print(", ")
            }
        }
    }

    val odds = numbers.filter {result -> result % 2 == 0}
    println(odds)
}

  📍 키보드로 부터 학생 수와 각 학생들의 점수를 입력받아서, 최고 점수 및 평균 점수를 구하는 프로그램

fun main() {

    var run = true // 반복문의 조건으로 사용 -> 값이 false가 된다면 반복문이 종료

    var scoreList: IntArray = IntArray(0)
    while (run) {
        println("-----------------------------------------------------")
        println("1.학생수 | 2.점수입력 | 3.점수리스트 | 4.분석 | 5.종료")
        println("-----------------------------------------------------")
        print("선택> ")
        val selectNo: Int = readln().trim().toInt()
        when (selectNo) {
           1 -> scoreList = inputStudentNum() // 학생수를 입력 받아서 배열 생성
           2 -> inputScores(scoreList) // 생성된 배열의 갯수 만큼 점수 입력
           3 -> printScores(scoreList) // 입력받은 배열의 값을 출력
           4 -> printAnalysis(scoreList) // 최고 점수, 평균 점수 출력
           5 -> run = setRun() // run 값 변경
        }
    }
    println("프로그램 종료")
}

fun inputStudentNum():IntArray {
    print("학생수> ")
    var studentNum = readln().toInt()
    return IntArray(studentNum)
}

fun inputScores(scores:IntArray) {
    for (i in scores.indices) {
        print("scores[$i] > ")
        scores[i] = readln().toInt()
    }
}

fun printScores(scores:IntArray) {
    for (i in scores.indices) {
        println("scores[$i] : " + scores[i])
    }
}

fun printAnalysis(scores: IntArray) {
    var max = scores[0]
    var sum = scores[0]
    var avg: Double

    for (i in 1 until scores.size) {
        if (scores[i] > max) {
            max = scores[i]
        }
        sum += scores[i]
    }

    avg = (sum / scores.size).toDouble()
    println("최고 점수: " + max)
    println("평균 점수: " + avg)

}

fun setRun(): Boolean {
    return false
}

[ 내용 참고 : IT 학원 강의 ]

1.  함수 function

🐰  자바스크립트 프로그램은 단순히 동작 하나만 실행되는게 아니라 여러 가지 동작이 연결된다

🐰  이렇게 동작해야 할 목적대로 묶은 명령을 함수 function (= 코드의 집합) 이라 함

🐰  함수를 사용하면 각 명령의 시작과 끝을 명확하게 구별할 수 있고,

      묶은 기능에 이름을 붙여 필요할 때마다 호출하여 반복적으로 사용 가능

💡  함수를 사용하면 좋은 점
    1. 반복되는 코드를 한 번만 정리해놓고 필요할 때마다 호출하므로 반복 작업을 피할 수 있다
    2. 긴 프로그램을 기능별로 나눠 여러 함수로 나누어 작성하면 모듈화로 전체 코드의 가독성이 좋아진다.
    3. 기능별(함수별)로 수정이 가능하므로 유지보수가 쉽다.

💡  용어 정리
    ·  함수 정의 : 함수를 만든 것
    ·  함수 호출 : 함수를 사용하는 것
    ·  인수 : 함수를 호출할 때 괄호 내부에 여러가지 자료를 넣는 것
    ·  매개변수 : 함수를 정의할 때 전달받을 인수를 정의하는 것
    ·  리턴 값 : 함수를 호출해서 최종적으로 나오는 결과

1)  매개변수와 리턴값

🍯  매개변수와 리턴값은 함수의 필수 요소가 아니고, 필요할 때만 사용

/* 기본형 */
function 함수명 (매개변수1, 매개변수2, ... 매개변수n) {
    문장;
    문장;
    return 리턴값;
}

<script>
    const f = function (x) {
        return x * x;
    }

    // 함수를 호출
    console.log(f(3)); // 9. 매개변수 x에 전달되는 인수가 3이고 리턴값이 9.
    console.log(f()); // NaN
</script>

자바스크립트는 인수와 매개변수의 개수가 달라도 에러가 나지 않음 

<script>
    const test1st = function (a) {
        console.log(a);
    }
    
    test1st(); // undefined
    test1st(1); // 1
    test1st(1, 2); // 1
    test1st(1, 2, 3); // 1
</script>

매개 변수가 있는 함수 정의문

<script>
    const myFunc = function (name, area) {
        document.write('안녕하세요. ' + name + '입니다.', '<br>');
        document.write('사는곳은 ' + area + '입니다.', '<br><br>');
    };
    myFunc('홍당무', '서울');
    myFunc('깍두기', '부산');
</script>

2)  return 문

🍯  데이터를 반환하고 강제 종료
🍯  return의 역할  1) 데이터를 반환   2) 함수의 강제 종료 (반환값이 없어도 됨)

데이터 반환

<script>
    const getAvg = function (arrData) {
        let sum = 0;
        for(let i = 0; i < arrData.length; i++) {
            sum += Number(prompt(`${arrData[i]} 점수는 ?`, `0`));
        }

        const avg = sum / arrData.length;
        return avg;
        //alert(avg); // return 이후의 코드라서 실행이 안됨. (Unreachable code)
    }

    const arrSubject = ['국어', '수학', '영어'];
    const result = getAvg(arrSubject);

    document.write(`평균 점수는 ${result}점 입니다.`);
</script>

강제 종료

<head>
<style>
        * {
            padding: 0;
            margin: 0;
        }

        #galleryZone {
            text-align: center;
        }
</style>
<script>

    let num = 1;
    const showGallery = function (direction) {
    /*
    다음을 클릭한 경우 pic_1.jpg -> pic_2.jpg : 번호가 증가
    이전을 클릭한 경우 pic_9.jpg -> pic_8.jpg : 번호가 감소
    */
    if  (direction === 1) { // 다음을 클릭한 경우
        if (num === 9) {
            alert('마지막 이미지입니다');
            return; // 이미지가 9개인 경우 num이 9인 경우 함수 종료
        }
         num++;
    } else { // 이전을 클릭한 경우
        if (num === 1) {
            alert('첫 이미지입니다.');
            return; // 첫 이미지가 1번이어서 종료
         }
         num--;
    }
    const imgTag = document.getElementById('photo'); // id 값이 photo인 요소를 가져옴
    imgTag.setAttribute('src', 'images/pic_' + num + '.jpg'); // id 값이 photo인 요소의 src 속성을 변경
    }
</script>
</head>
<body>
    <div id ="galleryZone">
        <p><img src="./images/pic_1.jpg" id="photo" alt=""></p>
        <p>
            <button onclick="showGallery(0)">이전</button>
            <button onclick="showGallery(1)">다음</button>
        </p>
    </div>
</body>

2.  익명 함수 선언하기

 🐰  익명 함수 anonymous function : 이름이 없는 함수

 🐰  익명함수는 변수 선언(함수 정의) 후 호출 가능
 🐰  익명함수는 동일한 이름으로 재선언 불가능. let과 const의 특징

기본형 : function () {}
<!-- 변수 할당 --> 
let 변수 = function () {
    실행문;
}

<script>
    // 변수를 선언해서 함수를 할당.
    const func = function () {
        console.log('함수 내부의 코드입니다 ... 1');
        console.log('함수 내부의 코드입니다 ... 2');
        console.log('함수 내부의 코드입니다 ... 3');
        console.log('');
    }

    // 함수를 호출
    func();
    func();

    // 출력
    console.log(typeof func); // function. 함수의 자료형 확인
    console.log(func); // 함수 자체도 단순한 자료이므로 출력할 수 있음.
</script>

<script>
    /* 선언 전 호출시 */
    compute(); // Uncaught ReferenceError: Cannot access 'compute' before initialization
    let compute = function() {
        let x = 10;
        let y = 100;
        let result = x * y;
        console.log(result);
    };
    compute(); // 1000
</script>
<script>
    /* 재선언 시 */
    let compute = function() {
        let x = 10;
        let y = 100;
        let result = x * y;
        console.log(result);
    }; // Uncaught SyntaxError: Identifier 'compute' has already been declared 
</script>

3.  선언적 함수 

🐰  선언적 함수 : 이름이 있는 함수

🐰  선언적 함수는 재정의 가능

 기본형 : function 함수 이름 () {}

   ✏️  대부분의 프로그램은 선언적 함수만 사용하거나(C),

         선언적 함수를 주로 사용하고 익명함수를 보조적인 수단(C++, 자바의 람다)으로 사용
   ✏️  자바스크립트는 함수지향 프로그램(ECMA script 6 이후)이라서 변수에 함수 할당하거나,
         익명함수를 주로 사용하고 선언적 함수를 보조적인 수단으로 사용하는 것을 지향함.

<script>
    // 함수를 생성
    function func1st () {
        console.log('함수 내부의 코드입니다 ... 1');
        console.log('함수 내부의 코드입니다 ... 2');
        console.log('함수 내부의 코드입니다 ... 3');
        console.log('');
    }

    // 함수를 호출
    func1st();
    func1st();

    // 출력
    console.log(typeof func1st); // function
    console.log(func1st);
</script>

동일한 이름의 함수가 존재하는 경우
 -  선언적 함수의 경우 동일한 이름의 함수가 존재하면 뒤에 선언된 함수가 실행이 됨

<script>
    let num = 100;
    function menu() {
        num += 100;
        document.write(num, ": 앞의 함수 실행<br>");
    }
    menu(); // 100: 뒤의 함수 실행

    function menu() {
        document.write(num, ": 뒤의 함수 실행<br>");
    }
</script>

💡  선언적 함수를 변수에 할당하는 방법 
      1. 변수에 할당하면서 선언적 함수 선언
            ➡️  변수에 할당하면서 선언적 함수를 선언하면 익명함수로 처리
      2. 선언적 함수를 선언 후에 변수에 할당

<script>
    // 1. 변수에 할당하면서 선언적 함수 선언
    const func2nd = function namedFunc2nd() { // 변수를 선언해서 함수를 할당
        console.log('namedFunc2nd() 함수 내부의 코드입니다 ...');
        console.log('');
    }

    // 호출
    func2nd(); // 변수를 통해 함수를 호출.
    // namedFunction(); // Uncaught ReferenceError: namedFunction is not defined\
    console.log(typeof func2nd); // function. 함수의 자료형 확인

    // 2. 선언적 함수를 선언 후에 변수에 할당
    function namedFunc() {
        console.log('namedFunc() 함수 내부의 코드입니다 ...');
        console.log('');
    }
    const func1st = namedFunc; // 선언적 함수를 변수에 할당.

    func1st(); // 변수를 통해 함수 호출
    namedFunc(); // 함수를 호출
    console.log(typeof func1st); // function. 자료형 확인
</script>

4.  호이스팅  Hoisting

🐰  var로 선언한 변수 or 선언적 함수는 변수나 함수 이전에 호출하여도 에러를 발생하지 않음
🐰  자바스크립트 해석기는 소스를 훑고 var를 사용한 변수는 실행하기전에 기억해 두기 때문에 선언한 것과 같은 효과가 있다

<script>
    compute(); // 110. 선언적 함수는 함수 정의 전에 사용가능.
    function compute() {
        let x = 10;
        let y = 100;
        let result = x + y;
        console.log(result);
    }
    compute(); // 110
</script>

[ 내용 참고 : IT 학원 강의 및 책 'Do it HTML+CSS+자바스크립트 웹 표준의 정석' ]

1. 함수란 ?

🚀  '코드의 집합'을 의미 def 키워드 사용함

🚀   함수 용어 정리
        a. 인수 : 함수에 전달할 입력(input)을 의미. argument
        b. 매개변수 : 인수를 받아서 저장하는 변수를 의미. parameter
        c. 반환값 : 함수의 출력(output)을 의미. return
        d. 함수 호출 : 만들어진 함수를 실제로 사용하는 것을 의미

def 함수이름(매개변수):
    본문
    return 반환값
    
# 함수이름을 개발자가 마음대로 결정가능
# 매개변수, 반환값은 필수 사항이 아님

# 함수 호출
변수 = 함수이름(인수)
# 함수의 호출 결과를 저장할 변수를 생략 가능

  ⚡️  4가지 함수 호출 형태

       1) 인수: x, 반환값: x
           함수이름()
       2) 인수: o, 반환값: x
           함수이름(인수)
       3) 인수: x, 반환값: o
           변수 = 함수이름()
       4) 인수: o, 반환값: o
           변수 = 함수이름(인수)

# welcome() 함수 정의
def welcome():
    print('Hello Python')
    print('Nice to meet you')

welcome()  # 함수가 정의된 후에 호출을 해야 함
# Hello Python
# Nice to meet you

# 파이썬 함수의 단점 : 데이터 타입이 없어서 다른 작업자가 만든 함수를 사용할 때 주의할 점이 많다.
def process(number):
    return number / 1

process("hello")  # TypeError: unsupported operand type(s) for /: 'str' and 'int'

# 어노테이션 사용 가능. 타입 강제는 아님
def process(number: int) -> float:
    return number / 1

# 파이썬의 함수는 객체이고 자료형이다.
def charge(energy):
    if energy < 0:
        print('0보다 작은 에너지를 충전할 수 없습니다.')
        return  
    print('에너지가 충전되었습니다.')
    
print(charge)  
# <function charge at 0x10360dcf0>

def print_charge(fun):
    fun(0)  # 에너지가 충전되었습니다.

print_charge(charge)  # 함수를 함수 호출시 인수로 사용이 가능.

# 함수안에 함수 선언도 가능하다.
def print_greet(name):
    def get_greet():
        return '안녕하세요'

    print(name + "님 " + get_greet())

print_greet('김철수')

2. 인수와 매개변수

1) 인수가 있는 함수

def introduce(name: str, age: int) -> None:
    print(f'내 이름은 {name}이고, 나이는 {age}살 입니다.')

introduce('james', 25)  # 내 이름은 james이고, 나이는 25살 입니다.
introduce(age=25, name='james')  # 내 이름은 james이고, 나이는 25살 입니다.

2) 가변 매개변수

🚀  함수로 전달해야 하는 인수의 개수가 정해지지 않아도 매개변수를 선언할 수 있음
🚀  가변 매개변수를 만드는 키워드는 애스터리스크(*)
🚀  매개변수 앞에 *를 붙이면 곧바로 가변 매개 변수가 되면서 전달되는 모든 인수를 하나의 튜플(tuple)로 만들어 줌

def show(*args):
    for item in args:
        print(item)

show('python')  # show 함수 호출. 인수가 1개
show('happy', 'birthday')  # show 함수 호출. 인수가 2개

def print_n(n, *values):
    for i in range(n):
        for value in values:
            print(value)
        print()
print_n(3, "안녕하세요", "파이썬 프로그래밍")
'''
안녕하세요
파이썬 프로그래밍

안녕하세요
파이썬 프로그래밍

안녕하세요
파이썬 프로그래밍
'''

  👾  가변 매개변수 뒤에 일반 매개변수 올 수 x

  👾  가변 매개변수는 하나만 사용 가능

3) 기본 매개변수

print(value, sep=' ', end='\n', file=sys.stdout)

🚀  가장 앞에 있는 value가 '가변 매개변수', 뒤에 '매개변수 = 값' 형태로 되어 있는 것이 '기본 매개변수'

🚀  매개변수를 입력하지 않았을 경우 매개변수에 들어가는 기본값을 말한다

🚀  기본 매개변수 뒤에 일반 매개변수가 올 수 없다

    ⚡️  end : value 출력 후 출력할 문자
                       ▶️ end 속성을 사용하지 않고 print() 함수를 사용하면 출력 후 자동으로 줄 바꿈이 진행
    ⚡️  sep : 출력할 value의 구분자
                       ▶️ sep 속성을 사용하지 않고 print() 함수를 사용하면 출력 대상은 공백으로 구분
    ⚡️  file : 출력 방향 지정
                       ▶️ file 속성을 사용하지 않고 print() 함수를 사용하면 출력 대상은 모니터에 출력

print('재미있는','파이썬') # sep 값을 지정하지 않으면 공백이 들어감.
print('재미있는', '파이썬', sep=' ') # 재미있는 파이썬 / 콤마(,)로 구분된 출력 대상은 공백으로 구분
print('Python','Java', 'C', sep=':') #Python:Java:C / sep 속성으로 구분
'''
재미있는 파이썬
재미있는 파이썬
Python:Java:C
'''

print('영화 타이타닉', end='\n') # 지정하지 않았을 때 기본값은 \n
print('평점', end=':')
print('5점') # 평점:5점 / value 출력 후 end 속성 출력. 줄 바꿈이 되지 않음
'''
영화 타이타닉
평점:5점
'''

fos = open('../02_21/sample.py', mode='wt')
print('print("Hello World")', file = fos) # file 속성으로 대상 출력. 파일 출력
fos.close()

4) 키워드 매개변수

 A. 기본 매개변수가 가변 매개변수보다 앞에 오는 경우

     - 기본 매개변수의 의미가 사라진다.

def print_n(n=2, *values):
    for i in range(2):
        for value in values:
            print(value)
            
print_n('안녕하세요','즐거운','파이썬 프로그래밍')
# TypeError 발생

    📌  n에는 안녕하세요가 들어가고, values에 즐거운, 파이썬 프로그래밍이 들어간다

    📌  range() 함수의 매개변수에는 숫자만 가능하기 때문에 에러가 발생

           ∴  기본 매개변수는 가변 매개변수 앞에 써도 의미가 없다.

  B. 가변 매개변수가 기본 매개변수보다 앞에 오는 경우

def print_n(*values, n=2):
    for i in range(2):
        for value in values:
            print(value)
            
print_n('안녕하세요','즐거운','파이썬 프로그래밍', 3)

📌  가변 매개변수가 우선이 되기 때문에 왼쪽과 같은 결과가 나온다.

  C. 키워드 매개변수

     - 매개변수 이름을 지정해서 입력하는 매개변수를 키워드 매개변수라고 한다

def print_n(*values, n=2):
    for i in range(2):
        for value in values:
            print(value)
            
print_n('안녕하세요','즐거운','파이썬 프로그래밍', n=3)
# n=3은 키워드 매개변수

5) 디폴트 매개변수

🚀  매개변수로 전달되는 인수가 없는 경우에 기본적으로 사용할 수 있도록 매개변수에 기본값을 설정할 수 있음

def greet(message='안녕하세요'):
    print(message)

greet('반갑습니다')  # 반갑습니다
greet()  # 안녕하세요
# -> 자바에서는 오버로딩이라 생각함. 파이썬에는 오버로딩 지원 x.

# 디폴트 매개변수와 일반 매개변수를 같이 사용하는 경우 디폴트 매개변수를 뒤(오른쪽)으로 배치
def greet(name, message= '안녕하세요'):
    print(f'{name}님 {message}')

greet('김철수')  # 김철수님 안녕하세요.
greet('김철수', '반갑습니다')  # 김철수님 반갑습니다

# 복수의 디폴트 매개변수를 사용하는 경우
def greet(name='이철수', message='안녕하세요'):
    print(f'{name}님 {message}.')

greet()  # 이철수님 안녕하세요.
greet('김철수')  # 김철수님 안녕하세요. / 왼쪽 부터 적용.
greet('김철수', '반갑습니다')  # 김철수님 반갑습니다.

3. 리턴

🚀  함수 호출 결과를 반환값(return value)이라 한다.
🚀  반환값이 있으면 함수 내부에서 return문을 통해 값을 반환할 수 있고,
      반환값이 없으면 함수 내부에 return문을 작성할 필요가 없음

def address():
    string = '우편번호 12345\n'
    string += '서울시 영등포구 여의도동'
    return string

print(address())
''' 
실행결과)
우편번호 12345
서울시 영등포구 여의도동
'''

def address():
    string = '우편번호 12345\n'
    string += '서울시 영등포구 여의도동'
    print(string)

print(address())  # None : 반환값이 없어서 출력이 안됨

1)  다중 반환

  👾  하나의 반환값도 처리할 수 있고 여러 개의 반환값도 처리할 수 있음

def calculator(*args):
    return sum(args), sum(args) / len(args), max(args), min(args)

a, b, c, d = calculator(1, 2, 3, 4, 5)  # 4개의 반환값을 모두 저장하기 위해서 변수 4개 배치
print('합계', a)  # 합계 15
print('평균', b)  # 평균 3.0
print('최댓값', c)  # 최댓값 5
print('최솟값', d)  # 최솟값 1

# result는 4개의 반환값을 저장하는 튜플.
result = calculator(1, 2, 3, 4, 5)
print('합계', result[0])  # 합계 15
print('평균', result[1])  # 평균 3.0
print('최댓값', result[2])  # 최댓값 5
print('최솟값', result[3])  # 최솟값 1

2) 함수의 종료를 위한 return

  - 반환값이 있으면 return문을 사용해 반환하고, 반환값이 없으면 return문을 생략하면 됨

def charge(energy):
    if energy < 0:
        print('0보다 작은 에너지를 충전할 수 없습니다.')
        return  # charge() 함수의 종료를 의미.
    print('에너지가 충전되었습니다.')

charge(1)   # 에너지가 충전되었습니다.
charge(-1)  # 0보다 작은 에너지를 충전할 수 없습니다.

[ 내용 참고 : IT 학원 강의 자료 및 책 '혼자 공부하는 파이썬' ]