JAVA 개발자의 PYTHON 도전기

이 포스트는 개인적으로 공부한 내용을 정리한 글입니다.
자세한 내용은 아래 참고자료를 봐주시면 감사하겠습니다.

기본 문법

Function

드디어 함수입니다.
함수를 정의하는 방법은 아래와 같습니다.

def [함수명](매개변수):
    pass

자바의 경우 리턴값이 있는지, 없는지를 입력해야하지만 파이썬은 자바스크립트와 같이 리턴타입을 명시하지 않고 값을 리턴하면 됩니다.(타입힌트라는 기능이 있지만 필수적으로 사용하는것도 아니고, 해당 기능을 사용한다고해서 컴파일 오류가 나는것도 아니기 때문에 논외로 칩니다.)

strs = "Hello, "
def function_test(s):
    s += "World!"
    return s

print(function_test(strs))

함수 기본 인자 값을 정의할 수 있습니다.
아래 3개의 인자가 있습니다. 최소 한개의 매개변수를 넣어줘야 실행이 되고, 순서대로 입력해야 합니다.

def ask_ok(prompt, retries=4, reminder='Please try again!'):
    while True:
        ok = input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise ValueError('invalid user response')
        print(reminder)

ask_ok("test")
ask_ok("test", 10)
ask_ok("test", 10, "다시 시도해주세요")

위의 방법이 java에서 자주 사용하는 메소드 오버로딩이라고 생각했지만 아니다.

파이썬은 메소드 오버로딩을 지원하지 않는다(!)(왜?)

자바의 경우 아래와 같이 메소드 오버로딩을 지원한다.

/**
 * java.util.List of method
 */
static <E> List<E> of() {
        return ImmutableCollections.emptyList();
    }
    static <E> List<E> of(E e1) {
        return new ImmutableCollections.List12<>(e1);
    }
    static <E> List<E> of(E e1, E e2) {
        return new ImmutableCollections.List12<>(e1, e2);
    }
    static <E> List<E> of(E e1, E e2, E e3) {
        return new ImmutableCollections.ListN<>(e1, e2, e3);
    }
    static <E> List<E> of(E e1, E e2, E e3, E e4) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4);
    }
    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5);
    }
    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6);
    }
    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6, e7);
    }
    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6, e7, e8);
    }
    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6, e7, e8, e9);
    }
    static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
        return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
                                                e6, e7, e8, e9, e10);
    }

위의 경우는 인자의 갯수에 따라 메소드 오버로딩을 하는 예제이다.
자료형이 달라도 메소드 오버로딩이 된다.

그럼 파이썬은 어떻게 사용해야 하는가..?

def function_test1(*args):
    print(args)


def function_test2(**kwargs):
    print(kwargs)


def function_test3(*args, **kwargs):
    print(args)
    print(kwargs)


function_test1(1, 2, 3, 4)
function_test2(test1=2, test2=4, test3="테스트3")
function_test3(1, 2, 3, 4, test1=2, test2=4, test3="테스트3")

위와 같이 사용하면 된다고 한다.
*args 는 tuple, **kwargs 는 dictionary 자료형이다.

참고자료 (파이썬 docs)