[파이썬 문법] 2. 입출력과 변수

 

---

1. 출력하기 - print()

1-1) 문자(열) 과 숫자 출력하기

---

‘출력’이란

어떠한 결과를 볼 수 있도록 화면에 띄우는 것

으로 생각해도 될 것 같다.




간단하게 화면에 원하는 문장(문자열) 을 출력할 수 있는 방법이다.


Shell에 print(" 안녕하세요! ")


라고 입력한 후 [enter]를 누르면 파이썬 코드가 실행되면서 안녕하세요! 라는 문장이 출력되는 것을 볼 수 있다.

출력하고자 하는 것이 ‘문자(열)’ 이라면 “” (쌍 따옴표)와 함께 print() 문을 사용하여,


print("  ") 의 쌍따옴표 사이에 출력하려는 문자(열)을 적어주면 된다.

숫자를 출력하고 싶은 경우에는 ""(쌍 따옴표) 없이
print( ) 괄호 안에 print( 2025 ) 와 같은 형태로 적으면 2025가 출력되는 것을 볼 수 있다.

물론, 2025도 숫자가 아닌 문자로 간주하고 다음과 같이print(" 2025 ") 처럼 쌍따옴표 안에 넣어 출력할 경우,

2025가 똑같이 출력되는 것을 볼 수 있지만
print( 2025 ) 와
print(" 2025 ") 의 차이점은

위에서 설명한 것처럼 문자(열)인가, 숫자인가에 차이가 있다고 할 수 있다.

print( 2025 + 1 ) 의 출력결과는 2026 이 되지만,
print(“ 2025 + 1 ”) 의 출력결과는 2025 + 1 이 된다.

즉, 숫자 취급을 받아야지만 ‘수의 연산’이 가능해진다.




1-2) 문자(열)과 숫자의 혼합 출력방법

---

만약, Happy 2025 ! 를 각각 문자(열)과 숫자로 출력하고 싶다면 서로 다른 타입 사이에 ,(콤마) 를 찍어준다.

print( "Happy" , 2025, "!")

숫자로 출력되는 2025 는 연산도 가능하다.

 

---

 

2. 입력하기- input()

2-1) 입력 요청문을 통해 유저에게 입력받기

---

‘입력’이란

프로그램 이용자가 어떤 값을 입력할 수 있도록 하는 것

이라고 생각한다.

그리고 입력은 input(" ") 을 통해 받을 수 있다.

* input(“ ”) 을 통해 입력받는 모든 문자(열)이나 숫자는
‘문자열’ 타입으로 받아진다.

---

코딩을 처음하는 사람이라면, 다음 ... 이 보일 때까지
넘기는 것을 추천한다.


Colab이라는 코딩 플랫폼을 통해, input(3)이라는
코드를 실행시켜 보았다.

혹시 쌍따옴표로 입력받아서, input으로 입력받은 값이 항상 문자(열)로 반환되는 것일까?

라는 개인적인 궁금증 때문이었다.

당연히 쌍따옴표가 없기 때문에 input함수에 문자열은 안들어갔고
input함수에 숫자를 넣으니 실행이 된다!

숫자취급이 되어 연산이 정상적으로 이뤄지는지 보려고 나눗셈을 연산하여 출력하게 해보았다.

타입에러가 뜨는 것을 보아하니, 여전히 입력된 333은 문자열로 반환되는 듯 했다.

input 함수는 문자열타입으로 반환한다는 말에, 이 함수의 내부구현이 궁금해졌고 c언어로 작성된 input함수의 구현을 찾아보게 되었다.

CPython의 소스 코드는 오픈 소스로 공개되어 있어서GitHub에서 코드를 찾아볼 수 있었다.

https://github.com/python/cpython/blob/main/Python/bltinmodule.c

cpython/Python/bltinmodule.c at main · python/cpython

 

/*[clinic input]
input as builtin_input

    prompt: object(c_default="NULL") = ""
    /

Read a string from standard input.  The trailing newline is stripped.

The prompt string, if given, is printed to standard output without a
trailing newline before reading input.

If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
On *nix systems, readline is used if available.
[clinic start generated code]*/

static PyObject *
builtin_input_impl(PyObject *module, PyObject *prompt)
/*[clinic end generated code: output=83db5a191e7a0d60 input=159c46d4ae40977e]*/
{
    PyThreadState *tstate = _PyThreadState_GET();
    PyObject *fin = _PySys_GetAttr(
        tstate, &_Py_ID(stdin));
    PyObject *fout = _PySys_GetAttr(
        tstate, &_Py_ID(stdout));
    PyObject *ferr = _PySys_GetAttr(
        tstate, &_Py_ID(stderr));
    PyObject *tmp;
    long fd;
    int tty;

    /* Check that stdin/out/err are intact */
    if (fin == NULL || fin == Py_None) {
        PyErr_SetString(PyExc_RuntimeError,
                        "input(): lost sys.stdin");
        return NULL;
    }
    if (fout == NULL || fout == Py_None) {
        PyErr_SetString(PyExc_RuntimeError,
                        "input(): lost sys.stdout");
        return NULL;
    }
    if (ferr == NULL || ferr == Py_None) {
        PyErr_SetString(PyExc_RuntimeError,
                        "input(): lost sys.stderr");
        return NULL;
    }

    if (PySys_Audit("builtins.input", "O", prompt ? prompt : Py_None) < 0) {
        return NULL;
    }

    /* First of all, flush stderr */
    if (_PyFile_Flush(ferr) < 0) {
        PyErr_Clear();
    }

    /* We should only use (GNU) readline if Python's sys.stdin and
       sys.stdout are the same as C's stdin and stdout, because we
       need to pass it those. */
    tmp = PyObject_CallMethodNoArgs(fin, &_Py_ID(fileno));
    if (tmp == NULL) {
        PyErr_Clear();
        tty = 0;
    }
    else {
        fd = PyLong_AsLong(tmp);
        Py_DECREF(tmp);
        if (fd < 0 && PyErr_Occurred())
            return NULL;
        tty = fd == fileno(stdin) && isatty(fd);
    }
    if (tty) {
        tmp = PyObject_CallMethodNoArgs(fout, &_Py_ID(fileno));
        if (tmp == NULL) {
            PyErr_Clear();
            tty = 0;
        }
        else {
            fd = PyLong_AsLong(tmp);
            Py_DECREF(tmp);
            if (fd < 0 && PyErr_Occurred())
                return NULL;
            tty = fd == fileno(stdout) && isatty(fd);
        }
    }

    /* If we're interactive, use (GNU) readline */
    if (tty) {
        PyObject *po = NULL;
        const char *promptstr;
        char *s = NULL;
        PyObject *stdin_encoding = NULL, *stdin_errors = NULL;
        PyObject *stdout_encoding = NULL, *stdout_errors = NULL;
        const char *stdin_encoding_str, *stdin_errors_str;
        PyObject *result;
        size_t len;

        /* stdin is a text stream, so it must have an encoding. */
        stdin_encoding = PyObject_GetAttr(fin, &_Py_ID(encoding));
        if (stdin_encoding == NULL) {
            tty = 0;
            goto _readline_errors;
        }
        stdin_errors = PyObject_GetAttr(fin, &_Py_ID(errors));
        if (stdin_errors == NULL) {
            tty = 0;
            goto _readline_errors;
        }
        if (!PyUnicode_Check(stdin_encoding) ||
            !PyUnicode_Check(stdin_errors))
        {
            tty = 0;
            goto _readline_errors;
        }
        stdin_encoding_str = PyUnicode_AsUTF8(stdin_encoding);
        if (stdin_encoding_str == NULL) {
            goto _readline_errors;
        }
        stdin_errors_str = PyUnicode_AsUTF8(stdin_errors);
        if (stdin_errors_str == NULL) {
            goto _readline_errors;
        }
        if (_PyFile_Flush(fout) < 0) {
            PyErr_Clear();
        }
        if (prompt != NULL) {
            /* We have a prompt, encode it as stdout would */
            const char *stdout_encoding_str, *stdout_errors_str;
            PyObject *stringpo;
            stdout_encoding = PyObject_GetAttr(fout, &_Py_ID(encoding));
            if (stdout_encoding == NULL) {
                tty = 0;
                goto _readline_errors;
            }
            stdout_errors = PyObject_GetAttr(fout, &_Py_ID(errors));
            if (stdout_errors == NULL) {
                tty = 0;
                goto _readline_errors;
            }
            if (!PyUnicode_Check(stdout_encoding) ||
                !PyUnicode_Check(stdout_errors))
            {
                tty = 0;
                goto _readline_errors;
            }
            stdout_encoding_str = PyUnicode_AsUTF8(stdout_encoding);
            if (stdout_encoding_str == NULL) {
                goto _readline_errors;
            }
            stdout_errors_str = PyUnicode_AsUTF8(stdout_errors);
            if (stdout_errors_str == NULL) {
                goto _readline_errors;
            }
            stringpo = PyObject_Str(prompt);
            if (stringpo == NULL)
                goto _readline_errors;
            po = PyUnicode_AsEncodedString(stringpo,
                stdout_encoding_str, stdout_errors_str);
            Py_CLEAR(stdout_encoding);
            Py_CLEAR(stdout_errors);
            Py_CLEAR(stringpo);
            if (po == NULL)
                goto _readline_errors;
            assert(PyBytes_Check(po));
            promptstr = PyBytes_AS_STRING(po);
            if ((Py_ssize_t)strlen(promptstr) != PyBytes_GET_SIZE(po)) {
                PyErr_SetString(PyExc_ValueError,
                        "input: prompt string cannot contain null characters");
                goto _readline_errors;
            }
        }
        else {
            po = NULL;
            promptstr = "";
        }
        s = PyOS_Readline(stdin, stdout, promptstr);
        if (s == NULL) {
            PyErr_CheckSignals();
            if (!PyErr_Occurred())
                PyErr_SetNone(PyExc_KeyboardInterrupt);
            goto _readline_errors;
        }

        len = strlen(s);
        if (len == 0) {
            PyErr_SetNone(PyExc_EOFError);
            result = NULL;
        }
        else {
            if (len > PY_SSIZE_T_MAX) {
                PyErr_SetString(PyExc_OverflowError,
                                "input: input too long");
                result = NULL;
            }
            else {
                len--;   /* strip trailing '\n' */
                if (len != 0 && s[len-1] == '\r')
                    len--;   /* strip trailing '\r' */
                result = PyUnicode_Decode(s, len, stdin_encoding_str,
                                                  stdin_errors_str);
            }
        }
        Py_DECREF(stdin_encoding);
        Py_DECREF(stdin_errors);
        Py_XDECREF(po);
        PyMem_Free(s);

        if (result != NULL) {
            if (PySys_Audit("builtins.input/result", "O", result) < 0) {
                return NULL;
            }
        }

        return result;

    _readline_errors:
        Py_XDECREF(stdin_encoding);
        Py_XDECREF(stdout_encoding);
        Py_XDECREF(stdin_errors);
        Py_XDECREF(stdout_errors);
        Py_XDECREF(po);
        if (tty)
            return NULL;

        PyErr_Clear();
    }

    /* Fallback if we're not interactive */
    if (prompt != NULL) {
        if (PyFile_WriteObject(prompt, fout, Py_PRINT_RAW) != 0)
            return NULL;
    }
    if (_PyFile_Flush(fout) < 0) {
        PyErr_Clear();
    }
    return PyFile_GetLine(fin, -1);
}

C언어로 구현되어있는 파이썬 input함수의 코드이다.

result = PyUnicode_Decode(s, len, stdin_encoding_str, stdin_errors_str);

위 코드는 파이썬의  input 함수의 내부구현 코드 중
입력값을 처리하는 부분이다.

이 코드에서 PyUnicode_Decode() 함수는
바이트 데이터(문자열이나 바이너리 데이터)를
유니코드 문자열 객체(PyUnicodeObject)로 변환하는 함수이다.

파이썬 input 함수의 내부구현에서 문자열로 반환하기 때문에 문자열을 반환할 수 밖에 없다는 것을 확인했다.

---

입력받을 때 사용하는 input(" ")함수를 보다가
입력받은 값이 왜 항상 문자열로 반환되는지 궁금해져서다른 길을 다녀왔다,, ㅎㅎ


정확히는, input() 처럼 따옴표없이 사용도 가능하지만,
이 경우, 유저가 보게되는 입력요청문이 숫자밖에 없다.

따라서 연산도 필요없은 입력요청문은 "" 문장으로 보여주는 것이 100% 효율적인 것이다.



위에서 말한 입력 요청문은 내가 지어낸 말인데,
프로그램 이용자에게 무엇을 입력하면 되는지 알려준다.


아래 사진은 예시이다.

쌍따옴표 안에 나이를 입력하세요 :  라고 적으면
유저들은 어떤 값을 입력해야하는지 알 수 있다.

20을 입력하면 위 사진과 같이 입력한 값이 ‘20’
문자열 형태로 출력된다.





2-2) 입력받은 문자열 타입의 값을 정수로 만들기

---

문자열로 출력된 20은
int() 라는 타입을 정수형으로 바꾸어주는 함수를 통해
숫자로 다시 바꾸어 줄 수 있다.

타입을 변환하고 싶은 것을 int( ) 괄호 안에 넣으면 된다.

int는 정수 타입을 지칭해주는데,입력받은 값이 숫자라면 꼭 정수가 아닌 다른 타입으로도 바꿀 수 있다.

출력과 입력을 알아보았다.

출력은 내가 보여주고 싶은 값을 보여주는 것이고,
입력은 입력요청문를 통해 원하는 값을 유저로부터 입력받는 것이다.

출력만 하는 것과

입력요청문을 출력하고 이를 통해 값을 입력받을 수 있다는 차이가 있다

프로그램을 작성할 때, 값을 입력받는 것은
그 값이 필요하고, 중요하기 때문이다.

입력받은 값은 데이터가 된다


위 사진처럼,

입력받은 값을 그대로 출력하기 위함이 아니라,
값을 통해 연산하고 적용하기 위함이다.

이를 위해 우리는 입력받은 값을 저장해야 한다.

---

3. 변수

변수는 ‘값을 보관하고 기억해주는 공간’ 같은 것이다.

어떤 값을 담고 있느냐에 따라 이름을 짧고 명료하게
지어줄 수 있다.

---

-변수 이름 생성 규칙 (문법적 규칙)-

1. 문자, 숫자, 밑줄(_)만 사용 가능

age = 25
name_1 = "Alice"
_score = 100


2. 숫자로 시작할 수 없음

1var = 10  # 오류 발생
var1 = 10  # 올바름


3. 대소문자 구분

age = 20
Age = 25
print(age)  # 20
print(Age)  # 25


4. 예약어(키워드) 사용 금지
: 파이썬에서 이미 정의된 키워드(keyword)는 변수명으로 사용할 수 없다.

if = 10  # 오류 발생
class = "A"  # 오류 발생


*예약어 확인 방법:

import keyword
print(keyword.kwlist)  # 예약어 목록 출력

---

위 규칙대로 변수를 이름지을 수 있다.
예를 들어서 나이를 입력받고 그 값을 저장하고 싶을 땐, age 라는 변수명을 지어줄 수 있다.

사용법은 (변수명) = (값) 이다.

위 코드는 입력문을 통해 나이를 20으로 입력받고,
문자열로 변환된 값을 정수 20으로 바꿔 출력한 것이다.

age = int( input(" 나이를 입력하세요 : “))
print( age )

라고 적어도 같다.

첫 번째 줄 코드처럼
= (등호)기준으로 오른쪽에 있는 값을,
등호기준 왼쪽에 선언된 변수에 저장해준다.

그럼 age라는 변수에는 내가 입력한 값이 들어간다.
변수에 저장되어있는 값을 출력하고 싶으면!
따옴표 없이 print( ) 괄호 안에 변수명을 적어주면 된다!