1_Python_Tutorial_hs_comment_(1).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "1. Python Tutorial hs comment (1).ipynb",
      "version": "0.3.2",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "[View in Colaboratory](https://colab.research.google.com/github/jenna1k/Datascience_self/blob/master/1_Python_Tutorial_hs_comment_(1).ipynb)"
      ]
    },
    {
      "metadata": {
        "id": "8cpYuj3lZ3m6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# 파이썬(Python) 튜토리얼\n",
        "\n",
        "파이썬은 프로그래밍을 처음 접하는 분들 입장에서는 가장 쉽게 배울 수 있는 프로그래밍 언어 중 하나입니다. 파이썬은 고레벨 프로그래밍 언어(High-Level Programming Language)이기 때문에, 일반인이 보유하고 있는 기초 상식과 직관에 가능한 일치하도록 구현되어 있습니다."
      ]
    },
    {
      "metadata": {
        "id": "96cANgwuZ3m9",
        "colab_type": "code",
        "colab": {},
        "outputId": "c057b198-beae-4a1c-99a9-b87e677ec4e9"
      },
      "cell_type": "code",
      "source": [
        "# 덧셈\n",
        "1 + 1"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "metadata": {
        "id": "M9KExCaxZ3nE",
        "colab_type": "code",
        "colab": {},
        "outputId": "38d57ba3-e020-4e7c-be04-d9edd302ca6f"
      },
      "cell_type": "code",
      "source": [
        "# 뺄셈\n",
        "7 - 4"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "metadata": {
        "id": "Ei2--rxWZ3nJ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "하지만 파이썬이 언제나 인간의 직관과 상식에 정확하게 일치하도록 동작하는 것은 아닙니다. 다음의 예시를 통해 이를 확인할 수 있습니다."
      ]
    },
    {
      "metadata": {
        "id": "2umefxpdZ3nK",
        "colab_type": "code",
        "colab": {},
        "outputId": "de07a74c-991e-4242-ccdd-7de5b0eedb45"
      },
      "cell_type": "code",
      "source": [
        "# 곱셈. 3 x 4는 알파벳 엑스(x)와 헷갈릴 수 있기 때문에, 코드를 명시적으로 작성하기 위해 별표(*)로 대체합니다.\n",
        "3 * 4"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "metadata": {
        "id": "es564KfuZ3nP",
        "colab_type": "code",
        "colab": {},
        "outputId": "f9fd39f8-f06b-4c7f-d825-952dd0e35026"
      },
      "cell_type": "code",
      "source": [
        "# 나눗셈. 나눗셈 기호(÷)는 키보드에 없기 때문에, 편의를 위해 슬래시(/)로 대체합니다.\n",
        "3 / 2"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "metadata": {
        "id": "iVaVweWtZ3nV",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "파이썬은 덧셈, 뺄셈, 곱셈, 나눗셈 외에도 나머지 연산(%)을 지원합니다."
      ]
    },
    {
      "metadata": {
        "id": "mrsn_a_IZ3nW",
        "colab_type": "code",
        "colab": {},
        "outputId": "3517f8dd-b90d-4c8e-f44e-5aab1dca1c88"
      },
      "cell_type": "code",
      "source": [
        "# 13에서 5를 나눈 나머지(%)는 3이 된다.\n",
        "13 % 5"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "metadata": {
        "id": "46TRdpqUZ3nc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "파이썬은 등호 두 개(==)를 통해 왼쪽과 오른쪽의 결과를 비교할 수 있습니다. (등호 하나(=)는 변수에 값을 할당하는 용도로 사용하기 때문에, 코드를 명시적으로 작성하기 위해 비교 연산은 등호 두 개(==)를 이용합니다)"
      ]
    },
    {
      "metadata": {
        "id": "PXUjo8cbZ3nl",
        "colab_type": "code",
        "colab": {},
        "outputId": "6eb1f2b8-42fd-494a-c80d-ef7e39a85e4b"
      },
      "cell_type": "code",
      "source": [
        "# 1에서 2를 더한 결과는 3이므로, 참(True)이 나옵니다.\n",
        "1 + 2 == 3"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "metadata": {
        "id": "ZmqISS6AZ3nw",
        "colab_type": "code",
        "colab": {},
        "outputId": "ccf15359-89c2-4126-b690-a4bdf79969dc"
      },
      "cell_type": "code",
      "source": [
        "# 1에서 2를 더한 결과는 4가 아니기 때문에, 거짓(False)이 나옵니다.\n",
        "1 + 2 == 4"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "metadata": {
        "id": "2M3auX52Z3n4",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "프로그래밍 언어는 적은 문법을 다양하게 응용함으로서 동작하는 무언가(=프로그램)를 만들어 냅니다. 다음은 나머지 연산자와 비교 연산자 두 개를 응용한 코드입니다."
      ]
    },
    {
      "metadata": {
        "id": "PxLTZkmmZ3n6",
        "colab_type": "code",
        "colab": {},
        "outputId": "0d3f8352-d9fe-4b03-bbab-870d2ee6478d"
      },
      "cell_type": "code",
      "source": [
        "# 10을 2로 나눈 나머지는 0이므로 참(True)이 나옵니다. 즉, 이 코드는 짝수와 홀수를 구분하는 용도로 쓰입니다.\n",
        "10 % 2 == 0"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "metadata": {
        "id": "sLJfHUdaZ3oE",
        "colab_type": "code",
        "colab": {},
        "outputId": "f02a448b-b331-4d6d-ccbe-a0eb7897b448"
      },
      "cell_type": "code",
      "source": [
        "# 반면, 11을 2로 나눈 나머지는 0이 아니므로 거짓(False)이 나옵니다.\n",
        "11 % 2 == 0"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "metadata": {
        "id": "PghWkhICZ3oL",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "어떤 경우에는 하나의 조건이 아닌, 두 개 이상의 조건을 중복해서 사용해야 할 경우가 있습니다. 이럴 경우에는 and와 or를 사용합니다."
      ]
    },
    {
      "metadata": {
        "id": "yNiB-uIGZ3oQ",
        "colab_type": "code",
        "colab": {},
        "outputId": "cb538dde-0313-4e3d-e531-74007b392d44"
      },
      "cell_type": "code",
      "source": [
        "# 12를 2로 나눈 나머지는 0이고, 마찬가지로 3으로 나눈 나머지도 0입니다. 그러므로 결과는 참(True)이 나옵니다.\n",
        "12 % 2 == 0 and 12 % 3 == 0"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "metadata": {
        "id": "g4kfMx4YZ3od",
        "colab_type": "code",
        "colab": {},
        "outputId": "458f3038-5cf9-4527-f42a-83301fdae062"
      },
      "cell_type": "code",
      "source": [
        "# 14는 2로 나눈 나머지가 0이지만, 3으로 나눈 나머지는 0이 아닙니다. 그러므로 결과는 거짓(False)이 나옵니다.\n",
        "14 % 2 == 0 and 14 % 3 == 0"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "metadata": {
        "id": "WGGf_GCOZ3oo",
        "colab_type": "code",
        "colab": {},
        "outputId": "e4c72efb-96c7-4054-9177-0557162608f9"
      },
      "cell_type": "code",
      "source": [
        "# 반면 or 조건은 둘 중 하나만 참이여도 참이 되기 때문에, 아래의 코드는 결과적으로 참(True)이 출력됩니다.\n",
        "14 % 2 == 0 or 14 % 3 == 0"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "metadata": {
        "id": "kdqgezWdZ3ow",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## 변수"
      ]
    },
    {
      "metadata": {
        "id": "K4XO8cNNZ3o6",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "변수를 이용해서 값을 할당할 수 있다. 변수를 할당 할 때는 = 한 개 만 이용합니다. (ex. 변수명 = 값)"
      ]
    },
    {
      "metadata": {
        "id": "Y3U8Y0diZ3o9",
        "colab_type": "code",
        "colab": {},
        "outputId": "6705a5b5-60e5-45d8-f3da-ef88003f7c87"
      },
      "cell_type": "code",
      "source": [
        "# a 변수에 3을 할당 합니다.\n",
        "a = 3\n",
        "# b 변수에 5를 할당 합니다.\n",
        "b = 5\n",
        "\n",
        "# 변수 a의 값 3과 변수 b의 값 5가 더해져 결과는 8이 나옵니다.\n",
        "a + b"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "metadata": {
        "id": "FyBCg0IWZ3pB",
        "colab_type": "code",
        "colab": {},
        "outputId": "a2205137-0190-46f2-9ada-01234a81bc76"
      },
      "cell_type": "code",
      "source": [
        "# a에는 3이 b에는 13이 할당 됩니다.\n",
        "a = 3\n",
        "b = 13\n",
        "\n",
        "# 변수 a의 값 3과 변수 b의 값 13가 더해져 결과는 16이 나옵니다.\n",
        "a + b"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "metadata": {
        "id": "y7HEzf4kZ3pH",
        "colab_type": "code",
        "colab": {},
        "outputId": "024e51b5-6c67-4f8a-d1ea-455c28a58c3b"
      },
      "cell_type": "code",
      "source": [
        "a = 3\n",
        "\n",
        "# 변수에 값을 변경하여 다시 할당할 수 있습니다.\n",
        "# (a의 기존 값 3과 1을 더한 결과 값을 다시 a에 할당합니다.)\n",
        "a = a + 1\n",
        "\n",
        "# 참고사항 : 쥬피터 노트북은 가장 마지막의 연산값만 출력합니다. 중간값 출력을 원한다면 print()를 활용하면 됩니다.\n",
        "\n",
        "# a의 값은 4이므로 4가 출력됩니다.\n",
        "print(a)\n",
        "\n",
        "# a는 a의 값 4와 2를 더한 결과 값이 할당됩니다.\n",
        "a = a + 2\n",
        "a"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "metadata": {
        "id": "9M3FZcpKZ3pT",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "문장을 프로그래밍 언어에서 다룰 수 있습니다. 그리고 그 문장을 문자열이라고 부릅니다."
      ]
    },
    {
      "metadata": {
        "id": "1r68_GKeZ3pU",
        "colab_type": "code",
        "colab": {},
        "outputId": "3f794cd6-8b56-4138-a0d5-43e3f2a413c4"
      },
      "cell_type": "code",
      "source": [
        "# 문자열에 \" \"를 사용하는 이유는 변수(명령어, 예약어 등등)와 헷갈릴수 있기 때문입니다.\n",
        "\"Hello World!\""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hello World!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "metadata": {
        "id": "icpnQVNmZ3pZ",
        "colab_type": "code",
        "colab": {},
        "outputId": "ed96a6a9-743d-4df6-83a9-a101720da3b8"
      },
      "cell_type": "code",
      "source": [
        "# 문자열에서는 ' '를 사용할 수도 있습니다.\n",
        "'Hello World!'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hello World!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "metadata": {
        "id": "-7poeXevZ3pe",
        "colab_type": "code",
        "colab": {},
        "outputId": "edac858c-4c04-4250-eec6-2a80f97cd307"
      },
      "cell_type": "code",
      "source": [
        "# \" \"와 ' ' 둘 다 사용가능한 이유는 문자열에 '을 사용할 수도 있기 때문에 오류를 방지하기 위해서입니다.\n",
        "\"Shayne's Name?\"\n",
        "\n",
        "# 'I say \"Hello World!\"' \n",
        "# ' '를 활용해서 문자열에서 \"도 활용이 가능합니다."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Shayne's Name?\""
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "metadata": {
        "id": "uVd_cC5hZ3ph",
        "colab_type": "code",
        "colab": {},
        "outputId": "28971cb1-9f94-47b8-a01d-03870261b703"
      },
      "cell_type": "code",
      "source": [
        "# jupyter notebook에서는 한 번 변수를 할당하면 파이썬 문장을 지워도 계속 유지 된다. 그래서 오류가 발생할 수 있습니다.\n",
        "# 헷갈리지 않으려면 다시 시작할 때 menu -> Kernel -> Restart & Clear Output를 하고 다시 실행하면 좋습니다.\n",
        "# tmp"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'tmp' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-19-e6be3f39e8cf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# jupyter notebook에서는 한 번 변수를 할당하면 파이썬 문장을 지워도 계속 유지 된다. 그래서 오류가 발생할 수 있습니다.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# 헷갈리지 않으려면 다시 시작할 때 menu -> Kernel -> Restart & Clear Output를 하고 다시 실행하면 좋습니다.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtmp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'tmp' is not defined"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "3JcautDAZ3pm",
        "colab_type": "code",
        "colab": {},
        "outputId": "f2f03298-0c56-4744-9a96-a85dc74b249a"
      },
      "cell_type": "code",
      "source": [
        "# 같은 형의 데이터들 끼리만 연산(+)이 가능합니다. (숫자와 문자는 더할 수 없다.)\n",
        "# int == integer == 숫자\n",
        "# str == string == 문자\n",
        "1 + \"2\"\n",
        "\n",
        "# error는 잘 못된 부분을 알려주기 위해서 발생한다. \n",
        "# 잘 못된 부분을 알려주지 않으면 다른 사람들과 코딩을 해야는데 서로 알 수가 없어서 힘들어집니다.\n",
        "\n",
        "# error 상황 시 대처 팁\n",
        "# 에러가 발생하면 당황하지 말고 에러의 마지막 문장을 천천히 살펴본다. (TypeError: unsupported operand type(s) for +: 'int' and 'str')\n",
        "# 마지막 문장을 보고 그 위로 올려보면 에러가 발생한 위치를 나타내준다.\n",
        "# 그래도 안되면 에러의 마지막 문장을 구글에 찾아본다.(unsupported operand type(s) for +: 'int' and 'str'를 찾아본다.)\n",
        "# stack overflow 라는 사이트에 내용은 믿을만 합니다."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-20-f3034dcc4d40>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# int == integer == 숫자\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# str == string == 문자\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"2\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m# error는 잘 못된 부분을 알려주기 위해서 발생한다.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "Pj6HO6_mZ3pr",
        "colab_type": "code",
        "colab": {},
        "outputId": "bdae331d-86d9-4d57-b77b-f54798e63907"
      },
      "cell_type": "code",
      "source": [
        "# 문자 더하기 연산(+)은 문자끼리 붙여준다.\n",
        "# 문자 '1'과 문자 '2'가 더해서 문자'12'가 결과가 됩니다.\n",
        "\"1\" + \"2\""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'12'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "metadata": {
        "id": "qv5n4v1LZ3pv",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## 포메팅"
      ]
    },
    {
      "metadata": {
        "id": "3dkU14gmZ3pw",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "포메팅은 문자열에 어떤 값을 삽입하는 방법입니다."
      ]
    },
    {
      "metadata": {
        "id": "yEpeX1paZ3px",
        "colab_type": "code",
        "colab": {},
        "outputId": "2c3b33f5-7ad8-45f9-e1b9-8cb3147bccd1"
      },
      "cell_type": "code",
      "source": [
        "# .format()는 지정한 변수의 값을 순서{0},{1}에 맞게 출력해오는 기능입니다.\n",
        "bananas = 5\n",
        "days = 3\n",
        "\"Shayne ate {1} bananas for {0} days\".format(bananas, days)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Shayne ate 3 bananas for 5 days'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "metadata": {
        "id": "RU3DjVfNZ3p2",
        "colab_type": "code",
        "colab": {},
        "outputId": "445e8276-df87-454e-d58a-9777355c1559"
      },
      "cell_type": "code",
      "source": [
        "# 신버전 파이썬의 경우 아래와 같이 축약된 명령어로 대체 가능합니다.\n",
        "f\"Shayne ate {bananas}bananas for {days} days.\""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Shayne ate 5bananas for 3 days.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "metadata": {
        "id": "OEbQHYONZ3qK",
        "colab_type": "code",
        "colab": {},
        "outputId": "52d937f9-9df2-4b1c-de1d-4df9efd5c8d9"
      },
      "cell_type": "code",
      "source": [
        "# 형식을 지정하여 값을 출력할 수 있습니다.\n",
        "model_a = 0.987654321\n",
        "model_b = 0.123456789\n",
        "\n",
        "# f == float == 소숫점\n",
        "# : 은 특수기능의 시작을 나타내고 .5는 5자리 까지 출력하는 것을 뜻하고 f는 float 소숫점의 숫자를 뜻합니다.(소숫점 5자리 까지 출력이 됩니다.)\n",
        "# 1:.3f 는 3자리 까지 소숫점을 출력합니다.\n",
        "\"[Accuracy] Model A = {0:.3f} Model B = {1:.5f}\".format(model_a, model_b)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'[Accuracy] Model A = 0.988 Model B = 0.12346'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "metadata": {
        "id": "UxABKXwLZ3qR",
        "colab_type": "code",
        "colab": {},
        "outputId": "febde426-bcc6-438e-8b72-9d6021d2351a"
      },
      "cell_type": "code",
      "source": [
        "# 위의 코드도 아래와 같이 변경 가능합니다.\n",
        "f\"[Accuracy] Model A = {model_a:.5f} Model B = {model_b:.3f}\""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'[Accuracy] Model A = 0.98765 Model B = 0.123'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "metadata": {
        "id": "-tgWq6HDZ3qV",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### 문자열"
      ]
    },
    {
      "metadata": {
        "collapsed": true,
        "id": "b6lQodmiZ3qX",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "# mesage에 문자열 \"Hello World!\"를 할당합니다.\n",
        "message = \"Hello World!\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "TkMm0j5_Z3qd",
        "colab_type": "code",
        "colab": {},
        "outputId": "656276d0-8203-45c4-b0a0-4bee92c6e0e2"
      },
      "cell_type": "code",
      "source": [
        "# 문자열의 n 번째 문자를 출력할 수 있습니다.\n",
        "# 프로그래밍의 순서는 0부터 시작 합니다.\n",
        "print(message[0])\n",
        "print(message[1])\n",
        "print(\"----\")\n",
        "\n",
        "# 뒤에서부터 문자를 출력할 때는 -1부터 시작합니다.\n",
        "print(message[-1])\n",
        "print(message[-2])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "H\n",
            "e\n",
            "----\n",
            "!\n",
            "d\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "_ySgJmcGZ3qh",
        "colab_type": "code",
        "colab": {},
        "outputId": "e23e79a3-1db2-4845-e36d-5ac3f54c6156"
      },
      "cell_type": "code",
      "source": [
        "# 특정 부분만 출력할 수 있습니다.\n",
        "# : 은 슬라이싱 이라고 합니다.\n",
        "# 0:4는 0 번째부터 3 번째까지 출력합니다.\n",
        "message[0:4]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hell'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "metadata": {
        "id": "TmHcNCzcZ3ql",
        "colab_type": "code",
        "colab": {},
        "outputId": "b0603ea3-d637-4a9f-9943-02521d41fc92"
      },
      "cell_type": "code",
      "source": [
        "# 문자열에 특정 문자가 있는지 확인 할 수 있습니다.\n",
        "# 파이썬은 대소문자를 구문합니다.\n",
        "print(\"H\" in message)\n",
        "print(\"h\" in message)\n",
        "print(\"A\" in message)\n",
        "print(\"Hell\" in message)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "JnP-SqHhZ3qp",
        "colab_type": "code",
        "colab": {},
        "outputId": "a259bc07-43b7-484c-c0b7-86a9a9dc2f10"
      },
      "cell_type": "code",
      "source": [
        "# 문자열의 특수 기능은 message.를 치고 Tab 키를 누르면 사용할 수 있는 특수 기능 리스트를 확인할 수 있습니다.\n",
        "\n",
        "# upper() 함수는 모든 문자를 대문자로 변환해주는 함수입니다.\n",
        "message.upper()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'HELLO WORLD!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "metadata": {
        "id": "yYOnkCiDZ3qx",
        "colab_type": "code",
        "colab": {},
        "outputId": "79b955d9-b50a-4060-b6b8-97d4dc159412"
      },
      "cell_type": "code",
      "source": [
        "# lower() 함수는 모든 문자를 소문자로 변환해주는 함수입니다.\n",
        "message.lower()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'hello world!'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "metadata": {
        "id": "ho0tVBf9Z3q1",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### 리스트"
      ]
    },
    {
      "metadata": {
        "id": "ol4_tJLrZ3q2",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "똑같은 코드를 반복적으로 짜야할 때 사용하는 기능이고 여러 개의 변수를 하나로 묶어서 표현하는 방법입니다."
      ]
    },
    {
      "metadata": {
        "id": "Y0XhERtsZ3q3",
        "colab_type": "code",
        "colab": {},
        "outputId": "a5e2ca55-3006-478d-8ddc-ddaf40dd8e4d"
      },
      "cell_type": "code",
      "source": [
        "# 대괄호[]를 사용합니다.\n",
        "odd = [1, 3, 5, 7, 9]\n",
        "odd"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 3, 5, 7, 9]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "metadata": {
        "id": "6a3fuBuWZ3q8",
        "colab_type": "code",
        "colab": {},
        "outputId": "7d32ee64-0c6e-4a8b-e333-e8b167b2f996"
      },
      "cell_type": "code",
      "source": [
        "# 문자열을 다루는 것과 공통점이 많다.\n",
        "\n",
        "print(odd[0])\n",
        "print(odd[1])\n",
        "print(\"----\")\n",
        "\n",
        "# - 값은 리스트의 뒤에서 부터 순서를 가리킵니다.\n",
        "print(odd[-1])\n",
        "print(odd[-2])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "----\n",
            "9\n",
            "7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "PgjjdPrDZ3rX",
        "colab_type": "code",
        "colab": {},
        "outputId": "d8f4b7fa-6887-48f4-ede2-2304bc106f22"
      },
      "cell_type": "code",
      "source": [
        "# 0번째부터 3번째까지 출력합니다.\n",
        "odd[0:4]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 3, 5, 7]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "metadata": {
        "id": "oFc9S1cRZ3rb",
        "colab_type": "code",
        "colab": {},
        "outputId": "bd09230d-1078-4bba-ba3e-6ace71cef743"
      },
      "cell_type": "code",
      "source": [
        "# 리스트에 특정값이 포함되어 있는지 확인할 수 있습니다.\n",
        "print(1 in odd)\n",
        "print(2 in odd)\n",
        "print(3 in odd)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "k8m9Qhl0Z3rg",
        "colab_type": "code",
        "colab": {},
        "outputId": "a9092df3-7ec0-4aee-cf53-5e6de45bc851"
      },
      "cell_type": "code",
      "source": [
        "# 리스트에 특정값을 추가할 수 있습니다.\n",
        "# append 함수는 리스트의 끝에 값을 추가로 저장합니다.\n",
        "# 실행하는 횟수만큼 추가됩니다.\n",
        "odd.append(11)\n",
        "odd"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 3, 5, 7, 9, 11]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "metadata": {
        "id": "b_XkCBA0Z3rn",
        "colab_type": "code",
        "colab": {},
        "outputId": "7ccd2be2-5d47-4e6b-a37c-e59485e0a617"
      },
      "cell_type": "code",
      "source": [
        "# 한 번에 여러개의 값을 추가할 수 있습니다.\n",
        "# +를 이용하여 [13, 15, 17, 19]를 odd에 추가합니다.\n",
        "odd = odd + [13, 15, 17, 19]\n",
        "odd"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "metadata": {
        "id": "9_Qv86LZZ3rs",
        "colab_type": "code",
        "colab": {},
        "outputId": "afdba931-3d71-4584-f4cf-3a0f204a53ee"
      },
      "cell_type": "code",
      "source": [
        "# 리스트의 특정 위치의 값을 변경할 수 있습니다.\n",
        "odd[3] = -1\n",
        "odd[5] = -1\n",
        "odd"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 3, 5, -1, 9, -1, 13, 15, 17, 19]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "metadata": {
        "id": "eQPELB4TZ3r2",
        "colab_type": "code",
        "colab": {},
        "outputId": "be2bb152-2e77-427c-aa62-8fd695c04ecb"
      },
      "cell_type": "code",
      "source": [
        "# pop 함수는 리스트의 마지막 값을 뽑아냅니다.\n",
        "odd.pop()\n",
        "odd"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 3, 5, -1, 9, -1, 13, 15, 17]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "metadata": {
        "id": "a3HVdPiEZ3r9",
        "colab_type": "code",
        "colab": {},
        "outputId": "4c029b89-5996-4277-e89e-7491a98007ad"
      },
      "cell_type": "code",
      "source": [
        "# 문자열과 리스트는 상호 변환이 가능하다.\n",
        "# 문자 -> 리스트로 변환\n",
        "# split 함수는 특정 문자를 기준으로 문자열을 쪼개어 리스트로 변환 시켜줍니다.\n",
        "message = \"Hello World!\"\n",
        "print(message.split(\" \"))\n",
        "print(message.split(\"o\"))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Hello', 'World!']\n",
            "['Hell', ' W', 'rld!']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "thLBSDPeZ3sN",
        "colab_type": "code",
        "colab": {},
        "outputId": "6fb266fc-6e59-4767-d019-792bd5e5f545"
      },
      "cell_type": "code",
      "source": [
        "# 리스트를 문자로 변환\n",
        "# join은 split와 반대 되는 함수로 특정 문자로 리스트를 합쳐 하나의 문자열로 만들어줍니다.\n",
        "words = [\"Hello\", \"World!\"]\n",
        "print(\" \".join(words))\n",
        "print(\",\".join(words))\n",
        "print(\", \".join(words))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World!\n",
            "Hello,World!\n",
            "Hello, World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "vfb_NewyZ3sR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### 제어문 "
      ]
    },
    {
      "metadata": {
        "id": "m8VuHeSGZ3sU",
        "colab_type": "code",
        "colab": {},
        "outputId": "1751736e-71f1-4451-81d2-b8fa3a401efb"
      },
      "cell_type": "code",
      "source": [
        "# if 제어문: \n",
        "#    실행문\n",
        "# 조건에 따라 값을 출력할 수 있습니다.\n",
        "age = 3\n",
        "\n",
        "# age가 5보다 작으면 참(True)이므로 \"아이\"가 출력됩니다.\n",
        "# age가 5보다 크면 거짓(False)이므로 \"어른\"가 출력됩니다.\n",
        "if age < 5:\n",
        "    print(\"아이\")\n",
        "else:\n",
        "    print(\"어른\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "아이\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "irwXSy4TZ3sa",
        "colab_type": "code",
        "colab": {},
        "outputId": "fccafc8b-e95d-4c85-be66-e56efa9bceef"
      },
      "cell_type": "code",
      "source": [
        "age = 10\n",
        "\n",
        "# elif 구문으로 조건을 추가할 수 있습니다.\n",
        "# elif 는 계속해서 추가하여 조건을 줄 수 있습니다.\n",
        "\n",
        "# age가 5보다 작으면 \"아이\"가 출력됩니다.\n",
        "# age가 5보다 크고 18 보다 작으면 \"학생\"이 출력됩니다.\n",
        "# age가 18보다 크면 \"어른\"이 출력됩니다.\n",
        "if age < 5:\n",
        "    print(\"아이\")\n",
        "elif age < 18:\n",
        "    print(\"학생\")\n",
        "else:\n",
        "    print(\"어른\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "학생\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "cQ6b2-ieZ3sc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### 반복문"
      ]
    },
    {
      "metadata": {
        "id": "s7JIIvH6Z3se",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "반복되는 기능을 한 줄로 처리하는 방법입니다."
      ]
    },
    {
      "metadata": {
        "id": "V0FHg7PDZ3se",
        "colab_type": "code",
        "colab": {},
        "outputId": "5410b82d-d559-4be7-ed85-baed9e68b99a"
      },
      "cell_type": "code",
      "source": [
        "baskets = ['apple', 'banana', 'chicken', 'pineapple', 'cherry']\n",
        "\n",
        "# basket 리스트에 있는 요소를 꺼내서 for문이 실행됩니다.\n",
        "for stuff in baskets:\n",
        "    print(stuff)\n",
        "\n",
        "# 위 반복문은 아래의 실행문과 결과가 같습니다. \n",
        "# stuff = basket[0]\n",
        "# print(stuff)\n",
        "# stuff = basket[1]\n",
        "# print(stuff)\n",
        "# stuff = basket[2]\n",
        "# print(stuff)\n",
        "# stuff = basket[3]\n",
        "# print(stuff)\n",
        "# stuff = basket[4]\n",
        "# print(stuff)\n",
        "# stuff = basket[5]\n",
        "# print(stuff)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "apple\n",
            "banana\n",
            "chicken\n",
            "pineapple\n",
            "cherry\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "egqPchmZZ3sk",
        "colab_type": "code",
        "colab": {},
        "outputId": "00b88c06-ddae-4951-dc45-b958eaeb62dc"
      },
      "cell_type": "code",
      "source": [
        "# 1부터 5까지 순서대로 실행됩니다.\n",
        "# 반복문 안에서 제어문을 사용할 수 있습니다.\n",
        "# 반복문과 제어문은 띄어쓰기가 중요합니다.\n",
        "for i in range(1, 6):\n",
        "    \n",
        "    if i == 2:\n",
        "        # continue은 해당 루프만 실행하지 않고 다음 루프를 다시 시작합니다.\n",
        "        continue\n",
        "    \n",
        "    if i == 5:\n",
        "        # 아래와 같이 if문 안에 들여써진 print(i)은 if 문에 포함됩니다.\n",
        "        # print(i)\n",
        "        \n",
        "        # break문은 for 반복문을 종료합니다.\n",
        "        break\n",
        "        \n",
        "    # print(i)은 if 문에 불포함\n",
        "    print(i)\n",
        "\n",
        "# range(5) => 0 부터 4 까지\n",
        "# range(1,5) => 1 부터 4 까지\n",
        "# range(1,6) => 1 부터 5 까지"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "y9W6mFPvZ3so",
        "colab_type": "code",
        "colab": {},
        "outputId": "44cfc1f0-b06b-4304-a03f-256de4d229e4"
      },
      "cell_type": "code",
      "source": [
        "double_list = []\n",
        "\n",
        "for i in range(1, 11):\n",
        "    \n",
        "    # i가 5이면 현재 루프를 중단하고 다음 루프로 간다.\n",
        "    if i == 5:\n",
        "        continue\n",
        "    \n",
        "    # i가 8이면 for 문이 끝난다.\n",
        "    if i == 8:\n",
        "        break\n",
        "    \n",
        "    # i 값에 2를 곱하여 결과를 double에 할당하고 doublie_list에 추가합니다.\n",
        "    double = i * 2\n",
        "    double_list.append(double)\n",
        "\n",
        "double_list"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 4, 6, 8, 12, 14]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "metadata": {
        "id": "xzuEiDrjZ3sr",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## 함수"
      ]
    },
    {
      "metadata": {
        "id": "w0FRXAuDZ3sr",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "함수는 많고 복잡한 코드를 하나로 묶어주는 기능 입니다."
      ]
    },
    {
      "metadata": {
        "id": "MnEIUy6tZ3ss",
        "colab_type": "code",
        "colab": {},
        "outputId": "89d5bff0-827f-40ed-fbc9-f4deead59365"
      },
      "cell_type": "code",
      "source": [
        "# def == define 특정 함수를 정의합니다.\n",
        "def multiply(a, b):\n",
        "    c = a * b\n",
        "    return c\n",
        "\n",
        "# multiply(1, 2)은\n",
        "# a에는 2를 할당, b에는 3을 할당\n",
        "# a + b의 값를 c에 할당하고 \n",
        "# 반환 시켜준다.\n",
        "print(multiply(1, 2))\n",
        "print(multiply(2, 3))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "qgqxRt8RZ3sw",
        "colab_type": "code",
        "colab": {},
        "outputId": "fa4b8a44-c645-4e35-bb1d-a1cafbe163e6"
      },
      "cell_type": "code",
      "source": [
        "def sign(n):\n",
        "    if n > 0:\n",
        "        return \"양수\"\n",
        "    elif n < 0:\n",
        "        return \"음수\"\n",
        "    else:\n",
        "        return \"0\"\n",
        "\n",
        "for n in [-1, 0, +1]:\n",
        "    print(sign(n))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "음수\n",
            "0\n",
            "양수\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "HxB4QFbxZ3s3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### 팩토리얼\n",
        "  * 3! = 3 x 2 x 1 = 6\n",
        "  * 4! = 4 x 3 x 2 x 1 = 24\n",
        "  * 5! = 5 x 4 x 3 x 2 x 1 = 120"
      ]
    },
    {
      "metadata": {
        "id": "E7iaM1BIZ3s4",
        "colab_type": "code",
        "colab": {},
        "outputId": "0af36c29-df47-4cff-ced2-07c8d07f705c"
      },
      "cell_type": "code",
      "source": [
        "# factorial 함수를 정의합니다.\n",
        "def factorial(n):\n",
        "    # result 변수에 1을 할당합니다.\n",
        "    result = 1\n",
        "    \n",
        "    # 반복문을 이용해서 1 부터 n까지를 반복합니다..\n",
        "    for i in range(1, n + 1):\n",
        "        # result값과 i값을 곱하여 result에 할당합니다.\n",
        "        result = result * i\n",
        "    \n",
        "    # result 값을 반환합니다.\n",
        "    return result\n",
        "\n",
        "print(factorial(3))\n",
        "print(factorial(4))\n",
        "print(factorial(5))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6\n",
            "24\n",
            "120\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "collapsed": true,
        "id": "6LuiwUupZ3s7",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}